০৮ সেপ, ২০২৫·8 মিনিট
FastAPI কী? এপিআই তৈরির জন্য একটি ব্যবহারিক গাইড
FastAPI হল একটি আধুনিক Python ফ্রেমওয়ার্ক যা দ্রুত API তৈরিতে সহায়ক—টাইপ হিন্ট, ভ্যালিডেশন, এবং স্বয়ংক্রিয় OpenAPI ডকস সহ। মৌলিক বিষয় ও ব্যবহার শিখুন।
FastAPI হল একটি আধুনিক Python ফ্রেমওয়ার্ক যা দ্রুত API তৈরিতে সহায়ক—টাইপ হিন্ট, ভ্যালিডেশন, এবং স্বয়ংক্রিয় OpenAPI ডকস সহ। মৌলিক বিষয় ও ব্যবহার শিখুন।
FastAPI হল একটি Python ফ্রেমওয়ার্ক যা পরিষ্কার কোড ও স্বয়ংক্রিয় ডকুমেন্টেশনের সঙ্গে দ্রুত ওয়েব API তৈরিতে সহায়ক। আপনি ছোট ফাংশন (যেগুলোকে “এন্ডপয়েন্ট” বলা হয়) লিখেন যা ঘোষণা করে API কী ডেটা নেবে এবং কী রিটার্ন করবে, আর FastAPI ওয়েবের পলিসি—রাউটিং, ভ্যালিডেশন, এবং JSON রেসপন্স তৈরি—সবটি সামলায়।
API হচ্ছে URL-এর একটি সেট যা একটি সফটওয়্যার আরেকটি সফটওয়্যারের সাথে কথা বলার সুযোগ দেয়।
উদাহরণস্বরূপ, আপনার ফোনের একটি আবহাওয়া অ্যাপ GET /weather?city=Berlin মতো URL কল করতে পারে। সার্ভার কাঠামোবদ্ধ ডেটা (সাধারণত JSON) দিয়ে উত্তর দেয়, যেমন তাপমাত্রা এবং পূর্বাভাস। ফোন অ্যাপকে সার্ভারের ডাটাবেসের সরাসরি অ্যাক্সেস দরকার নেই—এটা কেবল API-কে জিজ্ঞাসা করে এবং ফলাফল দেখায়।
FastAPI আপনাকে এই URLগুলো এবং রেসপন্সগুলো Python-এ তৈরি করতে সাহায্য করে।
আপনাকে অ্যাসিঙ্ক বিশেষজ্ঞ হতে হবে না—সরাসরি সহজ এন্ডপয়েন্ট লিখে শুরু করতে পারবেন এবং পরে উন্নত প্যাটার্নগুলো গ্রহণ করতে পারবেন।
FastAPI দ্রুত জনপ্রিয়তা পেয়েছে কারণ এটি Python-এ API তৈরি করার সময় যে প্রচলিত বাধাগুলো থাকে সেগুলো কমিয়ে দেয়।
প্রচলিত API প্রজেক্টগুলো প্রায়ই শুরুতে ধীর সেটআপ ও অনেক প্লাম্বিং-ওয়ার্ক নিয়ে আসে:
FastAPI-র মূল ফিচারগুলো এই সমস্যাগুলো সরাসরি টার্গেট করে, ফলে টিমগুলো এন্ডপয়েন্ট ডিজাইনে বেশি সময় ব্যয় করে এবং ফ্রেমওয়ার্ক বয়রাইটারের সাথে কম লড়াই করে।
FastAPI ব্যাপকভাবে Python টাইপ হিন্ট ব্যবহার করে। যখন আপনি একটি ফিল্ডকে int, অপশনাল বা কোন কিছুর তালিকা হিসেবে ঘোষণা করেন, FastAPI সেই তথ্য ব্যবহার করে ইনপুট ভ্যালিডেশন এবং আউটপুট গঠন করতে।
এতে “স্ট্রিংলি-টাইপড” ভুল (যেমন কোথাও ID টেক্সট হিসেবে এবং কোথাও সংখ্যা হিসেবে ব্যবহার করা) কমে যায় এবং ফাংশন সিগনেচারে স্পষ্ট প্রত্যাশা থাকে।
API স্কিমা কোড থেকে উৎপন্ন হওয়ায় FastAPI ইন্টারেক্টিভ ডকুমেন্টেশন স্বয়ংক্রিয়ভাবে তৈরি করে (OpenAPI + Swagger UI/ReDoc)। এটি সহযোগিতার জন্য গুরুত্বপূর্ণ: ফ্রন্টএন্ড ডেভেলপার, QA, ও ইন্টিগ্রেটররা এন্ডপয়েন্টগুলো ব্রাউজ করে পরীক্ষা করতে পারে এবং নির্দিষ্ট মডেলগুলো দেখতে পারে আলাদা ডকসের অপেক্ষা না করেই।
FastAPI খারাপ ডিজাইন করা API ঠিক করবে না। ভাল নামকরণ, ভার্সনিং, এরর হ্যান্ডলিং, এবং সিকিউরিটি সিদ্ধান্ত আপনাকেই নিতে হবে। তবে এটি আইডিয়া থেকে ভালভাবে নির্ধারিত API-তে পৌঁছানোর পথকে পরিষ্কার করে এবং কম অপ্রত্যাশিত সমস্যা দেয়।
FastAPI কিছু মূল আইডিয়ার ওপর নির্মিত; এগুলো একবার বুঝলে ফ্রেমওয়ার্কটি সহজ মনে হবে। মিনিমাম অন্তর্দৃষ্টি লাগবে—প্রতিদিন ব্যবহার করা অংশগুলো চিনতে হবে।
একটি ফ্রেমওয়ার্ক হলো সরঞ্জাম ও কনভেনশনগুলোর সেট যা আপনাকে শূন্য থেকে শুরু না করে API তৈরি করতে দেয়। FastAPI সাধারণ API কাজগুলো—এন্ডপয়েন্ট ডেফাইন করা, ইনপুট পড়া, আউটপুট রিটার্ন করা, এরর হ্যান্ডেল করা, এবং কোড সংগঠিত করার জন্য প্লাম্বিং প্রদান করে।
রাউটিং হল কীভাবে আপনি একটি URL ও HTTP মেথডকে পাইথন কোডের সঙ্গে যুক্ত করবেন।
উদাহরণ: আপনি GET /users-কে “ব্যবহারকারীদের তালিকা” এবং POST /users-কে “একজন ব্যবহারকারী তৈরি” এর সাথে রাউট করতে পারেন। FastAPI-তে সাধারণত @app.get(...) ও @app.post(...) এর মতো ডেকোরেটর ব্যবহার করা হয়, যা কোন এন্ডপয়েন্ট কী অফার করে তা এক নজরে দেখতে সহজ করে।
প্রতিটি API কল একটি রিকোয়েস্ট (ক্লায়েন্ট যা পাঠায়) এবং একটি রেসপন্স (সার্ভার যা রিটার্ন করে)।
FastAPI আপনাকে সাহায্য করে:
/users/{id}), কোয়েরি স্ট্রিং (?page=2), হেডার, এবং রিকোয়েস্ট বডি থেকে ডেটা পড়তে200, 201, 404)FastAPI ASGI-র উপর চলে, যা Python ওয়েব সার্ভারের একটি আধুনিক স্ট্যান্ডার্ড। বাস্তবে, এর মানে FastAPI অনেক সংযোগ দক্ষভাবে হ্যান্ডেল করতে পারে এবং দরকার হলে লং-লিভড কানেকশন (যেমন WebSockets) সাপোর্ট করতে পারে—আপনাকে নিম্নস্তরের নেটওয়ার্কিং ম্যানেজ করতে হবে না।
Python টাইপ হিন্ট (যেমন str, int, list[Item]) FastAPI-তে কেবল ডকুমেন্টেশন নয়—এগুলো মূল ইনপুট। FastAPI এগুলো ব্যবহার করে বুঝে কি ধরনের ডেটা আপনি প্রত্যাশা করছেন, ইনকামিং মানগুলোকে সঠিক টাইপে কনভার্ট করে, এবং ক্লিয়ার, পূর্বানুমানযোগ্য API তৈরি করে।
Pydantic মডেল আপনি এক জায়গায় ডেটার আকৃতি (ফিল্ড, টাইপ, ঐচ্ছিক ভ্যালু) নির্ধারণ করতে দেয়। FastAPI এগুলো ব্যবহার করে ইনকামিং JSON ভ্যালিডেট করে, অবৈধ ইনপুট সরিয়ে দেয় সহায়ক এরর মেসেজ দেখিয়ে, এবং আউটপুট কনসিস্টেন্টলি সিরিয়ালাইজ করে—ফলে ক্লায়েন্টদের অতিরিক্ত ময়লা ডেটা পাঠালে আপনার API আরও নির্ভরযোগ্য থাকে।
FastAPI অ্যাপগুলো এন্ডপয়েন্ট-এর চারপাশে গড়ে উঠেছে: একটি URL পাথ এবং একটি HTTP মেথড। একটি এন্ডপয়েন্ট বলতে বুঝায় “ক্লায়েন্ট কী চাইছে” এবং “কীভাবে তারা সেটা চাইছে”। উদাহরণ: ক্লায়েন্ট GET /users করে ব্যবহারকারীর তালিকা চাইতে পারে, অথবা POST /users করে নতুন ব্যবহারকারী তৈরি করতে পারে।
পাথ হল রুট, এবং মেথড হল অ্যাকশন:
GET /products → ডেটা ফেচ করাPOST /products → কিছু তৈরি করতে ডেটা পাঠানোPUT /products/123 → কিছু প্রতিস্থাপন/আপডেট করাDELETE /products/123 → কিছু মুছে ফেলাFastAPI পাথের অংশে থাকা ডেটা আলাদা করে এবং অপশনাল “ফিল্টার” হিসেবে থাকা ডেটা আলাদা করে।
GET /users/42 → এখানে 42 হলো ইউজারের আইডি।?-এর পরে যুক্ত হয় এবং সাধারণত অপশনাল।
GET /users?limit=10&active=true → limit ও active ফলাফল নিয়ন্ত্রণ করে।যখন ক্লায়েন্ট কাঠামোবদ্ধ ডেটা (সাধারণত JSON) পাঠায়, তা রিকোয়েস্ট বডি তে যায়, সাধারণত POST বা PUT রিকোয়েস্টে।
উদাহরণ: POST /orders JSON: { "item_id": 3, "quantity": 2 }।
FastAPI সাধারণ পাইথন অবজেক্ট (dict ইত্যাদি) রিটার্ন করতে পারে, কিন্তু এটি আরও ভালভাবে কাজ করে যখন আপনি একটি রেসপন্স মডেল ডেফাইন করেন। মডেল একটি কনট্রাক্ট হিসেবে কাজ করে: ফিল্ডগুলো কনসিস্টেন্ট থাকে, অতিরিক্ত ডেটা ফিল্টার করা যায়, এবং টাইপগুলো এনফোর্স করা যায়। ফলস্বরূপ ক্লায়েন্টরা জানে কী আশা করবে এবং ইন্টিগ্রেশন ফাটতে কম ঝুঁকি থাকে।
“Async” (asynchronous) হলো একটি উপায় আপনার API-কে অনেক রিকোয়েস্ট দক্ষভাবে হ্যান্ডেল করার—বিশেষত যখন অনেক সময় অপেক্ষা হয়।
ধরা যাক একটি ব্যারিস্টা অর্ডার নিচ্ছে। যদি তাকে ইস্প্রেসো মেশিন চলার সময় কিছুই না করে দাঁড়িয়ে থাকতে হয়, তিনি কম কাস্টমার সার্ভ করতে পারবেন। ভালো পদ্ধতি হলো: কফি শুরু কর, তারপর পরের অর্ডার নাও যখন মেশিন কাজ করছে।
Async ঠিক তেমনি কাজ করে। আপনার FastAPI অ্যাপ একটি অপারেশন শুরু করতে পারে যা ধীর—যেমন নেটওয়ার্ক অনুরোধ বা ডিবি কলে অপেক্ষা করে—আর অপেক্ষার সময় এটি অন্য ইনকামিং রিকোয়েস্ট সামলায়।
Async তখনই ভালো যখন আপনার API অনেক I/O করে—অর্থাৎ বেশি সময় অপেক্ষায় কাটে, কম “চিন্তা” করতে হয়। সাধারণ উদাহরণ:
এই ক্ষেত্রে async থ্রুপুট বাড়ায় এবং রিকোয়েস্ট জমে যাওয়ার সম্ভাবনা কমায়।
Async সবকিছু দ্রুত করে না। যদি আপনার এন্ডপয়েন্ট CPU-ভিত্তিক কাজ করে—যেমন বড় ইমেজ রিসাইজ, ডেটা সায়েন্স গণনা, বা বড় পে-লোড এনক্রিপশন—তখন async সেই কম্পিউটেশনকে দ্রুত করবে না। এসব ক্ষেত্রে পটভূমি ওয়ার্কার, প্রসেস পুল, বা আউটসকেলিং দরকার।
FastAPI-তে সবকিছু পুনরায় লিখতে হবে না। আপনি সাধারণ (sync) রুট ফাংশন লিখতে পারেন এবং FastAPI সেগুলো ঠিকমত চালাবে। অনেক প্রজেক্ট মিশ্র স্টাইল ব্যবহার করে: সহজ এন্ডপয়েন্ট sync রাখে, যেখানে স্পষ্টভাবে উপকারী সেখানে async def ব্যবহার করে (সাধারণত ডাটাবেস বা বাইরের HTTP কল চৌকশ ক্ষেত্রে)।
ভ্যালিডেশন হচ্ছে বাইরের জগত এবং আপনার কোডের মধ্যকার চেকপয়েন্ট। যখন API ইনপুট নেয় (JSON বডি, কোয়েরি প্যারাম, পাথ প্যারাম), আপনি চান তা সম্পূর্ণ, সঠিক টাইপের, এবং বৈধ সীমার মধ্যে—এটা ডাটাবেসে লেখার, অন্য সার্ভিস কল করার, বা ব্যবসায়িক লজিক ট্রিগার করার আগে।
FastAPI Pydantic মডেলের ওপর নির্ভর করে। একবার আপনি কি “ভালো ডেটা” তা বর্ণনা করলে, FastAPI স্বয়ংক্রিয়ভাবে:
যদি ক্লায়েন্ট ভুল আকৃতির ডেটা পাঠায়, FastAPI 422 Unprocessable Entity সহ একটি কাঠামোবদ্ধ এরর পে-লোড রিটার্ন করে যা সঠিক ফিল্ড ও কারণ নির্দেশ করে। এতে ক্লায়েন্ট ডেভেলপাররা দ্রুত ভুল ঠিক করতে পারে।
নীচে একটি ছোট মডেল দেখানো হলো যা আবশ্যক ফিল্ড, টাইপ, মিন/ম্যাক্স কনস্ট্রেইন্ট, এবং ফরম্যাট দেখায়:
from pydantic import BaseModel, EmailStr, Field
class UserCreate(BaseModel):
email: EmailStr
age: int = Field(ge=13, le=120)
username: str = Field(min_length=3, max_length=20)
email থাকা আবশ্যক।age একটি ইন্টিজার হতে হবে।age 13–120 সীমার মধ্যে থাকবে।EmailStr একটি বৈধ ইমেল আকার নিশ্চিত করে।একই মডেলগুলো আউটপুট গঠন করতেও ব্যবহার করা যায়, যাতে আপনার রেসপন্স অনেকাংশে অভ্যন্তরীণ ফিল্ড লিক না করে। আপনি পাইথন অবজেক্ট রিটার্ন করেন; FastAPI (Pydantic-এর মাধ্যমে) সেগুলোকে সঠিক ফিল্ড নাম ও টাইপ সহ JSON-এ রূপান্তর করে।
FastAPI-র সবচেয়ে ব্যবহারিক বৈশিষ্ট্যগুলোর একটি হলো এটি স্বয়ংক্রিয়ভাবে আপনার লিখে রাখা কোড থেকে API ডকুমেন্টেশন জেনারেট করে।
OpenAPI হলো একটি স্ট্যান্ডার্ড কিভাবে একটি API স্ট্রাকচারালি বর্ণনা করা যায় (সাধারণত JSON)। এটিকে একটি “কনট্রাক্ট” হিসেবে ভাবুন যা বলে:
GET /users/{id})মেশিন-পঠিত হওয়ায় টুলগুলো এটাকে ব্যবহার করে ক্লায়েন্ট জেনারেট করা, রিকোয়েস্ট যাচাই করা, এবং টিমর মধ্যে সমন্বয় করা সহজ হয়।
FastAPI স্বয়ংক্রিয়ভাবে দুইটি মানব-পাঠ্য ডকস পেজ সরবরাহ করে:
সাধারণত FastAPI প্রজেক্টে এগুলো দেখা যায়:
/docs (Swagger UI)/redoc (ReDoc)আপনি যখন পাথ প্যারামিটার, রিকোয়েস্ট মডেল, রেসপন্স মডেল বা ভ্যালিডেশন ঘরানায় পরিবর্তন করবেন, OpenAPI স্কিমা (এবং ডকস পেজগুলো) স্বয়ংক্রিয়ভাবে আপডেট হয়। আলাদা করে ডকস মেন্টেন করার দরকার পড়ে না।
একটি FastAPI অ্যাপ খুবই ছোট হলেও “রিয়েল” অনুভব দিতে পারে। আপনি একটি পাইথন অবজেক্ট app ডিফাইন করেন, কয়েকটি রুট যোগ করেন, এবং লোকালি সার্ভার চালিয়ে ব্রাউজারে চেষ্টা করেন।
নিচে সবচেয়ে ছোট কাজের উদাহরণ:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello, FastAPI"}
এটাই: এক রুট (GET /) যা JSON রিটার্ন করে।
কাজটি আরও API-র মত করে তুলতে আমরা আইটেমগুলো একটি লিস্টে রাখব। এটা ডাটাবেস নয়—সার্ভার রিস্টার্ট হলে ডেটা রিসেট হয়—কিন্ত শেখার জন্য পারফেক্ট।
from fastapi import FastAPI
app = FastAPI()
items = []
@app.post("/items")
def create_item(name: str):
item = {"id": len(items) + 1, "name": name}
items.append(item)
return item
@app.get("/items")
def list_items():
return items
এখন আপনি পারবেন:
POST /items?name=Coffee দিয়ে একটি আইটেম যোগ করাGET /items দিয়ে তালিকা আনাএকটি সাধারণ স্টার্টার স্ট্রাকচার হলো:
main.py (যেখানে app ও রুট থাকে)requirements.txt বা pyproject.toml (ডিপেন্ডেন্সি)সাধারণত আপনি:
uvicorn main:app --reload)http://127.0.0.1:8000 খুলে এন্ডপয়েন্টগুলো টেস্ট করবেনFastAPI-র “ডিপেন্ডেন্সি” হলো শেয়ার করা ইনপুট যা আপনার এন্ডপয়েন্টগুলোকে তাদের কাজ করতে লাগে—যেমন ডাটাবেস সেশন, বর্তমান লগ-ইন করা ব্যবহারকারী, অ্যাপ সেটিংস, অথবা সাধারণ কোয়েরি প্যারামিটার। প্রতিটি রুটে এগুলো ম্যানুয়ালি তৈরি না করে আপনি একবার ডিফাইন করে FastAPI কে ব্যবহার করতে দেন।
একটি ডিপেন্ডেন্সি সাধারণত একটি ফাংশন (বা ক্লাস) যা একটি মান রিটার্ন করে যা আপনার এন্ডপয়েন্ট ব্যবহার করবে। FastAPI এটি কল করবে, যা প্রয়োজন তা দেখে নেবে (তার প্যারামিটার অনুযায়ী), এবং রেজাল্ট আপনার পাথ অপারেশন ফাংশনে ইনজেক্ট করবে।
এটিকে ডিপেন্ডেন্সি ইনজেকশন বলা হয়ে থাকে, কিন্তু সহজ করে বললে: “আপনি যা চান তা ঘোষণা করুন, FastAPI সেটাকে বেঁধে দেবে।”
ডিপেন্ডেন্সি না হলে, আপনি হয়তো প্রতিটি এন্ডপয়েন্টে ডাটাবেস কানেকশন খুলে/বন্ধ করবেন, অথেনটিকেশন চেক বারবার লিখবেন, একই পেজিনেশন প্যার্সিং বারবার করবেন—সব জায়গায় একই লজিক থাকলে সময়ে পরিবর্তন করতে গিয়ে অনেক গুলো ফাইল সম্পাদনা করতে হবে।
ডিপেন্ডেন্সি দিয়ে আপনি সেই লজিক এক জায়গায় রাখেন—পরিবর্তন করতে হলে একই জায়গায় আপডেট করলে হয়ে যাবে।
page/limit পার্সিং ও ভ্যালিডেশন পুনরায় ব্যবহার করানীচে একটি ধারণাগত প্যাটার্ন:
from fastapi import Depends, FastAPI
app = FastAPI()
def get_settings():
return {"items_per_page": 20}
@app.get("/items")
def list_items(settings=Depends(get_settings)):
return {"limit": settings["items_per_page"]}
আপনি Depends(...) দিয়ে ডিপেন্ডেন্সি ঘোষণা করেন, এবং FastAPI তার রেজাল্ট এন্ডপয়েন্ট প্যারামিটারে দেয়। একই পদ্ধতি আরও জটিল বিল্ডিং ব্লকের জন্যও কাজ করে (যেমন get_db() বা get_current_user()), যা আপনার কোড বড় হলে পরিস্কার রাখতে সাহায্য করে।
FastAPI আপনার API-কে “স্বয়ংক্রিয়ভাবে সুরক্ষিত” করে না—আপনাকে স্কীম বেছে নিয়ে এন্ডপয়েন্টে তা লাগাতে হবে। ভাল খবর: FastAPI ডিপেন্ডেন্সি সিস্টেমের মাধ্যমে সাধারণ সিকিউরিটি প্যাটার্নগুলো সহজে ইমপ্লিমেন্ট করা যায়।
অথেনটিকেশন উত্তর দেয়: “আপনি কে?” অথোরাইজেশন উত্তর দেয়: “আপনি কী করতে পারবেন?”
উদাহরণ: একজন ইউজার অথেনটিকেটেড হতে পারে (বৈধ লগইন/টোকেন) কিন্তু একটি অ্যাডমিন-নির্দিষ্ট রুটে অথোরাইজড নাও থাকতে পারে।
X-API-Key)। রোটেশন ও রিভোকেশন ম্যানেজ করুন।FastAPI এগুলোকে fastapi.security মতো ইউটিলিটিজ দিয়ে সাপোর্ট করে এবং OpenAPI-এ পরিষ্কারভাবে ডক করে।
যদি আপনি ইউজার পাসওয়ার্ড স্টোর করেন, কখনও প্লেইনটেক্সটে স্টোর করবেন না। সল্টেড, স্লো হ্যাশ ব্যবহার করুন (উদাহরণ: bcrypt/argon2) এবং রেট লিমিটিং ও অ্যাকাউন্ট লকআউট নীতিগুলো বিবেচনা করুন।
নিরাপত্তা হলো বিশদ বিষয়: টোকেন সংরক্ষণ, CORS সেটিংস, HTTPS, সিক্রেট ম্যানেজমেন্ট, এবং প্রতিটি সংবেদনশীল এন্ডপয়েন্টে সঠিক অথোরাইজেশন চেক করা ইত্যাদি। বিল্ট-ইন হেল্পারগুলো একটি শুরু; প্রোডাকশনে ভরসা করার আগে রিভিউ ও টেস্ট করুন।
টেস্টিং হলো যেখানে FastAPI-র “আমাদের মেশিনে কাজ করে” প্রতিশ্রুতি আপনাকে প্রোডাকশনে আত্মবিশ্বাস দেয়। ভাল খবর: FastAPI Starlette-এর উপর নির্মিত, তাই শক্তিশালী টেস্টিং টুলস অনেক কম সেটআপে পাওয়া যায়।
ইউনিট টেস্ট ছোট অংশগুলো টেস্ট করে: একটি ফাংশন গণনা ঠিক করছে কিনা, একটি ডিপেন্ডেন্সি সঠিকভাবে বর্তমান ইউজার লোড করছে কিনা, অথবা একটি সার্ভিস মেথড ডাটাবেসে কথা বলছে কিনা (এখানে সাধারণত মক করা হয়)।
ইন্টিগ্রেশন টেস্ট এন্ড-টু-এন্ড API কল করে পুরো HTTP রেসপন্স যাচাই করে। এগুলো রাউটিং ভুল, ডিপেন্ডেন্সি ও ভ্যালিডেশন সমস্যা ধরতে সহায়ক।
সুস্থ টেস্ট সেটআপে সাধারণত বেশি ইউনিট টেস্ট (দ্রুত) এবং কম ইন্টিগ্রেশন টেস্ট (উচ্চ আত্মবিশ্বাস) থাকে।
FastAPI অ্যাপগুলোকে Starlette-এর TestClient ব্যবহার করে ইন-প্রসেসে কল করা যায়—কোন সার্ভার চালানো লাগে না।
from fastapi.testclient import TestClient
from app.main import app
client = TestClient(app)
def test_healthcheck():
r = client.get("/health")
assert r.status_code == 200
নিয়ত ডেটা ব্যবহার করুন, বাইরের সার্ভিসগুলো আলাদা করুন (মক বা টেস্ট DB), এবং টেস্টগুলোর মধ্যে শেয়ার্ড স্টেট এড়িয়ে চলুন। দ্রুত টেস্ট চালায়; ধীর টেস্ট বাদ পড়ে।
FastAPI অ্যাপ অনলাইনে তুলে দেওয়া বেশিরভাগ ক্ষেত্রেই সঠিক “রানার” বেছে নেওয়া এবং কয়েকটি প্রোডাকশন জরুরি বিষয় যোগ করা—এটাতেই নিহিত।
uvicorn main:app --reload লোকালি চালালে আপনি ডেভ সেটআপ পেয়েছেন: অটো-রিলোড, ডিটেইলি এরর, এবং কনভেনিয়েন্স অগ্রাধিকার পায়।
প্রডাকশনে সাধারণত Uvicorn reload ছাড়া চালানো হয়, প্রায়ই একটি প্রসেস ম্যানেজারের (যেমন Gunicorn + Uvicorn workers) পেছনে রাখা হয় বা রিভার্স প্রক্সির আচ্ছাদনে চালানো হয়। লক্ষ্য হলো স্থিতিশীলতা: নিয়ন্ত্রিত রিস্টার্ট, পূর্বানুমানযোগ্য পারফরম্যান্স, ও নিরাপদ ডিফল্ট।
একটি সাধারণ প্যাটার্ন:
এতে একই কোডবেস বিভিন্ন পরিবেশে এডিট না করে ডিপ্লয় করা যায়।
ডিপ্লয় করার আগে নিশ্চিত করুন:
/health মতো এন্ডপয়েন্ট মনিটরিং ও লোড ব্যালান্সারের জন্যস্থানান্তরের সময় API কনট্রাক্ট জেনারেট ও ম্যানেজ করার স্ট্যান্ডার্ড তৈরির বিষয়েও ভাবুন—কিছু টিম FastAPI-এর OpenAPI আউটপুটকে CI-তে ব্যবহার করে ক্লায়েন্ট জেনারেট করে, রিকোয়েস্ট ভ্যালিডেশন CI-বে চালায়, ইত্যাদি। Koder.ai-এর মত টুলগুলো এ ধাপে সাহায্য করতে পারে: আপনি চ্যাটে API বর্ণনা করে দ্রুত এন্ডপয়েন্ট ও মডেল প্রটোটাইপ করতে পারেন এবং পরে কোড এক্সপোর্ট করে সাধারণ রিভিউ/ডিপ্লয় পাইপলাইনে নিয়ে যেতে পারেন।
FastAPI একটি শক্তিশালী পছন্দ যখন আপনি একটি পরিচ্ছন্ন, আধুনিক উপায়ে Python-এ REST API বানাতে চান—বিশেষত যখন আপনি স্পষ্ট রিকোয়েস্ট/রেসপন্স মডেল ও পূর্বানুমানযোগ্য আচরণ চান।
FastAPI সাধারণত ভালো কাজ করে:
FastAPI সর্বসময় সবচেয়ে সহজ উত্তর নয়:
FastAPI বাস্তবে দ্রুত হতে পারে, তবে গতি নির্ভর করে আপনার ডাটাবেস কল, নেটওয়ার্ক ল্যাটেন্সি, এবং ব্যবসায়িক লজিকের ওপর। সাধারণ API ওয়ার্কলোডের জন্য আপনি ভালো থ্রুপুট ও ল্যাটেন্সি আশা করতে পারেন—কিন্তু ফ্রেমওয়ার্ককেই সবকিছু দ্রুত করতে পারবেন না; ধীর I/O বা অদক্ষ কুয়েরি ঠিক করতে হবে আপনার।
যদি FastAPI আপনার প্রয়োজনের সাথে মেলে, তাহলে রাউটিং প্যাটার্ন, Pydantic মডেল, ডাটাবেস ইন্টিগ্রেশন, ব্যাকগ্রাউন্ড টাস্ক, এবং বেসিক অথেনটিকেশন নিয়ে কাজ শুরু করুন।
প্র্যাকটিক্যাল পথে একটি ছোট এন্ডপয়েন্ট সেট বানান, পরে পুনঃব্যবহারযোগ্য ডিপেন্ডেন্সি ও টেস্ট যোগ করুন যেমনভাবে আপনার API বাড়বে। শুরুগামী স্ক্যাফোল্ডিং (রাউট, মডেল, প্রথম ডিপ্লয়মেন্ট-রেডি স্ট্রাকচার) দ্রুত করতে Koder.ai-র মতো ভিব-কোডিং ওয়ার্কফ্লো সাহায্য করতে পারে: চ্যাট থেকে একটি API আর্কিটেকচার প্রটোটাইপ করে, তারপর জেনারেটেড কোড রিভিউ করে বাস্তব প্রজেক্টে নিয়ে আসা যায়।
FastAPI হল একটি Python ওয়েব ফ্রেমওয়ার্ক যা ন্যূনতম বয়ৰাইটার (boilerplate) দিয়ে API তৈরির জন্য ব্যবহার করা হয়। আপনি endpoint ফাংশনগুলো লিখেন (যেমন @app.get("/users")) এবং FastAPI এগুলোকে রাউটিং, রিকোয়েস্ট পার্সিং, ভ্যালিডেশন এবং JSON রেসপন্স ব্যবস্থাপনা করে।
একটি প্রধান সুবিধা হলো আপনার টাইপ হিন্ট এবং Pydantic মডেলগুলোই নির্দিষ্ট করে দেয় API কী নেয় এবং কী রিটার্ন করে — অর্থাৎ একটি স্পষ্ট কনট্রাক্ট।
API হলো URL (endpoints)-এর সেট যা অন্য সফটওয়্যারকে ডেটা বিনিময় করতে দেয়।
উদাহরণস্বরূপ, একটি ক্লায়েন্ট GET /weather?city=Berlin দিয়ে আবহাওয়ার ডেটা চাইতে পারে, এবং সার্ভার কাঠামোবদ্ধ JSON দিয়ে উত্তর দেয়। ক্লায়েন্টকে ডাটাবেসে সরাসরি অ্যাক্সেস দরকার নেই—তারা কেবল API কল করে ফলাফল দেখায়।
রাউটিং হল HTTP মেথড + পাথকে পাইথন ফাংশনের সঙ্গে ম্যাপ করা।
FastAPI তে সাধারণত ডেকোরেটর ব্যবহার করা হয়:
@app.get("/items") → পড়ার (read) অপারেশন@app.post("/items") → তৈরি (create) অপারেশন@app.put("/items/{id}") → আপডেট/রিপ্লেসপাথ প্যারামিটারগুলো URL-এর অংশ এবং সাধারণত একটি নির্দিষ্ট রিসোর্স সনাক্ত করে (প্রয়োজনীয়)।
GET /users/42 → এখানে 42 হলো পাথ প্যারামিটারকোয়েরি প্যারামিটারগুলো ? এর পরে আসে এবং সাধারণত অপশনাল ফিল্টার বা কন্ট্রোলার হিসেবে ব্যবহার হয়।
Pydantic মডেলগুলো ডেটার আকার ও নিয়মগুলো (টাইপ, আবশ্যক/ঐচ্ছিক ফিল্ড, কনস্ট্রেইন্ট) নির্দিষ্ট করে। FastAPI এগুলো ব্যবহার করে:
যদি ভ্যালিডেশন ব্যর্থ হয়, FastAPI সাধারণত 422 Unprocessable Entity স্ট্যাটাস দেয় এবং কোন ফিল্ডে কী সমস্যা তা বিস্তারিতভাবে বলে।
FastAPI আপনার এন্ডপয়েন্ট, টাইপ হিন্ট, ও মডেল থেকে নিজে থেকেই OpenAPI স্কিমা জেনারেট করে।
সাধারণত আপনি পেয়ে থাকেন ইন্টারেক্টিভ ডকস:
/docs-এ/redoc-এযেহেতু স্কিমা কোড থেকেই ডেরাইভ হয়, ডকস আপনার বদল হওয়া প্যারামিটার ও মডেল অনুযায়ী আপডেট হয়।
async def ব্যবহার করুন যখন আপনার এন্ডপয়েন্ট অপেক্ষার মধ্যে বেশি সময় কাটায় (I/O): ডাটাবেস কল, বাইরের HTTP অনুরোধ, ফাইল/অবজেক্ট স্টোরেজ ইত্যাদি।
নিয়মিত def ব্যবহার করুন যখন:
একই অ্যাপেই sync ও async একসঙ্গে মেশানো খুবই সাধারণ।
ডিপেন্ডেন্সিগুলো হলো পুনঃব্যবহারযোগ্য “বিল্ডিং ব্লক” যেগুলো FastAPI Depends()ের মাধ্যমে এন্ডপয়েন্টে ইনজেক্ট করে।
সাধারণ ব্যবহারের উদাহরণ:
এগুলো পুনরাবৃত্তি কমায় এবং ক্রস-কাটিং লজিক এক জায়গায় কেন্দ্রীভূত করে।
FastAPI নিজে আপনার API-টা কিনা সুরক্ষিত সেটা ঠিক করে না—আপনি একটি স্কিম বেছে নিয়ে এন্ডপয়েন্টে প্রয়োগ করবেন।
সাধারণ প্যাটার্নগুলো:
X-API-Key)আরো কিছু মৌলিক বিষয়:
ফাস্টAPI/স্টারলেটের TestClient ব্যবহার করে আপনি অ্যাপকে ইন-প্রসেস আরেকটি ক্লায়েন্টের মতো কল করে পরীক্ষা করতে পারবেন (কোনো আলাদা সার্ভার চালানোর দরকার নেই)।
তাঁর প্রধান চেকগুলো:
ডিপ্লয়মেন্টে ASGI সার্ভার চালান (Uvicorn; প্রয়োজনে Gunicorn+Uvicorn workers), লগিং, হেলথ চেক (), টাইমআউট এবং এনভায়রনমেন্ট-কনফিগ নিশ্চিত করুন।
@app.delete("/items/{id}")এভাবে কোড থেকে সহজেই আপনার API-র সারফেস পড়ে নেওয়া যায়।
GET /users?limit=10&active=true → limit, active কোয়েরি প্যারামিটার/health