Celery ülesannete järjekord: Hajutatud ülesannete töötlemine Redis integratsiooni kaudu

Tänapäeva üha keerukamate ja nõudlikumate rakenduste maailmas on võime ülesandeid asünkroonselt käsitleda ülimalt oluline. Celery, võimas hajutatud ülesannete järjekord, pakub tugevat lahendust aeganõudvate või ressursimahukate ülesannete peamisest rakendusvoost eemaldamiseks. Koos Redisega, mitmekülgse mälusisese andmestruktuuride poega, pakub Celery väga skaleeritavat ja tõhusat lähenemist taustaülesannete töötlemisele.

Mis on Celery?

Celery on asünkroonne ülesannete/tööde järjekord, mis põhineb hajutatud sõnumiedastusel. Seda kasutatakse ülesannete asünkroonseks (taustal) täitmiseks väljaspool rakenduse peamist voogu. See on oluline:

• Rakenduse reageerimisvõime parandamine: Suunates ülesanded Celery töölistele, jääb teie veebirakendus reageerivaks ega külmu keeruliste toimingute töötlemise ajal.
• Skaleeritavus: Celery võimaldab teil jaotada ülesandeid mitme töölise sõlme vahel, skaleerides oma töötlemisvõimsust vastavalt vajadusele.
• Töökindlus: Celery toetab ülesannete korduskatseid ja veakäsitlust, tagades, et ülesanded lõpuks täidetakse isegi rikete korral.
• Pikaajaliste ülesannete käsitlemine: Protsessid, mis võtavad märkimisväärselt aega, nagu video transkodeerimine, aruannete genereerimine või suurte e-kirjade hulga saatmine, sobivad ideaalselt Celery jaoks.

Miks kasutada Redise koos Celeryga?

Kuigi Celery toetab erinevaid sõnumivahendajaid (RabbitMQ, Redis jne), on Redis populaarne valik oma lihtsuse, kiiruse ja seadistamise lihtsuse tõttu. Redis toimib nii sõnumivahendajana (transport) kui ka valikuliselt Celery tulemuste taustasüsteemina. Siin on, miks Redis sobib hästi:

• Kiirus: Redis on mälusisene andmehoidla, mis tagab ülikiire sõnumiedastuse ja tulemuste kättesaamise.
• Lihtsus: Redise seadistamine ja konfigureerimine on suhteliselt lihtne.
• Püsivus (valikuline): Redis pakub püsivusvõimalusi, mis võimaldavad teil ülesandeid taastada vahendaja rikke korral.
• Pub/Sub tugi: Redise avaldamise/tellimise võimekus sobib hästi Celery sõnumiedastuse arhitektuuriga.

Celery põhikomponendid

Celery põhikomponentide mõistmine on tõhusa ülesannete haldamise jaoks hädavajalik:

• Celery rakendus (celery): Peamine sisendpunkt Celeryga suhtlemiseks. See vastutab ülesannete järjekorra konfigureerimise ning vahendaja ja tulemuste taustasüsteemiga ühenduse loomise eest.
• Ülesanded: Funktsioonid või meetodid, mis on dekoreeritud @app.task'iga ja esindavad asünkroonselt täidetavaid töid.
• Töölised: Protsessid, mis täidavad ülesandeid. Töötlemisvõimsuse suurendamiseks saate käivitada mitu töölist ühel või mitmel masinal.
• Vahendaja (sõnumijärjekord): Vahendaja, mis transpordib ülesandeid rakendusest töölistele. Kasutada saab Redise, RabbitMQ-d ja teisi sõnumivahendajaid.
• Tulemuste taustasüsteem: Salvestab ülesannete tulemused. Celery saab tulemuste salvestamiseks kasutada Redise, andmebaase (nagu PostgreSQL või MySQL) või muid taustasüsteeme.

Celery ja Redise seadistamine

Siin on samm-sammuline juhend Celery ja Redise seadistamiseks:

1. Sõltuvuste paigaldamine

Esmalt paigaldage Celery ja Redis pip abil:

            pip install celery redis
            

              
                Copy
              
            
          

2. Redis serveri paigaldamine

Paigaldage redis-server. Juhised varieeruvad sõltuvalt teie operatsioonisüsteemist. Näiteks Ubuntus:

            sudo apt update
sudo apt install redis-server
            

              
                Copy
              
            
          

macOS jaoks (kasutades Homebrew'd):

            brew install redis
            

              
                Copy
              
            
          

Windowsi jaoks saate Redise alla laadida ametlikult Redise veebisaidilt või kasutada Chocolatey'd:

            choco install redis
            

              
                Copy
              
            
          

3. Celery konfigureerimine

Looge fail celeryconfig.py Celery konfigureerimiseks:

            # celeryconfig.py

broker_url = 'redis://localhost:6379/0'
result_backend = 'redis://localhost:6379/0'

task_serializer = 'json'
result_serializer = 'json'
accept_content = ['json']
timezone = 'UTC'
enable_utc = True
            

              
                Copy
              
            
          

Selgitus:

• broker_url: Määrab Redise vahendaja URL-i. Redise vaikimisi port on 6379. /0 tähistab Redise andmebaasi numbrit (0-15).
• result_backend: Määrab Redise tulemuste taustasüsteemi URL-i, kasutades sama konfiguratsiooni kui vahendaja puhul.
• task_serializer ja result_serializer: Seadistab serialiseerimismeetodiks JSON-i ülesannete ja tulemuste jaoks.
• accept_content: Loetleb ülesannete jaoks aktsepteeritud sisutüübid.
• timezone ja enable_utc: Konfigureerib ajavööndi seaded. Erinevate serverite vahelise järjepidevuse tagamiseks on soovitatav kasutada UTC-d.

4. Celery rakenduse loomine

Looge Pythoni fail (nt tasks.py) oma Celery rakenduse ja ülesannete määratlemiseks:

            # tasks.py

from celery import Celery
import time

app = Celery('my_tasks', broker='redis://localhost:6379/0', backend='redis://localhost:6379/0')
app.config_from_object('celeryconfig')

@app.task
def add(x, y):
    time.sleep(5)  # Simuleerib pikaajalist ülesannet
    return x + y

@app.task
def send_email(recipient, subject, body):
    # Simuleerib e-kirja saatmist
    print(f"Sending email to {recipient} with subject '{subject}' and body '{body}'")
    time.sleep(2)
    return f"Email sent to {recipient}"
            

              
                Copy
              
            
          

Selgitus:

• Celery('my_tasks', broker=...): Loob Celery rakenduse nimega 'my_tasks' ja konfigureerib vahendaja ning taustasüsteemi URL-ide abil. Alternatiivselt võite broker ja backend argumendid ära jätta, kui konfigureerite need ainult app.config_from_object('celeryconfig') abil.
• @app.task: Dekoraator, mis muudab tavalise Pythoni funktsiooni Celery ülesandeks.
• add(x, y): Lihtne ülesanne, mis liidab kaks arvu ja ootab 5 sekundit, et simuleerida pikaajalist toimingut.
• send_email(recipient, subject, body): Simuleerib e-kirja saatmist. Reaalses stsenaariumis hõlmaks see e-posti serveriga ühenduse loomist ja kirja saatmist.

5. Celery töölise käivitamine

Avage terminal ja navigeerige kausta, mis sisaldab faile tasks.py ja celeryconfig.py. Seejärel käivitage Celery tööline:

            celery -A tasks worker --loglevel=info
            

              
                Copy
              
            
          

Selgitus:

• celery -A tasks worker: Käivitab Celery töölise, määrates mooduli (tasks), kus teie Celery rakendus ja ülesanded on määratletud.
• --loglevel=info: Seadistab logimise tasemeks INFO, pakkudes üksikasjalikku teavet ülesannete täitmise kohta.

6. Ülesannete saatmine

Teises Pythoni skriptis või interaktiivses kestas importige ülesanded ja saatke need Celery töölisele:

            # client.py

from tasks import add, send_email

# Saada ülesanne 'add' asünkroonselt
result = add.delay(4, 5)
print(f"Task ID: {result.id}")

# Saada ülesanne 'send_email' asünkroonselt
email_result = send_email.delay('user@example.com', 'Hello', 'This is a test email.')
print(f"Email Task ID: {email_result.id}")

# Hiljem saate tulemuse kätte:
# print(result.get())
            

              
                Copy
              
            
          

Selgitus:

• add.delay(4, 5): Saadab ülesande add argumentidega 4 ja 5 Celery töölisele. Meetodit delay() kasutatakse ülesande asünkroonseks täitmiseks. See tagastab AsyncResult objekti.
• result.id: Annab ülesande unikaalse ID, mida saab kasutada selle edenemise jälgimiseks.
• result.get(): Blokeerib, kuni ülesanne on lõpetatud, ja tagastab tulemuse. Kasutage seda põhilõimes ettevaatlikult, kuna see nullib asünkroonse ülesannete töötlemise eesmärgi.

7. Ülesande staatuse jälgimine (valikuline)

Saate jälgida ülesannete staatust, kasutades AsyncResult objekti. Tulemuse nägemiseks peate ülaltoodud näites kommenteerimata jätma ja käivitama result.get() või kasutama mõnda muud jälgimismeetodit.

Celery pakub ka tööriistu nagu Flower reaalajas jälgimiseks. Flower on veebipõhine jälgimis- ja haldustööriist Celery jaoks.

Floweri paigaldamiseks:

            pip install flower
            

              
                Copy
              
            
          

Floweri käivitamiseks:

            celery -A tasks flower
            

              
                Copy
              
            
          

Flower töötab tavaliselt aadressil http://localhost:5555. Seejärel saate jälgida ülesannete staatust, tööliste staatust ja muid Celery mõõdikuid Floweri veebiliidese kaudu.

Celery täpsemad funktsioonid

Celery pakub laia valikut täpsemaid funktsioone teie ülesannete järjekorra haldamiseks ja optimeerimiseks:

Ülesannete marsruutimine

Saate marsruutida ülesandeid konkreetsetele töölistele nende nime, järjekordade või muude kriteeriumide alusel. See on kasulik ülesannete jaotamiseks ressursivajaduste või prioriteedi alusel. See saavutatakse, kasutades CELERY_ROUTES teie celeryconfig.py failis. Näiteks:

            # celeryconfig.py

CELERY_ROUTES = {
    'tasks.add': {'queue': 'priority_high'},
    'tasks.send_email': {'queue': 'emails'},
}
            

              
                Copy
              
            
          

Seejärel, oma töölise käivitamisel, määrake järjekorrad, mida see peaks kuulama:

            celery -A tasks worker -Q priority_high,emails --loglevel=info
            

              
                Copy
              
            
          

Ülesannete ajastamine (Celery Beat)

Celery Beat on ajastaja, mis paneb perioodiliselt ülesandeid järjekorda. Seda kasutatakse ülesannete jaoks, mida tuleb täita kindlate intervallidega (nt igapäevased aruanded, tunnipõhised varukoopiad). Seadistate selle oma celeryconfig.py failis CELERY_BEAT_SCHEDULE kaudu.

            # celeryconfig.py

from celery.schedules import crontab

CELERY_BEAT_SCHEDULE = {
    'add-every-30-seconds': {
        'task': 'tasks.add',
        'schedule': 30.0,
        'args': (16, 16)
    },
    'send-daily-report': {
        'task': 'tasks.send_email',
        'schedule': crontab(hour=7, minute=30), # Käivitub iga päev kell 7:30 UTC
        'args': ('reports@example.com', 'Daily Report', 'Here is the daily report.')
    },
}
            

              
                Copy
              
            
          

Celery Beati käivitamiseks:

            celery -A tasks beat --loglevel=info
            

              
                Copy
              
            
          

Märkus: Beat vajab kohta, kuhu salvestada, millal see viimati ajastatud ülesande käivitas. Vaikimisi kasutab see failipõhist andmebaasi (celerybeat-schedule), mis ei sobi tootmiskeskkondadesse. Tootmises kasutage andmebaasipõhist ajastajat (näiteks Redis).

Ülesannete korduskatsed

Celery saab automaatselt ebaõnnestunud ülesandeid uuesti proovida. See on kasulik ajutiste vigade (nt võrgutõrked, ajutised andmebaasi katkestused) käsitlemiseks. Saate konfigureerida korduskatsete arvu ja viivitust korduskatsete vahel, kasutades retry_backoff ja max_retries valikuid @app.task dekoraatoris.

            @app.task(bind=True, max_retries=5, retry_backoff=True)
def my_task(self, arg1, arg2):
    try:
        # Mõni potentsiaalselt ebaõnnestuv operatsioon
        result = perform_operation(arg1, arg2)
        return result
    except Exception as exc:
        self.retry(exc=exc, countdown=5) # Proovi uuesti 5 sekundi pärast
            

              
                Copy
              
            
          

Selgitus:

• bind=True: Võimaldab ülesandel pääseda juurde oma kontekstile (sealhulgas retry meetodile).
• max_retries=5: Määrab maksimaalse korduskatsete arvu viieks.
• retry_backoff=True: Lubab eksponentsiaalse tagasivõtmise korduskatsete jaoks (viivitus suureneb iga korduskatsega). Saate määrata ka fikseeritud viivituse, kasutades retry_backoff=False koos default_retry_delay argumendiga.
• self.retry(exc=exc, countdown=5): Proovib ülesannet uuesti 5 sekundi pärast. Argument exc on erand, mis põhjustas ebaõnnestumise.

Ülesannete aheldamine ja töövoogud

Celery võimaldab teil ülesandeid omavahel aheldada, et luua keerulisi töövoogusid. See on kasulik ülesannete jaoks, mis sõltuvad teiste ülesannete väljundist. Töövoogude määratlemiseks saate kasutada primitiive chain, group ja chord.

Chain (ahel): Täidab ülesandeid järjestikku.

            from celery import chain

workflow = chain(add.s(4, 4), multiply.s(8))
result = workflow.delay()
print(result.get())  # Väljund: 64
            

              
                Copy
              
            
          

Selles näites loob add.s(4, 4) ülesande add signatuuri argumentidega 4 ja 4. Sarnaselt loob multiply.s(8) ülesande multiply signatuuri argumendiga 8. Funktsioon chain kombineerib need signatuurid töövoogu, mis täidab esmalt add(4, 4), seejärel edastab tulemuse (8) funktsioonile multiply(8).

Group (grupp): Täidab ülesandeid paralleelselt.

            from celery import group

parallel_tasks = group(add.s(2, 2), multiply.s(3, 3), send_email.s('test@example.com', 'Parallel Tasks', 'Running in parallel'))
results = parallel_tasks.delay()

# Tulemuste saamiseks oodake, kuni kõik ülesanded on lõpule viidud
for res in results.get():
    print(res)
            

              
                Copy
              
            
          

Chord (akord): Täidab ülesannete grupi paralleelselt, seejärel täidab tagasikutse (callback) ülesande grupi tulemustega. See on kasulik, kui peate koondama mitme ülesande tulemused.

            from celery import group, chord

header = group(add.s(i, i) for i in range(10))
callback = send_email.s('aggregation@example.com', 'Chord Result', 'Here are the aggregated results.')

workflow = chord(header)(callback)
result = workflow.delay()
# Tagasikutse ülesanne (send_email) käivitatakse pärast seda, kui kõik päises olevad ülesanded (add) on lõpule viidud
# ja tulemused on sellele edastatud.
            

              
                Copy
              
            
          

Veakäsitlus

Celery pakub vigade käsitlemiseks mitmeid viise:

• Ülesannete korduskatsed: Nagu varem mainitud, saate konfigureerida ülesandeid ebaõnnestumise korral automaatselt uuesti proovima.
• Vea tagasikutsed: Saate määratleda vea tagasikutseid, mis käivitatakse ülesande ebaõnnestumisel. Need on määratud argumendiga link_error funktsioonides apply_async, delay või ahela osana.
• Globaalne veakäsitlus: Saate konfigureerida Celery saatma veateateid jälgimisteenusele (nt Sentry, Airbrake).

            @app.task(bind=True)
def my_task(self, arg1, arg2):
    try:
        result = perform_operation(arg1, arg2)
        return result
    except Exception as exc:
        # Logige viga või saatke veateade
        print(f"Task failed with error: {exc}")
        raise

@app.task
def error_handler(request, exc, traceback):
    print(f"Task {request.id} failed: {exc}\n{traceback}")

#Kasutusnäide
my_task.apply_async((1, 2), link_error=error_handler.s())
            

              
                Copy
              
            
          

Parimad praktikad Celery ja Redise kasutamisel

Optimaalse jõudluse ja töökindluse tagamiseks järgige neid parimaid praktikaid:

• Kasutage usaldusväärset Redis serverit: Tootmiskeskkondades kasutage spetsiaalset Redis serverit, millel on korralik jälgimine ja varukoopiad. Kõrge kättesaadavuse tagamiseks kaaluge Redis Sentineli kasutamist.
• Häälestage Redise konfiguratsiooni: Kohandage Redise konfiguratsiooniparameetreid (nt mälupiirangud, väljatõrjumise poliitikad) vastavalt oma rakenduse vajadustele.
• Jälgige Celery töölisi: Jälgige oma Celery tööliste tervist ja jõudlust, et probleemid kiiresti tuvastada ja lahendada. Kasutage jälgimiseks tööriistu nagu Flower või Prometheus.
• Optimeerige ülesannete serialiseerimist: Valige sobiv serialiseerimismeetod (nt JSON, pickle) vastavalt oma ülesannete argumentide ja tulemuste keerukusele ja suurusele. Pickle'i kasutamisel, eriti ebausaldusväärsete andmetega, olge teadlik turvamõjudest.
• Hoidke ülesanded idempotentsetena: Veenduge, et teie ülesanded on idempotentsed, mis tähendab, et neid saab mitu korda käivitada ilma soovimatuid kõrvalmõjusid põhjustamata. See on eriti oluline ülesannete puhul, mida võidakse pärast ebaõnnestumist uuesti proovida.
• Käsitsege erandeid sujuvalt: Rakendage oma ülesannetes korralikku veakäsitlust, et vältida ootamatuid kokkujooksmisi ja tagada, et vead logitakse või teatatakse asjakohaselt.
• Kasutage virtuaalseid keskkondi: Kasutage alati oma Pythoni projektide jaoks virtuaalseid keskkondi, et eraldada sõltuvused ja vältida konflikte.
• Hoidke Celery ja Redis ajakohastena: Värskendage regulaarselt Celeryt ja Redise uusimatele versioonidele, et saada kasu veaparandustest, turvapaikadest ja jõudluse parandustest.
• Nõuetekohane järjekordade haldamine: Määrake konkreetsed järjekorrad erinevat tüüpi ülesannete jaoks (nt kõrge prioriteediga ülesanded, taustatöötluse ülesanded). See võimaldab teil ülesandeid tõhusamalt prioritiseerida ja hallata.

Rahvusvahelised kaalutlused

Celery kasutamisel rahvusvahelistes kontekstides arvestage järgmisega:

• Ajavööndid: Veenduge, et teie Celery töölised ja Redis server on konfigureeritud õige ajavööndiga. Kasutage UTC-d järjepidevuse tagamiseks erinevates piirkondades.
• Lokaliseerimine: Kui teie ülesanded hõlmavad lokaliseeritud sisu töötlemist või genereerimist, veenduge, et teie Celery töölistel on juurdepääs vajalikele lokaadiandmetele ja teekidele.
• Märgikodeering: Kasutage kõigi ülesannete argumentide ja tulemuste jaoks UTF-8 kodeeringut, et toetada laia valikut märke.
• Andmekaitse eeskirjad: Olge teadlik andmekaitse eeskirjadest (nt GDPR), kui töötlete oma ülesannetes isikuandmeid. Rakendage asjakohaseid turvameetmeid tundliku teabe kaitsmiseks.
• Võrgu latentsus: Arvestage võrgu latentsusega oma rakendusserveri, Celery tööliste ja Redis serveri vahel, eriti kui need asuvad erinevates geograafilistes piirkondades. Optimeerige võrgukonfiguratsiooni ja kaaluge jõudluse parandamiseks geograafiliselt hajutatud Redise klastri kasutamist.

Reaalse maailma näited

Siin on mõned reaalse maailma näited sellest, kuidas Celeryt ja Redise saab kasutada levinud probleemide lahendamiseks:

• E-kaubanduse platvorm: Tellimuste töötlemine, tellimuste kinnituste saatmine, arvete genereerimine ja laoseisu uuendamine taustal.
• Sotsiaalmeedia rakendus: Piltide üleslaadimiste töötlemine, teavituste saatmine, isikupärastatud voogude genereerimine ja kasutajaandmete analüüsimine.
• Finantsteenuste rakendus: Tehingute töötlemine, aruannete genereerimine, riskihindamiste teostamine ja hoiatuste saatmine.
• Haridusplatvorm: Ülesannete hindamine, sertifikaatide genereerimine, kursuste meeldetuletuste saatmine ja õpilaste tulemuslikkuse analüüsimine.
• IoT platvorm: Andurite andmete töötlemine, seadmete juhtimine, hoiatuste genereerimine ja süsteemi jõudluse analüüsimine. Näiteks kaaluge targa põllumajanduse stsenaariumi. Celeryt saaks kasutada erinevate piirkondade (nt Brasiilia, India, Euroopa) farmide andurite näitude töötlemiseks ja nende näitude põhjal automaatsete niisutussüsteemide käivitamiseks.

Kokkuvõte

Celery koos Redisega pakub võimsat ja mitmekülgset lahendust hajutatud ülesannete töötlemiseks. Suunates aeganõudvad või ressursimahukad ülesanded Celery töölistele, saate parandada rakenduse reageerimisvõimet, skaleeritavust ja töökindlust. Oma rikkaliku funktsioonide komplekti ja paindlike konfiguratsioonivõimalustega saab Celeryt kohandada laiale hulgale kasutusjuhtudele, alates lihtsatest taustaülesannetest kuni keerukate töövoogudeni. Celery ja Redise omaksvõtmine avab potentsiaali ehitada väga suure jõudlusega ja skaleeritavaid rakendusi, mis suudavad toime tulla mitmekesiste ja nõudlike töökoormustega.