Calling tasks asynchronously in Django - Mini Project: Build & Apply

Calling tasks asynchronously in Django

📖 Scenario: You are building a Django web app that sends welcome emails to new users. To avoid slowing down the user signup process, you want to send these emails asynchronously in the background.

🎯 Goal: Learn how to call a task asynchronously in Django using Celery. You will create a simple task to send a welcome email and then call it asynchronously from a Django view.

📋 What You'll Learn

Create a Celery task function called send_welcome_email in tasks.py

Create a Django view function called signup that calls send_welcome_email asynchronously

Use the delay() method to call the task asynchronously

Ensure the task function accepts a user_email parameter

💡 Why This Matters

🌍 Real World

Many web apps need to perform slow tasks like sending emails or processing files without making users wait. Calling tasks asynchronously with Celery is a common solution.

💼 Career

Understanding how to run background tasks asynchronously is important for backend developers working with Django and Celery in real-world projects.

1

Create the Celery task function

Create a file called tasks.py and define a Celery task function named send_welcome_email that accepts a parameter user_email. Inside the function, add a comment # Code to send email to represent the email sending logic.

Django

# Create the send_welcome_email task function in tasks.py
# Your code here

Hint

Use the @shared_task decorator to define a Celery task function.

2

Create the signup view function

In your Django app's views.py, create a function called signup that accepts a request parameter. Inside the function, create a variable user_email and set it to the string '[e-mail]'.

Django

from celery import shared_task

@shared_task
def send_welcome_email(user_email):
    # Code to send email
    pass

# Create the signup view function
# Your code here

Hint

Define a simple view function with the exact name signup and set user_email to the given email string.

3

Call the task asynchronously

Inside the signup function, call the send_welcome_email task asynchronously using the delay() method and pass user_email as the argument.

Django

from celery import shared_task

@shared_task
def send_welcome_email(user_email):
    # Code to send email
    pass

def signup(request):
    user_email = '[e-mail]'
    # Call the task asynchronously here
    # Your code here

Hint

Use the delay() method on the task function to call it asynchronously.

4

Complete the signup view

Add a return statement in the signup function that returns a simple HTTP response with the text 'Signup successful' using Django's HttpResponse.

Django

from celery import shared_task
from django.http import HttpResponse

@shared_task
def send_welcome_email(user_email):
    # Code to send email
    pass

def signup(request):
    user_email = '[e-mail]'
    send_welcome_email.delay(user_email)
    # Return HTTP response here
    # Your code here

Hint

Import HttpResponse and return it with the exact text.

Practice

1. What is the main purpose of calling tasks asynchronously in a Django app using Celery?

easy

A. To avoid using any external libraries

B. To make the app run slower by adding extra steps

C. To run time-consuming tasks in the background without blocking the main app

D. To run tasks only when the server restarts

Solution

1. Step 1: Understand asynchronous task calling

   Calling tasks asynchronously means running them in the background so the main app can continue working without waiting.

2. Step 2: Identify the benefit in Django apps

   This helps keep the app fast and responsive by not blocking user requests with long tasks.

3. Final Answer:

   To run time-consuming tasks in the background without blocking the main app -> Option C

4. Quick Check:

   Async tasks = background work = To run time-consuming tasks in the background without blocking the main app [OK]

Hint: Async tasks run in background, keeping app responsive [OK]

Common Mistakes:

• Thinking async tasks slow down the app
• Believing async tasks run only on server restart
• Confusing async with avoiding external libraries

2. Which of the following is the correct way to call a Celery task named send_email asynchronously?

easy

A. send_email.delay()

B. send_email()

C. send_email.async()

D. send_email.run()

Solution

1. Step 1: Recall Celery task calling syntax

   Celery tasks are called asynchronously using the .delay() method.

2. Step 2: Match the correct method to the task name

   Calling send_email.delay() queues the task to run in the background.

3. Final Answer:

   send_email.delay() -> Option A

4. Quick Check:

   Use .delay() to call async tasks [OK]

Hint: Use .delay() to call Celery tasks asynchronously [OK]

Common Mistakes:

• Calling the task like a normal function without .delay()
• Using .async() which is not a Celery method
• Using .run() which executes task synchronously

3. Given the following Celery task and call:

@shared_task
def add(x, y):
    return x + y

result = add.delay(4, 5)

What will result.get() return after the task completes?

medium

A. 9

B. None

C. An error because .get() is not valid

D. A task ID string

Solution

1. Step 1: Understand what add.delay(4, 5) does

   This queues the add task with arguments 4 and 5 to run asynchronously.

2. Step 2: Understand result.get() usage

   Calling result.get() waits for the task to finish and returns the result, which is 4 + 5 = 9.

3. Final Answer:

   9 -> Option A

4. Quick Check:

   Task result = 4 + 5 = 9 [OK]

Hint: Use .get() to fetch async task result after completion [OK]

Common Mistakes:

• Thinking .get() returns task ID instead of result
• Believing .get() is invalid for Celery AsyncResult
• Expecting None because task runs asynchronously

4. What is wrong with this Celery task call?

@shared_task
def multiply(x, y):
    return x * y

result = multiply(3, 7)

medium

A. The arguments 3 and 7 are invalid types

B. The task is missing the @app.task decorator

C. The function multiply should not return a value

D. The task is called synchronously, not asynchronously

Solution

1. Step 1: Check how the task is called

   The task is called directly as multiply(3, 7), which runs it immediately and blocks.

2. Step 2: Identify correct async call method

   To call asynchronously, it should be multiply.delay(3, 7).

3. Final Answer:

   The task is called synchronously, not asynchronously -> Option D

4. Quick Check:

   Direct call runs sync, use .delay() for async [OK]

Hint: Use .delay() to call tasks async, not direct function call [OK]

Common Mistakes:

• Calling task function directly instead of using .delay()
• Confusing @shared_task with @app.task (both valid but different)
• Thinking return values are disallowed in tasks

5. You want to send a welcome email asynchronously after a user registers. Which approach correctly combines Django signals and Celery tasks to achieve this?

hard

A. Call send_welcome_email(user.id) directly inside the signal handler

B. Connect a signal handler that calls send_welcome_email.delay(user.id) after user creation

C. Use a signal to call send_welcome_email.run(user.id) synchronously

D. Call send_welcome_email.delay() before the user is saved

Solution

1. Step 1: Understand the goal

   We want to send the email asynchronously after the user is created to avoid slowing registration.

2. Step 2: Use Django signals with Celery correctly

   Connect a signal (like post_save) to call send_welcome_email.delay(user.id) after user creation, queuing the task.

3. Final Answer:

   Connect a signal handler that calls send_welcome_email.delay(user.id) after user creation -> Option B

4. Quick Check:

   Signal + .delay() after save = async email send [OK]

Hint: Use signals to trigger .delay() after user save [OK]

Common Mistakes:

• Calling task directly inside signal, blocking request
• Calling .run() which is synchronous
• Calling .delay() before user exists in DB