Introduction

In this tutorial, we will learn how to use Django Channels to integrate asynchronous tasks into a Django project. We will specifically focus on using Redis as the message broker for handling these tasks. By the end of this tutorial, you will be able to incorporate asynchronous functionality into your Django application, improving its responsiveness and scalability.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of:

Python programming language
Django framework
Redis, an in-memory data structure store

Setup

Before we begin, make sure you have the following software installed on your system:

Python 3.x
Django
Redis

You can install Django and Redis using pip: bash pip install django pip install redis

Creating a Django Project

Let’s start by creating a new Django project. Open your terminal and run the following command: bash django-admin startproject myproject Navigate to the newly created project directory: bash cd myproject

Installing Django Channels

Django Channels is not included in the default Django installation. We need to install it separately. Run the following command to install Django Channels: bash pip install channels

Configuring Redis

We will use Redis as the message broker for handling asynchronous tasks. Make sure Redis is installed on your system. Start the Redis server by running the following command: bash redis-server

Creating a Consumer

A consumer is a Python function that handles the incoming messages from the Channels layer. We need to create a consumer to handle the asynchronous tasks. Create a new file called consumers.py in the same directory as your Django project’s settings.py.

Add the following code to the consumers.py file: ```python from channels.generic.websocket import AsyncWebsocketConsumer import asyncio

class MyConsumer(AsyncWebsocketConsumer):

    async def connect(self):
        # Connect code here

    async def disconnect(self, close_code):
        # Disconnect code here

    async def receive(self, text_data):
        # Receive code here
``` This is a basic skeleton for a consumer. We will implement the required methods in the next sections.

Routing and Channels

Routing determines which consumer should handle each message. Open the myproject directory and create a new file called routing.py. Add the following code to the routing.py file: ```python from django.urls import path from . import consumers

websocket_urlpatterns = [
    path('ws/my_consumer/', consumers.MyConsumer.as_asgi()),
]
``` Next, open the `myproject` directory and locate the `asgi.py` file. Add the following code to the `asgi.py` file:
```python
import os
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
from . import routing

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

application = ProtocolTypeRouter({
    "http": get_asgi_application(),
    "websocket": URLRouter(
        routing.websocket_urlpatterns
    ),
})
``` These changes will enable Channels and connect the consumer to the URLs of the project.

Creating an Asynchronous Task

Now that we have set up the necessary files, let’s create an example asynchronous task. Inside the receive method of the MyConsumer class in consumers.py, add the following code: python async def receive(self, text_data): await self.send("Task started") await asyncio.sleep(5) await self.send("Task completed") This code will send a message to the connected client when the task starts, sleep for 5 seconds, and then send another message when the task is completed.

Running the Application

To run the application, open a new terminal window and start the Redis server if it’s not already running: bash redis-server In the terminal, navigate to your Django project’s root directory (myproject) and run the following command: bash python manage.py runserver Open your web browser and visit http://localhost:8000. You should see the Django default homepage.

Now, open the browser’s console and execute the following JavaScript code: ```javascript const socket = new WebSocket(‘ws://localhost:8000/ws/my_consumer/’);

socket.onmessage = function(e) {
  console.log(e.data);
};

socket.onopen = function() {
  socket.send('Start task');
};

socket.onclose = function() {
  console.log("Connection closed");
};
``` This code establishes a WebSocket connection with the Django server and sends a message. You should see the "Task started" message in the browser's console, followed by the "Task completed" message after 5 seconds.

Congratulations! You have successfully integrated Django Channels into your Django project for handling asynchronous tasks with Redis.

Conclusion

In this tutorial, we have learned how to use Django Channels and Redis to incorporate asynchronous tasks into a Django project. We covered the setup process, creating consumers, routing messages, and running the application. By implementing asynchronous tasks, you can improve the responsiveness and scalability of your Django applications.

Published: 19 June 2021

Django Channels: Asynchronous Tasks with Django and Redis

Table of Contents