Création d'une solution de suivi de localisation en temps réel avec Pulsetracker, Laravel et Python

Introduction : Qu'est-ce que PulseTracker ?

Pulsetracker est un service backend pour le suivi de localisation en temps réel, conçu spécifiquement pour les développeurs qui ont besoin d'un moyen robuste et flexible pour surveiller les données de localisation sans être liés à des SDK ou à une infrastructure propriétaire. Il permet aux développeurs d'implémenter leurs propres SDK clients à l'aide des protocoles UDP ou WebSocket. De plus, Pulsetracker peut envoyer des mises à jour de localisation en temps réel directement au backend du développeur, ce qui en fait un choix puissant pour les applications nécessitant un suivi en temps réel.

Dans ce didacticiel, nous expliquerons l'utilisation de Pulsetracker avec un script Python comme écouteur pour les mises à jour de localisation en temps réel. Le script Python agit comme un écouteur Pulsetracker qui reçoit les mises à jour et les envoie à un gestionnaire de tâches Laravel via Redis, permettant à Laravel de traiter ces mises à jour efficacement.

Conditions préalables

1.Compte Pulsetracker : créez un compte Pulsetracker et obtenez votre clé d'application et votre jeton d'autorisation.

2.Redis : assurez-vous que Redis est installé et en cours d'exécution.

3.Projet Laravel : créez un projet Laravel si vous n'en avez pas déjà un.

Configuration du projet

Cette configuration implique deux composants principaux :

1.Script Python : écoute les mises à jour de localisation de Pulsetracker.

2.Laravel Job : traite les données de localisation reçues du script Python.

Étape 1 : configuration du script Python

Le script Python se connecte au service Pusher de Pulsetracker, écoute les mises à jour de localisation et les envoie dans une file d'attente Redis pour que Laravel les gère.

#!/usr/bin/env python

import sys
sys.path.append('..')
import pysher
import time
import logging
import redis
import json 
import uuid

global pusher
global redis

def channel_callback(data):
    messageBody = json.dumps({
        "uuid": str(uuid.uuid4()),
        "displayName": "App\Jobs\PulseLocationUpdatedJob",
        "job": "App\Jobs\PulseLocationUpdatedJob@handle",
        "data": json.loads(data),
        "maxTries": 0,
        "attempts": 0
    })
    # YOUR_APP_NAME_database_queues:QUEUE_NAME
    redis.rpush("pulsetracker_database_queues:geopulse", messageBody)

def connect_handler(data):
    channel = pusher.subscribe("private-apps.<your_app_id>")
    channel.bind('App\Events\DeviceLocationUpdated', channel_callback)

if __name__ == '__main__':

    appkey = "<pusher_app_key_in_our_documentation>"
    auth_endpoint = "https://www.pulsestracker.com/api/broadcasting/auth"

    pusher = pysher.Pusher(
        key=appkey,
        auth_endpoint_headers={            
                "Authorization": "Bearer <your_token>"
        },
        auth_endpoint=auth_endpoint,
        custom_host="pusher.pulsestracker.com",
        secure=True,
    )

    redis = redis.Redis(host='127.0.0.1', port=6379, db=0, password="<your_redis_password>")

    pusher.connection.ping_interval = 30
    pusher.connect()

    pusher.connection.bind('pusher:connection_established', connect_handler)

    while True:
        time.sleep(1)

Dans ce script :

La fonction channel_callback envoie les mises à jour de localisation dans une file d'attente Redis.

La fonction connect_handler s'abonne à un canal Pulsetracker spécifique et le lie à l'événement DeviceLocationUpdated.

Ce script doit être exécuté en continu pour écouter les mises à jour et les transmettre à Redis pour Laravel

Étape 2 : Configuration de Laravel

Maintenant, créons une classe de travail Laravel qui traitera les mises à jour reçues du script Python.

Travail Laravel : PulseLocationUpdatedJob

Dans Laravel, la classe de travail traite les données poussées dans la file d'attente Redis par l'écouteur Python. Voici la classe PulseLocationUpdatedJob :

<?php

namespace App\Jobs;

use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Queue\Queueable;

class PulseLocationUpdatedJob implements ShouldQueue
{
    use Queueable;

    /**
     * Create a new job instance.
     */
    public function __construct()
    {
        //
    }

    /**
     * Execute the job.
     */
    public function handle($job, array $data)
    {
        // Handle the data here, e.g., save to the database
        var_dump($data);

        return $job->delete();
    }
}

Démarrez le travailleur de file d'attente Laravel pour commencer à traiter les tâches :

php artisan queue:work --queue=geopulse

Résultats

Conclusion

Dans cette configuration, l'écouteur Python diffuse efficacement les données de localisation en temps réel de Pulsetracker vers votre file d'attente Redis, que Laravel traite en tant que tâches en arrière-plan. Cette approche vous permet de gérer de gros volumes de données en temps réel, tout en laissant Laravel se concentrer sur la persistance des données et les tâches backend.

Ressources :
https://fly.io/laravel-bytes/queues-with-other-linguals/

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!