Créez des systèmes de suivi de localisation dynamique dans Django avec Redis Pub/Sub et Pulsetracker

Dans cet article, nous montrerons comment intégrer Redis Pub/Sub de Pulsetracker dans une application Django pour écouter les mises à jour de localisation en temps réel. De plus, nous allons créer un simple client JavaScript WebSocket pour envoyer des mises à jour de localisation chaque seconde à Pulsetracker, montrant ainsi comment le service peut être utilisé dans une application du monde réel.

---

Pourquoi Django ?

Django est un framework Web Python de haut niveau qui encourage un développement rapide et une conception propre et pragmatique. Il est connu pour son évolutivité, sa sécurité et son riche écosystème d'outils qui permettent de créer des applications Web robustes plus rapidement et plus facilement.

La fonctionnalité Redis Pub/Sub de Pulsetracker s'intègre parfaitement à Django, permettant aux développeurs de recevoir et de traiter efficacement les données de localisation en temps réel.

---

Configuration de Redis Pub/Sub dans Django

1. Installer les packages nécessaires

Tout d'abord, installez le support Redis pour Django :

pip install django-redis
pip install redis

---

2. Configurer Redis dans Django

Mettez à jour votre fichier settings.py pour inclure la connexion Pulsetracker Redis :

# settings.py

from decouple import config  # Recommended for managing environment variables

# Redis settings
PULSETRACKER_REDIS_URL = config('PULSETRACKER_REDIS_URL', default='redis://redis-sub.pulsestracker.com:6378')

---

3. Créer une commande de gestion pour l'abonné

Les commandes de gestion Django sont un excellent moyen de gérer les tâches en arrière-plan de longue durée.

Créez une nouvelle commande personnalisée dans votre application Django :

python manage.py startapp tracker

Dans votre application, créez la structure de dossiers et de fichiers suivante :

tracker/
    management/
        commands/
            subscribe_pulsetracker.py

Voici le code pour Subscribe_pulsetracker.py :

import redis
import hashlib
import hmac
from django.core.management.base import BaseCommand

class Command(BaseCommand):
    help = "Subscribe to Pulsetracker Redis Pub/Sub server"

    def generate_signature(self, app_key, token):
        if "|" not in token:
            raise ValueError("Invalid token format")

        token_hash = hashlib.sha256(token.split("|")[1].encode()).hexdigest()
        return hmac.new(token_hash.encode(), app_key.encode(), hashlib.sha256).hexdigest()

    def handle(self, *args, **options):
        app_key = 'your_app_key_here'
        token = 'your_token_here'
        signature = self.generate_signature(app_key, token)

        channel = f"app:{app_key}.{signature}"
        redis_connection = redis.StrictRedis.from_url('redis://redis-sub.pulsestracker.com:6378')

        print(f"Subscribed to {channel}")
        pubsub = redis_connection.pubsub()
        pubsub.subscribe(channel)

        for message in pubsub.listen():
            if message['type'] == 'message':
                print(f"Received: {message['data'].decode('utf-8')}")

Exécutez l'abonné avec :

python manage.py subscribe_pulsetracker

Pour garantir que l'abonné fonctionne en continu en production, utilisez un gestionnaire de processus comme Superviseur ou Django-Q.

---

Utiliser Django-Q pour les tâches en arrière-plan

Installer Django-Q :

pip install django-q

Mettre à jour settings.py :

# settings.py

Q_CLUSTER = {
    'name': 'Django-Q',
    'workers': 4,
    'recycle': 500,
    'timeout': 60,
    'redis': {
        'host': 'redis-sub.pulsestracker.com',
        'port': 6378,
        'db': 0,
    }
}

Créez une tâche pour écouter les mises à jour de Pulsetracker dans Tasks.py :

from django_q.tasks import async_task
import redis

def pulsetracker_subscribe():
    app_key = 'your_app_key_here'
    token = 'your_token_here'
    channel = f"app:{app_key}.{generate_signature(app_key, token)}"

    redis_connection = redis.StrictRedis.from_url('redis://redis-sub.pulsestracker.com:6378')
    pubsub = redis_connection.pubsub()
    pubsub.subscribe(channel)

    for message in pubsub.listen():
        if message['type'] == 'message':
            print(f"Received: {message['data'].decode('utf-8')}")

---

Exemple de client WebSocket

Voici un client JavaScript simple qui simule les mises à jour de localisation de l'appareil envoyées à Pulsetracker via WebSockets :

var wsServer = 'wss://ws-tracking.pulsestracker.com';
var websocket = new WebSocket(wsServer);
const appId = 'YOUR_APP_KEY';
const clientId = 'YOUR_CLIENT_KEY';

websocket.onopen = function(evt) {
    console.log("Connected to WebSocket server.");
    // Send location every 2 seconds
    setInterval(() => {
        if (websocket.readyState === WebSocket.OPEN) {
            navigator.geolocation.getCurrentPosition((position) => {
                console.log(position);
                const locationData = {
                    appId: appId,
                    clientId: clientId,
                    data: {
                        type: "Point",
                        coordinates: [position.coords.longitude, position.coords.latitude]
                    },
                    extra: {
                        key: "value"
                    }
                };


                // Send location data as JSON
                websocket.send(JSON.stringify(locationData));
                console.log('Location sent:', locationData);
            }, (error) => {
                console.error('Error getting location:', error);
            });
        }
    }, 3000); // Every 2 seconds
};

websocket.onclose = function(evt) {
    console.log("Disconnected");
};

websocket.onmessage = function(evt) {
    if (event.data === 'Pong') {
        console.log('Received Pong from server');
    } else {
        // Handle other messages
        console.log('Received:', event.data);
    }
};

websocket.onerror = function(evt, e) {
    console.log('Error occurred: ' + evt.data);
};

---

Conclusion

Pulsetracker, associé à Django et Redis Pub/Sub, offre une solution robuste pour le suivi de localisation en temps réel. Cette intégration permet aux développeurs de créer des systèmes évolutifs et prêts pour la production qui gèrent efficacement les données de localisation en direct. L'ajout d'un client WebSocket démontre avec quelle facilité Pulsetracker peut s'intégrer aux applications frontales, améliorant ainsi l'expérience utilisateur.

Essayez d'implémenter Pulsetracker dans votre projet Django dès aujourd'hui et partagez votre expérience ! Pour plus d'informations, visitez la documentation Pulsetracker.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!