Memastikan Pemprosesan Adil dengan Saderi - Bahagian II

Artikel ini meneroka keutamaan tugas dalam Celery, berdasarkan catatan sebelumnya tentang pemprosesan adil. Keutamaan tugas menawarkan cara untuk meningkatkan keadilan dan kecekapan dalam pemprosesan latar belakang dengan menetapkan tahap keutamaan yang berbeza kepada tugas berdasarkan kriteria tersuai.

Mengapa Keutamaan Tahap Tugasan?

Keutamaan peringkat tugas memberikan kawalan terperinci ke atas pelaksanaan tugas tanpa pelaksanaan yang rumit. Dengan menyerahkan semua tugasan ke baris gilir tunggal dengan nilai keutamaan yang ditetapkan, pekerja boleh memproses tugas berdasarkan keperluan mendesak mereka. Ini memastikan pengendalian yang adil tanpa mengira masa penyerahan.

Sebagai contoh, jika seorang penyewa menyerahkan 100 tugasan dan seorang lagi menyerahkan 5 sejurus selepas itu, keutamaan peringkat tugas menghalang penyewa kedua daripada menunggu semua 100 tugasan selesai.

Pendekatan ini memberikan keutamaan secara dinamik berdasarkan kiraan tugas penyewa. Tugas pertama setiap penyewa bermula dengan keutamaan yang tinggi, tetapi dengan setiap 10 tugasan serentak, keutamaan berkurangan. Ini memastikan penyewa yang mempunyai tugas yang lebih sedikit tidak mengalami kelewatan yang tidak perlu.

Melaksanakan Keutamaan Tugas

Mula-mula, pasang Saderi dan Redis:

pip install celery redis

Konfigurasikan Celery untuk menggunakan Redis sebagai broker dan dayakan pemprosesan tugas berasaskan keutamaan:

from celery import Celery

app = Celery(
    "tasks",
    broker="redis://localhost:6379/0",
    broker_connection_retry_on_startup=True,
)

app.conf.broker_transport_options = {
    "priority_steps": list(range(10)),
    "sep": ":",
    "queue_order_strategy": "priority",
}

Tentukan kaedah untuk mengira keutamaan dinamik menggunakan Redis untuk cache setiap kiraan tugas penyewa:

import redis

redis_client = redis.StrictRedis(host="localhost", port=6379, db=1)

def calculate_priority(tenant_id):
    """
    Calculate task priority based on the number of tasks for the tenant.
    """
    key = f"tenant:{tenant_id}:task_count"
    task_count = int(redis_client.get(key) or 0)
    return min(10, task_count // 10)

Buat kelas tugas tersuai untuk mengurangkan kiraan tugas apabila berjaya disiapkan:

from celery import Task

class TenantAwareTask(Task):
    def on_success(self, retval, task_id, args, kwargs):
        tenant_id = kwargs.get("tenant_id")

        if tenant_id:
            key = f"tenant:{tenant_id}:task_count"
            redis_client.decr(key, 1)

        return super().on_success(retval, task_id, args, kwargs)

@app.task(name="tasks.send_email", base=TenantAwareTask)
def send_email(tenant_id, task_data):
    """
    Simulate sending an email.
    """
    sleep(1)
    key = f"tenant:{tenant_id}:task_count"
    task_count = int(redis_client.get(key) or 0)
    logger.info("Tenant %s tasks: %s", tenant_id, task_count)

Cetuskan tugas untuk penyewa yang berbeza, memastikan tenant_id disertakan dalam hujah kata kunci tugas:

if __name__ == "__main__":
    tenant_id = 1
    for _ in range(100):
        priority = calculate_priority(tenant_id)
        key = f"tenant:{tenant_id}:task_count"
        redis_client.incr(key, 1)
        send_email.apply_async(
            kwargs={"tenant_id": tenant_id, "task_data": {}}, priority=priority
        )


    tenant_id = 2
    for _ in range(10):
        priority = calculate_priority(tenant_id)
        key = f"tenant:{tenant_id}:task_count"
        redis_client.incr(key, 1)
        send_email.apply_async(
            kwargs={"tenant_id": tenant_id, "task_data": {}}, priority=priority
        )

Anda boleh melihat kod penuh di sini.

Mulakan pekerja Saderi dan cetuskan tugas:

# Run the worker
celery -A tasks worker --loglevel=info

# Trigger the tasks
python tasks.py

Persediaan ini menunjukkan bagaimana baris gilir keutamaan Celery, digabungkan dengan Redis, memastikan pemprosesan tugas yang adil dengan melaraskan keutamaan secara dinamik berdasarkan aktiviti penyewa. Mari lihat keluaran pekerja yang dipermudahkan:

Kesimpulan

Keutamaan peringkat tugas dengan Celery dan Redis menyediakan penyelesaian yang mantap untuk memastikan pemprosesan yang adil dalam sistem berbilang penyewa. Dengan menetapkan keutamaan secara dinamik dan memanfaatkan satu baris gilir, anda boleh mengekalkan kesederhanaan sambil memenuhi keperluan perniagaan.

Terdapat banyak cara untuk melaksanakan keutamaan peringkat tugas, contohnya menggunakan RabbitMQ adalah lebih cekap kerana ia menyokong keutamaan pada terasnya tetapi memandangkan kami juga menggunakan Redis untuk pengiraan tugas, ia memudahkan keseluruhan seni bina kami.

Semoga anda mendapati ini berguna dan lihat pada yang seterusnya!

Atas ialah kandungan terperinci Memastikan Pemprosesan Adil dengan Saderi - Bahagian II. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!