Come controllare lo stato delle attività in Celery?

Come si controlla se un'attività è in esecuzione in sedano (in particolare, sto usando celery-django)?

Ho letto la documentazione e ho cercato su Google, ma non riesco a vedere una chiamata come:

my_example_task.state() == RUNNING

Il mio caso d'uso è che dispongo di un servizio esterno (java) per la transcodifica. Quando invio un documento da transcodificare, desidero verificare se l'attività che esegue quel servizio è in esecuzione e, in caso contrario, (ri) avviarla.

Sto usando le attuali versioni stabili - 2.4, credo.

Restituire task_id (che è dato da .delay ()) e chiedere successivamente all'istanza di celery sullo stato:

x = method.delay(1,2)
print x.task_id

Quando lo chiedi, ottieni un nuovo AsyncResult usando questo task_id:

from celery.result import AsyncResult
res = AsyncResult("your-task-id")
res.ready()

La creazione di un AsyncResultoggetto dall'id dell'attività è il modo consigliato nelle FAQ per ottenere lo stato dell'attività quando l'unica cosa che hai è l'ID dell'attività.

Tuttavia, a partire da Celery 3.x, ci sono avvertimenti significativi che potrebbero mordere le persone se non prestano loro attenzione. Dipende davvero dallo scenario del caso d'uso specifico.

Per impostazione predefinita, Celery non registra uno stato "in esecuzione".

Al fine di sedano per registrare che un compito è in esecuzione, è necessario impostare task_track_starteda True. Ecco una semplice attività che verifica questo:

@app.task(bind=True)
def test(self):
    print self.AsyncResult(self.request.id).state

Quando task_track_startedè False, che è l'impostazione predefinita, lo stato mostra PENDINGanche se l'attività è iniziata. Se imposti task_track_startedsu True, lo stato saràSTARTED .

Lo stato PENDING significa "non lo so".

Un AsyncResultcon lo stato PENDINGnon significa altro che Celery non conosce lo stato del compito. Ciò potrebbe essere dovuto a diversi motivi.

Per prima cosa, AsyncResultpuò essere costruito con ID attività non validi. Tali "compiti" saranno considerati in sospeso da Celery:

>>> task.AsyncResult("invalid").status
'PENDING'

Ok, quindi nessuno fornirà ID ovviamente non validi a AsyncResult. Abbastanza giusto, ma ha anche l'effetto che AsyncResultconsidererà anche un'attività che è stata eseguita con successo ma che Celery ha dimenticato come essere PENDING. Di nuovo, in alcuni casi d'uso questo può essere un problema. Parte del problema dipende dal modo in cui Celery è configurato per conservare i risultati delle attività, perché dipende dalla disponibilità delle "lapidi" nel backend dei risultati. ("Tombstones" è il termine utilizzato nella documentazione di Celery per i blocchi di dati che registrano il modo in cui l'attività è terminata.) L'utilizzo AsyncResultnon funzionerà affatto se task_ignore_resultèTrue . Un problema più fastidioso è che Celery fa scadere le lapidi per impostazione predefinita. Ilresult_expiresl'impostazione predefinita è impostata su 24 ore. Quindi, se avvii un'attività e registri l'id nella memoria a lungo termine e più 24 ore dopo, crei un AsyncResultcon esso, lo stato sarà PENDING.

Tutti i "compiti reali" iniziano nello PENDINGstato. Quindi PENDINGeseguire un'attività potrebbe significare che l'attività è stata richiesta ma non è mai progredita oltre (per qualsiasi motivo). Oppure potrebbe significare che l'attività è stata eseguita ma Celery ha dimenticato il suo stato.

Ahia! AsyncResultnon funzionerà per me. Cos'altro posso fare?

Preferisco tenere traccia degli obiettivi piuttosto che tenere traccia delle attività stesse . Conservo alcune informazioni sulle attività, ma è davvero secondario per tenere traccia degli obiettivi. Gli obiettivi sono conservati in un magazzino indipendente da Celery. Quando una richiesta deve eseguire un calcolo dipende dal raggiungimento di un obiettivo, controlla se l'obiettivo è già stato raggiunto, se sì, utilizza questo obiettivo memorizzato nella cache, altrimenti avvia l'attività che avrà effetto sull'obiettivo e invia a il client che ha effettuato la richiesta HTTP una risposta che indica che dovrebbe attendere un risultato.

I nomi delle variabili e i collegamenti ipertestuali sopra riportati sono per Celery 4.x. In 3.x le variabili e collegamenti corrispondenti sono: CELERY_TRACK_STARTED, CELERY_IGNORE_RESULT, CELERY_TASK_RESULT_EXPIRES.

Ogni Taskoggetto ha una .requestproprietà, che lo contiene AsyncRequestoggetto. Di conseguenza, la riga seguente fornisce lo stato di un'attività task:

task.AsyncResult(task.request.id).state

Puoi anche creare stati personalizzati e aggiornare la sua esecuzione dell'attività di valore. Questo esempio è tratto da documenti:

@app.task(bind=True)
def upload_files(self, filenames):
    for i, file in enumerate(filenames):
        if not self.request.called_directly:
            self.update_state(state='PROGRESS',
                meta={'current': i, 'total': len(filenames)})

http://celery.readthedocs.org/en/latest/userguide/tasks.html#custom-states

Vecchia domanda ma recentemente mi sono imbattuto in questo problema.

Se stai cercando di ottenere task_id, puoi farlo in questo modo:

import celery
from celery_app import add
from celery import uuid

task_id = uuid()
result = add.apply_async((2, 2), task_id=task_id)

Ora sai esattamente cos'è task_id e ora puoi usarlo per ottenere AsyncResult:

# grab the AsyncResult 
result = celery.result.AsyncResult(task_id)

# print the task id
print result.task_id
09dad9cf-c9fa-4aee-933f-ff54dae39bdf

# print the AsyncResult's status
print result.status
SUCCESS

# print the result returned 
print result.result
4

Usa questa API dalle domande frequenti sul sedano

result = app.AsyncResult(task_id)

Funziona bene.

Risposta del 2020:

#### tasks.py
@celery.task()
def mytask(arg1):
    print(arg1)

#### blueprint.py
@bp.route("/args/arg1=<arg1>")
def sleeper(arg1):
    process = mytask.apply_async(args=(arg1,)) #mytask.delay(arg1)
    state = process.state
    return f"Thanks for your patience, your job {process.task_id} \
             is being processed. Status {state}"

Provare:

task.AsyncResult(task.request.id).state

questo fornirà lo stato dell'attività sul sedano. Se Celery Task è già in stato di FALLIMENTO , verrà generata un'eccezione:

raised unexpected: KeyError('exc_type',)

per compiti semplici, possiamo usare http://flower.readthedocs.io/en/latest/screenshots.html e http://policystat.github.io/jobtastic/ per eseguire il monitoraggio.

e per compiti complicati, diciamo un compito che si occupa di molti altri moduli. Si consiglia di registrare manualmente lo stato di avanzamento e il messaggio sull'unità di attività specifica.

Ho trovato informazioni utili nel file

Celery Project Workers Guide ispettori-lavoratori

Nel mio caso, sto controllando se Celery è in esecuzione.

inspect_workers = task.app.control.inspect()
if inspect_workers.registered() is None:
    state = 'FAILURE'
else:
    state = str(task.state) 

Puoi giocare con inspect per soddisfare le tue esigenze.

• Primo ， nella tua APP sedano ：

vi my_celery_apps / app1.py

app = Celery(worker_name)

• e successivamente, passa al file delle attività ， importa l'app dal modulo dell'app sedano.

vi task / task1.py

from my_celery_apps.app1 import app

app.AsyncResult(taskid)

try:
   if task.state.lower() != "success":
        return
except:
    """ do something """

A parte l'approccio programmatico di cui sopra, lo stato di utilizzo di Flower Task può essere facilmente visto.

Monitoraggio in tempo reale tramite Celery Events. Flower è uno strumento basato sul web per il monitoraggio e l'amministrazione dei cluster di Celery.

1. Avanzamento e cronologia delle attività
2. Possibilità di mostrare i dettagli dell'attività (argomenti, ora di inizio, runtime e altro)
3. Grafici e statistiche

Documento ufficiale: Fiore - Strumento di monitoraggio del sedano

Installazione:

$ pip install flower

Utilizzo:

http://localhost:5555

res = method.delay()
    
print(f"id={res.id}, state={res.state}, status={res.status} ")

print(res.get())