คุณรัน background task ด้วย Celery อย่างไร?

Question

Accepted Answer

**Celery** เป็นเครื่องมือมาตรฐานสำหรับการรัน **background task และ scheduled task** ใน Django — งานที่ไม่ควรบล็อก HTTP request (การส่งอีเมล, การประมวลผลไฟล์, การเรียก API ที่ช้า) หรืองานที่รันตามตารางเวลา task จะถูกใส่คิวและประมวลผลแบบ asynchronous โดยกระบวนการ **worker** ที่แยกต่างหาก

## ปัญหาที่ Celery แก้

```python
# ❌ doing slow work inline blocks the response — the user waits, risks timeouts
def register(request):
    user = create_user(request.POST)
    send_welcome_email(user)           # slow — the user waits for the email to send
    generate_report(user)               # even slower
    return redirect("home")             # finally responds after all that
```

การทำงานที่ช้าแบบ inline ทำให้ผู้ใช้ต้องรอและเสี่ยงต่อ request timeout Celery ย้ายมันไปยัง background worker เพื่อให้ request return ทันที

## การนิยามและเรียก Celery task

```python
# tasks.py — define a task
from celery import shared_task

@shared_task
def send_welcome_email(user_id):
    user = User.objects.get(id=user_id)
    send_email(user.email, "Welcome!")    # runs in a WORKER, not the web process

# in a view — QUEUE the task instead of running it inline
def register(request):
    user = create_user(request.POST)
    send_welcome_email.delay(user.id)     # .delay() queues it → returns IMMEDIATELY
    return redirect("home")                # user gets a fast response
```

decorator `@shared_task` นิยาม task; `.delay()` (หรือ `.apply_async()`) ใส่มันลงคิวเพื่อให้ worker ประมวลผลแบบ asynchronous — view ไม่ต้องรอ

## สถาปัตยกรรม

```text
Django (web) --.delay()--> BROKER (Redis/RabbitMQ) --> CELERY WORKER (processes the task)
                              (the message queue)         (separate process/machine)
```

```text
Components:
  ✓ Broker (Redis or RabbitMQ) — holds the queue of pending tasks
  ✓ Celery worker(s) — separate processes that pull and execute tasks
  ✓ Result backend (optional) — stores task results/status
Run workers separately: `celery -A myproject worker`
```

## Scheduled / periodic task (Celery Beat)

```python
# run tasks on a schedule (like cron) via Celery Beat
CELERY_BEAT_SCHEDULE = {
    "daily-report": {
        "task": "myapp.tasks.generate_daily_report",
        "schedule": crontab(hour=0, minute=0),     # every midnight
    },
}
```

## ฟีเจอร์ด้านความน่าเชื่อถือ

```python
@shared_task(bind=True, max_retries=3, default_retry_delay=60)
def sync_data(self):
    try:
        do_sync()
    except Exception as exc:
        raise self.retry(exc=exc)             # automatic retries on failure
```

```text
✓ Retries with backoff (resilience against transient failures)
✓ Task persistence (queued tasks survive restarts via the broker)
✓ Scheduling (Celery Beat — periodic/cron-like tasks)
✓ Rate limiting, concurrency control, task routing/priorities
✓ Workers scale independently of web servers
```

## ทำไมจึงสำคัญ

การประมวลผล background task ด้วย Celery เป็นความรู้ที่จำเป็นสำหรับการสร้างแอปพลิเคชัน Django ที่ตอบสนองได้ดีและขยายตัวได้ เนื่องจากความต้องการในโลกจริงจำนวนมากต้องการงานที่ไม่ควรเกิดขึ้นแบบ inline ระหว่าง request

การเข้าใจมันสำคัญเพราะปัญหาหลัก — การย้ายงานที่ช้าหรือเลื่อนเวลาได้ (การส่งอีเมล, การประมวลผลรูปภาพ/ไฟล์, การสร้างรายงาน, การเรียก external API ที่ช้า, การ sync ข้อมูล) ออกจากวงจร request-response — เป็นเรื่องที่พบได้ทั่วไปในแอปพลิเคชัน production

การทำงานเช่นนั้นแบบ inline ทำให้ผู้ใช้ต้องรอ, เสี่ยงต่อ request timeout และสูญเสียงานหากมันล้มเหลว ในขณะที่ **Celery** ให้คุณตอบสนองผู้ใช้ทันทีในขณะที่ **worker** ที่แยกต่างหากประมวลผลงานแบบ asynchronous และเชื่อถือได้

นอกเหนือจากการ offload แบบ async ง่าย ๆ Celery ยังมีความสามารถ production ที่สำคัญยิ่ง: **scheduled/periodic task** (ผ่าน Celery Beat แทนที่ cron สำหรับการตั้งตารางเวลาในระดับแอปพลิเคชัน — รายงานรายวัน, งานทำความสะอาด, การ sync ที่เกิดซ้ำ), **การ retry อัตโนมัติพร้อม backoff** (ความทนทานต่อความล้มเหลวชั่วคราว), **task persistence** (task ในคิวอยู่รอดจากการ restart ผ่าน broker ดังนั้นงานไม่สูญหาย) และ **การขยายตัวอย่างอิสระ** ของ worker จากเว็บเซิร์ฟเวอร์

การเข้าใจสถาปัตยกรรมของ Celery (broker อย่าง Redis/RabbitMQ ที่เก็บคิว, worker ที่ประมวลผล task, result backend), วิธีนิยามและใส่คิว task (`@shared_task`, `.delay()`), การตั้งตารางงาน periodic และการตั้งค่าฟีเจอร์ด้านความน่าเชื่อถือ เป็นความรู้ระดับ senior ที่มีค่าสำหรับการสร้างระบบ Django production ที่จัดการงานหนักหรือเลื่อนเวลาได้อย่างราบรื่น

เนื่องจากการประมวลผลแบบ background เป็นความต้องการที่พบบ่อยและสำคัญสำหรับแอปพลิเคชันที่ตอบสนองได้ดีและทนทาน — และ Celery เป็นโซลูชันมาตรฐานโดยพฤตินัยในระบบนิเวศ Django — การเชี่ยวชาญมันเป็นทักษะเชิงปฏิบัติที่เกี่ยวข้องบ่อย ซึ่งสะท้อนความสามารถในการออกแบบสถาปัตยกรรมแอปพลิเคชัน Django ในโลกจริงที่เกินกว่าการจัดการ request แบบ synchronous ง่าย ๆ