BackgroundTasks के साथ हल्का ऑफलोडिंग
प्रतिक्रिया को अवरुद्ध किए बिना तुरंत लौटने वाले पार्श्व प्रभावों के लिए FastAPI के अंतर्निहित BackgroundTasks का उपयोग कीजिए।
BackgroundTasks के साथ हल्का ऑफलोडिंग, CoddyKit पर FastAPI बैकएंड डेवलपमेंट बूटकैंप का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह FastAPI बैकएंड डेवलपमेंट बूटकैंप सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
काम को अलग प्रक्रिया में क्यों भेजें
जब कोई क्लाइंट अनुरोध भेजता है, तो वह प्रतिक्रिया की प्रतीक्षा करता है। यदि आपका एंडपॉइंट स्वागत ईमेल भेजता है, ऑडिट लॉग लिखता है या कैश को पहले से तैयार करता है, तो उपयोगकर्ता ऐसे काम के लिए प्रतीक्षा करता रहता है जिसकी उसे परवाह नहीं है।
प्रतिक्रिया के बाद किए जाने वाले प्रभाव वे कार्य हैं जो प्रतिक्रिया भेजे जाने के बाद चलने चाहिए और उसे रोकना नहीं चाहिए:
- सूचना वाले ईमेल भेजना
- विश्लेषण या ऑडिट लॉग लिखना
- कैश को अमान्य करना या पहले से तैयार करना
- अस्थायी फ़ाइलों को साफ़ करना
FastAPI में इसी काम के लिए एक अंतर्निर्मित उपकरण उपलब्ध है: BackgroundTasks।
BackgroundTasks घोषित करना
इसका उपयोग करने के लिए अपने पाथ ऑपरेशन फ़ंक्शन में BackgroundTasks प्रकार का एक पैरामीटर जोड़ें। FastAPI प्रकार की व्याख्या देखकर आपके लिए इसका एक इंस्टेंस इंजेक्ट कर देता है, ठीक किसी अन्य निर्भरता की तरह।
इसके बाद .add_task(func, *args, **kwargs) के साथ काम पंजीकृत करें। फ़ंक्शन तुरंत नहीं बुलाया जाता; प्रतिक्रिया लौटाए जाने के बाद चलाने के लिए उसे कतार में रखा जाता है।
from fastapi import BackgroundTasks, FastAPI
app = FastAPI()
def write_log(message: str) -> None:
with open("log.txt", mode="a") as f:
f.write(message + "\n")
@app.post("/signup")
async def signup(email: str, tasks: BackgroundTasks):
tasks.add_task(write_log, f"signup: {email}")
return {"status": "accepted"}निष्पादन क्रम
महत्वपूर्ण बात यह है: बैकग्राउंड कार्य क्लाइंट को प्रतिक्रिया भेजे जाने के बाद चलते हैं, लेकिन उसी सर्वर प्रक्रिया के भीतर।
- एंडपॉइंट अपना
dictयाResponseलौटाता है। - FastAPI नेटवर्क के माध्यम से प्रतिक्रिया भेज देता है।
- इसके बाद ही वह कतार में रखे गए हर कार्य को उसी क्रम में चलाता है, जिस क्रम में वे जोड़े गए थे।
इसलिए उपयोगकर्ता को तुरंत 202-शैली की प्रतिक्रिया मिल जाती है, जबकि ईमेल या लॉग पर्दे के पीछे चलता रहता है।
किसी कार्य को तर्क पास करना
add_task को दिए गए तर्क संग्रहीत किए जाते हैं और कार्य चलने पर उन्हें आगे भेज दिया जाता है। स्थितिगत और नामित, दोनों प्रकार के तर्क काम करते हैं।
यह पैटर्न प्रभाव से जुड़े तर्क को एक साधारण फ़ंक्शन में रखता है, जिसकी अलग से इकाई जाँच आसानी से की जा सकती है और जो FastAPI से पूरी तरह स्वतंत्र रहता है।
from fastapi import BackgroundTasks, FastAPI
app = FastAPI()
def send_email(to: str, subject: str, body: str) -> None:
# imagine an SMTP client here
print(f"Sending to {to}: {subject}")
@app.post("/orders")
async def create_order(email: str, tasks: BackgroundTasks):
order_id = 1234
tasks.add_task(
send_email,
to=email,
subject="Order confirmed",
body=f"Your order {order_id} is on the way!",
)
return {"order_id": order_id}समकालिक बनाम अतुल्यकालिक कार्य फ़ंक्शन
कार्य फ़ंक्शन सामान्य def या async def, दोनों में से कोई भी हो सकता है।
- async कार्य का सीधे इवेंट लूप पर इंतज़ार किया जाता है।
- सामान्य regular
defकार्य को थ्रेड पूल में चलाया जाता है, ताकि वह लूप को अवरुद्ध न करे।
सामान्य नियम: यदि आपका प्रभाव डालने वाला काम अवरोधकारी I/O करता है (फ़ाइल लिखना, समकालिक DB ड्राइवर), तो साधारण def पर्याप्त है; FastAPI उसे थ्रेड में भेज देता है। async def का उपयोग तभी करें जब आप वास्तव में अतुल्यकालिक I/O का इंतज़ार करते हों।
async def notify_async(user_id: int) -> None:
# awaits an async HTTP client, for example
await some_async_push(user_id)
def notify_sync(user_id: int) -> None:
# blocking call, run in a threadpool by FastAPI
requests_post(user_id)कई कार्य जोड़ना
आप add_task को जितनी बार चाहें कॉल कर सकते हैं। कार्य जोड़े गए सटीक क्रम में एक-एक करके चलते हैं और अगले कार्य के शुरू होने से पहले वर्तमान कार्य पूरा होता है।
क्योंकि वे एक के बाद एक चलते हैं, इसलिए धीमा कार्य उसके पीछे कतार में रखे कार्यों को देर कर देता है, लेकिन HTTP प्रतिक्रिया को कभी देर नहीं करता।
from fastapi import BackgroundTasks, FastAPI
app = FastAPI()
@app.post("/publish")
async def publish(post_id: int, tasks: BackgroundTasks):
tasks.add_task(reindex_search, post_id)
tasks.add_task(invalidate_cache, post_id)
tasks.add_task(notify_followers, post_id)
return {"published": post_id}निर्भरताओं में BackgroundTasks का उपयोग करना
एक उपयोगी तरकीब यह है कि निर्भरता भी BackgroundTasks पैरामीटर घोषित करके कार्य कतार में रख सकती है। FastAPI उस अनुरोध के लिए सब कुछ एक साझा कार्य-समूह में मिला देता है।
इससे ऑडिट लॉग जैसे सभी हिस्सों में लागू होने वाले सरोकार हर एंडपॉइंट में बार-बार लिखने के बजाय दोबारा उपयोग योग्य निर्भरता में रखे जा सकते हैं।
from fastapi import BackgroundTasks, Depends, FastAPI
app = FastAPI()
def audit(action: str, tasks: BackgroundTasks):
tasks.add_task(write_audit_row, action)
return action
@app.delete("/items/{item_id}")
async def delete_item(item_id: int, action=Depends(audit)):
return {"deleted": item_id}साधारण Python कार्य कतार का मानसिक मॉडल
अंदर से देखें तो BackgroundTasks प्रतिक्रिया के बाद चलाए जाने वाले कॉल करने योग्य फ़ंक्शनों की सूची से थोड़ा ही अधिक है। अवधारणा समझने के लिए आप इसे शुद्ध Python में मॉडल कर सकते हैं।
नीचे दिया गया कोड-खंड स्वतंत्र है, इसमें FastAPI की आवश्यकता नहीं है और यह पहले जोड़ने, फिर बाद में चलाने का पैटर्न दिखाता है।
class TaskList:
def __init__(self):
self.tasks = []
def add_task(self, func, *args, **kwargs):
self.tasks.append((func, args, kwargs))
def run_all(self):
for func, args, kwargs in self.tasks:
func(*args, **kwargs)
def log(msg):
print("LOG:", msg)
q = TaskList()
q.add_task(log, "user signed up")
q.add_task(log, "email queued")
print("response sent")
q.run_all()कार्यों के भीतर त्रुटि प्रबंधन
क्योंकि कोई कार्य प्रतिक्रिया के बाद चलता है, इसलिए उसकी विफलता को HTTP त्रुटि में नहीं बदला जा सकता; क्लाइंट को 200 पहले ही मिल चुका होता है।
बैकग्राउंड कार्य में बिना संभाली गई अपवाद को सर्वर लॉग करता है, लेकिन क्लाइंट उसे नहीं देख पाता। जोखिम वाले काम को हमेशा try/except में रखें और पुनः प्रयास या विफल-कार्य रणनीति का निर्णय स्वयं लें।
def send_receipt(order_id: int) -> None:
try:
deliver_email(order_id)
except Exception as exc:
# the client already has its 200, so log and recover here
logger.exception("receipt failed for %s: %s", order_id, exc)
schedule_retry(order_id)सबसे बड़ी सीमा: वही प्रक्रिया
BackgroundTasks आपके ऐप्लिकेशन के उसी वर्कर प्रक्रिया में चलता है। इससे कुछ वास्तविक सीमाएँ आती हैं:
- भारी CPU कार्य अभी भी उस वर्कर के संसाधनों का उपयोग करता है।
- यदि प्रक्रिया क्रैश हो जाती है या उसे फिर से परिनियोजित किया जाता है, तो कतार में रखे कार्य खो जाते हैं; कोई स्थायित्व नहीं होता।
- कार्य कई मशीनों के बीच टिके नहीं रहते और क्षैतिज रूप से स्केल नहीं होते।
यह हल्के, सर्वोत्तम-प्रयास वाले प्रभावों के लिए बहुत अच्छा है, लेकिन विश्वसनीय, लंबे समय तक चलने वाले या वितरित कार्यों के लिए नहीं।
Celery का उपयोग कब करें
जब काम छोटा, गैर-महत्वपूर्ण हो और क्रैश होने पर उसके खो जाने को स्वीकार किया जा सके — जैसे ईमेल भेजना, काउंटर बढ़ाना या अस्थायी फ़ाइल हटाना — तब BackgroundTasks चुनें।
जब आपको निम्न सुविधाएँ चाहिए हों, तब सेलेरी या किसी अन्य वितरित कतार (RQ, Dramatiq, Arq) का उपयोग करें:
- स्थायित्व — Redis/RabbitMQ जैसे ब्रोकर के माध्यम से कार्य पुनः आरंभ होने के बाद भी सुरक्षित रहें।
- पुनः प्रयास, समय-निर्धारण और दर सीमित करना।
- समर्पित वर्कर मशीनों के बीच क्षैतिज स्केलिंग।
- भारी CPU कार्य, जो अन्यथा आपके वेब वर्करों को काम से भर देते।
त्वरित जाँच
यह जाँचें कि आप समझते हैं कि BackgroundTasks का उपयोग कब सही उपकरण है।
पुनरावलोकन
मुख्य बातें:
BackgroundTasksपैरामीटर जोड़ें और साइड इफ़ेक्ट को बाद में चलाने के लिएadd_task(func, *args, **kwargs)कॉल करें।- कार्य प्रतिक्रिया भेजे जाने के बाद, उसी worker प्रक्रिया में क्रमिक रूप से चलते हैं।
- सिंक्रोनस
defकार्य थ्रेड पूल में चलते हैं;async defकार्य इवेंट लूप पर चलते हैं। - निर्भरताएँ भी कार्यों को कतार में डाल सकती हैं, जो ऑडिटिंग जैसी विभिन्न हिस्सों में लागू होने वाली चिंताओं के लिए उपयोगी है।
- कोई स्थायित्व नहीं होता: विफलताएँ क्लाइंट को दिखाई नहीं देतीं और प्रक्रिया समाप्त होने पर कार्य भी समाप्त हो जाते हैं।
- इसे हल्के, सर्वोत्तम-प्रयास वाले कार्यों के लिए उपयोग करें; स्थायी, पुनःप्रयास योग्य, वितरित या CPU-प्रधान कार्यों के लिए Celery चुनें।
एआई शिक्षक के साथ FastAPI बैकएंड डेवलपमेंट बूटकैंप सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 21
- पाठ
- 84
अक्सर पूछे जाने वाले प्रश्न
क्या “BackgroundTasks के साथ हल्का ऑफलोडिंग” पाठ निःशुल्क है?
हाँ — FastAPI बैकएंड डेवलपमेंट बूटकैंप अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “BackgroundTasks के साथ हल्का ऑफलोडिंग” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“BackgroundTasks के साथ हल्का ऑफलोडिंग” में मैं क्या सीखूँगा?
प्रतिक्रिया को अवरुद्ध किए बिना तुरंत लौटने वाले पार्श्व प्रभावों के लिए FastAPI के अंतर्निहित BackgroundTasks का उपयोग कीजिए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ FastAPI बैकएंड डेवलपमेंट बूटकैंप का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या FastAPI बैकएंड डेवलपमेंट बूटकैंप शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर FastAPI बैकएंड डेवलपमेंट बूटकैंप शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“BackgroundTasks के साथ हल्का ऑफलोडिंग” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर FastAPI बैकएंड डेवलपमेंट बूटकैंप पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- BackgroundTasks के साथ हल्का ऑफलोडिंग
- Celery वर्करों को FastAPI ऐप से जोड़ना
- पुनःप्रयास, इडेम्पोटेंसी और डेड-लेटर प्रबंधन
- Celery Beat के साथ निर्धारित और आवधिक जॉब