Фреймворк Django представляет разработчику исчерпывающий набор функций для работы с базами данных, инъекцией зависимостей, обработке шаблонов и многим другим через механизм дополнений. Часто Django используется как решение для разработки динамического содержания сайтов, но также с его помощью можно создавать REST-интерфейсы (например, для взаимодействия с мобильным или frontend-приложением) через расширение DRF (Django Rest Framework), однако REST-методы часто не подходят для ситуаций динамического обновления информации на стороне клиента. В этом случае рационально использовать веб-сокеты для поддержки двухстороннего обмена данными с клиентом и асинхронные расширения Django Channels для создания таких каналов передачи информации. В этой статье мы последовательно разберем механизм работы Django Channels и сделаем простую реализацию чата с использованием веб-сокетов.
Для реализации чата мы будем использовать актуальные версии DRF (3.14.0) и Django Channels (4.0.0). Создадим новый проект Django и добавим необходимые зависимости. Важно, что для работы каналов требуется дополнительное внешнее хранилище и, например, можно использовать для этих целей пакет channels-redis (в дальнейшем мы зададим конфигурацию хранилища для каналов).
Использование веб-сокетов предполагает поддержку асинхронных вызовов со стороны процесса, обрабатывающего веб-запросы, поэтому для публикации будет использоваться протокол asgi. В нашем случае мы будем использовать сервер daphne, его тоже необходимо добавить в зависимости приложения. Для запуска Django приложения будем использовать следующую команду:
daphne -b 0.0.0.0 -p 8080 sample.asgi:applicationВ модуле sample создадим файл asgi.py и свяжем приложение с router. Router будет использоваться для одновременной обработки запросов через web socket и обычных REST-запросов.
from django.core.asgi import get_asgi_application
from messages import routing
asgi = get_asgi_application()
application = ProtocolTypeRouter({
"http": asgi,
"websocket": CookieMiddleware(SessionMiddleware(URLRouter(routing.websocket_urlpatterns))),
})В модуле messages маршрутизация привязывается к Consumer-классам, которые должны быть преобразованы к необходимому интерфейсу через вызов метода .as_asgi()
websocket_urlpatterns = [
re_path(r'^ws/$', WebSocketConsumer.as_asgi()),
]Здесь мы регистрируем префикс /ws для служебных целей (например, открытие нового чата, завершения чата и другие запросы, которые предполагают асинхронный двухсторонний обмен данными) и обмена сообщениями (также можно было бы создать дополнительные web-socket соединения для каждого группового чата, при этом в адресе нужно дополнительно передавать uuid).
Класс поддержки чата должен наследоваться от AsyncWebsocketConsumer (из from channels.generic.websocket import AsyncWebsocketConsumer), при этом необходимо переопределить несколько асинхронных методов:
connect- вызывается при открытии веб-сокета, может использовать метод self.send для отправки сообщения в открытый сокет (например, идентификатор сессии или приветственное сообщение)receive- будет вызван при получении сообщения через веб-сокет (сообщение будет в объекте event).disconnect- вызывается при завершении соединения через веб-сокет
Важно, что для каждого нового websocket-подключения создается новый объект Consumer и он будет существовать в течении всего времени, пока соединение установлено. Это позволяет сохранять внутри объекта дополнительное состояние (например, авторизацию, идентификатор сессии и др.).
Информация об исходном запросе доступна также через свойство self.scope, например из него можно получить параметры запроса:
id = self.scope['url_route']['kwargs']['id']Также можно извлечь информацию об аутентификации (например, через токен авторизации или basic auth), в этом случае имя пользователя будет доступно в self.scope['user'].
Если для обработки запросов потребуется подключение к базе данных нужно будет обернуть ORM-запросы в адаптер database_sync_to_async из asgiref.sync. Завершение соединения через веб-сокет можно инициировать со стороны сервера через вызов метода disconnect.
Однако, как можно увидеть из описания, такой механизм поддерживает только диалоги между клиентом и сервером, но не между несколькими клиентами, что предполагается в реализации чата. А поскольку каждое сокет-соединение представляет отдельный объект, то взаимодействие между ними требует отдельный механизм, который может быть реализован посредством базы данных, очередей сообщений или встроенной поддержки каналов. Для работы с каналами прежде всего необходимо источник данных для хранения их состояния:
CHANNELS_REDIS_HOST = env.str('CHANNELS_REDIS_HOST', 'localhost')
CHANNELS_REDIS_PORT = env.int('CHANNELS_REDIS_PORT', 6379)
CHANNEL_LAYERS = {
'default': {
'BACKEND': 'channels_redis.core.RedisChannelLayer',
'CONFIG': {
"hosts": [f"redis://{CHANNELS_REDIS_HOST}:{CHANNELS_REDIS_PORT}/3"],
},
},
}
Каналы имеют собственные имена и любой consumer может получить доступ к каналам через self.channel_layer. У каждого соединения есть уникальное имя self.channel_name, которое должно использоваться при подключении или отключении от группового канала:
self.channel_layer.group_add('name', self.channel_name)
self.channel_layer.group_discard('name', self.channel_name)Для отправки сообщения всем подписчикам канала используется метод self.channel_layer.group_send('name', message), где message - сериализуемый python-объект. Также можно отправить сообщение адресно, если известно имя канала (из self.channel_name), в этом случае используется метод self.channel_layer.send('name', message).
Во всех случаях отправленное в канал сообщение будет вызывать метод on_chat(self, event), где в event будет доступен отправленный объект.
Также каналы могут использоваться не только в consumer (например, для отправки уведомлений при получении внешнего события), в этом случае доступ к channel_layer может быть получен через вызов соответствующей функции:
from channels.layers import get_channel_layer
channel_layer = get_channel_layer()
channel_layer.group_send('notifications', {})Теперь перейдем к созданию непосредственно реализации чата. Предполагается, что в чат могут входить два или более пользователя (в этом случае они должны отправить уведомление о подключении к группе через отдельный веб-сокет). Также через дополнительный сокет отправляются уведомления на клиента о том, что необходимо открыть окно чата, поскольку он был инициирован со стороны другого пользователя. Кроме этого, предполагается что будут поддержаны глобальные уведомления для всех активных чатов (например, об обслуживании системы).
Начнем с реализации служебного протокола. Это важно, поскольку для запуска любого чата сначала будет отправлено сообщение с информацией о собеседнике (или собеседниках), а также создан идентификатор группы. В нашей реализации мы будем сохранять информацию об активных пользователях и чатах в памяти, но в реальных условиях здесь должно использоваться постоянное хранилище в базе данных.
Все взаимодействие происходит через JSON протокол, поэтому мы будем использовать реализацию AsyncJsonWebsocketConsumer, в которой необходимо определить метод receive_json (получает декодированный объект в content) и использовать send_json для отправки произвольного объекта.
Служебный протокол будет поддерживать следующие команды (различаются по полю command):
start - начать чат, в команде указываются members - список идентификаторов пользователей, которым будет отправлено приглашение в групповой чат (отправляется от клиента на сервер)
invite - приглашение в чат, содержит поле id с идентификатором канала чата (с сервера на клиент). Клиент должен открыть web-socket соединение с адресом chat/<id> для подключения к групповому чату
terminate - прервать чат, должен содержать поле id с идентификатором канала чата.
welcome - приветствие нового клиента, для идентификации будет использоваться
scope["user"]notify - отправка сообщений (может быть как от клиента, так и от сервера), содержит id с указанием идентификатора группы
Обмен сообщениями происходит через передачу сообщений notify, сами сообщения передаются в виде json-объектов с типом kind="message" для обычного сообщения или kind="notification" для системных уведомлений. Текст сообщения всегда отправляется в поле text.
При получении сообщения от клиента (сообщение с type="message" в направлении к серверу), сервер рассылает это сообщение всем подписчикам группового чата (для них это входящее сообщение с type="message") кроме отправителя.
clients = {}
chats = []
import uuid
class ChatWebSocket(AsyncJsonWebsocketConsumer):
async def connect(self):
global clients
clients[scope["user"]] = self.channel_name
self.send_json({"type": "welcome"})
async def disconnect(self):
pass
async def receive_json(self, content):
global chats, clients
if content["type"]=="invite":
chat = str(uuid.uuid4())
chats.append(chat)
for member in content["members"]:
self.channel_layer.send(clients[member], {
"type": "invite",
"id": chat
})
if content["type"]=="disconnect":
self.channel_layer.group_send(content["id"], {
"type": "disconnect",
"id": content["id"]
})
chats.remove(content["id"])
if content["type"]=="notify":
# входящее сообщение от клиента
self.channel_layer.group_send(content["id"], {
"type": "notify",
"kind": content.kind,
"message": content.message,
"sender": self.channel_name
})
async def chat_message(self, event):
# пересылаем клиенту внутреннее сообщение о приглашении в группу
if event["type"]=="invite"
# добавимся также в группу
await self.group_add(event["id"], self.channel_name)
self.send_json(event)
if event["type"]=="disconnect":
# отключаемся от группы
await self.group_discard(event["id"], self.channel_name)
if event["type"]=="notify":
if event["sender"]!=self.channel_name:
self.send_json(event)Здесь мы сохраняем связь имени пользователя и соответствующего управляющего канала (для отправки invite), а также добавляем-удаляем себя из группы, соответствующей указанному чату (по идентификатору канала). Обмен сообщениями выглядит значительно проще, фактически сообщение просто ретранслируется в канал и отправляется всем участникам группы, как входящее сообщение (кроме отправителя).
Для отправки внешних событий (системных уведомлений) можно получить get_channel_layer и отправить во все каналы (список идентификаторов каналов может быть получен итератором по глобальной переменной chats). Аналогично можно добавить пересылку файлов, в этом случае предпочтительно открывать отдельное соединение и передавать по нему двоичные данные через await self.send_body(body=data).
Разумеется, при необходимости можно сочетать обработку web socket и обычные DRF-методы, в этом случае для REST используются синхронные методы. Для совместного использования кода для REST и WebSocket'ов можно использовать адаптеры async_to_sync (для вызова асинхронных методов, например отправки уведомления в канал) и sync_to_async (для обращения к синхронным методам в контексте веб-сокетов).
Для настройки внешнего веб-сервера nginx (например, для отправки статических ресурсов совместно с поддержкой web sockets можно использовать следующую конфигурацию:
upstream channels-backend {
server localhost:8080;
}
server {
listen 80;
server_name example.com
location /static/ {
root /var/www/nginx;
}
location /ws/ {
proxy_pass http://channels-backend;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection “upgrade”;
proxy_redirect off;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Host $server_name;
}
}Таким образом, использование asgi и механизмов асинхронной обработки сообщений в python может быть полезно для создания приложений для взаимодействия в реальном времени через web sockets.
В заключение приглашаю всех на бесплатный урок курса "Специализация Python Developer" по теме: "Модули и импорты". Всем, кто зарегистрируется на урок и будет присутствовать онлайн, подарим абсолютно бесплатно подготовительный курс по Python.