Bạn chạy background task với Celery như thế nào?

Question

Accepted Answer

**Celery** là công cụ tiêu chuẩn để chạy các **background task và scheduled task** trong Django — công việc không nên block HTTP request (gửi email, xử lý file, gọi API chậm) hoặc chạy theo lịch. Task được đưa vào hàng đợi và xử lý bất đồng bộ bởi các process **worker** riêng.

## Vấn đề Celery giải quyết

```python
# ❌ làm công việc chậm inline block response — user chờ, rủi ro timeout
def register(request):
    user = create_user(request.POST)
    send_welcome_email(user)           # chậm — user chờ email gửi xong
    generate_report(user)               # còn chậm hơn
    return redirect("home")             # cuối cùng mới phản hồi sau tất cả
```

Làm công việc chậm inline khiến user chờ và rủi ro request timeout. Celery chuyển nó cho background worker để request trả về ngay.

## Định nghĩa và gọi một Celery task

```python
# tasks.py — định nghĩa một 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!")    # chạy trong một WORKER, không phải web process

# trong một view — ĐƯA VÀO HÀNG ĐỢI task thay vì chạy inline
def register(request):
    user = create_user(request.POST)
    send_welcome_email.delay(user.id)     # .delay() đưa vào hàng đợi → trả về NGAY
    return redirect("home")                # user nhận phản hồi nhanh
```

Decorator `@shared_task` định nghĩa một task; `.delay()` (hoặc `.apply_async()`) đưa nó vào hàng đợi để một worker xử lý bất đồng bộ — view không chờ.

## Kiến trúc

```text
Django (web) --.delay()--> BROKER (Redis/RabbitMQ) --> CELERY WORKER (xử lý task)
                              (hàng đợi message)        (process/máy riêng)
```

```text
Các thành phần:
  ✓ Broker (Redis hoặc RabbitMQ) — giữ hàng đợi các task đang chờ
  ✓ Celery worker — các process riêng kéo và thực thi task
  ✓ Result backend (tùy chọn) — lưu kết quả/trạng thái task
Chạy worker riêng: `celery -A myproject worker`
```

## Scheduled / periodic task (Celery Beat)

```python
# chạy task theo lịch (như cron) qua Celery Beat
CELERY_BEAT_SCHEDULE = {
    "daily-report": {
        "task": "myapp.tasks.generate_daily_report",
        "schedule": crontab(hour=0, minute=0),     # mỗi nửa đêm
    },
}
```

## Tính năng độ tin cậy

```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)             # tự động thử lại khi thất bại
```

```text
✓ Thử lại với backoff (chống chịu các thất bại tạm thời)
✓ Persistence của task (task trong hàng đợi sống sót qua restart nhờ broker)
✓ Lập lịch (Celery Beat — task định kỳ/kiểu cron)
✓ Giới hạn tốc độ, kiểm soát đồng thời, routing/ưu tiên task
✓ Worker scale độc lập với web server
```

## Tại sao điều này quan trọng

Xử lý background task với Celery là kiến thức thiết yếu để xây dựng các ứng dụng Django phản hồi nhanh, mở rộng được, vì nhiều nhu cầu thực tế đòi hỏi công việc không nên xảy ra inline trong một request.

Hiểu nó quan trọng vì vấn đề cốt lõi — chuyển công việc chậm hoặc bị hoãn (gửi email, xử lý ảnh/file, sinh báo cáo, gọi API bên ngoài chậm, đồng bộ dữ liệu) ra khỏi chu kỳ request-response — là phổ biến trong các ứng dụng production.

Làm công việc như vậy inline khiến user chờ, rủi ro request timeout, và mất công việc nếu nó thất bại, trong khi **Celery** cho phép bạn phản hồi user ngay lập tức trong khi các **worker** riêng xử lý công việc bất đồng bộ và đáng tin cậy.

Ngoài việc chuyển async đơn giản, Celery cung cấp các năng lực production then chốt: **task theo lịch/định kỳ** (qua Celery Beat, thay thế cron cho lập lịch cấp ứng dụng — báo cáo hàng ngày, công việc dọn dẹp, đồng bộ định kỳ), **tự động thử lại với backoff** (chống chịu các thất bại tạm thời), **persistence của task** (task trong hàng đợi sống sót qua restart nhờ broker, nên công việc không bị mất), và **scale độc lập** của worker với web server.

Hiểu kiến trúc của Celery (broker như Redis/RabbitMQ giữ hàng đợi, worker xử lý task, result backend), cách định nghĩa và đưa task vào hàng đợi (`@shared_task`, `.delay()`), lập lịch công việc định kỳ, và cấu hình các tính năng độ tin cậy là kiến thức cấp senior có giá trị để xây dựng các hệ thống Django production xử lý công việc nặng hoặc bị hoãn một cách duyên dáng.

Vì xử lý background là một yêu cầu phổ biến, quan trọng cho các ứng dụng phản hồi nhanh, vững chắc — và Celery là giải pháp tiêu chuẩn de facto trong hệ sinh thái Django — nắm vững nó là một kỹ năng thực tế, thường liên quan phản ánh khả năng kiến trúc các ứng dụng Django thực tế vượt ra ngoài xử lý request đồng bộ đơn giản.