Django-Skonfigurować Zaplanowaną Pracę?

Selery jest rozproszoną kolejką zadań, zbudowaną na AMQP (RabbitMQ). Obsługuje również zadania okresowe w sposób podobny do crona(Zobacz zadania okresowe ). W zależności od aplikacji, może warto rzucić okiem.

Selery jest dość łatwy do skonfigurowania za pomocą django (docs), a okresowe zadania będą faktycznie pomijać pominięte zadania w przypadku przestoju. Seler posiada również wbudowane mechanizmy retry, w przypadku niepowodzenia zadania.

Mamy open-source to, co myślę, że jest strukturyzowaną aplikacją. To rozwiązanie Briana również nawiązuje. Chciałbym wszelkie / wszystkie opinie!

Https://github.com/tivix/django-cron

Pochodzi z jednego polecenia zarządzania:

./manage.py runcrons

Jeśli używasz standardowego systemu operacyjnego POSIX, używasz cron .

Jeśli używasz Windows, używasz at .

Napisz polecenie zarządzania Django do

1. Dowiedz się, na jakiej platformie są.

2. Wykonaj odpowiednie polecenie " AT " dla swoich użytkowników, lub zaktualizuj plik crontab dla swoich użytkowników.

Ciekawy nowy pluggable Django app: django-chronograph

Musisz dodać tylko jeden wpis crona, który działa jak timer, i masz bardzo ładny interfejs admina Django do uruchamiania skryptów.

Spójrz na Django Poor Man ' s Cron, który jest aplikacją Django, która wykorzystuje spamboty, roboty indeksujące wyszukiwarki i podobne do uruchamiania zaplanowanych zadań w mniej więcej regularnych odstępach

Zobacz: http://code.google.com/p/django-poormanscron/

Sugestia Briana Neala dotycząca uruchamiania poleceń zarządzania przez cron działa dobrze, ale jeśli szukasz czegoś bardziej solidnego (ale nie tak rozbudowanego jak selery), zajrzyj do biblioteki typu Kronos :

# app/cron.py

import kronos

@kronos.register('0 * * * *')
def task():
    pass

RabbitMQ i selery mają więcej funkcji i możliwości obsługi zadań niż Cron. Jeśli niepowodzenie zadania nie jest problemem i uważasz, że poradzisz sobie z uszkodzonymi zadaniami w następnym wywołaniu, Cron jest wystarczający.

Selery & AMQP pozwoli Ci obsłużyć zepsute zadanie i zostanie ono ponownie wykonane przez innego pracownika (pracownicy selery słuchają następnego zadania do pracy), dopóki nie zostanie osiągnięty atrybut max_retries zadania. Możesz nawet wywoływać zadania w przypadku awarii, takie jak rejestrowanie awarii lub wysyłanie wiadomości e-mail do administratora po osiągnięciu max_retries.

I możesz dystrybuować Serwery selery i AMQP, gdy potrzebujesz skalować swoją aplikację.

Osobiście używam crona, ale Jobs Scheduling części django-extensions wygląda interesująco.

Umieść następujące na górze swojej cron.py plik:

#!/usr/bin/python
import os, sys
sys.path.append('/path/to/') # the parent directory of the project
sys.path.append('/path/to/project') # these lines only needed if not on path
os.environ['DJANGO_SETTINGS_MODULE'] = 'myproj.settings'

# imports and code below

Właśnie pomyślałem o tym dość prostym rozwiązaniu:

1. Zdefiniuj funkcję widoku do_work(req, param) tak jak w przypadku każdego innego widoku, z mapowaniem URL, zwracaniem HttpResponse i tak dalej.
2. Skonfiguruj zadanie cron z preferencjami czasu (lub używając zadań AT lub zaplanowanych w systemie Windows), które uruchamia curl http://localhost/your/mapped/url?param = wartość.

Możesz dodawać parametry, ale po prostu dodawać parametry do adresu URL.

Powiedz mi co myślicie.

[Update] używam teraz komendy runjob z django-extensions zamiast curl.

Mój cron wygląda mniej więcej tak:

@hourly python /path/to/project/manage.py runjobs hourly

... i tak dalej dla dziennych, miesięcznych itp". Możesz również skonfigurować go tak, aby uruchamiał określone zadanie.

Chociaż nie jest częścią Django, Airflow jest nowszym projektem (stan na 2016), który jest przydatny do zarządzania zadaniami.

Airflow to system automatyzacji przepływu pracy i planowania, który może być używany do tworzenia i zarządzania potokami danych. Interfejs internetowy zapewnia programistom szereg opcji zarządzania i przeglądania tych potoków.

Airflow jest napisany w Pythonie i jest zbudowany przy użyciu Flask.

Airflow został stworzony przez Maxime Beauchemin w Airbnb I open source wiosną 2015 roku. Dołączył do programu inkubacji Apache Software Foundation zimą 2016 roku. Oto strona projektu Git i kilka dodatkowych informacji .

Miałem dokładnie ten sam wymóg jakiś czas temu, i skończyło się rozwiązując go za pomocą APScheduler (Instrukcja obsługi )

Sprawia, że planowanie zadań jest bardzo proste i utrzymuje je niezależne od wykonywania kodu opartego na żądaniach. Poniżej znajduje się prosty przykład, którego użyłem w swoim kodzie.

from apscheduler.schedulers.background import BackgroundScheduler

scheduler = BackgroundScheduler()
job = None

def tick():
    print('One tick!')\

def start_job():
    global job
    job = scheduler.add_job(tick, 'interval', seconds=3600)
    try:
        scheduler.start()
    except:
        pass

Po części kodu mogę napisać wszystko tak jak mój views.py :)

#######################################
import os,sys
sys.path.append('/home/administrator/development/store')
os.environ['DJANGO_SETTINGS_MODULE']='store.settings'
from django.core.management impor setup_environ
from store import settings
setup_environ(settings)
#######################################

Od http://www.cotellese.net/2007/09/27/running-external-scripts-against-django-models/

Miałem dzisiaj coś podobnego z Twoim problemem.

Nie chciałem, aby obsługiwał go serwer trhough cron (a większość libów to w końcu tylko pomocnicy crona).

Więc stworzyłem moduł planowania i dołączyłem go do init .

Nie jest to najlepsze podejście, ale pomaga mi mieć cały kod w jednym miejscu i z jego wykonaniem związanym z główną aplikacją.

Tak, powyższa metoda jest świetna. Próbowałem kilku z nich. W końcu znalazłem taką metodę:

    from threading import Timer

    def sync():

        do something...

        sync_timer = Timer(self.interval, sync, ())
        sync_timer.start()

Podobnie jak rekurencyjne .

Ok, mam nadzieję, że ta metoda może spełnić twoje wymagania. :)

Używam selera do tworzenia moich periodycznych zadań. Najpierw musisz zainstalować go w następujący sposób:

pip install django-celery

Nie zapomnij zarejestrować django-celery w ustawieniach, a potem możesz zrobić coś takiego:

from celery import task
from celery.decorators import periodic_task
from celery.task.schedules import crontab
from celery.utils.log import get_task_logger
@periodic_task(run_every=crontab(minute="0", hour="23"))
def do_every_midnight():
 #your code

Nie jestem pewien, czy będzie to przydatne dla kogokolwiek, ponieważ musiałem zapewnić innym użytkownikom systemu zaplanować zadania, nie dając im dostępu do rzeczywistego Harmonogramu zadań serwera (windows), stworzyłem tę aplikację wielokrotnego użytku.

Należy pamiętać, że użytkownicy mają dostęp do jednego folderu udostępnionego na serwerze, w którym mogą utworzyć wymagane polecenie / zadanie/.plik bat. To zadanie można następnie zaplanować za pomocą tej aplikacji.

Nazwa aplikacji to Django_Windows_Scheduler

Zrzut ekranu:

Bardziej nowoczesnym rozwiązaniem (w porównaniu do selera) jest Django Q: https://django-q.readthedocs.io/en/latest/index.html

Ma świetną dokumentację i jest łatwy do grok. Brak wsparcia dla systemu Windows, ponieważ system Windows nie obsługuje rozwidlania procesów. Ale działa to dobrze, jeśli tworzysz środowisko programistyczne przy użyciu podsystemu Windows for Linux.

Zdecydowanie powinieneś sprawdzić django-q! Nie wymaga dodatkowej konfiguracji i ma prawdopodobnie wszystko, co potrzebne do obsługi wszelkich problemów produkcyjnych w projektach komercyjnych.

# django-q
# -------------------------------------------------------------------------
# See: http://django-q.readthedocs.io/en/latest/configure.html
Q_CLUSTER = {
    # Match recommended settings from docs.
    'name': 'DjangoORM',
    'workers': 4,
    'queue_limit': 50,
    'bulk': 10,
    'orm': 'default',

# Custom Settings
# ---------------
# Limit the amount of successful tasks saved to Django.
'save_limit': 10000,

# See https://github.com/Koed00/django-q/issues/110.
'catch_up': False,

# Number of seconds a worker can spend on a task before it's terminated.
'timeout': 60 * 5,

# Number of seconds a broker will wait for a cluster to finish a task before presenting it again. This needs to be
# longer than `timeout`, otherwise the same task will be processed multiple times.
'retry': 60 * 6,

# Whether to force all async() calls to be run with sync=True (making them synchronous).
'sync': False,

# Redirect worker exceptions directly to Sentry error reporter.
'error_reporter': {
    'sentry': RAVEN_CONFIG,
},
}

Jeśli chcesz czegoś więcej wiarygodnego niż selera , wypróbuj TaskHawk , który jest zbudowany na bazie AWS SQS/SNS .

Zobacz: http://taskhawk.readthedocs.io