python - template - django urls
Django-configurar un trabajo programado? (21)
He estado trabajando en una aplicación web usando Django, y tengo curiosidad por saber si hay una manera de programar un trabajo para que se ejecute periódicamente.
Básicamente, solo quiero correr a través de la base de datos y hacer algunos cálculos / actualizaciones de forma automática y regular, pero parece que no puedo encontrar ninguna documentación sobre cómo hacer esto.
¿Alguien sabe cómo configurar esto?
Para aclarar: sé que puedo configurar un trabajo cron para hacer esto, pero tengo curiosidad por saber si hay alguna característica en Django que proporciona esta funcionalidad. Me gustaría que la gente pudiera implementar esta aplicación sin tener que hacer mucha configuración (preferiblemente cero).
He considerado desencadenar estas acciones "retroactivamente" simplemente verificando si un trabajo debería haberse ejecutado desde la última vez que se envió una solicitud al sitio, pero espero algo un poco más limpio.
¡Definitivamente deberías revisar django-q! No requiere ninguna configuración adicional y posiblemente tenga todo lo necesario para manejar cualquier problema de producción en proyectos comerciales.
Se desarrolla activamente y se integra muy bien con django, django ORM, mongo, redis. Aquí está mi configuración:
# 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,
},
}
Acabo de pensar en esta solución bastante simple:
- Defina una función de vista do_work (req, param) como lo haría con cualquier otra vista, con la asignación de URL, devolverá una HttpResponse y así sucesivamente.
- Configure un trabajo cron con sus preferencias de tiempo (o usando AT o Tareas programadas en Windows) que ejecuta curl http://localhost/your/mapped/url?param=value .
Puede agregar parámetros pero solo agregar parámetros a la URL.
Dime que piensan ustedes.
[Actualización] Ahora estoy usando el comando runjob de django-extensions lugar de curl.
Mi cron se ve algo como esto:
@hourly python /path/to/project/manage.py runjobs hourly
... y así sucesivamente para diario, mensual, etc ''. También puede configurarlo para ejecutar un trabajo específico.
Lo encuentro más manejable y más limpio. No requiere asignar una URL a una vista. Solo define tu clase de trabajo y crontab y listo.
Aunque no es parte de Django, Airflow es un proyecto más reciente (a partir de 2016) que es útil para la administración de tareas.
Airflow es un sistema de programación y automatización del flujo de trabajo que se puede utilizar para crear y administrar las tuberías de datos. Una interfaz de usuario basada en la web proporciona al desarrollador una amplia gama de opciones para administrar y ver estos canales.
El flujo de aire está escrito en Python y se construye utilizando Flask.
El flujo de aire fue creado por Maxime Beauchemin en Airbnb y se abrió en la primavera de 2015. Se unió al programa de incubación de Apache Software Foundation en el invierno de 2016. Aquí está la página del proyecto Git e información adicional sobre los antecedentes .
La sugerencia de Brian Neal de ejecutar comandos de administración a través de cron funciona bien, pero si buscas algo un poco más robusto (pero no tan elaborado como Celery) buscaría en una biblioteca como Kronos :
# app/cron.py
import kronos
@kronos.register(''0 * * * *'')
def task():
pass
Mire el Cron del pobre hombre de Django, que es una aplicación de Django que utiliza robots de búsqueda, robots de indexación de motores de búsqueda y por igual para ejecutar tareas programadas en intervalos aproximadamente regulares.
No estoy seguro de que esto sea útil para nadie, ya que tuve que proporcionar a otros usuarios del sistema para programar los trabajos, sin darles acceso al Programador de tareas real del servidor (Windows), creé esta aplicación reutilizable.
Tenga en cuenta que los usuarios tienen acceso a una carpeta compartida en el servidor donde pueden crear el archivo de comando / tarea / .bat requerido. Esta tarea puede ser programada usando esta aplicación.
El nombre de la aplicación es Django_Windows_Scheduler
Nueva aplicación Django interesante e interesante: django-chronograph
Solo tiene que agregar una entrada cron que actúe como un temporizador, y tiene una interfaz de administración de Django muy agradable en los scripts para ejecutar.
Personalmente uso cron, pero las partes de Programación de trabajos de django-extensions parecen interesantes.
Ponga lo siguiente en la parte superior de su archivo 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
RabbitMQ y Celery tienen más funciones y capacidades de manejo de tareas que Cron. Si la falla de la tarea no es un problema, y cree que manejará las tareas interrumpidas en la próxima llamada, Cron es suficiente.
Celery & AMQP le permitirá manejar la tarea rota, y será ejecutado de nuevo por otro trabajador (los trabajadores de Celery escucharán la siguiente tarea para trabajar), hasta que se max_retries atributo max_retries la tarea. Incluso puede invocar tareas en caso de error, como registrar el error o enviar un correo electrónico al administrador una vez que se ha alcanzado el max_retries .
Y puede distribuir los servidores Celery y AMQP cuando necesite escalar su aplicación.
Sí, el método anterior es muy bueno. Y probé algunos de ellos. Por fin, encontré un método como este:
from threading import Timer
def sync():
do something...
sync_timer = Timer(self.interval, sync, ())
sync_timer.start()
Al igual que recursivo .
Ok, espero que este método pueda satisfacer sus necesidades. :)
Si desea algo más confiable que Celery , pruebe TaskHawk que está construido sobre AWS SQS / SNS .
Consulte: http://taskhawk.readthedocs.io
Tenía exactamente el mismo requisito hace un tiempo y terminé resolviéndolo utilizando APScheduler ( Guía del usuario )
Hace que la programación de trabajos sea súper simple y la mantiene independiente de la ejecución de algún código basada en la solicitud. A continuación hay un ejemplo simple que utilicé en mi código.
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
Espero que esto ayude a alguien!
Tenemos una fuente abierta que creo que es una aplicación estructurada. que la solución de Brian anterior alude también. Me encantaría cualquier / todos los comentarios!
https://github.com/tivix/django-cron
Viene con un comando de gestión:
./manage.py runcrons
Eso hace el trabajo. Cada cron se modela como una clase (por lo que es todo OO) y cada cron se ejecuta en una frecuencia diferente y nos aseguramos de que el mismo tipo de cron no se ejecute en paralelo (¡en caso de que los crons demoren más en ejecutarse que su frecuencia!)
¡Gracias!
Tuve algo similar con tu problema hoy.
No quería que lo manejara el servidor a través de cron (y la mayoría de las librerías eran solo ayudantes de cron al final).
Así que he creado un módulo de programación y lo he adjuntado al init .
No es el mejor enfoque, pero me ayuda a tener todo el código en un solo lugar y con su ejecución relacionada con la aplicación principal.
Una solución más moderna (en comparación con Celery) es Django Q: https://django-q.readthedocs.io/en/latest/index.html
Tiene una gran documentación y es fácil de asimilar. Falta el soporte de Windows, porque Windows no admite el procesamiento de procesos. Pero funciona bien si creas tu entorno de desarrollo con Windows para el subsistema de Linux.
Una solución que he empleado es hacer esto:
1) Crear un comando de gestión personalizado , por ejemplo,
python manage.py my_cool_command
2) Use cron (en Linux) o at (en Windows) para ejecutar mi comando en los momentos requeridos.
Esta es una solución simple que no requiere la instalación de una pila AMQP pesada. Sin embargo, hay buenas ventajas de usar algo como el apio, mencionado en las otras respuestas. En particular, con Celery es bueno no tener que distribuir la lógica de su aplicación en archivos crontab. Sin embargo, la solución cron funciona bastante bien para una aplicación de tamaño pequeño a mediano y donde no se desean muchas dependencias externas.
EDITAR:
En la versión posterior de Windows, el comando at está en desuso para Windows 8, Server 2012 y superior. Puedes usar schtasks.exe para el mismo uso.
Uso el apio para crear mis tareas periódicas. Primero necesitas instalarlo de la siguiente manera:
pip install django-celery
No olvides registrar django-celery en tu configuración y luego podrías hacer algo como esto:
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
después de la parte del código, puedo escribir cualquier cosa como mis 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)
#######################################
de http://www.cotellese.net/2007/09/27/running-external-scripts-against-django-models/
Celery es una cola de tareas distribuida, construida en AMQP (RabbitMQ). También maneja tareas periódicas de manera similar a cron (ver tareas periódicas ). Dependiendo de tu aplicación, podría valer la pena echarle un vistazo.
El apio es bastante fácil de configurar con django ( docs ), y las tareas periódicas en realidad omitirán las tareas perdidas en caso de un tiempo de inactividad. El apio también tiene mecanismos de reintento incorporados, en caso de que una tarea falle.