FastAPI কী? এপিআই তৈরির জন্য একটি ব্যবহারিক গাইড

FastAPI এক মিনিটে: সংক্ষিপ্ত সংজ্ঞা

FastAPI হল একটি Python ফ্রেমওয়ার্ক যা পরিষ্কার কোড ও স্বয়ংক্রিয় ডকুমেন্টেশনের সঙ্গে দ্রুত ওয়েব API তৈরিতে সহায়ক। আপনি ছোট ফাংশন (যেগুলোকে “এন্ডপয়েন্ট” বলা হয়) লিখেন যা ঘোষণা করে API কী ডেটা নেবে এবং কী রিটার্ন করবে, আর FastAPI ওয়েবের পলিসি—রাউটিং, ভ্যালিডেশন, এবং JSON রেসপন্স তৈরি—সবটি সামলায়।

API কী? একটি সহজ উদাহরণ

API হচ্ছে URL-এর একটি সেট যা একটি সফটওয়্যার আরেকটি সফটওয়্যারের সাথে কথা বলার সুযোগ দেয়।

উদাহরণস্বরূপ, আপনার ফোনের একটি আবহাওয়া অ্যাপ GET /weather?city=Berlin মতো URL কল করতে পারে। সার্ভার কাঠামোবদ্ধ ডেটা (সাধারণত JSON) দিয়ে উত্তর দেয়, যেমন তাপমাত্রা এবং পূর্বাভাস। ফোন অ্যাপকে সার্ভারের ডাটাবেসের সরাসরি অ্যাক্সেস দরকার নেই—এটা কেবল API-কে জিজ্ঞাসা করে এবং ফলাফল দেখায়।

FastAPI আপনাকে এই URLগুলো এবং রেসপন্সগুলো Python-এ তৈরি করতে সাহায্য করে।

FastAPI কার জন্য?

• শুরুতেই শিখতে চাওয়াররা যাদের আধুনিক, নির্দেশনামূলক পদ্ধতি চান বেশি বয়রাইটার না লিখে API বানাতে।
• একক ডেভেলপাররা যারা দ্রুত কাজ করতে চান এবং কোড পড়তে সহজ রাখতেও চান।
• টিম যারা প্রোডাকশন সেবাগুলো বানায়—বিশিষ্ঠ ভ্যালিডেশন, সঙ্গতিপূর্ণ কনট্রাক্ট, ও ভালো ডকস থেকে সুবিধা পায়।

আপনাকে অ্যাসিঙ্ক বিশেষজ্ঞ হতে হবে না—সরাসরি সহজ এন্ডপয়েন্ট লিখে শুরু করতে পারবেন এবং পরে উন্নত প্যাটার্নগুলো গ্রহণ করতে পারবেন।

এই গাইডে আপনি কী শিখবেন

• FastAPI-কে অন্যান্য Python API অপশন থেকে কী আলাদা করে তোলে
• রিকোয়েস্ট ও রেসপন্স কিভাবে কাজ করে (এবং “async” আসলে কী)
• Pydantic দিয়ে ডেটা ভ্যালিডেশন কিভাবে হয়
• FastAPI কীভাবে OpenAPI ডকস (Swagger UI ও ReDoc) তৈরি করে
• ডিপেন্ডেন্সি, সিকিউরিটি, টেস্ট ও ডিপ্লয়মেন্ট বেসিকসহ অ্যাপ কিভাবে স্ট্রাকচার করা যায়

কেন FastAPI জনপ্রিয় হয়েছে

FastAPI দ্রুত জনপ্রিয়তা পেয়েছে কারণ এটি Python-এ API তৈরি করার সময় যে প্রচলিত বাধাগুলো থাকে সেগুলো কমিয়ে দেয়।

এটি সাধারণ API সমস্যা গুলো মোকাবিলা করে

প্রচলিত API প্রজেক্টগুলো প্রায়ই শুরুতে ধীর সেটআপ ও অনেক প্লাম্বিং-ওয়ার্ক নিয়ে আসে:

• রিকোয়েস্ট পার্সিং, ভ্যালিডেশন এবং এরর মেসেজ ম্যানুয়ালি লিখে ব্যস্ত থাকা
• অস্পষ্ট API কনট্রাক্ট—এই এন্ডপয়েন্টটি ঠিক কী নেবে এবং কী রিটার্ন করবে?
• ডকুমেন্টেশন কোডের পিছনে থেকে যায়, বিশেষত টিম বড় হলে

FastAPI-র মূল ফিচারগুলো এই সমস্যাগুলো সরাসরি টার্গেট করে, ফলে টিমগুলো এন্ডপয়েন্ট ডিজাইনে বেশি সময় ব্যয় করে এবং ফ্রেমওয়ার্ক বয়রাইটারের সাথে কম লড়াই করে।

টাইপ হিন্ট কোডকে একটি কনট্রাক্টের মতো তৈরি করে

FastAPI ব্যাপকভাবে Python টাইপ হিন্ট ব্যবহার করে। যখন আপনি একটি ফিল্ডকে int, অপশনাল বা কোন কিছুর তালিকা হিসেবে ঘোষণা করেন, FastAPI সেই তথ্য ব্যবহার করে ইনপুট ভ্যালিডেশন এবং আউটপুট গঠন করতে।

এতে “স্ট্রিংলি-টাইপড” ভুল (যেমন কোথাও ID টেক্সট হিসেবে এবং কোথাও সংখ্যা হিসেবে ব্যবহার করা) কমে যায় এবং ফাংশন সিগনেচারে স্পষ্ট প্রত্যাশা থাকে।

স্বয়ংক্রিয় ডকস টিমকে দ্রুত চালিত করে

API স্কিমা কোড থেকে উৎপন্ন হওয়ায় FastAPI ইন্টারেক্টিভ ডকুমেন্টেশন স্বয়ংক্রিয়ভাবে তৈরি করে (OpenAPI + Swagger UI/ReDoc)। এটি সহযোগিতার জন্য গুরুত্বপূর্ণ: ফ্রন্টএন্ড ডেভেলপার, QA, ও ইন্টিগ্রেটররা এন্ডপয়েন্টগুলো ব্রাউজ করে পরীক্ষা করতে পারে এবং নির্দিষ্ট মডেলগুলো দেখতে পারে আলাদা ডকসের অপেক্ষা না করেই।

জনপ্রিয়, কিন্তু জাদুমন্ত্র নয়

FastAPI খারাপ ডিজাইন করা API ঠিক করবে না। ভাল নামকরণ, ভার্সনিং, এরর হ্যান্ডলিং, এবং সিকিউরিটি সিদ্ধান্ত আপনাকেই নিতে হবে। তবে এটি আইডিয়া থেকে ভালভাবে নির্ধারিত API-তে পৌঁছানোর পথকে পরিষ্কার করে এবং কম অপ্রত্যাশিত সমস্যা দেয়।

যে মূল ধারণাগুলো জানা দরকার

FastAPI কিছু মূল আইডিয়ার ওপর নির্মিত; এগুলো একবার বুঝলে ফ্রেমওয়ার্কটি সহজ মনে হবে। মিনিমাম অন্তর্দৃষ্টি লাগবে—প্রতিদিন ব্যবহার করা অংশগুলো চিনতে হবে।

FastAPI একটি ফ্রেমওয়ার্ক

একটি ফ্রেমওয়ার্ক হলো সরঞ্জাম ও কনভেনশনগুলোর সেট যা আপনাকে শূন্য থেকে শুরু না করে API তৈরি করতে দেয়। FastAPI সাধারণ API কাজগুলো—এন্ডপয়েন্ট ডেফাইন করা, ইনপুট পড়া, আউটপুট রিটার্ন করা, এরর হ্যান্ডেল করা, এবং কোড সংগঠিত করার জন্য প্লাম্বিং প্রদান করে।

রাউটিং: কীভাবে এন্ডপয়েন্ট ডিফাইন্ড হয়

রাউটিং হল কীভাবে আপনি একটি URL ও HTTP মেথডকে পাইথন কোডের সঙ্গে যুক্ত করবেন।

উদাহরণ: আপনি GET /users-কে “ব্যবহারকারীদের তালিকা” এবং POST /users-কে “একজন ব্যবহারকারী তৈরি” এর সাথে রাউট করতে পারেন। FastAPI-তে সাধারণত @app.get(...) ও @app.post(...) এর মতো ডেকোরেটর ব্যবহার করা হয়, যা কোন এন্ডপয়েন্ট কী অফার করে তা এক নজরে দেখতে সহজ করে।

রিকোয়েস্ট ও রেসপন্স

প্রতিটি API কল একটি রিকোয়েস্ট (ক্লায়েন্ট যা পাঠায়) এবং একটি রেসপন্স (সার্ভার যা রিটার্ন করে)।

FastAPI আপনাকে সাহায্য করে:

• পাথ (/users/{id}), কোয়েরি স্ট্রিং (?page=2), হেডার, এবং রিকোয়েস্ট বডি থেকে ডেটা পড়তে
• সঠিক স্ট্যাটাস কোড সহ কাঠামোবদ্ধ JSON রেসপন্স রিটার্ন করতে (যেমন 200, 201, 404)

ASGI (উচ্চ স্তর)

FastAPI ASGI-র উপর চলে, যা Python ওয়েব সার্ভারের একটি আধুনিক স্ট্যান্ডার্ড। বাস্তবে, এর মানে FastAPI অনেক সংযোগ দক্ষভাবে হ্যান্ডেল করতে পারে এবং দরকার হলে লং-লিভড কানেকশন (যেমন WebSockets) সাপোর্ট করতে পারে—আপনাকে নিম্নস্তরের নেটওয়ার্কিং ম্যানেজ করতে হবে না।

টাইপ হিন্ট: কেবল “ভদ্র” নয়

Python টাইপ হিন্ট (যেমন str, int, list[Item]) FastAPI-তে কেবল ডকুমেন্টেশন নয়—এগুলো মূল ইনপুট। FastAPI এগুলো ব্যবহার করে বুঝে কি ধরনের ডেটা আপনি প্রত্যাশা করছেন, ইনকামিং মানগুলোকে সঠিক টাইপে কনভার্ট করে, এবং ক্লিয়ার, পূর্বানুমানযোগ্য API তৈরি করে।

Pydantic মডেলগুলো ভ্যালিডেশনের জন্য

Pydantic মডেল আপনি এক জায়গায় ডেটার আকৃতি (ফিল্ড, টাইপ, ঐচ্ছিক ভ্যালু) নির্ধারণ করতে দেয়। FastAPI এগুলো ব্যবহার করে ইনকামিং JSON ভ্যালিডেট করে, অবৈধ ইনপুট সরিয়ে দেয় সহায়ক এরর মেসেজ দেখিয়ে, এবং আউটপুট কনসিস্টেন্টলি সিরিয়ালাইজ করে—ফলে ক্লায়েন্টদের অতিরিক্ত ময়লা ডেটা পাঠালে আপনার API আরও নির্ভরযোগ্য থাকে।

FastAPI কিভাবে রিকোয়েস্ট এবং রেসপন্স হ্যান্ডেল করে

FastAPI অ্যাপগুলো এন্ডপয়েন্ট-এর চারপাশে গড়ে উঠেছে: একটি URL পাথ এবং একটি HTTP মেথড। একটি এন্ডপয়েন্ট বলতে বুঝায় “ক্লায়েন্ট কী চাইছে” এবং “কীভাবে তারা সেটা চাইছে”। উদাহরণ: ক্লায়েন্ট GET /users করে ব্যবহারকারীর তালিকা চাইতে পারে, অথবা POST /users করে নতুন ব্যবহারকারী তৈরি করতে পারে।

এন্ডপয়েন্ট = পাথ + মেথড

পাথ হল রুট, এবং মেথড হল অ্যাকশন:

• GET /products → ডেটা ফেচ করা
• POST /products → কিছু তৈরি করতে ডেটা পাঠানো
• PUT /products/123 → কিছু প্রতিস্থাপন/আপডেট করা
• DELETE /products/123 → কিছু মুছে ফেলা

পাথ প্যারামিটার বনাম কোয়েরি প্যারামিটার

FastAPI পাথের অংশে থাকা ডেটা আলাদা করে এবং অপশনাল “ফিল্টার” হিসেবে থাকা ডেটা আলাদা করে।

• পাথ প্যারামিটার: URL স্ট্রাকচারের অংশ।
  • উদাহরণ: GET /users/42 → এখানে 42 হলো ইউজারের আইডি।
• কোয়েরি প্যারামিটার: ?-এর পরে যুক্ত হয় এবং সাধারণত অপশনাল।
  • উদাহরণ: GET /users?limit=10&active=true → limit ও active ফলাফল নিয়ন্ত্রণ করে।

JSON পে-লোডের জন্য রিকোয়েস্ট বডি

যখন ক্লায়েন্ট কাঠামোবদ্ধ ডেটা (সাধারণত JSON) পাঠায়, তা রিকোয়েস্ট বডি তে যায়, সাধারণত POST বা PUT রিকোয়েস্টে।

উদাহরণ: POST /orders JSON: { "item_id": 3, "quantity": 2 }।

রেসপন্স মডেল ও কনসিস্টেন্ট আউটপুট

FastAPI সাধারণ পাইথন অবজেক্ট (dict ইত্যাদি) রিটার্ন করতে পারে, কিন্তু এটি আরও ভালভাবে কাজ করে যখন আপনি একটি রেসপন্স মডেল ডেফাইন করেন। মডেল একটি কনট্রাক্ট হিসেবে কাজ করে: ফিল্ডগুলো কনসিস্টেন্ট থাকে, অতিরিক্ত ডেটা ফিল্টার করা যায়, এবং টাইপগুলো এনফোর্স করা যায়। ফলস্বরূপ ক্লায়েন্টরা জানে কী আশা করবে এবং ইন্টিগ্রেশন ফাটতে কম ঝুঁকি থাকে।

FastAPI-তে Async: কী এবং কখন সাহায্য করে

“Async” (asynchronous) হলো একটি উপায় আপনার API-কে অনেক রিকোয়েস্ট দক্ষভাবে হ্যান্ডেল করার—বিশেষত যখন অনেক সময় অপেক্ষা হয়।

একটি দৈনন্দিন উপমা: I/O অপেক্ষা

ধরা যাক একটি ব্যারিস্টা অর্ডার নিচ্ছে। যদি তাকে ইস্প্রেসো মেশিন চলার সময় কিছুই না করে দাঁড়িয়ে থাকতে হয়, তিনি কম কাস্টমার সার্ভ করতে পারবেন। ভালো পদ্ধতি হলো: কফি শুরু কর, তারপর পরের অর্ডার নাও যখন মেশিন কাজ করছে।

Async ঠিক তেমনি কাজ করে। আপনার FastAPI অ্যাপ একটি অপারেশন শুরু করতে পারে যা ধীর—যেমন নেটওয়ার্ক অনুরোধ বা ডিবি কলে অপেক্ষা করে—আর অপেক্ষার সময় এটি অন্য ইনকামিং রিকোয়েস্ট সামলায়।

কখন async সবচেয়ে কার্যকর

Async তখনই ভালো যখন আপনার API অনেক I/O করে—অর্থাৎ বেশি সময় অপেক্ষায় কাটে, কম “চিন্তা” করতে হয়। সাধারণ উদাহরণ:

• ডাটাবেসে কল করা (বিশেষত নেটওয়ার্কের উপর)
• বাইরের সার্ভিস কল করা (পেমেন্ট, ম্যাপ, ইমেইল API)
• ফাইল পড়া/লেখা বা অবজেক্ট স্টোরেজে কথা বলা

এই ক্ষেত্রে async থ্রুপুট বাড়ায় এবং রিকোয়েস্ট জমে যাওয়ার সম্ভাবনা কমায়।

কখন async ততটা জরুরি নয়

Async সবকিছু দ্রুত করে না। যদি আপনার এন্ডপয়েন্ট CPU-ভিত্তিক কাজ করে—যেমন বড় ইমেজ রিসাইজ, ডেটা সায়েন্স গণনা, বা বড় পে-লোড এনক্রিপশন—তখন async সেই কম্পিউটেশনকে দ্রুত করবে না। এসব ক্ষেত্রে পটভূমি ওয়ার্কার, প্রসেস পুল, বা আউটসকেলিং দরকার।

ভাল খবর: sync কোড এখনও কাজ করে

FastAPI-তে সবকিছু পুনরায় লিখতে হবে না। আপনি সাধারণ (sync) রুট ফাংশন লিখতে পারেন এবং FastAPI সেগুলো ঠিকমত চালাবে। অনেক প্রজেক্ট মিশ্র স্টাইল ব্যবহার করে: সহজ এন্ডপয়েন্ট sync রাখে, যেখানে স্পষ্টভাবে উপকারী সেখানে async def ব্যবহার করে (সাধারণত ডাটাবেস বা বাইরের HTTP কল চৌকশ ক্ষেত্রে)।

Pydantic দিয়ে ডেটা ভ্যালিডেশন ও সিরিয়ালাইজেশন

ভ্যালিডেশন হচ্ছে বাইরের জগত এবং আপনার কোডের মধ্যকার চেকপয়েন্ট। যখন API ইনপুট নেয় (JSON বডি, কোয়েরি প্যারাম, পাথ প্যারাম), আপনি চান তা সম্পূর্ণ, সঠিক টাইপের, এবং বৈধ সীমার মধ্যে—এটা ডাটাবেসে লেখার, অন্য সার্ভিস কল করার, বা ব্যবসায়িক লজিক ট্রিগার করার আগে।

FastAPI Pydantic মডেলের ওপর নির্ভর করে। একবার আপনি কি “ভালো ডেটা” তা বর্ণনা করলে, FastAPI স্বয়ংক্রিয়ভাবে:

• খারাপ ইনপুট তাড়াতাড়ি প্রত্যাখ্যান করে
• সম্ভব হলে টাইপ কভার্ট করে (উদাহরণ: "42" → ইন্টিজার)
• ধারাবাহিক JSON রেসপন্স দেয় (সিরিয়ালাইজেশন)

খারাপ ইনপুট দ্রুত ধরা (পরিষ্কার এরর সহ)

যদি ক্লায়েন্ট ভুল আকৃতির ডেটা পাঠায়, 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 একটি বৈধ ইমেল আকার নিশ্চিত করে।

সিরিয়ালাইজেশন: পরিষ্কার, পূর্বানুমানযোগ্য JSON রিটার্ন করা

একই মডেলগুলো আউটপুট গঠন করতেও ব্যবহার করা যায়, যাতে আপনার রেসপন্স অনেকাংশে অভ্যন্তরীণ ফিল্ড লিক না করে। আপনি পাইথন অবজেক্ট রিটার্ন করেন; FastAPI (Pydantic-এর মাধ্যমে) সেগুলোকে সঠিক ফিল্ড নাম ও টাইপ সহ JSON-এ রূপান্তর করে।

স্বয়ংক্রিয় API ডকস: OpenAPI, Swagger UI, ReDoc

FastAPI-র সবচেয়ে ব্যবহারিক বৈশিষ্ট্যগুলোর একটি হলো এটি স্বয়ংক্রিয়ভাবে আপনার লিখে রাখা কোড থেকে API ডকুমেন্টেশন জেনারেট করে।

OpenAPI: মেশিন-পড়ার যোগ্য API কনট্রাক্ট

OpenAPI হলো একটি স্ট্যান্ডার্ড কিভাবে একটি API স্ট্রাকচারালি বর্ণনা করা যায় (সাধারণত JSON)। এটিকে একটি “কনট্রাক্ট” হিসেবে ভাবুন যা বলে:

• কোন এন্ডপয়েন্ট আছে (যেমন GET /users/{id})
• কোন প্যারামিটার নেয়
• রিকোয়েস্ট বডি কেমন হওয়া উচিত
• কী রেসপন্স ও এরর ফরম্যাট প্রত্যাশা করা যায়

মেশিন-পঠিত হওয়ায় টুলগুলো এটাকে ব্যবহার করে ক্লায়েন্ট জেনারেট করা, রিকোয়েস্ট যাচাই করা, এবং টিমর মধ্যে সমন্বয় করা সহজ হয়।

Swagger UI ও ReDoc: ব্রাউজারে ইন্টারেক্টিভ ডকস

FastAPI স্বয়ংক্রিয়ভাবে দুইটি মানব-পাঠ্য ডকস পেজ সরবরাহ করে:

• Swagger UI (ইন্টারেক্টিভ): ব্রাউজারে সরাসরি এন্ডপয়েন্ট ট্রাই করা যায়, প্যারামিটার ভরা যায়, রিকোয়েস্ট পাঠানো যায় এবং রেসপন্স দেখা যায়।
• ReDoc (রিডেবল): একটি পরিষ্কার রেফারেন্স-স্টাইল ডক পেজ।

সাধারণত FastAPI প্রজেক্টে এগুলো দেখা যায়:

• /docs (Swagger UI)
• /redoc (ReDoc)

ডকস যা কোডের সঙ্গে সিঙ্কে থাকে

আপনি যখন পাথ প্যারামিটার, রিকোয়েস্ট মডেল, রেসপন্স মডেল বা ভ্যালিডেশন ঘরানায় পরিবর্তন করবেন, OpenAPI স্কিমা (এবং ডকস পেজগুলো) স্বয়ংক্রিয়ভাবে আপডেট হয়। আলাদা করে ডকস মেন্টেন করার দরকার পড়ে না।

কেন এটা ফ্রন্টএন্ড ও QA কাজকে দ্রুত করে

• ফ্রন্টএন্ড ডেভেলপার সহজেই এন্ডপয়েন্টগুলো এক্সপ্লোর করে প্রয়োজনীয় ফিল্ড বুঝতে পারে।
• QA দ্রুত এজ কেস টেস্ট করতে পারে (মিসিং ফিল্ড, ভুল টাইপ) এবং সঠিক এরর রেসপন্স দেখতে পারে।
• সবাই একই সুত্র থেকে তথ্য পায়: রানিং API এবং তার OpenAPI কনট্রাক্ট।

আপনার প্রথম FastAPI অ্যাপ (ধারণাগত হেঁটে দেখা)

একটি FastAPI অ্যাপ খুবই ছোট হলেও “রিয়েল” অনুভব দিতে পারে। আপনি একটি পাইথন অবজেক্ট app ডিফাইন করেন, কয়েকটি রুট যোগ করেন, এবং লোকালি সার্ভার চালিয়ে ব্রাউজারে চেষ্টা করেন।

1) একটি ন্যূনতম “হেলো” এন্ডপয়েন্ট

নিচে সবচেয়ে ছোট কাজের উদাহরণ:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello, FastAPI"}

এটাই: এক রুট (GET /) যা JSON রিটার্ন করে।

2) সহজ create/read আইটেম এন্ডপয়েন্ট (ইন-মেমোরি)

কাজটি আরও 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 দিয়ে তালিকা আনা

3) সাধারণ ছোট প্রজেক্ট লেআউট

একটি সাধারণ স্টার্টার স্ট্রাকচার হলো:

• main.py (যেখানে app ও রুট থাকে)
• requirements.txt বা pyproject.toml (ডিপেন্ডেন্সি)

4) লোকালি চালানো (ধারণাগতভাবে)

সাধারণত আপনি:

1. ডিপেন্ডেন্সি ইন্সটল করবেন (FastAPI + একটি ASGI সার্ভার যেমন Uvicorn)
2. ডেভ সার্ভার চালাবেন (উদাহরণ: uvicorn main:app --reload)
3. 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 ডিপেন্ডেন্সি সিস্টেমের মাধ্যমে সাধারণ সিকিউরিটি প্যাটার্নগুলো সহজে ইমপ্লিমেন্ট করা যায়।

অথেনটিকেশন বনাম অথোরাইজেশন

অথেনটিকেশন উত্তর দেয়: “আপনি কে?” অথোরাইজেশন উত্তর দেয়: “আপনি কী করতে পারবেন?”

উদাহরণ: একজন ইউজার অথেনটিকেটেড হতে পারে (বৈধ লগইন/টোকেন) কিন্তু একটি অ্যাডমিন-নির্দিষ্ট রুটে অথোরাইজড নাও থাকতে পারে।

সাধারণ অথেনটিকেশন পদ্ধতি (উচ্চ স্তর)

• API কী: সার্ভিস-টু-সার্ভিসের জন্য সহজ। সাধারণত হেডারে পাঠানো হয় (যেমন X-API-Key)। রোটেশন ও রিভোকেশন ম্যানেজ করুন।
• OAuth2: ডেলিগেটেড অ্যাক্সেসের স্ট্যান্ডার্ড; “Sign in with …” বা আলাদা অথ সার্ভিসের জন্য সাধারণ।
• JWT (JSON Web Tokens): বেয়ারার টোকেন হিসেবে ব্যবহৃত হয়; স্টেটলেস API-র জন্য সুবিধাজনক, তবে এক্সপায়ারি, সাইনিং কী ও রিভোকেশন কৌশল ম্যানেজ করতে হবে।

FastAPI এগুলোকে fastapi.security মতো ইউটিলিটিজ দিয়ে সাপোর্ট করে এবং OpenAPI-এ পরিষ্কারভাবে ডক করে।

পাসওয়ার্ড হ্যান্ডলিং বেসিক

যদি আপনি ইউজার পাসওয়ার্ড স্টোর করেন, কখনও প্লেইনটেক্সটে স্টোর করবেন না। সল্টেড, স্লো হ্যাশ ব্যবহার করুন (উদাহরণ: bcrypt/argon2) এবং রেট লিমিটিং ও অ্যাকাউন্ট লকআউট নীতিগুলো বিবেচনা করুন।

সতর্ক নোট

নিরাপত্তা হলো বিশদ বিষয়: টোকেন সংরক্ষণ, CORS সেটিংস, HTTPS, সিক্রেট ম্যানেজমেন্ট, এবং প্রতিটি সংবেদনশীল এন্ডপয়েন্টে সঠিক অথোরাইজেশন চেক করা ইত্যাদি। বিল্ট-ইন হেল্পারগুলো একটি শুরু; প্রোডাকশনে ভরসা করার আগে রিভিউ ও টেস্ট করুন।

FastAPI অ্যাপের টেস্টিং

টেস্টিং হলো যেখানে FastAPI-র “আমাদের মেশিনে কাজ করে” প্রতিশ্রুতি আপনাকে প্রোডাকশনে আত্মবিশ্বাস দেয়। ভাল খবর: FastAPI Starlette-এর উপর নির্মিত, তাই শক্তিশালী টেস্টিং টুলস অনেক কম সেটআপে পাওয়া যায়।

ইউনিট টেস্ট বনাম ইন্টিগ্রেশন টেস্ট

ইউনিট টেস্ট ছোট অংশগুলো টেস্ট করে: একটি ফাংশন গণনা ঠিক করছে কিনা, একটি ডিপেন্ডেন্সি সঠিকভাবে বর্তমান ইউজার লোড করছে কিনা, অথবা একটি সার্ভিস মেথড ডাটাবেসে কথা বলছে কিনা (এখানে সাধারণত মক করা হয়)।

ইন্টিগ্রেশন টেস্ট এন্ড-টু-এন্ড API কল করে পুরো HTTP রেসপন্স যাচাই করে। এগুলো রাউটিং ভুল, ডিপেন্ডেন্সি ও ভ্যালিডেশন সমস্যা ধরতে সহায়ক।

সুস্থ টেস্ট সেটআপে সাধারণত বেশি ইউনিট টেস্ট (দ্রুত) এবং কম ইন্টিগ্রেশন টেস্ট (উচ্চ আত্মবিশ্বাস) থাকে।

TestClient ধারণা

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

কি কি টেস্ট করবেন (প্র্যাকটিক্যাল চেকলিস্ট)

• স্ট্যাটাস কোড (200 বনাম 201 বনাম 404 বনাম 422)
• ভ্যালিডেশন এরর (মিসিং ফিল্ড, ভুল টাইপ, অতিরিক্ত ফিল্ড)
• রেসপন্স শেইপ (কি কি কী আছে, টাইপ সঠিক, খালি লিস্ট সঠিকভাবে হ্যান্ডেল হয়েছে)
• এজ কেস (জিরো রেজাল্ট, বড় ইনপুট, বাউন্ডারি ডেট)
• অথ কেস (টোকেন নেই, এক্সপায়ার্ড টোকেন, পর্যাপ্ত রোল নেই)

টেস্টগুলো দ্রুত ও পুনরাবৃত্তিযোগ্য রাখুন

নিয়ত ডেটা ব্যবহার করুন, বাইরের সার্ভিসগুলো আলাদা করুন (মক বা টেস্ট DB), এবং টেস্টগুলোর মধ্যে শেয়ার্ড স্টেট এড়িয়ে চলুন। দ্রুত টেস্ট চালায়; ধীর টেস্ট বাদ পড়ে।

FastAPI ডিপ্লয়মেন্ট: ব্যবহারিক অপশন ও চেকলিস্ট

FastAPI অ্যাপ অনলাইনে তুলে দেওয়া বেশিরভাগ ক্ষেত্রেই সঠিক “রানার” বেছে নেওয়া এবং কয়েকটি প্রোডাকশন জরুরি বিষয় যোগ করা—এটাতেই নিহিত।

ডেভেলপমেন্ট বনাম প্রডাকশনের সার্ভার

uvicorn main:app --reload লোকালি চালালে আপনি ডেভ সেটআপ পেয়েছেন: অটো-রিলোড, ডিটেইলি এরর, এবং কনভেনিয়েন্স অগ্রাধিকার পায়।

প্রডাকশনে সাধারণত Uvicorn reload ছাড়া চালানো হয়, প্রায়ই একটি প্রসেস ম্যানেজারের (যেমন Gunicorn + Uvicorn workers) পেছনে রাখা হয় বা রিভার্স প্রক্সির আচ্ছাদনে চালানো হয়। লক্ষ্য হলো স্থিতিশীলতা: নিয়ন্ত্রিত রিস্টার্ট, পূর্বানুমানযোগ্য পারফরম্যান্স, ও নিরাপদ ডিফল্ট।

পরিবেশ ভেরিয়েবল দিয়ে কনফিগারেশন

একটি সাধারণ প্যাটার্ন:

• সিক্রেট ও পরিবেশ-নির্ভর মান (ডাটাবেস URL, API কী, allowed origins) এনভায়রনমেন্ট ভেরিয়েবল হিসেবে রাখুন।
• লোকাল ব্যবহারের জন্য কোডে যুক্তসামান্য ডিফল্ট রাখুন।
• স্টার্টআপে সেটিংস লোড ও ভ্যালিডেট করুন (সাধারণত Pydantic settings ব্যবহার করে)।

এতে একই কোডবেস বিভিন্ন পরিবেশে এডিট না করে ডিপ্লয় করা যায়।

সাধারণ ডিপ্লয় টার্গেট (সংক্ষেপে)

• কন্টেইনার (Docker/Kubernetes): পুনরাবৃত্তি যোগ্য বিল্ড ও স্কেলিংয়ের জন্য জনপ্রিয়।
• ভার্চুয়াল মেশিন: সরল ও নমনীয়; নিজের সার্ভার ম্যানেজ করলে ভাল।
• সার্ভারলেস: ছোট API-র জন্য কাজ করে; কোল্ড স্টার্ট ও প্ল্যাটফর্ম সীমা খেয়াল রাখুন।

ব্যবহারিক ডিপ্লয় চেকলিস্ট

ডিপ্লয় করার আগে নিশ্চিত করুন:

• লগিং: স্ট্রাকচারড লগ, রিকোয়েস্ট আইডি (প্রয়োজনে) এবং পরিবেশভিত্তিক লগ লেভেল
• হেলথ চেক: /health মতো এন্ডপয়েন্ট মনিটরিং ও লোড ব্যালান্সারের জন্য
• এরর হ্যান্ডলিং: ধারাবাহিক JSON এরর রেসপন্স; ইউজারদের সামনে স্ট্যাক ট্রেস দেখাবেন না
• টাইমআউট ও লিমিট: রিকোয়েস্ট বডি সাইজ, ওয়ার্কার টাইমআউট, রেট লিমিটিং
• ডকস পলিসি: Swagger UI/ReDoc পাবলিক করা হবে নাকি সীমাবদ্ধ রাখা হবে

স্থানান্তরের সময় API কনট্রাক্ট জেনারেট ও ম্যানেজ করার স্ট্যান্ডার্ড তৈরির বিষয়েও ভাবুন—কিছু টিম FastAPI-এর OpenAPI আউটপুটকে CI-তে ব্যবহার করে ক্লায়েন্ট জেনারেট করে, রিকোয়েস্ট ভ্যালিডেশন CI-বে চালায়, ইত্যাদি। Koder.ai-এর মত টুলগুলো এ ধাপে সাহায্য করতে পারে: আপনি চ্যাটে API বর্ণনা করে দ্রুত এন্ডপয়েন্ট ও মডেল প্রটোটাইপ করতে পারেন এবং পরে কোড এক্সপোর্ট করে সাধারণ রিভিউ/ডিপ্লয় পাইপলাইনে নিয়ে যেতে পারেন।

কখন FastAPI ব্যবহার করবেন (এবং কখন না)

FastAPI একটি শক্তিশালী পছন্দ যখন আপনি একটি পরিচ্ছন্ন, আধুনিক উপায়ে Python-এ REST API বানাতে চান—বিশেষত যখন আপনি স্পষ্ট রিকোয়েস্ট/রেসপন্স মডেল ও পূর্বানুমানযোগ্য আচরণ চান।

উপযুক্ত ব্যবহার ক্ষেত্র

FastAPI সাধারণত ভালো কাজ করে:

• অভ্যন্তরীণ সার্ভিস যেখানে টিম দ্রুত ইটারেট করে, পাঠযোগ্য এন্ডপয়েন্ট ও সার্ভিস-টু-সার্ভিস কনট্রাক্ট দরকার
• পাবলিক API যেখানে কড়া ইনপুট ভ্যালিডেশন ও ধারাবাহিক এরর হ্যান্ডলিং দরকার
• মাইক্রোসার্ভিস যেখানে ছোট, ফোকাসড API আলাদাভাবে ডেপ্লয় করা হয়
• প্রোটোটাইপ ও MVP যেখানে দ্রুত অগ্রসর হতে চান কিন্তু স্ট্রাকচারও রাখতে চান (ভ্যালিডেশন + ডকস)

কখন অন্য টুল ভাল হতে পারে

FastAPI সর্বসময় সবচেয়ে সহজ উত্তর নয়:

• যদি আপনি একটি ওয়ান-অফ স্ক্রিপ্ট লিখছেন বা একটি ছোট webhook হ্যান্ডলার দরকার, কোনো হালকা জিনিস (বা প্লেইন পাইথন) যথেষ্ট হতে পারে।
• যদি আপনার প্রজেক্টে সম্পূর্ণ Django “batteries included” স্ট্যাক দরকার (ORM কনভেনশন, অ্যাডমিন, টেমপ্লেটিং, ব্যাপক ইকোসিস্টেম), তখন Django বা Django REST Framework সিদ্ধান্তগুলো কম কাজ বাড়াতে পারে।

পারফরম্যান্স সম্পর্কে বাস্তবিক কথা

FastAPI বাস্তবে দ্রুত হতে পারে, তবে গতি নির্ভর করে আপনার ডাটাবেস কল, নেটওয়ার্ক ল্যাটেন্সি, এবং ব্যবসায়িক লজিকের ওপর। সাধারণ API ওয়ার্কলোডের জন্য আপনি ভালো থ্রুপুট ও ল্যাটেন্সি আশা করতে পারেন—কিন্তু ফ্রেমওয়ার্ককেই সবকিছু দ্রুত করতে পারবেন না; ধীর I/O বা অদক্ষ কুয়েরি ঠিক করতে হবে আপনার।

পরবর্তী ধাপ

যদি FastAPI আপনার প্রয়োজনের সাথে মেলে, তাহলে রাউটিং প্যাটার্ন, Pydantic মডেল, ডাটাবেস ইন্টিগ্রেশন, ব্যাকগ্রাউন্ড টাস্ক, এবং বেসিক অথেনটিকেশন নিয়ে কাজ শুরু করুন।

প্র্যাকটিক্যাল পথে একটি ছোট এন্ডপয়েন্ট সেট বানান, পরে পুনঃব্যবহারযোগ্য ডিপেন্ডেন্সি ও টেস্ট যোগ করুন যেমনভাবে আপনার API বাড়বে। শুরুগামী স্ক্যাফোল্ডিং (রাউট, মডেল, প্রথম ডিপ্লয়মেন্ট-রেডি স্ট্রাকচার) দ্রুত করতে Koder.ai-র মতো ভিব-কোডিং ওয়ার্কফ্লো সাহায্য করতে পারে: চ্যাট থেকে একটি API আর্কিটেকচার প্রটোটাইপ করে, তারপর জেনারেটেড কোড রিভিউ করে বাস্তব প্রজেক্টে নিয়ে আসা যায়।