Uncategorized

    Comment utiliser MQTT dans Golang

    Comment utiliser MQTT dans Golang

    Golang est un langage de programmation statique, fortement typé, compilé, concurrent et de récupération de place développé par Google. Go est expressif, propre et efficace. Son mécanisme de concurrence facilite l’écriture de programmes qui maximisent l’utilisation de machines multicœurs et réseau, et son système de type innovant permet une construction de programme flexible et modulaire. Go se compile rapidement en code machine, mais avec la commodité de la récupération de place et la puissance de la réflexion à l’exécution. C’est un langage rapide, compilé et typé statiquement, comme un langage interprété dynamiquement typé.

    MQTT est une sorte de protocole de messagerie IoT léger basé sur le modèle de publication/abonnement, qui peut fournir un service de messagerie fiable et en temps réel pour les appareils IoT, en n’utilisant que très peu de code et de bande passante. Il convient aux appareils avec des ressources matérielles limitées et un environnement réseau avec une bande passante limitée. Par conséquent, le protocole MQTT est largement utilisé dans l’IoT, l’Internet mobile, l’IoV, l’électricité et d’autres industries.

    Cet article explique comment utiliser le paho.mqtt.golang bibliothèque cliente dans le projet Golang et implémentez la connexion, l’abonnement et la messagerie entre le client et le courtier MQTT.

    Initialisation du projet

    Ce projet est basé sur go 1.13.12 développer et tester :

    go version
go version go1.13.12 darwin/amd64

    Ce projet utilise paho.mqtt.golang comme bibliothèque client MQTT. Utilisez ce qui suit pour installer : 

    go get github.com/eclipse/paho.mqtt.golang

    Utilisation de Go MQTT

    Cet article utilisera le courtier MQTT public gratuit fourni par EMQX. Les informations d’accès du serveur sont les suivantes :

    • Courtier: broker.emqx.io
    • Port TCP : 1883
    • Port WebSocket : 8083

    Connectez-vous au courtier MQTT

    package main

import (
    "fmt"
    mqtt "github.com/eclipse/paho.mqtt.golang"
    "time"
)

var messagePubHandler mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Message) {
    fmt.Printf("Received message: %s from topic: %s\n", msg.Payload(), msg.Topic())
}

var connectHandler mqtt.OnConnectHandler = func(client mqtt.Client) {
    fmt.Println("Connected")
}

var connectLostHandler mqtt.ConnectionLostHandler = func(client mqtt.Client, err error) {
    fmt.Printf("Connect lost: %v", err)
}

func main() {
    var broker = "broker.emqx.io"
    var port = 1883
    opts := mqtt.NewClientOptions()
    opts.AddBroker(fmt.Sprintf("tcp://%s:%d", broker, port))
    opts.SetClientID("go_mqtt_client")
    opts.SetUsername("emqx")
    opts.SetPassword("public")
    opts.SetDefaultPublishHandler(messagePubHandler)
    opts.OnConnect = connectHandler
    opts.OnConnectionLost = connectLostHandler
    client := mqtt.NewClient(opts)
    if token := client.Connect(); token.Wait() && token.Error() != nil {
        panic(token.Error())
  }
}

    • ClientOptions: utilisé pour définir le courtier, le port, l’ID client, le nom d’utilisateur, le mot de passe et d’autres options.
    • messagePubHandler: Traitement global des messages de publication MQTT.
    • connectHandler: Rappel pour la connexion.
    • connectLostHandler: Rappel pour la perte de connexion.

    Si vous souhaitez utiliser la connexion TLS, vous pouvez utiliser les paramètres suivants :

    func NewTlsConfig() *tls.Config {
    certpool := x509.NewCertPool()
    ca, err := ioutil.ReadFile("ca.pem")
    if err != nil {
        log.Fatalln(err.Error())
    }
    certpool.AppendCertsFromPEM(ca)
    // Import client certificate/key pair
    clientKeyPair, err := tls.LoadX509KeyPair("client-crt.pem", "client-key.pem")
    if err != nil {
        panic(err)
    }
    return &tls.Config{
        RootCAs: certpool,
        ClientAuth: tls.NoClientCert,
        ClientCAs: nil,
        InsecureSkipVerify: true,
        Certificates: []tls.Certificate{clientKeyPair},
    }
}

    Si le certificat client n’est pas défini, il peut être défini comme suit :

    func NewTlsConfig() *tls.Config {
    certpool := x509.NewCertPool()
    ca, err := ioutil.ReadFile("ca.pem")
    if err != nil {
        log.Fatalln(err.Error())
    }
    certpool.AppendCertsFromPEM(ca)
    return &tls.Config{
        RootCAs: certpool,
}

    Définissez ensuite TLS :

    var broker = "broker.emqx.io"
var port = 8883
opts := mqtt.NewClientOptions()
opts.AddBroker(fmt.Sprintf("ssl://%s:%d", broker, port))
tlsConfig := NewTlsConfig()
opts.SetTLSConfig(tlsConfig)
// other options

    Abonnement

    Ensuite, utilisez le code ci-dessous pour les abonnements : 

    func sub(client mqtt.Client) {
    topic := "topic/test"
    token := client.Subscribe(topic, 1, nil)
    token.Wait()
    fmt.Printf("Subscribed to topic %s", topic)
}

    Publier des messages

    Pour publier des messages, vous pouvez utiliser le code suivant : 

    func publish(client mqtt.Client) {
    num := 10
    for i := 0; i < num; i++ {
        text := fmt.Sprintf("Message %d", i)
        token := client.Publish("topic/test", 0, false, text)
        token.Wait()
        time.Sleep(time.Second)
    }
}

    Test

    Enfin, nous utilisons le code suivant pour tester :

    package main

import (
    "fmt"
    mqtt "github.com/eclipse/paho.mqtt.golang"
    "log"
    "time"
)

var messagePubHandler mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Message) {
    fmt.Printf("Received message: %s from topic: %s\n", msg.Payload(), msg.Topic())
}

var connectHandler mqtt.OnConnectHandler = func(client mqtt.Client) {
    fmt.Println("Connected")
}

var connectLostHandler mqtt.ConnectionLostHandler = func(client mqtt.Client, err error) {
    fmt.Printf("Connect lost: %v", err)
}

func main() {
    var broker = "broker.emqx.io"
    var port = 1883
    opts := mqtt.NewClientOptions()
    opts.AddBroker(fmt.Sprintf("tcp://%s:%d", broker, port))
    opts.SetClientID("go_mqtt_client")
    opts.SetUsername("emqx")
    opts.SetPassword("public")
    opts.SetDefaultPublishHandler(messagePubHandler)
    opts.OnConnect = connectHandler
    opts.OnConnectionLost = connectLostHandler
    client := mqtt.NewClient(opts)
    if token := client.Connect(); token.Wait() && token.Error() != nil {
        panic(token.Error())
    }

    sub(client)
    publish(client)

    client.Disconnect(250)
}

func publish(client mqtt.Client) {
    num := 10
    for i := 0; i < num; i++ {
        text := fmt.Sprintf("Message %d", i)
        token := client.Publish("topic/test", 0, false, text)
        token.Wait()
        time.Sleep(time.Second)
    }
}

func sub(client mqtt.Client) {
    topic := "topic/test"
    token := client.Subscribe(topic, 1, nil)
    token.Wait()
  fmt.Printf("Subscribed to topic: %s", topic)
}

    Après avoir exécuté le code, nous pouvons voir que la connexion et l’abonnement MQTT sont réussis, et nous pouvons recevoir avec succès le message du sujet d’abonnement :gomqtt.png

    Conclusion

    Jusqu’à présent, nous avons atteint notre objectif en utilisant le paho.mqtt.golang client de se connecter au courtier MQTT public et d’avoir implémenté la connexion, la publication des messages et l’abonnement entre le client de test et le courtier MQTT.

    Share.
    Add A Comment

    Leave A Reply