Django और अजवाइन के साथ अतुल्यकालिक कार्य

जब मैं Django के लिए नया था, तो मैंने अनुभव की सबसे निराशाजनक चीजों में से एक को समय-समय पर थोड़ा सा कोड चलाने की आवश्यकता थी। मैंने एक अच्छा फंक्शन लिखा था जिसने एक ऐसा एक्शन किया जिसे रोजाना 12 बजे चलाने की जरूरत थी। आसान, है ना? गलत। यह मेरे लिए एक बड़ी समस्या साबित हुई क्योंकि उस समय मुझे "Cpanel-type" वेब होस्टिंग की आदत हो गई थी, जहां इस उद्देश्य के लिए क्रॉन जॉब स्थापित करने के लिए एक अच्छा आसान GUI था।

बहुत शोध के बाद, मुझे एक अच्छा समाधान मिला- अजवाइन, एक शक्तिशाली एसिंक्रोनस जॉब कतार जिसका उपयोग पृष्ठभूमि में कार्यों को चलाने के लिए किया जाता है। लेकिन इससे अतिरिक्त समस्याएं पैदा हुईं, क्योंकि मुझे सेलेरी को Django प्रोजेक्ट में एकीकृत करने के लिए निर्देशों का एक आसान सेट नहीं मिला।

निश्चित रूप से मैंने अंततः इसका पता लगाने में कामयाबी हासिल कर ली- इस लेख में क्या शामिल होगा:सेलेरी को Django प्रोजेक्ट में कैसे एकीकृत करें और समय-समय पर कार्य कैसे बनाएं।

निःशुल्क बोनस: एक मुफ्त Django लर्निंग रिसोर्स गाइड (पीडीएफ) तक पहुंच प्राप्त करने के लिए यहां क्लिक करें जो आपको टिप्स और ट्रिक्स के साथ-साथ पायथन + Django वेब एप्लिकेशन बनाते समय बचने के लिए सामान्य नुकसान दिखाता है।

<ब्लॉकक्वॉट>

यह प्रोजेक्ट Python 3.4, Django 1.8.2, Celery 3.1.18 और Redis 3.0.2 का उपयोग करता है।

अवलोकन

आपकी सुविधा के लिए, चूंकि यह इतनी बड़ी पोस्ट है, कृपया प्रत्येक चरण की संक्षिप्त जानकारी के लिए और संबंधित कोड प्राप्त करने के लिए इस तालिका को देखें।

चरण	अवलोकन	गिट टैग
बॉयलरप्लेट	बॉयलरप्लेट डाउनलोड करें	v1
सेटअप	अजवाइन को Django के साथ एकीकृत करें	v2
अजवाइन कार्य	मूल अजवाइन कार्य जोड़ें	v3
आवधिक कार्य	आवधिक कार्य जोड़ें	v4
स्थानीय रूप से चल रहा है	हमारे ऐप को स्थानीय रूप से चलाएं	v5
दूर से दौड़ना	हमारे ऐप को दूर से चलाएं	v6

अजवाइन क्या है?

"अजवाइन एक अतुल्यकालिक कार्य कतार / कार्य कतार है जो वितरित संदेश पासिंग पर आधारित है। यह रीयल-टाइम ऑपरेशन पर केंद्रित है, लेकिन शेड्यूलिंग का भी समर्थन करता है।" इस पोस्ट के लिए, हम समय-समय पर किसी कार्य/कार्य को चलाने के लिए शेड्यूलिंग सुविधा पर ध्यान केंद्रित करेंगे।

यह क्यों उपयोगी है?

उस समय के बारे में सोचें जब आपको भविष्य में एक निश्चित कार्य को पूरा करना हो। शायद आपको हर घंटे एक एपीआई एक्सेस करने की जरूरत है। या हो सकता है कि आपको दिन के अंत में ईमेल का एक बैच भेजने की आवश्यकता हो। बड़ा हो या छोटा, अजवाइन ऐसे आवधिक कार्यों को शेड्यूल करना आसान बनाता है।
आप कभी नहीं चाहते कि अंतिम उपयोगकर्ताओं को पृष्ठों के लोड होने या कार्रवाई पूरी होने के लिए अनावश्यक रूप से प्रतीक्षा करनी पड़े। यदि एक लंबी प्रक्रिया आपके एप्लिकेशन के वर्कफ़्लो का हिस्सा है, तो आप पृष्ठभूमि में उस प्रक्रिया को निष्पादित करने के लिए सेलेरी का उपयोग कर सकते हैं, क्योंकि संसाधन उपलब्ध हो जाते हैं, ताकि आपका एप्लिकेशन क्लाइंट अनुरोधों का जवाब देना जारी रख सके। यह कार्य को एप्लिकेशन के संदर्भ से बाहर रखता है।

सेटअप

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

इसके बाद, पाइप का उपयोग करके अजवाइन स्थापित करें:

$ pip install celery==3.1.18
$ pip freeze > requirements.txt

अब हम केवल तीन आसान चरणों में सेलेरी को अपने Django प्रोजेक्ट में एकीकृत कर सकते हैं।

चरण 1:celery.py जोड़ें

"पिचा" निर्देशिका के अंदर, celery.py . नामक एक नई फ़ाइल बनाएं :

from __future__ import absolute_import
import os
from celery import Celery
from django.conf import settings

# set the default Django settings module for the 'celery' program.
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'picha.settings')
app = Celery('picha')

# Using a string here means the worker will not have to
# pickle the object when using Windows.
app.config_from_object('django.conf:settings')
app.autodiscover_tasks(lambda: settings.INSTALLED_APPS)


@app.task(bind=True)
def debug_task(self):
    print('Request: {0!r}'.format(self.request))

कोड में टिप्पणियों पर ध्यान दें।

चरण 2:अपना नया अजवाइन ऐप आयात करें

यह सुनिश्चित करने के लिए कि Django शुरू होने पर सेलेरी ऐप लोड हो गया है, निम्न कोड को __init__.py में जोड़ें। फ़ाइल जो आपकी settings.py के बगल में स्थित है फ़ाइल:

from __future__ import absolute_import

# This will make sure the app is always imported when
# Django starts so that shared_task will use this app.
from .celery import app as celery_app

ऐसा करने के बाद, आपका प्रोजेक्ट लेआउट अब इस तरह दिखना चाहिए:

├── manage.py
├── picha
│   ├── __init__.py
│   ├── celery.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── requirements.txt

चरण 3:रेडिस को अजवाइन "दलाल" के रूप में स्थापित करें

सेलेरी एक Django प्रोजेक्ट और सेलेरी कार्यकर्ताओं के बीच संदेश भेजने के लिए "दलालों" का उपयोग करता है। इस ट्यूटोरियल में, हम रेडिस को मैसेज ब्रोकर के रूप में इस्तेमाल करेंगे।

सबसे पहले, आधिकारिक डाउनलोड पृष्ठ से या काढ़ा के माध्यम से रेडिस स्थापित करें (brew install redis ) और फिर अपने टर्मिनल की ओर मुड़ें, एक नई टर्मिनल विंडो में, सर्वर को सक्रिय करें:

$ redis-server

आप इसे अपने टर्मिनल में टाइप करके जांच सकते हैं कि रेडिस ठीक से काम कर रहा है:

$ redis-cli ping

रेडिस को PONG के साथ जवाब देना चाहिए - कोशिश करो!

Redis के चालू होने के बाद, अपनी settings.py फ़ाइल में निम्न कोड जोड़ें:

# CELERY STUFF
BROKER_URL = 'redis://localhost:6379'
CELERY_RESULT_BACKEND = 'redis://localhost:6379'
CELERY_ACCEPT_CONTENT = ['application/json']
CELERY_TASK_SERIALIZER = 'json'
CELERY_RESULT_SERIALIZER = 'json'
CELERY_TIMEZONE = 'Africa/Nairobi'

आपको Django प्रोजेक्ट में Redis को एक निर्भरता के रूप में जोड़ने की भी आवश्यकता है:

$ pip install redis==2.10.3
$ pip freeze > requirements.txt

इतना ही! अब आप Django के साथ अजवाइन का उपयोग करने में सक्षम होना चाहिए। सेलेरी को Django के साथ सेट करने के बारे में अधिक जानकारी के लिए, कृपया आधिकारिक सेलेरी दस्तावेज़ देखें।

आगे बढ़ने से पहले, यह सुनिश्चित करने के लिए कि सब कुछ ठीक है, कुछ विवेक जाँच करें…

जांचें कि अजवाइन कार्यकर्ता कार्यों को प्राप्त करने के लिए तैयार है:

$ celery -A picha worker -l info
...
[2015-07-07 14:07:07,398: INFO/MainProcess] Connected to redis://localhost:6379//
[2015-07-07 14:07:07,410: INFO/MainProcess] mingle: searching for neighbors
[2015-07-07 14:07:08,419: INFO/MainProcess] mingle: all alone

CTRL-C के साथ प्रक्रिया को समाप्त करें। अब, परीक्षण करें कि अजवाइन कार्य अनुसूचक कार्रवाई के लिए तैयार है:

$ celery -A picha beat -l info
...
[2015-07-07 14:08:23,054: INFO/MainProcess] beat: Starting...

बूम!

दोबारा, प्रक्रिया पूरी होने पर समाप्त करें।

अजवाइन कार्य

अजवाइन उन कार्यों का उपयोग करता है, जिन्हें नियमित पायथन कार्यों के रूप में माना जा सकता है जिन्हें सेलेरी कहा जाता है।

उदाहरण के लिए, आइए इस मूल कार्य को अजवाइन के कार्य में बदल दें:

def add(x, y):
    return x + y

सबसे पहले, एक डेकोरेटर जोड़ें:

from celery.decorators import task

@task(name="sum_two_numbers")
def add(x, y):
    return x + y

फिर आप इस कार्य को अतुल्यकालिक रूप से अजवाइन के साथ चला सकते हैं जैसे:

add.delay(7, 8)

सरल, है ना?

इसलिए, जब आप उपयोगकर्ता को किसी पृष्ठभूमि प्रक्रिया के पूरा होने की प्रतीक्षा किए बिना किसी वेब पेज को लोड करना चाहते हैं, तो इस प्रकार के कार्य एकदम सही हैं।

आइए एक उदाहरण देखें…

Django प्रोजेक्ट पर वापस जा रहे हैं, संस्करण तीन को पकड़ें, जिसमें एक ऐप शामिल है जो उपयोगकर्ताओं से फीडबैक स्वीकार करता है, जिसे उपयुक्त रूप से feedback कहा जाता है। :

├── feedback
│   ├── __init__.py
│   ├── admin.py
│   ├── emails.py
│   ├── forms.py
│   ├── models.py
│   ├── tests.py
│   └── views.py
├── manage.py
├── picha
│   ├── __init__.py
│   ├── celery.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── requirements.txt
└── templates
    ├── base.html
    └── feedback
        ├── contact.html
        └── email
            ├── feedback_email_body.txt
            └── feedback_email_subject.txt

नई आवश्यकताओं को स्थापित करें, ऐप को सक्रिय करें, और http://localhost:8000/feedback/ पर नेविगेट करें। आपको देखना चाहिए:

आइए सेलेरी टास्क को तार-तार करें।

कार्य जोड़ें

मूल रूप से, उपयोगकर्ता द्वारा फीडबैक फॉर्म जमा करने के बाद, हम पृष्ठभूमि में फीडबैक को संसाधित करते हुए, एक ईमेल भेजते हैं, आदि, हम तुरंत उसे अपने मजेदार रास्ते पर जारी रखना चाहते हैं।

इसे पूरा करने के लिए, पहले tasks.py . नामक फ़ाइल जोड़ें "फ़ीडबैक" निर्देशिका में:

from celery.decorators import task
from celery.utils.log import get_task_logger

from feedback.emails import send_feedback_email

logger = get_task_logger(__name__)


@task(name="send_feedback_email_task")
def send_feedback_email_task(email, message):
    """sends an email when feedback form is filled successfully"""
    logger.info("Sent feedback email")
    return send_feedback_email(email, message)

फिर forms.py . को अपडेट करें इस तरह:

from django import forms
from feedback.tasks import send_feedback_email_task


class FeedbackForm(forms.Form):
    email = forms.EmailField(label="Email Address")
    message = forms.CharField(
        label="Message", widget=forms.Textarea(attrs={'rows': 5}))
    honeypot = forms.CharField(widget=forms.HiddenInput(), required=False)

    def send_email(self):
        # try to trick spammers by checking whether the honeypot field is
        # filled in; not super complicated/effective but it works
        if self.cleaned_data['honeypot']:
            return False
        send_feedback_email_task.delay(
            self.cleaned_data['email'], self.cleaned_data['message'])

संक्षेप में, send_feedback_email_task.delay(email, message) जैसे-जैसे उपयोगकर्ता साइट का उपयोग करना जारी रखता है, कार्य प्रक्रिया करता है और प्रतिक्रिया ईमेल पृष्ठभूमि में भेजता है।

<ब्लॉकक्वॉट>

नोट :success_url views.py . में उपयोगकर्ता को / . पर रीडायरेक्ट करने के लिए सेट किया गया है , जो अभी तक मौजूद नहीं है। हम इस समापन बिंदु को अगले भाग में स्थापित करेंगे।

आवधिक कार्य

अक्सर, आपको किसी कार्य को एक विशिष्ट समय पर हर बार चलाने के लिए शेड्यूल करने की आवश्यकता होगी - उदाहरण के लिए, एक वेब स्क्रैपर को दैनिक चलाने की आवश्यकता हो सकती है। ऐसे कार्य, जिन्हें आवधिक कार्य कहा जाता है, सेलेरी के साथ स्थापित करना आसान है।

अजवाइन आवधिक कार्यों को निर्धारित करने के लिए "अजवाइन बीट" का उपयोग करती है। सेलेरी बीट नियमित अंतराल पर कार्य चलाता है, जिसे बाद में सेलेरी वर्कर्स द्वारा निष्पादित किया जाता है।

उदाहरण के लिए, निम्न कार्य हर पंद्रह मिनट में चलने के लिए निर्धारित है:

from celery.task.schedules import crontab
from celery.decorators import periodic_task


@periodic_task(run_every=(crontab(minute='*/15')), name="some_task", ignore_result=True)
def some_task():
    # do something

आइए इस कार्यक्षमता को Django प्रोजेक्ट में जोड़कर अधिक मजबूत उदाहरण देखें…

Django प्रोजेक्ट पर वापस, संस्करण चार लें, जिसमें एक और नया ऐप शामिल है, जिसे photos . कहा जाता है , जो साइट पर प्रदर्शित करने के लिए नई तस्वीरें प्राप्त करने के लिए फ़्लिकर एपीआई का उपयोग करता है:

├── feedback
│   ├── __init__.py
│   ├── admin.py
│   ├── emails.py
│   ├── forms.py
│   ├── models.py
│   ├── tasks.py
│   ├── tests.py
│   └── views.py
├── manage.py
├── photos
│   ├── __init__.py
│   ├── admin.py
│   ├── models.py
│   ├── settings.py
│   ├── tests.py
│   ├── utils.py
│   └── views.py
├── picha
│   ├── __init__.py
│   ├── celery.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── requirements.txt
└── templates
    ├── base.html
    ├── feedback
    │   ├── contact.html
    │   └── email
    │       ├── feedback_email_body.txt
    │       └── feedback_email_subject.txt
    └── photos
        └── photo_list.html

नई आवश्यकताओं को स्थापित करें, माइग्रेशन चलाएँ, और फिर यह सुनिश्चित करने के लिए सर्वर को सक्रिय करें कि सब कुछ ठीक है। फ़ीडबैक फ़ॉर्म का पुन:परीक्षण करने का प्रयास करें। इस बार इसे ठीक रीडायरेक्ट करना चाहिए।

आगे क्या है?

ठीक है, चूंकि हमें अपनी साइट पर और तस्वीरें जोड़ने के लिए समय-समय पर फ़्लिकर एपीआई को कॉल करने की आवश्यकता होगी, हम एक सेलेरी कार्य जोड़ सकते हैं।

कार्य जोड़ें

एक tasks.py जोड़ें photos . के लिए ऐप:

from celery.task.schedules import crontab
from celery.decorators import periodic_task
from celery.utils.log import get_task_logger

from photos.utils import save_latest_flickr_image

logger = get_task_logger(__name__)


@periodic_task(
    run_every=(crontab(minute='*/15')),
    name="task_save_latest_flickr_image",
    ignore_result=True
)
def task_save_latest_flickr_image():
    """
    Saves latest image from Flickr
    """
    save_latest_flickr_image()
    logger.info("Saved image from Flickr")

यहां, हम save_latest_flickr_image() चलाते हैं फ़ंक्शन कॉल को task . में लपेटकर हर पंद्रह मिनट में कार्य करें . @periodic_task डेकोरेटर tasks.py . को छोड़कर, सेलेरी टास्क को चलाने के लिए कोड को एब्सट्रैक्ट करता है फ़ाइल साफ़ और पढ़ने में आसान!

स्थानीय रूप से चल रहा है

इस चीज़ को चलाने के लिए तैयार हैं?

अपने Django ऐप और रेडिस के चलने के साथ, दो नई टर्मिनल विंडो/टैब खोलें। प्रत्येक नई विंडो में, अपनी परियोजना निर्देशिका में नेविगेट करें, अपने वर्चुअलएन्व को सक्रिय करें, और फिर निम्नलिखित कमांड चलाएँ (प्रत्येक विंडो में एक):

$ celery -A picha worker -l info
$ celery -A picha beat -l info

जब आप http://127.0.0.1:8000/ पर साइट पर जाते हैं तो अब आपको एक छवि देखनी चाहिए। हमारे ऐप को फ़्लिकर से हर 15 मिनट में एक इमेज मिलती है:

photos/tasks.py पर एक नजर डालें कोड देखने के लिए। "फ़ीडबैक" बटन पर क्लिक करने से आप... कुछ फ़ीडबैक भेज सकते हैं:

यह एक अजवाइन कार्य के माध्यम से काम करता है। feedback/tasks.py पर एक नजर डालें अधिक के लिए।

बस, आपके पास पिचा प्रोजेक्ट चल रहा है!

यह आपके Django प्रोजेक्ट को स्थानीय रूप से विकसित करते समय परीक्षण के लिए अच्छा है, लेकिन जब आपको उत्पादन के लिए तैनात करने की आवश्यकता होती है - जैसे DigitalOcean पर, शायद यह इतनी अच्छी तरह से काम नहीं करता है। उसके लिए, यह अनुशंसा की जाती है कि आप पर्यवेक्षक के साथ डेमॉन के रूप में पृष्ठभूमि में अजवाइन कार्यकर्ता और अनुसूचक को चलाएं।

दूर से चल रहा है

स्थापना सरल है। रेपो से संस्करण पांच प्राप्त करें (यदि आपके पास पहले से नहीं है)। फिर अपने रिमोट सर्वर में SSH करें और चलाएं:

$ sudo apt-get install supervisor

फिर हमें दूरस्थ सर्वर पर "/etc/supervisor/conf.d/" निर्देशिका में कॉन्फ़िगरेशन फ़ाइलों को जोड़कर हमारे सेलेरी कार्यकर्ताओं के बारे में पर्यवेक्षक को बताने की आवश्यकता है। हमारे मामले में, हमें दो ऐसी कॉन्फ़िगरेशन फ़ाइलों की आवश्यकता है - एक सेलेरी वर्कर के लिए और एक सेलेरी शेड्यूलर के लिए।

स्थानीय रूप से, प्रोजेक्ट रूट में "पर्यवेक्षक" नामक फ़ोल्डर बनाएं। फिर निम्न फ़ाइलें जोड़ें…

अजवाइन कार्यकर्ता:picha_celery.conf

; ==================================
;  celery worker supervisor example
; ==================================

; the name of your supervisord program
[program:pichacelery]

; Set full path to celery program if using virtualenv
command=/home/mosh/.virtualenvs/picha/bin/celery worker -A picha --loglevel=INFO

; The directory to your Django project
directory=/home/mosh/sites/picha

; If supervisord is run as the root user, switch users to this UNIX user account
; before doing any processing.
user=mosh

; Supervisor will start as many instances of this program as named by numprocs
numprocs=1

; Put process stdout output in this file
stdout_logfile=/var/log/celery/picha_worker.log

; Put process stderr output in this file
stderr_logfile=/var/log/celery/picha_worker.log

; If true, this program will start automatically when supervisord is started
autostart=true

; May be one of false, unexpected, or true. If false, the process will never
; be autorestarted. If unexpected, the process will be restart when the program
; exits with an exit code that is not one of the exit codes associated with this
; process’ configuration (see exitcodes). If true, the process will be
; unconditionally restarted when it exits, without regard to its exit code.
autorestart=true

; The total number of seconds which the program needs to stay running after
; a startup to consider the start successful.
startsecs=10

; Need to wait for currently executing tasks to finish at shutdown.
; Increase this if you have very long running tasks.
stopwaitsecs = 600

; When resorting to send SIGKILL to the program to terminate it
; send SIGKILL to its whole process group instead,
; taking care of its children as well.
killasgroup=true

; if your broker is supervised, set its priority higher
; so it starts first
priority=998

अजवाइन शेड्यूलर:picha_celerybeat.conf

; ================================
;  celery beat supervisor example
; ================================

; the name of your supervisord program
[program:pichacelerybeat]

; Set full path to celery program if using virtualenv
command=/home/mosh/.virtualenvs/picha/bin/celerybeat -A picha --loglevel=INFO

; The directory to your Django project
directory=/home/mosh/sites/picha

; If supervisord is run as the root user, switch users to this UNIX user account
; before doing any processing.
user=mosh

; Supervisor will start as many instances of this program as named by numprocs
numprocs=1

; Put process stdout output in this file
stdout_logfile=/var/log/celery/picha_beat.log

; Put process stderr output in this file
stderr_logfile=/var/log/celery/picha_beat.log

; If true, this program will start automatically when supervisord is started
autostart=true

; May be one of false, unexpected, or true. If false, the process will never
; be autorestarted. If unexpected, the process will be restart when the program
; exits with an exit code that is not one of the exit codes associated with this
; process’ configuration (see exitcodes). If true, the process will be
; unconditionally restarted when it exits, without regard to its exit code.
autorestart=true

; The total number of seconds which the program needs to stay running after
; a startup to consider the start successful.
startsecs=10

; if your broker is supervised, set its priority higher
; so it starts first
priority=999

सुनिश्चित करें कि दूरस्थ सर्वर के फाइल सिस्टम से मेल खाने के लिए इन फ़ाइलों में पथ अपडेट करें।

मूल रूप से, ये पर्यवेक्षक कॉन्फ़िगरेशन फ़ाइलें पर्यवेक्षक को बताती हैं कि हमारे 'कार्यक्रम' को कैसे चलाना और प्रबंधित करना है (जैसा कि उन्हें पर्यवेक्षक द्वारा कहा जाता है)।

ऊपर के उदाहरणों में, हमने "पिचसेलरी" और "पिचसेलरीबीट" नामक दो पर्यवेक्षक कार्यक्रम बनाए हैं।

अब इन फ़ाइलों को "/etc/supervisor/conf.d/" निर्देशिका में दूरस्थ सर्वर पर कॉपी करें।

हमें दूरस्थ सर्वर पर उपरोक्त लिपियों में उल्लिखित लॉग फ़ाइलें भी बनाने की आवश्यकता है:

$ touch /var/log/celery/picha_worker.log
$ touch /var/log/celery/picha_beat.log

अंत में, पर्यवेक्षक को कार्यक्रमों से अवगत कराने के लिए निम्नलिखित कमांड चलाएँ - जैसे, pichacelery और pichacelerybeat :

$ sudo supervisorctl reread
$ sudo supervisorctl update

pichacelery . की स्थिति को रोकने, शुरू करने और/या जाँचने के लिए निम्न कमांड चलाएँ कार्यक्रम:

$ sudo supervisorctl stop pichacelery
$ sudo supervisorctl start pichacelery
$ sudo supervisorctl status pichacelery

आप आधिकारिक दस्तावेज से पर्यवेक्षक के बारे में अधिक पढ़ सकते हैं।

अंतिम सुझाव

Django मॉडल ऑब्जेक्ट को सेलेरी टास्क में पास न करें। उन मामलों से बचने के लिए जहां मॉडल ऑब्जेक्ट को सेलेरी कार्य में पास करने से पहले ही बदल दिया गया है, ऑब्जेक्ट की प्राथमिक कुंजी सेलेरी को पास करें। तब, निश्चित रूप से, इस पर काम करने से पहले आपको डेटाबेस से ऑब्जेक्ट प्राप्त करने के लिए प्राथमिक कुंजी का उपयोग करना होगा।
डिफ़ॉल्ट सेलेरी शेड्यूलर अपने शेड्यूल को स्थानीय रूप से संग्रहीत करने के लिए कुछ फ़ाइलें बनाता है। ये फ़ाइलें "celerybeat-schedule.db" और "celerybeat.pid" होंगी। यदि आप गिट (जो आपको चाहिए!) जैसे संस्करण नियंत्रण प्रणाली का उपयोग कर रहे हैं, तो इन फ़ाइलों को अनदेखा करना और उन्हें अपने भंडार में नहीं जोड़ना एक अच्छा विचार है क्योंकि वे स्थानीय रूप से प्रक्रियाओं को चलाने के लिए हैं।

अगले चरण

खैर, यह सेलेरी को Django प्रोजेक्ट में एकीकृत करने के मूल परिचय के लिए है।

अधिक चाहते हैं?

अधिक जानने के लिए आधिकारिक अजवाइन उपयोगकर्ता मार्गदर्शिका देखें।
पर्यवेक्षक और कॉन्फ़िगरेशन फ़ाइलों को सेटअप करने के लिए एक Fabfile बनाएँ। आदेशों को reread . में जोड़ना सुनिश्चित करें और update पर्यवेक्षक।
रेपो से परियोजना को फोर्क करें और एक नया सेलेरी कार्य जोड़ने के लिए पुल अनुरोध खोलें।

हैप्पी कोडिंग!