Django est un framework Python populaire utilisé pour développer des applications Web à l'aide du Wgsi (Interface de passerelle Web Server) et ASGI (Interface de passerelle asynchrone) Spécifications du serveur. WGSI est utilisé pour développer des applications Python synchrones, et AGSI est utilisé pour développer des applications Web asynchrones et synchrones. Canaliser est une caractéristique utile de Django qui est utilisée pour gérer WebSocket, Protocole de chat, etc. aux côtés du protocole HTTP. Le canal est construit sur les spécifications du serveur ASGI. Une session de communication interactive bidirectionnelle entre le navigateur de l'utilisateur et le serveur peut être ouverte en utilisant un WebSocket. Le client initie le Websocket connexion et le serveur répond avec un accepter ou fermer message. Le Websocket Les messages sont poussés dans le canal en utilisant producteurs et envoyé au consommateurs qui écoutent sur la chaîne. Ce tutoriel vous montre comment utiliser canaux gérer Websocket messages.

Conditions préalables

Avant de pratiquer le script indiqué dans ce tutoriel, assurez-vous de terminer les tâches suivantes.

• Installez Django version 3+ sur Ubuntu 20+ (de préférence)
• Créer un projet Django
• Exécutez le serveur Django pour vérifier si le serveur fonctionne correctement

Configurer une application Django

Exécutez la commande suivante pour créer une application django nommée socketapp:

$ python3 gérer.py startapp socketapp

Exécutez la commande suivante pour installer le canal:

$ PIP Installer les canaux

Ajouter les canaux et le nom de l'application au Installé_app partie de la paramètres.py déposer:

Installé_apps = [
…
'canaux',
'socketapp'
]]

Définir la valeur d'Asgi_application dans le paramètres.py déposer:

ASGI_APPLICATION = 'Channel_pro.ASGI.application'

Créer un dossier nommé modèles à l'intérieur de socketapp dossier et définissez l'emplacement du modèle de l'application dans le Modèles partie de la paramètres.py déposer:

Modèles = [

… .
'DIRS': ['/ home / fahmida / canal_pro / socketapp / modèles']],
… .
,
]]

La sortie suivante apparaîtra dans le terminal après avoir exécuté le serveur Django. La sortie montre que ASGI / Channels version 3.0.3 est en cours d'exécution.

Créer un fichier de modèle nommé indice.html Dans l'emplacement du modèle défini pour afficher les données envoyées par le WebSocket. L'objet Socket créé à l'aide de JavaScript lira les données à l'aide du JSON.méthode parse (), puis transmette la valeur dans le contenu du

balise qui contient la valeur d'ID, 'msg.'

indice.html

texte

Modifier le vues.py fichier du socketapp avec le contenu suivant. Le indice.html Le fichier de modèle sera affiché dans le navigateur avec le texte variable lorsque le indice() la méthode de ce script est appelée à partir du URL.py déposer. Si aucun message n'est transmis à partir de la prise, alors le texte 'Linuxhint'sera affiché dans le navigateur.

vues.py

# Importer le module de rendu de Django
De Django.Raccourcis
# Créer une fonction d'index pour afficher le fichier HTML dans le navigateur
index def (demande):
Retour Render (demande, "Index.html ", context = 'text': 'linuxhint')

Modifier le URL.py fichier du socketapp avec le contenu suivant. Deux chemins sont définis dans le script: le 'admin /'Le chemin est utilisé pour ouvrir le tableau de bord de l'administration Django, et le'msg /'Le chemin est utilisé pour lire le message WebSocket.

URL.py

De Django.contriber d'importation administrateur
De Django.Chemin d'importation des URL
à partir des vues d'importation SocketApp
urlpatterns = [
Path ('admin /', admin.placer.URL),
Path ('msg /', vues.indice)
]]

Lorsque l'URL suivante est exécutée sans définir le consommateur et les fichiers de routage, le protocole HTTP fonctionnera et la sortie suivante apparaîtra.

http: // localhost: 8000 / msg

Maintenant, créez un consommateurs.py fichier à l'intérieur du socketapp dossier avec le script suivant. Le connecter() méthode de WS_CONSUMER sera utilisé pour accepter la connexion de socket, lire la valeur de temps actuelle à chaque seconde et envoyer l'heure actuelle au format JSON via WebSocket lorsque cette méthode est appelée à partir du fichier de routage.

consommateurs.py

# Importer le module JSON
Importer JSON
# Importer WebSocketConsumer
des canaux.générique.WebSocket importe WebSocketConsumer
# Importer le module DateTime
à partir de Datetime Import Datetime
# Importer le module de sommeil
à partir de temps pour sommeil
# Définissez la classe de consommation pour envoyer les données via WebSocketConsumer
classe WS_Consumer (WebSocketConsumer):
def connect (self):
soi.accepter()
tandis que (vrai):
maintenant = datetime.maintenant()
soi.Envoyer (JSON.Dumps ('TimeValue': maintenant.strftime ("% h:% m:% s")))
sommeil (1)

Créer le routage.py à l'intérieur de socketapp dossier avec le script suivant. Le 'msg /'Le chemin est défini dans le script pour appeler le consommateur pour avoir envoyé les données à la prise.

routage.py

De Django.Chemin d'importation des URL
depuis .Les consommateurs importent WS_Consumer
# Définissez le chemin pour appeler le consommateur
ws_urlpatterns = [
chemin ('msg /', ws_consumer.as_asgi ())
]]

Modifier le ASGI.py fichier avec le script suivant. Les modules nécessaires pour gérer les demandes HTTP et WebSocket sont importés dans le script.

ASGI.py

# Module d'importation du système d'exploitation
Importer un système d'exploitation
# Importez get_asgi_application pour gérer le protocole HTTP
De Django.cœur.ASGI IMPORT GET_ASGI_APPLICATION
# Importer ProtocoltyPerouter et UrlRouter pour définir le routage WebSocket
des canaux.Protocoltypeuter des protocoles d'importation, Urlrouter
# Importez Authmiddlewarestack pour gérer WebSocket
des canaux.Auth import authmiddlewarestack
# Importer le routage WebSocket
De SocketApp.Route d'importation ws_urlpatterns
# Attribuer une valeur pour django_settings_module
OS.environ.setDefault ('django_settings_module', 'channel_pro.paramètres')
# Définir la variable d'application pour gérer HTTP et WebSocket
application = protocoltyPerouter (
'http': get_asgi_application (),
'WebSocket': authmiddlewarestack (UrlRouter (ws_urlpatterns)))
)

Maintenant, exécutez à nouveau l'URL suivante à partir du navigateur pour lire les données de WebSocket.

http: // localhost: 8000 / msg /

Si le consommateur et le routeur fonctionnent correctement, l'horloge numérique suivante sera affichée dans le navigateur. Ici, le routeur a envoyé la demande WebSocket en utilisant le 'msg /'Chemin vers le consommateur qui a accepté la demande et a envoyé les données au modèle pour afficher l'horloge numérique du navigateur où la deuxième valeur de l'heure actuelle est la mise à jour de chaque seconde.

Conclusion

Ce tutoriel vous a montré comment implémenter une application en temps réel à l'aide du framework et des canaux Django en créant une simple horloge numérique. D'autres types d'applications en temps réel peuvent également être mis en œuvre à l'aide de Django et de canaux, tels que les systèmes de chat en ligne. Les scripts utilisés dans ce tutoriel fonctionnent pour les versions Django 3+ et les versions de canal 3+ seulement. Donc, si vous utilisez une version antérieure Django ou Channel, vous devrez mettre à niveau la version avant de tester le script fourni dans ce tutoriel.