अजवाइन सीखना चुनौतीपूर्ण हो सकता है। हालाँकि इसका दस्तावेज़ीकरण व्यापक है, इसमें बुनियादी बातों को छोड़ देने की प्रवृत्ति है।

यह पोस्ट अजवाइन में चार मुख्य अवधारणाओं को परिभाषित करेगी, अजवाइन और कोम्बू के बीच संबंधों पर चर्चा करेगी, और कुछ कोड उदाहरणों का उपयोग करके यह बताएगी कि अजवाइन वास्तविक अनुप्रयोगों में कैसे उपयोगी हो सकती है। उदाहरण Django वेब फ्रेमवर्क और इसके @shared_task डेकोरेटर का उपयोग करेंगे, लेकिन अवधारणाएं फ्लास्क, फास्टएपीआई और अन्य पर भी लागू होती हैं।

कार्य, दलाल, कार्यकर्ता और बैकएंड

आपको वर्तमान सेलेरी दस्तावेज़ पर एक जगह ढूंढने में कठिनाई होगी जो स्पष्ट रूप से बताती है कि वह किसे ब्रोकर या बैकएंड मानता है, लेकिन पर्याप्त खोज के साथ आप पा सकते हैं और परिभाषाएँ निकालें।

नीचे वे अवधारणाएं हैं जिन्हें आपको अजवाइन के साथ शुरुआत करने से पहले जानना चाहिए।

काम

एक कार्य कुछ कार्य है जिसे सेलेरी असिंक्रोनस रूप से निष्पादित करेगी (इस संदर्भ में, यह "तुरंत नहीं" के लिए एक फैंसी शब्द है)। किसी वेब एप्लिकेशन में, उपयोगकर्ता द्वारा फॉर्म सबमिट करने के बाद एक कार्य ईमेल भेजना हो सकता है। ईमेल भेजना एक बहु-सेकंड ऑपरेशन हो सकता है, और उपयोगकर्ता को रीडायरेक्ट करने से पहले ईमेल भेजने के लिए इंतजार करने के लिए मजबूर करने से एप्लिकेशन धीमा हो सकता है।

सेलेरी में डेकोरेटर्स का उपयोग करके कार्यों को परिभाषित किया जाता है। नीचे हम @shared_task डेकोरेटर का उपयोग सेंड_थैंक_यू_ईमेल() को सेलेरी कार्य में बदलने के लिए करते हैं जिसका उपयोग सबमिट_फीडबैक() फॉर्म सबमिशन हैंडलर में किया जा सकता है।

from config.celery import shared_task
from django.core.mail import send_mail
from django.shortcuts import render, redirect
from feedback.forms import FeedbackForm

@shared_task
def send_thank_you_email(email_address):
    send_mail(
        "Thank you for your feedback!",
        "We appreciate your input.",
        "[email protected]",
        [email_address],
    )

def submit_feedback(request):
    if request.method == "POST":
        form = FeedbackForm(request.POST)
        if form.is_valid():
            form.save()

            # Push the task to the broker using the delay() method.
            send_thank_you_email.delay(form.cleaned_data["email"])

            return redirect("/thank-you/")
    else:
        form = FeedbackForm()

    return render(request, "feedback.html", {"form": form})

जब किसी कार्य को सेलेरी में डेकोरेटर का उपयोग करके परिभाषित किया जाता है, तो यह कार्य में देरी() विधि जोड़ता है। फॉर्म सफलतापूर्वक सहेजे जाने के बाद आप ऊपर दिए गए उदाहरण में 'send_thank_you_email' कार्य को 'विलंब()' विधि को कॉल करते हुए देख सकते हैं। जब देरी() को कॉल किया जाता है, तो यह सेंड_थैंक_यू_ईमेल कार्य और उसका डेटा ब्रोकर को भेज देगा जहां इसे संग्रहीत किया जाता है और बाद में एक कार्यकर्ता द्वारा निष्पादित किया जाएगा, जिस बिंदु पर उपयोगकर्ता करेगा ईमेल किया जाए.

यदि आपको फॉर्म सहेजने के बाद अतिरिक्त ईमेल भेजने की आवश्यकता है तो सेलेरी पर काम आगे बढ़ाने का लाभ अधिक स्पष्ट हो जाता है। उदाहरण के लिए, हो सकता है कि आप ग्राहक सहायता टीम को ईमेल करना चाहें कि उन्हें नई प्रतिक्रिया प्राप्त हुई है। सेलेरी के साथ, इससे प्रतिक्रिया में लगभग कोई अतिरिक्त समय नहीं लगता है।

अजवाइन कार्य अतिरिक्त उन्नत कॉन्फ़िगरेशन की भी अनुमति देते हैं। किसी ईमेल के भेजने में विफल होने की स्थिति में, आप स्वचालित रूप से पुनः प्रयास करने के लिए अपने कार्य को कोड कर सकते हैं और max_retries, retry_backoff, retry_जिटर इत्यादि जैसी सेटिंग्स कॉन्फ़िगर कर सकते हैं।

दलाल

सेलेरी एन्हांसमेंट प्रपोजल्स की शब्दावली में मैसेज ब्रोकर्स के बारे में निम्नलिखित बातें कही गई हैं:

एंटरप्राइज़ इंटीग्रेशन पैटर्न एक मैसेज ब्रोकर को एक आर्किटेक्चरल बिल्डिंग ब्लॉक के रूप में परिभाषित करता है जो कई गंतव्यों से संदेश प्राप्त कर सकता है, सही गंतव्य निर्धारित कर सकता है और संदेश को सही चैनल पर रूट कर सकता है।

सेलेरी के साथ हमारे उद्देश्यों के लिए, हम एक ब्रोकर को एक "संदेश परिवहन" पर विचार करेंगे जहां बनाए गए कार्य संग्रहीत होते हैं। दलाल वास्तव में कार्य को निष्पादित नहीं करते हैं: यह एक कार्यकर्ता का काम है। इसके बजाय ब्रोकर वह स्थान है जहां निर्धारित कार्यों को में संग्रहीत किया जाता है जब कोई कार्य निर्धारित किया जाता है, और से खींच लिया जाता है जब कोई कार्यकर्ता अंततः किसी कार्य को निष्पादित करता है। सेलेरी के काम करने के लिए ब्रोकर एक आवश्यक घटक है, और सेलेरी ठीक एक ब्रोकर से जुड़ेगी।

सेलेरी के बैकएंड और ब्रोकर्स पेज में कुछ समर्थित ब्रोकरों की सूची है, और इसके द्वारा समर्थित अन्य प्रायोगिक ब्रोकर भी हैं जो सूचीबद्ध नहीं हैं (जैसे कि SQLAlchemy)। इन दलालों (या "संदेश परिवहन") को कोम्बू नामक संदेश परिवहन के लिए सेलेरी द्वारा बनाए गए पायथन लाइब्रेरी द्वारा प्रबंधित किया जाता है। ब्रोकरों को कॉन्फ़िगर करने के बारे में जानकारी की तलाश करते समय, कभी-कभी सेलेरी के बजाय कोम्बू के दस्तावेज़ों से परामर्श करना सहायक होता है।

कुछ ब्रोकरों के पास टास्क फैनआउट और प्राथमिकता जैसी उन्नत सुविधाएं होती हैं, जबकि अन्य सरल कतार के रूप में काम करते हैं।

मज़दूर

A

worker सेलेरी का एक उदाहरण है जो ब्रोकर से कार्य खींचता है और आपके पायथन ऐप में परिभाषित कार्य कार्यों को निष्पादित करता है। सेलेरी अपने कर्मचारियों में पायथन कोड चलाने में सक्षम है क्योंकि सेलेरी स्वयं पायथन में लिखी गई है।

कई कार्यकर्ता कार्यों को निष्पादित करने के लिए एक साथ चल सकते हैं। जब आप सेलेरी वर्कर कमांड चलाते हैं, तो यह डिफ़ॉल्ट रूप से आपके कंप्यूटर के प्रत्येक कोर के लिए एक वर्कर को स्पिन कर देगा। यदि आपके कंप्यूटर में 16 कोर हैं, तो सेलेरी वर्कर चलाने से 16 वर्कर शुरू हो जाएंगे।

यदि कोई कर्मचारी नहीं चल रहा है, तो संदेश (कार्य) ब्रोकर में तब तक जमा रहेंगे जब तक कर्मचारी उन्हें निष्पादित करने के लिए उपलब्ध नहीं हो जाते।

बैकएंड

सेलेरी उपयोगकर्ता गाइड में कार्य पृष्ठ में

बैकएंड के बारे में निम्नलिखित कहा गया है:

यदि आप कार्यों का ट्रैक रखना चाहते हैं या रिटर्न मानों की आवश्यकता है, तो सेलेरी को राज्यों को कहीं संग्रहीत या भेजना होगा ताकि उन्हें बाद में पुनर्प्राप्त किया जा सके। चुनने के लिए कई अंतर्निहित परिणाम बैकएंड हैं: SQLAlchemy/Django ORM, Memcached, RabbitMQ/QPid (rpc), और Redis - या आप अपना स्वयं का परिभाषित कर सकते हैं।

TLDR: एक बैकएंड एसिंक कार्यों के परिणामों और लौटे गए परिणामों को ट्रैक करता है। वास्तव में इसका क्या मतलब है, और यह कब उपयोगी हो सकता है?

कल्पना करें कि आप Django में एक अकाउंटिंग ऐप बना रहे हैं जो एक वार्षिक रिपोर्ट तैयार कर सकता है। रिपोर्ट तैयार होने में कुछ मिनट लग सकते हैं।

अपने उपयोगकर्ताओं को अधिक प्रतिक्रियाशील अनुभव देने के लिए, आप रिपोर्ट जनरेशन कार्य शुरू करने के लिए AJAX अनुरोध का उपयोग करते हैं। वह अनुरोध कार्य की एक आईडी लौटाता है, जिसका उपयोग वह सर्वर को हर कुछ सेकंड में सर्वेक्षण करने के लिए कर सकता है यह देखने के लिए कि रिपोर्ट उत्पन्न हुई है या नहीं। एक बार कार्य पूरा हो जाने पर, यह रिपोर्ट की आईडी लौटा देगा, जिसका उपयोग ग्राहक जावास्क्रिप्ट के माध्यम से रिपोर्ट का लिंक प्रदर्शित करने के लिए कर सकता है।

हम इसे निम्नलिखित कोड का उपयोग करके सेलेरी और Django के साथ कार्यान्वित कर सकते हैं:

अजवाइन आयात से साझा_कार्य django.http से JsonResponse आयात करें django.views.decorator.http से आयात require_http_methods अकाउंटिंग.मॉडल से संपत्ति आयात करें लेखांकन.रिपोर्ट से वार्षिकरिपोर्ट जेनरेटर आयात करें @साझा_कार्य def generate_report_task(वर्ष): # इसमें कुछ मिनट लग सकते हैं... रिपोर्ट = वार्षिकरिपोर्ट जेनरेटर().जेनरेट(वर्ष) संपत्ति = Asset.objects.create( नाम=f"{वर्ष} वार्षिक रिपोर्ट", यूआरएल=रिपोर्ट.यूआरएल, ) वापसी संपत्ति.आईडी @require_http_methods(["POST"]) def generate_annual_report_view(अनुरोध): वर्ष = request.POST.get("वर्ष") कार्य = generate_report_task.delay(वर्ष) वापसी JsonResponse({"taskId": Task.id}) def get_annual_report_generation_status_view(अनुरोध, कार्य_आईडी): कार्य = generate_report_task.AsyncResult(task_id) # स्थिति आम तौर पर "लंबित", "सफलता", या "असफलता" होती है स्थिति = कार्य.स्थिति वापसी JsonResponse({"status": स्थिति, "assetId": Task.result})

from celery import shared_task
from django.http import JsonResponse
from django.views.decorators.http import require_http_methods
from accounting.models import Asset
from accounting.reports import AnnualReportGenerator

@shared_task
def generate_report_task(year):
    # This could take minutes...
    report = AnnualReportGenerator().generate(year)
    asset = Asset.objects.create(
        name=f"{year} annual report",
        url=report.url,
    )
    return asset.id

@require_http_methods(["POST"])
def generate_annual_report_view(request):
    year = request.POST.get("year")
    task = generate_report_task.delay(year)
    return JsonResponse({"taskId": task.id})

def get_annual_report_generation_status_view(request, task_id):
    task = generate_report_task.AsyncResult(task_id)

    # The status is typically "PENDING", "SUCCESS", or "FAILURE"
    status = task.status
    return JsonResponse({"status": status, "assetId": task.result})

इस उदाहरण में, generate_report_task() द्वारा लौटाई गई संपत्ति आईडी को

बैकएंड में संग्रहीत किया जाता है। बैकएंड परिणाम और लौटे गए परिणाम को संग्रहीत करता है। बैकएंड अभी तक संसाधित होने वाले कार्यों की स्थिति को नहीं संग्रहीत करता है: परिणाम आने के बाद ही इन्हें जोड़ा जाएगा। एक कार्य जो "लंबित" लौटाता है, उसकी स्थिति पूरी तरह से अज्ञात होती है: एक संबद्ध कार्य अस्तित्व में भी नहीं हो सकता है। कार्य आम तौर पर "सफलता" या "असफलता" लौटाएंगे, लेकिन आप सेलेरी स्थिति दस्तावेज़ों में सभी स्थितियाँ देख सकते हैं।

सेलेरी को कार्यों को चलाने के लिए बैकएंड की आवश्यकता नहीं है। हालांकि, यदि आपको कभी किसी कार्य के परिणाम की जांच करने या किसी कार्य के परिणाम को वापस करने की आवश्यकता होती है तो यह आवश्यक है। यदि सेलेरी में बैकएंड कॉन्फ़िगर नहीं होने पर आप किसी कार्य की स्थिति की जांच करने का प्रयास करते हैं, तो एक अपवाद उठाया जाएगा।

---

मुझे आशा है कि यह पोस्ट आपको अजवाइन के अलग-अलग टुकड़ों को समझने में मदद करेगी और आप इसका उपयोग करने पर विचार क्यों कर सकते हैं। जबकि आधिकारिक दस्तावेज़ीकरण को टटोलना चुनौतीपूर्ण है, अजवाइन को गहराई से सीखना आपके पायथन अनुप्रयोगों के भीतर नई संभावनाओं को खोल सकता है।