Impostare un lavoro pianificato?

Ho lavorato su un'app Web usando Django e sono curioso di sapere se esiste un modo per pianificare l'esecuzione periodica di un lavoro.

Fondamentalmente voglio solo scorrere il database ed eseguire alcuni calcoli / aggiornamenti su base automatica e regolare, ma non riesco a trovare alcuna documentazione su come farlo.

Qualcuno sa come impostare questo?

Per chiarire: so di poter impostare un cronlavoro per farlo, ma sono curioso di sapere se c'è qualche funzionalità in Django che fornisce questa funzionalità. Vorrei che le persone fossero in grado di distribuire questa app da soli senza dover fare molta configurazione (preferibilmente zero).

Ho pensato di innescare queste azioni "retroattivamente" semplicemente controllando se un lavoro avrebbe dovuto essere eseguito dall'ultima volta che una richiesta è stata inviata al sito, ma spero in qualcosa di un po 'più pulito.

Una soluzione che ho impiegato è di fare questo:

1) Creare un comando di gestione personalizzato , ad es

python manage.py my_cool_command

2) Utilizzare cron(su Linux) oat (su Windows) per eseguire il mio comando nei tempi richiesti.

Questa è una soluzione semplice che non richiede l'installazione di uno stack AMQP pesante. Tuttavia ci sono dei bei vantaggi nell'usare qualcosa come il sedano, menzionato nelle altre risposte. In particolare, con Celery è bello non dover diffondere la logica dell'applicazione in file crontab. Tuttavia, la soluzione cron funziona abbastanza bene per un'applicazione di piccole e medie dimensioni e dove non si vogliono molte dipendenze esterne.

MODIFICARE:

Nella versione successiva di Windows il atcomando è obsoleto per Windows 8, Server 2012 e versioni successive. Puoi usare schtasks.exeper lo stesso uso.

**** AGGIORNAMENTO **** Questo è il nuovo link di django doc per la scrittura del comando di gestione personalizzato

Il sedano è una coda di attività distribuita, costruita su AMQP (RabbitMQ). Gestisce anche le attività periodiche in modo cronologico (vedere le attività periodiche ). A seconda della tua app, potrebbe valere la pena.

Il sedano è abbastanza facile da configurare con django ( docs ) e le attività periodiche salteranno effettivamente le attività perse in caso di tempi di inattività. Il sedano ha anche meccanismi di riprova integrati, nel caso in cui un'attività fallisca.

Abbiamo scoperto ciò che penso sia un'app strutturata. che anche la soluzione di Brian allude. Ci piacerebbe qualsiasi / tutti i feedback!

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

Viene fornito con un comando di gestione:

./manage.py runcrons

Questo fa il lavoro. Ogni cron è modellato come una classe (quindi è tutto OO) e ogni cron funziona a una frequenza diversa e ci assicuriamo che lo stesso tipo cron non funzioni in parallelo (nel caso in cui i croni stessi impieghino più tempo a correre rispetto alla loro frequenza!)

Se stai usando un sistema operativo POSIX standard, usi cron .

Se stai usando Windows, lo usi a .

Scrivi un comando di gestione Django su

1. Scopri su quale piattaforma si trovano.

2. Esegui il comando "AT" appropriato per i tuoi utenti o aggiorna il crontab per i tuoi utenti.

Interessante nuova app Django collegabile: django-chronograph

Devi solo aggiungere una voce cron che funge da timer e hai un'interfaccia di amministrazione Django molto bella negli script da eseguire.

Guarda Cronologia del povero uomo di Django che è un'app di Django che utilizza spambots, robot di indicizzazione dei motori di ricerca e simili per eseguire attività pianificate a intervalli di circa regolari

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

Avevo esattamente lo stesso requisito qualche tempo fa e ho finito per risolverlo usando APScheduler ( Guida per l'utente )

Rende la pianificazione dei lavori super semplice e lo mantiene indipendente dall'esecuzione basata su richiesta di alcuni codici. Di seguito è riportato un semplice esempio.

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

Spero che questo aiuti qualcuno!

Il suggerimento di Brian Neal di eseguire i comandi di gestione tramite cron funziona bene, ma se stai cercando qualcosa di un po 'più robusto (ma non così elaborato come il sedano) guarderei in una libreria come Kronos :

# app/cron.py

import kronos

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

RabbitMQ e Sedano hanno più funzioni e capacità di gestione delle attività rispetto a Cron. Se il fallimento dell'attività non è un problema e pensi che gestirai le attività interrotte nella prossima chiamata, allora Cron è sufficiente.

Sedano e AMQP ti permetteranno di gestire l'attività interrotta e verrà eseguita di nuovo da un altro lavoratore (i lavoratori del sedano ascoltano l'attività successiva su cui lavorare), fino a quando non max_retriesviene raggiunto l' attributo dell'attività. È anche possibile richiamare attività in caso di errore, come la registrazione dell'errore o l'invio di un'e-mail all'amministratore una voltamax_retries è stato raggiunto.

E puoi distribuire i server Celery e AMQP quando devi ridimensionare la tua applicazione.

Personalmente uso cron, ma le parti di Job Scheduling di django-extensions sembrano interessanti.

Sebbene non faccia parte di Django, Airflow è un progetto più recente (a partire dal 2016) che è utile per la gestione delle attività.

Airflow è un sistema di automazione e pianificazione del flusso di lavoro che può essere utilizzato per creare e gestire pipeline di dati. Un'interfaccia utente basata sul Web offre allo sviluppatore una gamma di opzioni per la gestione e la visualizzazione di queste pipeline.

Airflow è scritto in Python ed è costruito usando Flask.

Airflow è stato creato da Maxime Beauchemin presso Airbnb e open source nella primavera del 2015. È entrato a far parte del programma di incubazione della Apache Software Foundation nell'inverno del 2016. Ecco la pagina del progetto Git e alcune informazioni di base aggiuntive .

Inserisci quanto segue nella parte superiore del file cron.py:

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

Ho appena pensato a questa soluzione piuttosto semplice:

1. Definisci una funzione di visualizzazione do_work (req, param) come faresti con qualsiasi altra vista, con mappatura URL, restituisce un HttpResponse e così via.
2. Imposta un processo cron con le tue preferenze di temporizzazione (o usando AT o Attività pianificate in Windows) che esegue l' arricciatura http: // localhost / your / mapped / url? Param = value .

Puoi aggiungere parametri ma semplicemente aggiungere parametri all'URL.

Dimmi cosa ne pensate voi ragazzi.

[Aggiornamento] Ora sto usando il comando runjob da django-extensions anziché curl.

Il mio cron ha un aspetto simile al seguente:

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

... e così via ogni giorno, mensilmente, ecc. È inoltre possibile configurarlo per eseguire un lavoro specifico.

Lo trovo più gestibile e più pulito. Non richiede il mapping di un URL a una vista. Basta definire la propria classe professionale e crontab e il gioco è fatto.

dopo la parte del codice, posso scrivere qualcosa come il mio 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)
#######################################

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

Dovresti assolutamente dare un'occhiata a Django-q! Non richiede alcuna configurazione aggiuntiva e ha probabilmente tutto il necessario per gestire eventuali problemi di produzione su progetti commerciali.

È attivamente sviluppato e si integra molto bene con django, django ORM, mongo, redis. Ecco la mia configurazione:

# 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 per lavori Scheduler. Advanced Python Scheduler (APScheduler) è una libreria Python che consente di pianificare l'esecuzione del codice Python in un secondo momento, una sola volta o periodicamente. Puoi aggiungere nuovi lavori o rimuovere quelli vecchi al volo come preferisci.

nota: sono l'autore di questa biblioteca

Installa APScheduler

pip install apscheduler

Visualizza la funzione del file da chiamare

nome del file: scheduler_jobs.py

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

Configurazione dello scheduler

crea il file execute.py e aggiungi i seguenti codici

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

Le tue funzioni scritte Qui, le funzioni dello scheduler sono scritte in scheduler_jobs

import scheduler_jobs 

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

Collegare il file per l'esecuzione

Ora, aggiungi la riga in basso nella parte inferiore del file Url

import execute

• Puoi controllare il codice completo eseguendo [Fai clic qui] https://github.com/devchandansh/django-apscheduler

Ho avuto qualcosa di simile con il tuo problema oggi.

Non volevo che fosse gestito dal server tramite cron (e la maggior parte delle librerie erano solo aiutanti di cron alla fine).

Quindi ho creato un modulo di programmazione e l'ho collegato all'init .

Non è l'approccio migliore, ma mi aiuta ad avere tutto il codice in un unico posto e con la sua esecuzione correlata all'app principale.

Sì, il metodo sopra è fantastico. E ho provato alcuni di loro. Alla fine, ho trovato un metodo come questo:

    from threading import Timer

    def sync():

        do something...

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

Proprio come ricorsivo .

Ok, spero che questo metodo possa soddisfare le tue esigenze. :)

Una soluzione più moderna (rispetto al sedano) è Django Q: https://django-q.readthedocs.io/en/latest/index.html

Ha un'ottima documentazione ed è facile da capire. Manca il supporto di Windows, perché Windows non supporta il processo di biforcazione. Funziona bene se crei il tuo ambiente di sviluppo usando il sottosistema Windows per Linux.

Uso il sedano per creare i miei compiti periodici. Innanzitutto è necessario installarlo come segue:

pip install django-celery

Non dimenticare di registrarti django-celerynelle tue impostazioni e quindi potresti fare qualcosa del genere:

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

Non sono sicuro che questo sarà utile a chiunque, dato che ho dovuto fornire ad altri utenti del sistema la pianificazione dei lavori, senza dare loro l'accesso all'utilità di pianificazione del server (Windows), ho creato questa app riutilizzabile.

Si noti che gli utenti hanno accesso a una cartella condivisa sul server in cui possono creare il file comando / task / .bat richiesto. Questa attività può quindi essere pianificata utilizzando questa app.

Il nome dell'app è Django_Windows_Scheduler

Immagine dello schermo:

Se vuoi qualcosa di più affidabile del sedano , prova TaskHawk che si basa su AWS SQS / SNS .

Consultare: http://taskhawk.readthedocs.io

Per i semplici progetti dockerizzati, non riuscivo a vedere alcuna risposta adatta.

Quindi ho scritto una soluzione molto barebone senza la necessità di librerie o trigger esterni, che funziona da solo. Nessun os-cron esterno necessario, dovrebbe funzionare in ogni ambiente.

Funziona aggiungendo un 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',
    ...
]

Un modo semplice è scrivere un comando shell personalizzato, consultare la documentazione Django ed eseguirlo usando un cronjob su Linux. Tuttavia consiglio vivamente di utilizzare un broker di messaggi come RabbitMQ accoppiato con sedano. Forse puoi dare un'occhiata a questo tutorial