Menyiapkan pekerjaan yang dijadwalkan?

Saya telah bekerja pada aplikasi web menggunakan Django, dan saya ingin tahu apakah ada cara untuk menjadwalkan pekerjaan untuk dijalankan secara berkala.

Pada dasarnya saya hanya ingin menjalankan melalui database dan membuat beberapa perhitungan / pembaruan secara otomatis, secara teratur, tetapi sepertinya saya tidak dapat menemukan dokumentasi untuk melakukan hal ini.

Adakah yang tahu cara mengatur ini?

Untuk memperjelas: Saya tahu saya dapat mengatur cronpekerjaan untuk melakukan ini, tapi saya ingin tahu apakah ada beberapa fitur di Django yang menyediakan fungsi ini. Saya ingin orang dapat menggunakan aplikasi ini sendiri tanpa harus melakukan banyak konfigurasi (sebaiknya nol).

Saya telah mempertimbangkan untuk memicu tindakan ini "surut" dengan hanya memeriksa apakah suatu pekerjaan seharusnya sudah dijalankan sejak terakhir kali permintaan dikirim ke situs, tetapi saya berharap untuk sesuatu yang sedikit lebih bersih.

Salah satu solusi yang saya gunakan adalah melakukan ini:

1) Buat perintah manajemen kustom , mis

python manage.py my_cool_command

2) Gunakan cron(di Linux) atau at(di Windows) untuk menjalankan perintah saya pada waktu yang diperlukan.

Ini adalah solusi sederhana yang tidak perlu menginstal tumpukan AMQP yang berat. Namun ada keuntungan bagus menggunakan sesuatu seperti Celery, yang disebutkan dalam jawaban lain. Secara khusus, dengan Seledri itu baik untuk tidak harus menyebarkan logika aplikasi Anda ke file crontab. Namun solusi cron bekerja cukup baik untuk aplikasi kecil hingga menengah dan di mana Anda tidak ingin banyak ketergantungan eksternal.

EDIT:

Di versi Windows yang lebih baru atperintahnya sudah tidak digunakan lagi untuk Windows 8, Server 2012 dan di atasnya. Anda dapat menggunakan schtasks.exeuntuk penggunaan yang sama.

**** PEMBARUAN **** Ini tautan baru django doc untuk menulis perintah manajemen kustom

Selery adalah antrian tugas terdistribusi, dibangun di atas AMQP (RabbitMQ). Itu juga menangani tugas-tugas berkala dengan cara yang mirip cron (lihat tugas-tugas berkala ). Tergantung pada aplikasi Anda, itu mungkin layak dilihat.

Seledri cukup mudah untuk diatur dengan Django ( dokumen ), dan tugas-tugas berkala benar-benar akan melewatkan tugas yang terlewat jika terjadi downtime. Selery juga memiliki mekanisme coba lagi bawaan, jika tugasnya gagal.

Kami telah open-source yang saya pikir adalah aplikasi terstruktur. bahwa solusi Brian di atas juga menyinggung. Kami akan sangat menyukai setiap / semua umpan balik!

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

Itu datang dengan satu perintah manajemen:

./manage.py runcrons

Itu berhasil. Setiap cron dimodelkan sebagai kelas (jadi semuanya OO) dan masing-masing cron berjalan pada frekuensi yang berbeda dan kami memastikan jenis cron yang sama tidak berjalan secara paralel (seandainya crons sendiri membutuhkan waktu lebih lama untuk berjalan daripada frekuensinya!)

Jika Anda menggunakan OS POSIX standar, Anda menggunakan cron .

Jika Anda menggunakan Windows, Anda gunakan di .

Tulis perintah manajemen Django ke

1. Cari tahu apa platform mereka.

2. Baik jalankan perintah "AT" yang sesuai untuk pengguna Anda, atau perbarui crontab untuk pengguna Anda.

Aplikasi Django pluggable baru yang menarik: Django-chronograph

Anda hanya perlu menambahkan satu entri cron yang bertindak sebagai penghitung waktu, dan Anda memiliki antarmuka admin Django yang sangat bagus ke dalam skrip untuk dijalankan.

Lihatlah Django Poor Man's Cron yang merupakan aplikasi Django yang menggunakan robot spam, robot pengindeksan mesin pencari dan juga untuk menjalankan tugas terjadwal dalam interval yang kurang lebih teratur

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

Saya memiliki persyaratan yang persis sama beberapa waktu lalu, dan akhirnya menyelesaikannya menggunakan APScheduler ( Panduan Pengguna )

Itu membuat pekerjaan penjadwalan super sederhana, dan membuatnya independen untuk dari eksekusi berdasarkan permintaan beberapa kode. Berikut ini adalah contoh sederhana.

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

Semoga ini bisa membantu seseorang!

Saran Brian Neal untuk menjalankan perintah manajemen melalui cron bekerja dengan baik, tetapi jika Anda mencari sesuatu yang sedikit lebih kuat (namun tidak serumit Celery) saya akan melihat ke perpustakaan seperti Kronos :

# app/cron.py

import kronos

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

RabbitMQ dan Celery memiliki lebih banyak fitur dan kemampuan penanganan tugas daripada Cron. Jika kegagalan tugas tidak menjadi masalah, dan Anda pikir Anda akan menangani tugas yang rusak di panggilan berikutnya, maka Cron sudah cukup.

Seledri & AMQP akan membiarkan Anda menangani tugas yang rusak, dan itu akan dieksekusi lagi oleh pekerja lain (pekerja Seledri mendengarkan tugas berikutnya untuk dikerjakan), sampai max_retriesatribut tugas tercapai. Anda bahkan dapat menjalankan tugas pada kegagalan, seperti mencatat kegagalan, atau mengirim email ke admin setelah max_retriestercapai.

Dan Anda dapat mendistribusikan server Seledri dan AMQP ketika Anda perlu mengatur skala aplikasi Anda.

Saya pribadi menggunakan cron, tetapi bagian Penjadwalan Pekerjaan dari Django-ekstensi terlihat menarik.

Meskipun bukan bagian dari Django, Airflow adalah proyek yang lebih baru (per 2016) yang berguna untuk manajemen tugas.

Airflow adalah sistem otomatisasi dan penjadwalan alur kerja yang dapat digunakan untuk membuat dan mengelola saluran data. UI berbasis web memberi pengembang sejumlah pilihan untuk mengelola dan melihat saluran pipa ini.

Aliran udara ditulis dengan Python dan dibangun menggunakan Flask.

Airflow dibuat oleh Maxime Beauchemin di Airbnb dan bersumber terbuka pada musim semi 2015. Airflow bergabung dengan program inkubasi Apache Software Foundation pada musim dingin 2016. Berikut adalah halaman proyek Git dan beberapa informasi latar belakang tambahan .

Letakkan yang berikut di bagian atas file cron.py Anda:

#!/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

Saya hanya memikirkan solusi yang agak sederhana ini:

1. Tentukan fungsi tampilan do_work (req, param) seperti yang Anda lakukan dengan tampilan lain, dengan pemetaan URL, kembalikan respons HttpResponse dan sebagainya.
2. Atur pekerjaan cron dengan preferensi waktu Anda (atau menggunakan AT atau Tugas Terjadwal di Windows) yang menjalankan curl http: // localhost / your / mapped / url? Param = value .

Anda dapat menambahkan parameter tetapi hanya menambahkan parameter ke URL.

Katakan apa yang kalian pikirkan.

[Perbarui] Saya sekarang menggunakan perintah runjob dari django-extensions bukan curl.

Cron saya terlihat seperti ini:

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

... dan seterusnya untuk harian, bulanan, dll. Anda juga dapat mengaturnya untuk menjalankan pekerjaan tertentu.

Saya merasa lebih mudah diatur dan lebih bersih. Tidak memerlukan pemetaan URL untuk dilihat. Cukup tentukan kelas pekerjaan Anda dan crontab dan Anda sudah siap.

setelah bagian kode, saya bisa menulis apa saja seperti views.py saya :)

#######################################
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)
#######################################

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

Anda pasti harus memeriksa Django-q! Ini tidak memerlukan konfigurasi tambahan dan sangat mungkin semua yang diperlukan untuk menangani masalah produksi pada proyek komersial.

Ini aktif dikembangkan dan terintegrasi dengan sangat baik dengan Django, Django ORM, Mongo, Redis. Ini konfigurasi saya:

# 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,
},
}

Django APScheduler untuk Pekerjaan Penjadwal. Penjadwal Python Lanjutan (APScheduler) adalah pustaka Python yang memungkinkan Anda menjadwalkan kode Python Anda untuk dieksekusi nanti, baik hanya sekali atau secara berkala. Anda dapat menambahkan pekerjaan baru atau menghapus yang lama dengan cepat.

catatan: Saya penulis perpustakaan ini

Instal APScheduler

pip install apscheduler

Lihat fungsi file untuk memanggil

nama file: scheduler_jobs.py

def FirstCronTest():
    print("")
    print("I am executed..!")

Mengkonfigurasi penjadwal

buat file execut.py dan tambahkan kode di bawah ini

from apscheduler.schedulers.background import BackgroundScheduler
scheduler = BackgroundScheduler()

Fungsi tertulis Anda Di sini, fungsi scheduler ditulis dalam scheduler_jobs

import scheduler_jobs 

scheduler.add_job(scheduler_jobs.FirstCronTest, 'interval', seconds=10)
scheduler.start()

Tautkan File untuk Eksekusi

Sekarang, tambahkan baris di bawah ini di bagian bawah file Url

import execute

• Anda dapat memeriksa kode lengkap dengan menjalankan [Klik di sini] https://github.com/devchandansh/django-apscheduler

Saya memiliki sesuatu yang mirip dengan masalah Anda hari ini.

Saya tidak ingin itu ditangani oleh server trhough cron (dan sebagian besar Lib hanya pembantu cron pada akhirnya).

Jadi saya telah membuat modul penjadwalan dan melampirkannya di init .

Ini bukan pendekatan terbaik, tetapi ini membantu saya untuk memiliki semua kode di satu tempat dan dengan eksekusi yang terkait dengan aplikasi utama.

Ya, metode di atas sangat bagus. Dan saya mencoba beberapa dari mereka. Akhirnya, saya menemukan metode seperti ini:

    from threading import Timer

    def sync():

        do something...

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

Sama seperti Rekursif .

Ok, saya harap metode ini dapat memenuhi kebutuhan Anda. :)

Solusi yang lebih modern (dibandingkan dengan Seledri) adalah Django Q: https://django-q.readthedocs.io/en/latest/index.html

Ini memiliki dokumentasi yang bagus dan mudah untuk grok. Dukungan Windows kurang, karena Windows tidak mendukung proses forking. Tapi itu berfungsi dengan baik jika Anda membuat lingkungan dev Anda menggunakan Subsistem Windows untuk Linux.

Saya menggunakan seledri untuk membuat tugas berkala saya. Pertama, Anda perlu menginstalnya sebagai berikut:

pip install django-celery

Jangan lupa untuk mendaftar django-celerydi pengaturan Anda dan kemudian Anda dapat melakukan sesuatu seperti ini:

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

Saya tidak yakin apakah ini akan berguna bagi siapa pun, karena saya harus menyediakan pengguna lain dari sistem untuk menjadwalkan pekerjaan, tanpa memberi mereka akses ke Penjadwal Tugas server (windows), saya membuat aplikasi yang dapat digunakan kembali ini.

Harap perhatikan pengguna memiliki akses ke satu folder bersama di server tempat mereka dapat membuat file perintah / tugas / .bat yang diperlukan. Tugas ini kemudian dapat dijadwalkan menggunakan aplikasi ini.

Nama aplikasi adalah Django_Windows_Scheduler

Tangkapan Layar:

Jika Anda menginginkan sesuatu yang lebih dapat diandalkan daripada Seledri , coba TaskHawk yang dibangun di atas AWS SQS / SNS .

Rujuk: http://taskhawk.readthedocs.io

Untuk proyek-proyek buruh pelabuhan sederhana, saya tidak bisa benar-benar melihat jawaban yang sesuai.

Jadi saya menulis solusi yang sangat barebones tanpa perlu perpustakaan atau pemicu eksternal, yang berjalan sendiri. Tidak diperlukan os-cron eksternal, harus bekerja di setiap lingkungan.

Ini berfungsi dengan menambahkan middleware: middleware.py

import threading

def should_run(name, seconds_interval):
    from application.models import CronJob
    from django.utils.timezone import now

    try:
        c = CronJob.objects.get(name=name)
    except CronJob.DoesNotExist:
        CronJob(name=name, last_ran=now()).save()
        return True

    if (now() - c.last_ran).total_seconds() >= seconds_interval:
        c.last_ran = now()
        c.save()
        return True

    return False


class CronTask:
    def __init__(self, name, seconds_interval, function):
        self.name = name
        self.seconds_interval = seconds_interval
        self.function = function


def cron_worker(*_):
    if not should_run("main", 60):
        return

    # customize this part:
    from application.models import Event
    tasks = [
        CronTask("events", 60 * 30, Event.clean_stale_objects),
        # ...
    ]

    for task in tasks:
        if should_run(task.name, task.seconds_interval):
            task.function()


def cron_middleware(get_response):

    def middleware(request):
        response = get_response(request)
        threading.Thread(target=cron_worker).start()
        return response

    return middleware

models/cron.py:

from django.db import models


class CronJob(models.Model):
    name = models.CharField(max_length=10, primary_key=True)
    last_ran = models.DateTimeField()

settings.py:

MIDDLEWARE = [
    ...
    'application.middleware.cron_middleware',
    ...
]

Cara sederhana adalah dengan menulis perintah shell kustom lihat Django Documentation dan jalankan dengan menggunakan cronjob di linux. Namun saya sangat merekomendasikan menggunakan broker pesan seperti RabbitMQ ditambah dengan seledri. Mungkin Anda bisa melihat Tutorial ini