Celery Feladat Várólista: Elosztott Feladatfeldolgozás Redis Integrációval

A mai, egyre összetettebb és nagyobb teljesítményt igénylő alkalmazások világában az aszinkron feladatkezelés képessége kulcsfontosságú. A Celery, egy erőteljes, elosztott feladat várólista, robusztus megoldást nyújt az időigényes vagy erőforrás-igényes feladatok leválasztására az alkalmazás fő folyamatáról. A Redis-szel, egy sokoldalú, memóriában tárolt adatszerkezet-tárolóval párosítva a Celery egy rendkívül skálázható és hatékony megközelítést kínál a háttérben futó feladatok feldolgozásához.

Mi az a Celery?

A Celery egy aszinkron feladat/munka várólista, amely elosztott üzenetküldésen alapul. Arra használják, hogy a feladatokat aszinkron módon (a háttérben) hajtsa végre, az alkalmazás fő folyamatán kívül. Ez kulcsfontosságú a következők miatt:

• Alkalmazás válaszkészségének javítása: Azáltal, hogy a feladatokat a Celery workerekre bízza, a webalkalmazása reszponzív marad, és nem fagy le bonyolult műveletek feldolgozása közben.
• Skálázhatóság: A Celery lehetővé teszi a feladatok elosztását több worker csomópont között, így szükség szerint skálázhatja a feldolgozási kapacitást.
• Megbízhatóság: A Celery támogatja a feladatok újrapróbálkozását és a hibakezelést, biztosítva, hogy a feladatok végül sikeresen befejeződjenek még hibák esetén is.
• Hosszan futó feladatok kezelése: A jelentős időt igénylő folyamatok, mint például a videó átkódolás, jelentéskészítés vagy nagy mennyiségű e-mail küldése, ideálisak a Celery számára.

Miért használjunk Redis-t a Celery-vel?

Bár a Celery többféle üzenetbrókert (RabbitMQ, Redis stb.) támogat, a Redis egyszerűsége, sebessége és könnyű beállíthatósága miatt népszerű választás. A Redis egyszerre működik üzenetbrókerként (transzport) és opcionálisan eredmény-háttérrendszerként (result backend) a Celery számára. Íme, miért illik jól a Redis a Celery-hez:

• Sebesség: A Redis egy memóriában tárolt adattár, amely rendkívül gyors üzenetküldést és eredmény-lekérdezést biztosít.
• Egyszerűség: A Redis beállítása és konfigurálása viszonylag egyszerű.
• Perzisztencia (Opcionális): A Redis perzisztencia lehetőségeket kínál, lehetővé téve a feladatok helyreállítását brókerhiba esetén.
• Pub/Sub támogatás: A Redis publish/subscribe képességei jól illeszkednek a Celery üzenetküldő architektúrájához.

A Celery fő komponensei

A Celery kulcsfontosságú komponenseinek megértése elengedhetetlen a hatékony feladatkezeléshez:

• Celery Alkalmazás (celery): A Celery-vel való interakció fő belépési pontja. Felelős a feladat várólista konfigurálásáért, valamint a brókerhez és az eredmény-háttérrendszerhez való csatlakozásért.
• Feladatok (Tasks): Az @app.task dekorátorral ellátott függvények vagy metódusok, amelyek az aszinkron módon végrehajtandó munkaegységeket képviselik.
• Workerek (Workers): A feladatokat végrehajtó folyamatok. Több workert futtathat egy vagy több gépen a feldolgozási kapacitás növelése érdekében.
• Bróker (Üzenet Várólista): A közvetítő, amely a feladatokat az alkalmazástól a workerekhez szállítja. Redis, RabbitMQ és más üzenetbrókerek is használhatók.
• Eredmény-háttérrendszer (Result Backend): A feladatok eredményeit tárolja. A Celery használhat Redis-t, adatbázisokat (mint a PostgreSQL vagy MySQL) vagy más háttérrendszereket az eredmények tárolására.

A Celery beállítása Redis-szel

Itt egy lépésről lépésre útmutató a Celery és Redis beállításához:

1. Függőségek telepítése

Először telepítse a Celery-t és a Redis-t pip segítségével:

            pip install celery redis
            

              
                Copy
              
            
          

2. Redis Szerver telepítése

Telepítse a redis-server-t. Az utasítások az operációs rendszertől függően változnak. Például Ubuntun:

            sudo apt update
sudo apt install redis-server
            

              
                Copy
              
            
          

macOS esetén (Homebrew használatával):

            brew install redis
            

              
                Copy
              
            
          

Windows esetén letöltheti a Redis-t a hivatalos Redis weboldalról vagy használhatja a Chocolatey-t:

            choco install redis
            

              
                Copy
              
            
          

3. Celery konfigurálása

Hozzon létre egy celeryconfig.py fájlt a Celery konfigurálásához:

            # 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
              
            
          

Magyarázat:

• broker_url: Megadja a Redis bróker URL-jét. Az alapértelmezett Redis port a 6379. A /0 a Redis adatbázis számát jelöli (0-15).
• result_backend: Megadja a Redis eredmény-háttérrendszer URL-jét, ugyanazzal a konfigurációval, mint a bróker.
• task_serializer és result_serializer: A szerializálási módszert JSON-ra állítja a feladatok és eredmények esetében.
• accept_content: Felsorolja a feladatok elfogadott tartalomtípusait.
• timezone és enable_utc: Az időzóna beállításokat konfigurálja. Javasolt az UTC használata a különböző szerverek közötti konzisztencia érdekében.

4. Celery alkalmazás létrehozása

Hozzon létre egy Python fájlt (pl. tasks.py) a Celery alkalmazás és a feladatok definiálásához:

            # 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)  # Simulate a long-running task
    return x + y

@app.task
def send_email(recipient, subject, body):
    # Simulate sending an email
    print(f"Sending email to {recipient} with subject '{subject}' and body '{body}'")
    time.sleep(2)
    return f"Email sent to {recipient}"
            

              
                Copy
              
            
          

Magyarázat:

• Celery('my_tasks', broker=...): Létrehoz egy 'my_tasks' nevű Celery alkalmazást, és a brókert, valamint a háttérrendszert URL-ekkel konfigurálja. Alternatívaként elhagyhatja a broker és backend argumentumokat, ha kizárólag az app.config_from_object('celeryconfig') segítségével konfigurálja őket.
• @app.task: Dekorátor, amely egy normál Python függvényt Celery feladattá alakít.
• add(x, y): Egy egyszerű feladat, amely összead két számot és 5 másodpercig alszik, hogy egy hosszan futó műveletet szimuláljon.
• send_email(recipient, subject, body): Egy e-mail küldését szimulálja. Valós esetben ez egy e-mail szerverhez való csatlakozást és az e-mail elküldését jelentené.

5. Celery Worker indítása

Nyisson meg egy terminált, és navigáljon abba a könyvtárba, amely a tasks.py és a celeryconfig.py fájlokat tartalmazza. Ezután indítsa el a Celery workert:

            celery -A tasks worker --loglevel=info
            

              
                Copy
              
            
          

Magyarázat:

• celery -A tasks worker: Elindítja a Celery workert, megadva azt a modult (tasks), ahol a Celery alkalmazás és a feladatok definiálva vannak.
• --loglevel=info: A naplózási szintet INFO-ra állítja, részletes információkat szolgáltatva a feladatok végrehajtásáról.

6. Feladatok küldése

Egy másik Python szkriptben vagy interaktív shellben importálja a feladatokat, és küldje el őket a Celery workernek:

            # client.py

from tasks import add, send_email

# Send the 'add' task asynchronously
result = add.delay(4, 5)
print(f"Task ID: {result.id}")

# Send the 'send_email' task asynchronously
email_result = send_email.delay('user@example.com', 'Hello', 'This is a test email.')
print(f"Email Task ID: {email_result.id}")

# Later, you can retrieve the result:
# print(result.get())
            

              
                Copy
              
            
          

Magyarázat:

• add.delay(4, 5): Elküldi az add feladatot a Celery workernek a 4 és 5 argumentumokkal. A delay() metódus a feladat aszinkron végrehajtására szolgál. Egy AsyncResult objektumot ad vissza.
• result.id: Megadja a feladat egyedi azonosítóját, amellyel követni lehet a haladását.
• result.get(): Blokkolja a végrehajtást, amíg a feladat be nem fejeződik, és visszaadja az eredményt. Óvatosan használja a fő szálban, mivel ez megszünteti az aszinkron feladatfeldolgozás célját.

7. Feladat állapotának figyelése (Opcionális)

A feladatok állapotát az AsyncResult objektum segítségével figyelheti. A fenti példában a result.get() sor kommentjét fel kell oldani és futtatni kell, hogy lássa az eredményt, miután a feladat befejeződött, vagy használjon egy másik monitorozási módszert.

A Celery olyan eszközöket is kínál, mint a Flower a valós idejű monitorozáshoz. A Flower egy web-alapú monitorozó és adminisztrációs eszköz a Celery számára.

A Flower telepítése:

            pip install flower
            

              
                Copy
              
            
          

A Flower indítása:

            celery -A tasks flower
            

              
                Copy
              
            
          

A Flower általában a http://localhost:5555 címen fut. Ezután a Flower webes felületén keresztül figyelheti a feladatok állapotát, a workerek állapotát és más Celery metrikákat.

Haladó Celery funkciók

A Celery haladó funkciók széles skáláját kínálja a feladat várólista kezeléséhez és optimalizálásához:

Feladatok irányítása (Routing)

A feladatokat nevük, várólistáik vagy más kritériumok alapján specifikus workerekhez irányíthatja. Ez hasznos a feladatok erőforrás-igény vagy prioritás alapján történő elosztásához. Ezt a CELERY_ROUTES használatával érheti el a celeryconfig.py fájlban. Például:

            # celeryconfig.py

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

              
                Copy
              
            
          

Ezután, amikor elindítja a workert, adja meg, hogy mely várólistákat figyelje:

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

              
                Copy
              
            
          

Feladatok időzítése (Celery Beat)

A Celery Beat egy időzítő, amely periodikusan helyez el feladatokat a várólistában. Olyan feladatokhoz használják, amelyeket meghatározott időközönként kell végrehajtani (pl. napi jelentések, óránkénti biztonsági mentések). A CELERY_BEAT_SCHEDULE segítségével konfigurálható a celeryconfig.py fájlban.

            # 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), # Executes every day at 7:30 AM UTC
        'args': ('reports@example.com', 'Daily Report', 'Here is the daily report.')
    },
}
            

              
                Copy
              
            
          

A Celery Beat indítása:

            celery -A tasks beat --loglevel=info
            

              
                Copy
              
            
          

Megjegyzés: A Beat-nek tárolnia kell, hogy mikor futtatott utoljára egy időzített feladatot. Alapértelmezés szerint egy fájl alapú adatbázist (celerybeat-schedule) használ, ami nem alkalmas éles (production) környezetekben. Éles környezetben használjon adatbázis-alapú időzítőt (például Redis-t).

Feladatok újrapróbálkozása (Retries)

A Celery automatikusan újrapróbálhatja a sikertelen feladatokat. Ez hasznos az átmeneti hibák kezelésére (pl. hálózati problémák, ideiglenes adatbázis-leállások). Az újrapróbálkozások számát és a köztük lévő késleltetést a retry_backoff és max_retries opciókkal konfigurálhatja az @app.task dekorátorban.

            @app.task(bind=True, max_retries=5, retry_backoff=True)
def my_task(self, arg1, arg2):
    try:
        # Some potentially failing operation
        result = perform_operation(arg1, arg2)
        return result
    except Exception as exc:
        self.retry(exc=exc, countdown=5) # Retry after 5 seconds
            

              
                Copy
              
            
          

Magyarázat:

• bind=True: Lehetővé teszi, hogy a feladat hozzáférjen a saját kontextusához (beleértve a retry metódust).
• max_retries=5: Az újrapróbálkozások maximális számát 5-re állítja.
• retry_backoff=True: Exponenciális visszalépést (backoff) engedélyez az újrapróbálkozásokhoz (a késleltetés minden újrapróbálkozással növekszik). Megadhat fix késleltetést is a retry_backoff=False és egy default_retry_delay argumentum használatával.
• self.retry(exc=exc, countdown=5): 5 másodperc múlva újrapróbálja a feladatot. Az exc argumentum a hibát okozó kivétel.

Feladatok láncolása és munkafolyamatok

A Celery lehetővé teszi a feladatok összeláncolását komplex munkafolyamatok létrehozásához. Ez hasznos olyan feladatoknál, amelyek más feladatok kimenetétől függenek. A chain, group és chord primitívekkel definiálhat munkafolyamatokat.

Lánc (Chain): Sorban hajtja végre a feladatokat.

            from celery import chain

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

              
                Copy
              
            
          

Ebben a példában az add.s(4, 4) létrehoz egy szignatúrát az add feladathoz a 4 és 4 argumentumokkal. Hasonlóképpen, a multiply.s(8) létrehoz egy szignatúrát a multiply feladathoz a 8 argumentummal. A chain függvény ezeket a szignatúrákat egy olyan munkafolyamatba kombinálja, amely először az add(4, 4)-et hajtja végre, majd az eredményt (8) átadja a multiply(8)-nak.

Csoport (Group): Párhuzamosan hajtja végre a feladatokat.

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

# To get results, wait for all tasks to complete
for res in results.get():
    print(res)
            

              
                Copy
              
            
          

Akkord (Chord): Párhuzamosan végrehajt egy feladatcsoportot, majd egy visszahívási (callback) feladatot futtat a csoport eredményeivel. Ez akkor hasznos, ha több feladat eredményét kell összesíteni.

            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()
# The callback task (send_email) will execute after all tasks in the header (add) are completed
# with the results passed to it.
            

              
                Copy
              
            
          

Hibakezelés

A Celery többféle módot biztosít a hibák kezelésére:

• Feladatok újrapróbálkozása: Ahogy korábban említettük, beállíthatja a feladatokat, hogy hiba esetén automatikusan újrapróbálkozzanak.
• Hiba visszahívások (Error Callbacks): Definiálhat hiba visszahívásokat, amelyek akkor futnak le, ha egy feladat sikertelen. Ezeket a link_error argumentummal lehet megadni az apply_async-ban, delay-ben, vagy egy lánc részeként.
• Globális hibakezelés: Konfigurálhatja a Celery-t, hogy hibajelentéseket küldjön egy monitorozó szolgáltatásnak (pl. Sentry, Airbrake).

            @app.task(bind=True)
def my_task(self, arg1, arg2):
    try:
        result = perform_operation(arg1, arg2)
        return result
    except Exception as exc:
        # Log the error or send an error report
        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}")

#Example usage
my_task.apply_async((1, 2), link_error=error_handler.s())
            

              
                Copy
              
            
          

Bevált gyakorlatok a Celery és Redis használatához

Az optimális teljesítmény és megbízhatóság érdekében kövesse ezeket a bevált gyakorlatokat:

• Használjon megbízható Redis szervert: Éles környezetekben használjon dedikált Redis szervert megfelelő monitorozással és biztonsági mentésekkel. Fontolja meg a Redis Sentinel használatát a magas rendelkezésre állás érdekében.
• Hangolja a Redis konfigurációt: Állítsa be a Redis konfigurációs paramétereit (pl. memória korlátok, kiürítési szabályok) az alkalmazás igényeinek megfelelően.
• Monitorozza a Celery workereket: Figyelje a Celery workerek állapotát és teljesítményét, hogy gyorsan azonosíthassa és megoldhassa a problémákat. Használjon olyan eszközöket, mint a Flower vagy a Prometheus a monitorozáshoz.
• Optimalizálja a feladat szerializációját: Válasszon megfelelő szerializációs módszert (pl. JSON, pickle) a feladat argumentumainak és eredményeinek bonyolultsága és mérete alapján. Legyen tisztában a pickle használatának biztonsági következményeivel, különösen nem megbízható adatok esetén.
• Tartsa a feladatokat idempotensnek: Biztosítsa, hogy a feladatai idempotensek legyenek, ami azt jelenti, hogy többszöri végrehajtásuk sem okoz nem kívánt mellékhatásokat. Ez különösen fontos olyan feladatoknál, amelyeket hiba után újrapróbálhat a rendszer.
• Kezelje a kivételeket elegánsan: Implementáljon megfelelő hibakezelést a feladataiban a váratlan összeomlások megelőzése és a hibák megfelelő naplózása vagy jelentése érdekében.
• Használjon virtuális környezeteket: Mindig használjon virtuális környezeteket a Python projektjeihez a függőségek izolálása és a konfliktusok elkerülése érdekében.
• Tartsa naprakészen a Celery-t és a Redis-t: Rendszeresen frissítse a Celery-t és a Redis-t a legújabb verziókra, hogy kihasználja a hibajavításokat, biztonsági frissítéseket és teljesítményjavulásokat.
• Megfelelő várólista-kezelés: Jelöljön ki specifikus várólistákat a különböző feladattípusokhoz (pl. magas prioritású feladatok, háttérfeldolgozási feladatok). Ez lehetővé teszi a feladatok hatékonyabb priorizálását és kezelését.

Nemzetközi megfontolások

Amikor a Celery-t nemzetközi kontextusban használja, vegye figyelembe a következőket:

• Időzónák: Győződjön meg róla, hogy a Celery workerek és a Redis szerver a megfelelő időzónával vannak konfigurálva. Használjon UTC-t a különböző régiók közötti konzisztencia érdekében.
• Lokalizáció: Ha a feladatai lokalizált tartalom feldolgozását vagy generálását foglalják magukban, győződjön meg róla, hogy a Celery workerek hozzáférnek a szükséges helyi adatokhoz és könyvtárakhoz.
• Karakterkódolás: Használjon UTF-8 kódolást minden feladat argumentumhoz és eredményhez, hogy a karakterek széles skáláját támogassa.
• Adatvédelmi szabályozások: Legyen tisztában az adatvédelmi szabályozásokkal (pl. GDPR), amikor személyes adatokat dolgoz fel a feladataiban. Védje a bizalmas információkat megfelelő biztonsági intézkedésekkel.
• Hálózati késleltetés: Vegye figyelembe az alkalmazás szervere, a Celery workerek és a Redis szerver közötti hálózati késleltetést, különösen, ha különböző földrajzi régiókban helyezkednek el. Optimalizálja a hálózati konfigurációt, és fontolja meg egy földrajzilag elosztott Redis klaszter használatát a jobb teljesítmény érdekében.

Valós példák

Íme néhány valós példa arra, hogyan lehet a Celery-t és a Redis-t gyakori problémák megoldására használni:

• E-kereskedelmi platform: Megrendelések feldolgozása, rendelés-visszaigazolások küldése, számlák generálása és készletfrissítés a háttérben.
• Közösségi média alkalmazás: Képfeltöltések feldolgozása, értesítések küldése, személyre szabott hírfolyamok generálása és felhasználói adatok elemzése.
• Pénzügyi szolgáltatások alkalmazása: Tranzakciók feldolgozása, jelentések generálása, kockázatértékelések végzése és riasztások küldése.
• Oktatási platform: Feladatok értékelése, tanúsítványok generálása, kurzus-emlékeztetők küldése és a diákok teljesítményének elemzése.
• IoT Platform: Szenzoradatok feldolgozása, eszközök vezérlése, riasztások generálása és a rendszer teljesítményének elemzése. Például, vegyünk egy okos mezőgazdasági forgatókönyvet. A Celery használható a különböző régiókban (pl. Brazília, India, Európa) található farmok szenzoradatainak feldolgozására és automatizált öntözőrendszerek elindítására ezen adatok alapján.

Összegzés

A Celery, Redis-szel kombinálva, egy erőteljes és sokoldalú megoldást kínál az elosztott feladatfeldolgozásra. Az időigényes vagy erőforrás-igényes feladatok leválasztásával a Celery workerekre javíthatja az alkalmazás válaszkészségét, skálázhatóságát és megbízhatóságát. Gazdag funkciókészletével és rugalmas konfigurációs lehetőségeivel a Celery a felhasználási esetek széles skálájához igazítható, az egyszerű háttérfeladatoktól a komplex munkafolyamatokig. A Celery és a Redis alkalmazása megnyitja a lehetőséget a rendkívül teljesítőképes és skálázható alkalmazások építésére, amelyek képesek a változatos és megterhelő munkaterhelések kezelésére.