Python Django Channels: Kattava opas WebSocket-toteutukseen

Nykypäivän dynaamisessa verkkomaailmassa reaaliaikaiset sovellukset eivät ole enää ylellisyyttä vaan välttämättömyys. Live-chat-sovelluksista ja yhteistyömuokkaustyökaluista online-pelaamiseen ja reaaliaikaisiin tietojen hallintapaneeleihin, välittömän viestinnän ja päivitysten kysyntä kasvaa jatkuvasti. Onneksi Pythonin Django-kehys tarjoaa tehokkaan ratkaisun tällaisten sovellusten rakentamiseen: Django Channels.

Tämä opas tarjoaa kattavan tutkimusmatkan Django Channelsiin ja sen WebSocket-toteutukseen. Perehdymme ydinajatuksiin, käymme läpi käytännön esimerkin ja keskustelemme edistyneistä tekniikoista, joiden avulla voit luoda vankkoja ja skaalautuvia reaaliaikaisia sovelluksia Djangolla.

Django Channelsin ymmärtäminen

Django Channels laajentaa Djangon ominaisuuksia perinteisen pyyntö-vastaus-syklin ulkopuolelle, mahdollistaen asynkronisen viestinnän ja pysyvät yhteydet. Se saavuttaa tämän tuomalla käyttöön Asynchronous Server Gateway Interface (ASGI) -liittymän, joka on WSGI:n (Web Server Gateway Interface) henkinen seuraaja, Djangon perinteisen synkronisen liittymän.

Avainkäsitteet

• ASGI (Asynchronous Server Gateway Interface): ASGI on vakioliittymä asynkronisten Python-verkkosovellusten ja palvelimien välillä. Sen avulla Django voi käsitellä pitkäikäisiä yhteyksiä, kuten WebSocketit, jotka pysyvät avoinna pitkiä aikoja.
• Channels Layers: Channels Layers tarjoaa viestintäselkäytimen viestien jakamiseen sovelluksesi eri osien välillä. Ajattele sitä viestijonona tai pub/sub-järjestelmänä. Yleisiä toteutuksia ovat Redis, muistissa olevat kanavakerrokset kehitystä varten ja pilvipohjaiset viestipalvelut.
• Consumers: Consumers ovat Djangon näkymien asynkronisia vastineita. Ne käsittelevät saapuvia viestejä ja suorittavat toimintoja viestin sisällön perusteella. Consumers voidaan kirjoittaa funktioina tai luokkina, mikä tarjoaa joustavuutta ja uudelleenkäytettävyyttä.
• Routing: Routing määrittää, miten saapuvat viestit reititetään tietyille consumereille. Se on samanlainen kuin Djangon URL-reititys, mutta WebSocket-yhteyksille.

Django-projektin määrittäminen Channelsin kanssa

Aloitetaan määrittämällä Django-projekti ja asentamalla Django Channels. Tässä osiossa oletetaan, että Python ja Django on asennettu.

1. Uuden Django-projektin luominen

Avaa terminaali ja luo uusi Django-projekti:

            django-admin startproject myproject
cd myproject
            

              
                Copy
              
            
          

2. Virtuaaliympäristön luominen (suositus)

On aina hyvä käytäntö luoda virtuaaliympäristö projektin riippuvuuksien eristämiseksi:

            python3 -m venv venv
source venv/bin/activate  # Linux/macOS
.\venv\Scripts\activate  # Windows
            

              
                Copy
              
            
          

3. Django Channelsin asentaminen

Asenna Django Channels ja sen riippuvuudet pipillä:

            pip install channels daphne
            

              
                Copy
              
            
          

Daphne on ASGI-palvelin, jota käytämme Channels-sovelluksemme suorittamiseen. Myös muut ASGI-palvelimet, kuten uvicorn, ovat yhteensopivia.

4. Django-asetusten määrittäminen

Avaa projektisi `settings.py`-tiedosto ja lisää `channels` `INSTALLED_APPS`-luetteloon:

            INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'channels',
    # Muut sovelluksesi
]
            

              
                Copy
              
            
          

Lisää ASGI-sovelluskokoonpano `settings.py`-tiedostoon:

            ASGI_APPLICATION = 'myproject.asgi.application'
            

              
                Copy
              
            
          

Tämä kertoo Djongolle, että se käyttäisi `myproject/asgi.py`-tiedostossa määriteltyä ASGI-sovellusta.

5. Channels Layerin määrittäminen

            CHANNEL_LAYERS = {
    'default': {
        'BACKEND': 'channels_redis.core.RedisChannelLayer',
        'CONFIG': {
            "hosts": [('127.0.0.1', 6379)],
        },
    },
}
            

              
                Copy
              
            
          

Jos sinulla ei ole `channels_redis` asennettuna, asenna se:

            pip install channels_redis
            

              
                Copy
              
            
          

6. asgi.py:n luominen

Jos sitä ei ole olemassa, luo `asgi.py`-tiedosto projektikansioosi (`wsgi.py`:n viereen). Tämä tiedosto määrittää ASGI-sovelluksen:

            # myproject/asgi.py
import os

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
import chat.routing  # Tuo sovelluksesi reititys

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

application = ProtocolTypeRouter({
    "http": get_asgi_application(),
    "websocket": AuthMiddlewareStack(
        URLRouter(
            chat.routing.websocket_urlpatterns
        )
    ),
})
            

              
                Copy
              
            
          

Yksinkertaisen chat-sovelluksen rakentaminen

Rakennetaan yksinkertainen chat-sovellus havainnollistamaan Django Channelsia ja WebSocketia. Tämä esimerkki mahdollistaa käyttäjien lähettää ja vastaanottaa viestejä yhdessä chat-huoneessa.

1. Uuden Django-sovelluksen luominen

Luo uusi Django-sovellus nimeltä `chat`:

            python manage.py startapp chat
            

              
                Copy
              
            
          

Lisää `chat` `INSTALLED_APPS`-luetteloon `settings.py`-tiedostossa:

            INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'channels',
    'chat',
    # Muut sovelluksesi
]
            

              
                Copy
              
            
          

2. WebSocket-reitityksen määrittäminen

Luo `routing.py`-tiedosto `chat`-sovellukseen määrittämään WebSocket-reitityksen:

            # chat/routing.py
from django.urls import re_path

from . import consumers

websocket_urlpatterns = [
    re_path(r'ws/chat/(?P<room_name>\w+)/$', consumers.ChatConsumer.as_asgi()),
]
            

              
                Copy
              
            
          

Tämä määrittää reitin WebSocket-yhteyksille polkuun `/ws/chat//`, jossa `` on chat-huoneen nimi. Se yhdistää tämän URLin `ChatConsumer`-kuluttajaan.

3. Consumerin luominen

Luo `consumers.py`-tiedosto `chat`-sovellukseen määrittämään `ChatConsumer`:

            # chat/consumers.py
import json

from channels.generic.websocket import AsyncWebsocketConsumer
from asgiref.sync import sync_to_async

from django.contrib.auth.models import User

class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        self.room_name = self.scope['url_route']['kwargs']['room_name']
        self.room_group_name = f'chat_{self.room_name}'

        # Liity huoneryhmään
        await self.channel_layer.group_add(
            self.room_group_name,
            self.channel_name
        )

        await self.accept()

    async def disconnect(self, close_code):
        # Poistu huoneryhmästä
        await self.channel_layer.group_discard(
            self.room_group_name,
            self.channel_name
        )

    # Vastaanota viesti WebSocketiltä
    async def receive(self, text_data):
        text_data_json = json.loads(text_data)
        message = text_data_json['message']
        username = text_data_json['username'] # Pura käyttäjänimi vastaanotetusta datasta

        # Lähetä viesti huoneryhmälle
        await self.channel_layer.group_send(
            self.room_group_name,
            {
                'type': 'chat.message',
                'message': message,
                'username': username,
            }
        )

    # Vastaanota viesti huoneryhmältä
    async def chat_message(self, event):
        message = event['message']
        username = event['username']

        # Lähetä viesti WebSocketille
        await self.send(text_data=json.dumps({
            'message': message,
            'username': username,
        }))

            

              
                Copy
              
            
          

Tämä consumer käsittelee WebSocket-yhteyksiä, liittyy ja poistuu chat-huoneista, vastaanottaa viestejä asiakkailta ja lähettää viestejä huoneryhmälle. Ratkaisevaa on, että se on asynkroninen, mikä mahdollistaa useiden yhteyksien käsittelyn samanaikaisesti.

4. Yksinkertaisen mallin luominen

Luo `templates/chat/room.html`-tiedosto projektiisi. Sinun on ehkä luotava `templates`-hakemisto projektisi juurihakemistoon ja sitten `chat`-hakemisto sen sisälle. Tämä malli näyttää chat-huoneen ja antaa käyttäjien lähettää viestejä.

            <!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8"/>
    <title>Chat Room</title>
</head>
<body>
    <h1>Chat Room: {{ room_name }}</h1>
    <div id="chat-log"></div>
    <input type="text" id="chat-message-input" size="100"/><br/>
    <input type="text" id="chat-username-input" size="100" placeholder="Enter your username"/><br/>
    <button id="chat-message-submit">Send</button>

    <script>
        const roomName = {{ room_name|json_script:"room-name" }};
        const chatSocket = new WebSocket(
            'ws://'
            + window.location.host
            + '/ws/chat/'
            + roomName
            + '/'
        );

        chatSocket.onmessage = function(e) {
            const data = JSON.parse(e.data);
            document.querySelector('#chat-log').value += (data.username + ': ' + data.message + '\n');
        };

        chatSocket.onclose = function(e) {
            console.error('Chat socket closed unexpectedly');
        };

        document.querySelector('#chat-message-input').focus();
        document.querySelector('#chat-message-input').onkeyup = function(e) {
            if (e.keyCode === 13) {  // enter, return
                document.querySelector('#chat-message-submit').click();
            }
        };

        document.querySelector('#chat-message-submit').onclick = function(e) {
            const messageInputDom = document.querySelector('#chat-message-input');
            const usernameInputDom = document.querySelector('#chat-username-input');
            const message = messageInputDom.value;
            const username = usernameInputDom.value;  // Hae käyttäjänimi
            chatSocket.send(JSON.stringify({
                'message': message,
                'username': username
            }));
            messageInputDom.value = '';
        };
    </script>
</body>
</html>
            

              
                Copy
              
            
          

Tämä malli käyttää JavaScriptiä WebSocket-yhteyden muodostamiseen, viestien lähettämiseen ja vastaanotettujen viestien näyttämiseen `chat-log`-elementissä. Se sisältää nyt myös käyttäjänimen syöttökentän ja lähettää käyttäjänimen jokaisen viestin mukana.

5. Näkymän luominen

Luo `views.py`-tiedosto `chat`-sovellukseen määrittämään näkymän, joka renderöi chat-huoneen mallin:

            # chat/views.py
from django.shortcuts import render

def room(request, room_name):
    return render(request, 'chat/room.html', {
        'room_name': room_name
    })
            

              
                Copy
              
            
          

6. URL-mallien määrittäminen

Sisällytä chat-sovelluksen URLit projektisi `urls.py`-tiedostoon:

            # myproject/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('chat/', include('chat.urls')),
]
            

              
                Copy
              
            
          

Luo `urls.py`-tiedosto `chat`-sovellukseen:

            # chat/urls.py
from django.urls import path

from . import views

urlpatterns = [
    path('<str:room_name>/', views.room, name='room'),
]
            

              
                Copy
              
            
          

7. Kehityspalvelimen suorittaminen

Käynnistä Djangon kehityspalvelin Daphnen kanssa:

            python manage.py runserver
            

              
                Copy
              
            
          

Avaa verkkoselain ja siirry osoitteeseen `http://127.0.0.1:8000/chat/myroom/` (korvaa `myroom` halutulla chat-huoneen nimellä). Sinun pitäisi nähdä chat-huoneen käyttöliittymä. Avaa sama URL toisessa selainikkunassa simuloidaksesi useita käyttäjiä.

Edistyneet tekniikat ja parhaat käytännöt

Nyt kun sinulla on perus chat-sovellus toiminnassa, tutkitaan joitain edistyneitä tekniikoita ja parhaita käytäntöjä vankkojen ja skaalautuvien reaaliaikaisten sovellusten rakentamiseen Django Channelsilla.

Todennus ja valtuutus

WebSocket-yhteyksiesi suojaaminen on ratkaisevan tärkeää. Django Channels tarjoaa sisäänrakennetun tuen todennukselle ja valtuutukselle. Voit käyttää Djangon tavallista todennusjärjestelmää käyttäjien todentamiseen ennen kuin he muodostavat yhteyden WebSocketiin. `AuthMiddlewareStack` `asgi.py`-tiedostossasi todentaa käyttäjät automaattisesti heidän istuntonsa perusteella. Voit käyttää todennettua käyttäjää `self.scope['user']`-arvon kautta consumerissasi.

Esimerkki:

            # chat/consumers.py
from channels.generic.websocket import AsyncWebsocketConsumer

class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        user = self.scope['user']
        if user.is_authenticated:
            await self.accept()
        else:
            await self.close()
            

              
                Copy
              
            
          

Monimutkaisemmissa valtuutusskenaarioissa voit toteuttaa mukautettuja väli- tai tarkistuksia consumereidesi sisällä.

Skaalautuvuus ja suorituskyky

Sovelluksesi kasvaessa skaalautuvuudesta tulee kriittinen huolenaihe. Django Channels on suunniteltu skaalautuvaksi, mutta sinun on otettava huomioon useita tekijöitä:

• Channels Layer: Valitse vankka ja skaalautuva Channels Layer, kuten Redis tai pilvipohjainen viestipalvelu, kuten Amazon MQ tai Google Cloud Pub/Sub. Redis on hyvä lähtökohta, mutta suuren liikenteen sovelluksissa harkitse hallittua pilviratkaisua.
• ASGI-palvelin: Käytä tuotantovalmista ASGI-palvelinta, kuten Daphne tai Uvicorn. Nämä palvelimet on suunniteltu käsittelemään suurta määrää samanaikaisia yhteyksiä tehokkaasti.
• Vaakasuuntainen skaalaus: Ota käyttöön useita Django-sovelluksesi esiintymiä kuormituksen tasaimen takana jakaaksesi työmäärän. Jokaisen esiintymän tulisi muodostaa yhteys samaan Channels Layeriin.
• Tietokannan optimointi: Jos sovelluksesi sisältää tietokantavuorovaikutuksia, optimoi tietokantakyselysi ja harkitse välimuistin käyttöä tietokannan kuormituksen vähentämiseksi.

Testaus

Channels-sovellusten testaaminen on välttämätöntä niiden luotettavuuden ja oikeellisuuden varmistamiseksi. Django Channels tarjoaa testityökaluja WebSocket-yhteyksien simulointiin ja consumereidesi käyttäytymisen tarkistamiseen.

Esimerkki:

            # chat/tests.py
import pytest
from channels.testing.websocket import WebsocketCommunicator
from chat.consumers import ChatConsumer

@pytest.mark.asyncio
async def test_chat_consumer():
    communicator = WebsocketCommunicator(ChatConsumer.as_asgi(), "ws/chat/testroom/")
    connected, subprotocol = await communicator.connect()
    assert connected

    await communicator.send_to(text_data={"message": "Hello", "username": "TestUser"})
    response = await communicator.receive_from()
    assert response == '{"message":"Hello","username":"TestUser"}'

    await communicator.disconnect()
            

              
                Copy
              
            
          

Tämä esimerkki käyttää `WebsocketCommunicator`ia simuloidakseen WebSocket-yhteyden `ChatConsumer`iin, lähettää viestin ja vahvistaa vastauksen.

Virheiden käsittely

Vankka virheiden käsittely on ratkaisevan tärkeää sovellusten kaatumisten estämiseksi ja hyvän käyttökokemuksen tarjoamiseksi. Toteuta asianmukainen virheiden käsittely consumereissasi poikkeusten sieppaamiseksi ja odottamattomien tilanteiden hallitsemiseksi sulavasti. Voit käyttää `try...except`-lohkoja poikkeusten sieppaamiseen ja virheviestien lähettämiseen asiakkaille.

Esimerkki:

            # chat/consumers.py
import json
from channels.generic.websocket import AsyncWebsocketConsumer

class ChatConsumer(AsyncWebsocketConsumer):
    async def receive(self, text_data):
        try:
            text_data_json = json.loads(text_data)
            message = text_data_json['message']
            username = text_data_json['username']

            await self.channel_layer.group_send(
                self.room_group_name,
                {
                    'type': 'chat.message',
                    'message': message,
                    'username': username
                }
            )
        except Exception as e:
            await self.send(text_data=json.dumps({
                'error': str(e)
            }))
            

              
                Copy
              
            
          

Käyttöönottohuomiot

Django Channels -sovellusten käyttöönotto vaatii huolellista suunnittelua ja harkintaa. Tässä on joitain keskeisiä näkökohtia, jotka on pidettävä mielessä:

• ASGI-palvelin: Käytä tuotantolaatuista ASGI-palvelinta, kuten Daphne tai Uvicorn. Määritä palvelin käsittelemään suurta määrää samanaikaisia yhteyksiä ja optimoimaan suorituskyky.
• Channels Layer: Valitse luotettava ja skaalautuva Channels Layer. Redis on hyvä vaihtoehto pienille ja keskisuurille sovelluksille, mutta suuremmissa sovelluksissa kannattaa harkita pilvipohjaista viestipalvelua. Varmista, että Channels Layer on määritetty oikein ja suojattu.
• Kuormituksen tasapainotus: Käytä kuormituksen tasainetta liikenteen jakamiseen useiden Django-sovelluksesi esiintymien kesken. Tämä parantaa suorituskykyä ja varmistaa korkean käytettävyyden.
• Valvonta: Toteuta kattava valvonta seurataksesi sovelluksesi suorituskykyä ja tunnistaaksesi mahdolliset ongelmat. Valvo aktiivisten WebSocket-yhteyksien määrää, viestien läpivirtausta ja virheprosentteja.
• Turvallisuus: Suojaa WebSocket-yhteytesi SSL/TLS-salauksella. Toteuta asianmukaiset todennus- ja valtuutusmekanismit suojataksesi sovelluksesi luvattomalta pääsyltä.

Käyttötapaukset chat-sovellusten ulkopuolella

Vaikka esimerkkimme keskittyi chat-sovellukseen, Django Channels on monipuolinen ja sitä voidaan soveltaa monenlaisiin reaaliaikaisiin sovelluksiin. Tässä on joitain esimerkkejä:

• Reaaliaikaiset tietojen hallintapaneelit: Näytä reaaliaikaiset tietopäivitykset hallintapaneeleissa järjestelmän suorituskyvyn, rahoitusmarkkinoiden tai sosiaalisen median trendien seuraamiseksi. Esimerkiksi rahoituskaupankäyntialusta voisi käyttää Django Channelsia lähettämään reaaliaikaisia osakekursseja käyttäjille.
• Yhteistyömuokkaustyökalut: Anna useiden käyttäjien muokata asiakirjoja, laskentataulukoita tai koodia samanaikaisesti, ja muutokset näkyvät reaaliajassa. Harkitse Googlen Docsia vastaavaa yhteistyöasiakirjojen muokkausalustaa.
• Online-pelaaminen: Rakenna moninpelejä, joissa on reaaliaikaisia vuorovaikutuksia pelaajien välillä. Tämä voi vaihdella yksinkertaisista lautapeleistä monimutkaisiin toimintapeleihin.
• Reaaliaikaiset ilmoitukset: Lähetä reaaliaikaisia ilmoituksia käyttäjille tapahtumista, päivityksistä tai hälytyksistä. Esimerkiksi verkkokauppa-alusta voisi ilmoittaa käyttäjille, kun heidän tilauksensa tila muuttuu.
• IoT (esineiden internet) -sovellukset: Kerää ja käsittele tietoja IoT-laitteista reaaliajassa. Kuvittele älykäs kotisovellus, joka vastaanottaa anturitietoja eri laitteista ja päivittää käyttöliittymän vastaavasti.

Johtopäätös

Django Channels tarjoaa tehokkaan ja joustavan kehyksen reaaliaikaisten sovellusten rakentamiseen Pythonilla ja Djangolla. Hyödyntämällä WebSocketia, ASGI:tä ja Channels Layeriä voit luoda erittäin interaktiivisia ja kiinnostavia käyttökokemuksia. Tämä opas on tarjonnut kattavan yleiskatsauksen Django Channelsista, joka kattaa ydinajatukset, käytännön esimerkin ja edistyneet tekniikat. Kun jatkat Django Channelsin tutkimista, huomaat sen valtavan potentiaalin innovatiivisten ja vaikuttavien reaaliaikaisten sovellusten rakentamisessa.

Hyödynnä asynkronisen ohjelmoinnin voima ja hyödynnä Django-projektiesi koko potentiaali Django Channelsin avulla!