Etiqueta: Mosquitto

Broker Mosquitto con MQTTS

amonsalvesDeja un comentario

Hace un tiempo publiqué una entrada cuyo tema principal era el protocolo MQTT mediante el broker Eclipse Mosquitto. En la entrada de hoy, Broker Mosquitto con MQTTS, describiré cómo utilizar el protocolo MQTT de forma segura, es decir, cómo utilizar el protocolo MQTTS.

El protocolo MQTT es un protocolo muy utilizado en los sistemas IoT y, para conseguir un nivel de seguridad adecuado, es necesario utilizar el protocolo con comunicaciones seguras.

1.-Componentes de seguridad

Para la creación de los certificados, claves privadas y los certificados de solicitud de firma utilizaremos OpenSSL. En los siguientes apartados, realizaré la descripción de los elementos necesarios para nuestro ejemplo de prueba.

Para facilitar la comprensión de los elementos a crear y la configuración del broker, utilizaré una carpeta, con nombre certs, en la cual se ubicarán las siguientes carpetas: carpeta ca, carpeta para almacenar los componentes de seguridad de la autoridad certificadora; carpeta broker, carpeta para almacenar los componentes de seguridad para el broker MQTT; y, por último, la carpeta client, carpeta para almacenar los componentes de seguridad para los clientes, en nuestro caso, los agentes con funcionalidad de publicadores y suscriptores.

La herramienta a utilizar para la creación de los diferentes componentes es OpenSSL la cual se encuentra instalada al menos en los sistemas Linux o Mac de forma predeterminada. Para utilizarla simplemente invocamos el comando openssl desde una consola de comandos.

1.1.- Creación de certificados

La creación de la autoridad de certificados la realizamos con el comando openssl y, para ello, nos ubicamos en la carpeta ~/certs2/ca en una consola de comandos. El comando a utilizar es el siguiente:

openssl req -new -x509 -days 365 -extensions v3_ca -keyout ca.key -out ca.crt

El comando anterior realiza la creación de un certificado definido en el fichero ca.crt y realiza la creación de una clave privada en el fichero ca.key. La validez del certificado es de un año (365 días) desde la fecha de creación. El comando requiere la introducción de unos campos necesarios como son, entre otros: password del certificado, país, ciudad, nombre de la compañía,…

1.2.- Creación de clave privada y certificados para el broker

La creación de las claves y certificados necesarios para el broker la realizamos con el comando openssl y, como en el casa anterior, nos ubicamos en la carpeta creada para ello, carpeta ~/certs2/broker. En este caso, debemos de realizar más operaciones las cuáles son:

  • Generación de una clave privada.

Para la creación de una clave privada RSA para el broker ejecutamos el siguiente comando:

openssl genrsa -out broker.key 2048

El comando anterior realiza la creación de una clave RSA en el fichero broker.key

  • Generación del fichero de solicitud de firmas csr.

Para la creación del fichero para realizar la solicitud de firmas para los certificados se emplea el siguiente comando openssl el cual utiliza la clave privada creada previamente, el comando es el siguiente:

openssl req -out broker.csr -key broker.key -new

La ejecución del comando anterior requiere de la inserción de un conjunto de datos como son, entre otros: país, ciudad y otros datos de identificación; de todos ellos, requiere una especial atención el campo CN Command Name el cual identifica el nombre del dominio en donde se ejecuta el broker, en nuestro caso, el campo CN tiene el valor ‘localhost’.

  • Generación del fichero certificado.

Por último, realizamos la creación del certificado con todos los elementos creados previamente. El comando es el siguiente:

openssl x509 -req -in broker.csr -CA ../ca/ca.crt -CAkey ../ca/ca.key -CAcreateserial -out broker.crt -days 100

El comando anterior realiza un certificado en el fichero broker.crt con una validez de 100 días utilizando el fichero de solicitud de firmas broker.csr y los ficheros de la autoridad certificadora ca.crt y ca.key.

1.3.- Creación de clave privada y certificados para los clientes

La creación de las claves y certificados necesarios para el broker lo realizamos con el comando openssl y, como en el casa anterior, nos ubicamos en la carpeta creada para ello, carpeta ~/certs2/client. En este caso, debemos de realizar más operaciones las cuáles son:

  • Generación de una clave privada.

Para la creación de una clave privada RSA para el cliente ejecutamos el siguiente comando:

openssl genrsa -out client.key 2048

El comando anterior realiza la creación de una clave RSA en el fichero client.key

  • Generación del fichero de solicitud de firmas csr.

Para la creación del fichero para realizar la solicitud de firmas para los certificados se emplea el siguiente comando openssl el cual utiliza la clave privada creada previamente, el comando es el siguiente:

openssl req -out client.csr -key client.key -new

La ejecución del comando anterior requiere de la inserción de un conjunto de datos como son, entre otros: país, ciudad y otros datos de identificación; de todos ellos, requiere una especial atención el campo CN Command Name el cual identifica el nombre del dominio en donde se ejecuta el broker, en nuestro caso, el campo CN tiene el valor ‘localhost’.

  • Generación del fichero certificado.

Por último, realizamos la creación del certificado con todos los elementos creados previamente. El comando es el siguiente:

openssl x509 -req -in client.csr -CA ../ca/ca.crt -CAkey ../ca/ca.key -CAcreateserial -out client.crt -days 100

El comando anterior realiza un certificado en el fichero client.crt con una validez de 100 días utilizando el fichero de solicitud de firmas client.csr y los ficheros de la autoridad certificadora ca.crt y ca.key.

2.- Configuración del broker Mosquitto

La configuración del broker Mosquitto se realiza en el fichero mosquitto.conf ubicado en la carpeta de instalación del mismo. Para poder operar con el broker es necesario que la configuración sea como mínimo la siguiente:

  listener 8883
  certfile /Users/usuario/mosquitto/certs2/broker/broker.crt
  keyfile /Users/usuario/mosquitto/certs2/broker/broker.key
  require_certificate true
  cafile /Users/usuario/mosquitto/certs2/ca/ca.crt
  use_identity_as_username true

3.- Ejemplo de uso

3.1.- Arranque del broker

Para arrancar Mosquitto con la configuración, en un entorno Linux/Mac, el comando a ejecutar es el siguiente:

/usr/local/opt/mosquitto/sbin/mosquitto -c /usr/local/etc/mosquitto/mosquitto.conf

La salida por consola del broker es la siguiente:

Consola del broker Mosquitto

3.2.- Arranque del suscriptor.

Pare simular la recepción de un mensaje utilizaremos la herramienta mosquitto_sub el cual simula la suscripción de un elemento. El comando a utilizar para ejecutar un suscriptor desde línea de comando es el siguiente:

mosquitto_sub -h localhost -t "casa/habitaciones/hab1/luz" --cafile "/Users/E050690/mosquitto/certs2/ca/ca.crt"  --cert "/Users/E050690/mosquitto/certs2/client/client.crt" --key "/Users/E050690/mosquitto/certs2/client/client.key" -p 8883

Los parámetros del comando anterior tienen la siguiente descripción:

  • -h.- Nombre del host donde está funcionando Mosquitto. Es el mismo nombre que el campo CN de los certificados.
  • -t.- Topic del broker donde se conecta el suscriptor.
  • –cafile.- Localización del certificado de la entidad certificadora.
  • –cert.- Localización del certificado del cliente, en nuestro caso, el componente suscriptor.
  • –key.- Localización de la clave privada del cliente, en nuestro caso, el componente suscriptor.
  • -p.- Puerto del protocolo MQTTS.

La consola del suscriptor queda vacía a la espera de los mensajes que realice el publicador/productor.

3.3.- Arranque del publicador.

Para simular el envío de un mensaje utilizaremos la herramienta mosquitto_pub el cual realiza la producción de mensajes a un topic del broker. El comando a utilizar para ejecutar una publicación de un mensaje desde la línea de comandos el el siguiente:

mosquitto_pub -h localhost -t "casa/habitaciones/hab1/luz" --cafile "/Users/E050690/mosquitto/certs2/ca/ca.crt"  --cert "/Users/E050690/mosquitto/certs2/client/client.crt" --key "/Users/E050690/mosquitto/certs2/client/client.key" -p 8883  -m "ON1"

Los parámetros del comando anterior tienen la siguiente descripción:

  • -h.- Nombre del host donde está funcionando Mosquitto. Es el mismo nombre que el campo CN de los certificados.
  • -t.- Topic del broker donde se publica el mensaje.
  • –cafile.- Localización del certificado de la entidad certificadora.
  • –cert.- Localización del certificado del cliente, en nuestro caso, el componente publicador.
  • –key.- Localización de la clave privada del productor, en nuestro caso, el componente publicador.
  • -p.- Puerto del protocolo MQTTS.
  • -m.- Mensaje que se publica en el topic -t

La salida de la consola del broker Mosquitto es la siguiente:

Consola del broker Mosquitto

La salida de la consola del simulador de del suscriptor es la siguiente:

4.- Conclusiones

La complejidad del ejercicio planteado es la creación de los certificados, claves privadas y certificados de petición de firma ya que la configuración y uso del suscriptor, publicador y broker, si se sabe su uso sin certificados, es relativamente sencilla. Un detalle importante es el valor asignado al campo Command Name (CN) de los certificados de firma ya que un valor erróneo puede originar errores de protocolo en las pruebas.

Cliente Mosquitto: Paho-mqtt

amonsalvesDeja un comentario

En la anterior entrada con título «Mosquitto», realicé la descripción del broker Mosquitto, explicando las tareas de instalación, estructuras de carpetas y uso del Broker desde la consola del sistema. En esta entrada, «Cliente Mosquitto: Paho-mqtt», me centraré en cómo los dispositivos se pueden conectar al broker Mosquitto utilizando la librería Paho-mqtt.

Paho-mqtt es aquella librería cliente en lenguaje Python la cual implementa la versión 3.1 y 3.1.1 del protocolo MQTT.

Creación del proyecto

Para la realización de los ejemplos con el cliente Paho-mqtt, reallizaré la creación de un proyecto Python con el cliente Paho-mqtt. El proceso de creación consistirá en lo siguiente:

  1.  Creación de un proyecto Python en el IDE.
  2. Desde la carpeta del proyecto y en la consola del sistema, creación del entorno virtual del proyecto ejecutando el siguiente comando: 
     python3 -m venv venv
  3. Desde la carpeta del proyecto y en la consola del sistema, instalación del cliente Paho-mqtt ejecutando el siguiente comando: 
     pip install paho-mqtt

Una vez realizado los pasos anteriores, tenemos creado un proyecto Python con el cliente Paho-mqtt para desarrollar los publicadores y subscriptores del broker Mosquitto.

Broker Mosquitto

Para realizar las pruebas, necesitamos arrancar el broker Mosquitto, un publicador y un subscriptor para realizar las pruebas. Los pasos a seguir y la estructura de topics serán los mismos que en la entrada anterior. Los comandos a ejecutar son los siguientes:

  • Para el arranque del broker Mosquitto en el puerto por defecto en la línea de comandos, se realiza con el siguiente comando:
sudo /usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf
  • Para el arranque de un publicador en la línea de comandos, se realiza con el siguiente comando:
mosquitto_pub -t "casa/habitaciones/hab1/luz" -m "ON"
  • Para el arranque de un subscriptor en la línea de comandos, se realiza con el siguiente comando:
mosquitto_sub -t "casa/habitaciones/hab1/luz" -v

Una vez realizados estos pasos, tenemos el broker levantado, las consolas del publicador y subscriptor abiertas para ver la actividad existente.

Publicadores

En el presente apartado, me centraré en presentar tres ejemplos de publicación de mensajes en un topic del broker Mosquitto. El publicador es aquel elemento que genera mensajes que son enviados al broker Mosquitto.

Ejemplo básico

El primer ejemplo, lo realizamos en un fichero Python con nombre publicador_ejem1.py, es aquel ejemplo básico de creación de un cliente, conexión al broker y publicación del mensaje «Ejemplo desde Python» en el topic del broker Mosquitto.

El snippet del código es el siguiente:

 import paho.mqtt.client as mqtt

 broker_address = "localhost"
 client = mqtt.Client('Publicador_ejem1') # Creación del cliente
 client.connect(broker_address)
 topic = "casa/habitaciones/hab1/luz"

 client.publish(topic, "Ejemplo desde Python")

Tras la ejecución de publicador_ejem1.py, la salida en la consola del subscriptor Mosquitto, abierta conforme lo descrito en el apartado anterior, es la siguiente:

casa/habitaciones/hab1/luz Ejemplo desde Python

Ejemplo publicador de un mensaje

El segundo ejemplo, lo realizamos en un fichero Python con nombre publicador_ejem2.py, es aquel ejemplo de creación de un publicador, definición del topic al cual informar, y envío del mensaje «Ejemplo de publicador simple desde Python» al broker Mosquitto mediante la función single del publicador. El snippet del código es el siguiente:

 import paho.mqtt.publish as publish

 broker_address = "localhost"
 topic = "casa/habitaciones/hab1/luz"
 publish.single(topic, "Ejemplo de publicador simple desde Python", hostname=broker_address,
 client_id='publicador_ejem2.py')

Tras la ejecución de publicador_ejem2.py, la salida en la consola del subscriptor Mosquitto, abierta conforme lo descrito en el apartado anterior, es la siguiente:

casa/habitaciones/hab1/luz Ejemplo de publicador simple desde Python

Ejemplo publicador de mensaje múltiple

El tercer ejemplo, lo realizamos en un fichero Python con nombre publicador_ejem3.py, es aquel que utiliza un publicador, se definen tres mensajes (mensaje1, mensaje2 y mensaje3) para ser enviados al broker Mosquitto mediante la función multiple del publicador. El snippet del código es el siguiente:

 import paho.mqtt.publish as publish

 broker_address = "localhost"
 topic = "casa/habitaciones/hab1/luz"
 mensaje1 = "Mensaje 1 de un envío multiple"
 mensaje2 = "Mensaje 2 de un envío multiple"
 mensaje3 = "Mensaje 3 de un envío multiple"

 msgs = [{'topic': topic, 'payload': mensaje1},
 (topic, mensaje2, 0, False),
 (topic, mensaje3, 0, False)]

 publish.multiple(msgs, hostname=broker_address)

Tras la ejecución de publicador_ejem3.py, la salida en la consola del subscriptor Mosquitto, abierta conforme lo descrito en el apartado anterior, es la siguiente:

casa/habitaciones/hab1/luz Mensaje 3 de un envío multiple
casa/habitaciones/hab1/luz Mensaje 2 de un envío multiple
casa/habitaciones/hab1/luz Mensaje 1 de un envío multiple

Subscriptores

En el presente apartado, me centraré en presentar tres ejemplos de subscriptores de mensajes en un topic del broker Mosquitto. El subscriptor es aquel elemento que recibe mensajes de un topic del broker Mosquitto originados en un publicador determinado.

Ejemplo básico de subscriptor

El primer ejemplo, lo realizamos en el fichero subscriptor_ejem1.py, es aquel que utiliza un cliente MQTT con las siguientes tareas: definición de un callback para la recepción de mensajes del topic en la función on_message; conexión al broker con la función connect;y, la subscripción al topic del broker de Mosquitto, mediante la función subscribe. El presente ejemplo realiza solo una iteración por las funciones loop_start() y loop_stop. El snippet del código es el siguiente:

import time
import paho.mqtt.client as mqtt # import the client1

broker_address = "localhost"
broker_port = 1883
topic = "casa/habitaciones/hab1/luz"

def on_message(client, userdata, message):
 print("Mensaje recibido=", str(message.payload.decode("utf-8")))
 print("Topic=", message.topic)
 print("Nivel de calidad [0|1|2]=", message.qos)
 print("Flag de retención o nuevo?=", message.retain)

client = mqtt.Client("Subscriptor_ejem1")
client.on_message = on_message 
client.connect(broker_address) 
client.loop_start() # Inicio del bucle
client.subscribe(topic)
time.sleep(10) # Paramos el hilo para recibir mensajes.
client.loop_stop() # Fin del bucle

Tras la ejecución del subscriptor_ejem1.py y tras la publicación de un mensaje en la consola Mosquitto, conforme a lo descrito en el apartado anterior, la salida es la siguiente:

Mensaje recibido= PRUEBA
Topic= casa/habitaciones/hab1/luz
Nivel de calidad [0|1|2]= 0
Flag de retención o nuevo?= 0

Ejemplo de subscriptor de N mensajes

El segundo ejemplo, lo realizamos en el fichero subscriptor_ejem2.py, es aquel ejemplo que espera infinitos mensajes de un topic del broker Mosquitto. Las operaciones son casi las mismas al apartado anterior, estando las diferencias en la definición de un bucle infinito con la función loop_forever(). El snippet del código es el siguiente:

import paho.mqtt.client as mqtt

broker_address = "localhost"
broker_port = 1883
topic = "casa/habitaciones/hab1/luz"

def on_message(client, userdata, message):
 print("Mensaje recibido=", str(message.payload.decode("utf-8")))
 print("Topic=", message.topic)
 print("Nivel de calidad [0|1|2]=", message.qos)
 print("Flag de retención =", message.retain)

client = mqtt.Client('Cliente1') 
client.on_message = on_message 
client.connect(broker_address, broker_port, 60) 
client.subscribe(topic) # Subscripción al topic
client.loop_forever()

Tras la ejecución del subscriptor_ejem2.py y tras la publicación de dos mensajes en el consola Mosquitto, conforme a lo descrito en el apartado anterior, la salida es la siguiente:

Mensaje recibido= PRUEBA1
Topic= casa/habitaciones/hab1/luz
Nivel de calidad [0|1|2]= 0
Flag de retención = 0
Mensaje recibido= PRUEBA2
Topic= casa/habitaciones/hab1/luz
Nivel de calidad [0|1|2]= 0
Flag de retención = 0

Ejemplo con control de conexión al topic

El tercer ejemplo, lo realizamos en el fichero subscriptor_ejem3.py, es aquel ejemplo que espera infinitos mensaje de un topic del broker Mosquitto pero se define un callback para realizar la conexión definida en la función on_connect; este callback, si se pierde la conexión, realiza la reconexión al topic. El snippet del código es el siguiente:

import paho.mqtt.client as mqtt
broker_address = "localhost"
broker_port = 1883
topic = "casa/habitaciones/hab1/luz"

def on_connect(client, userdata, flags, rc):
 print("Connected with result code " + str(rc))
 print("UserData= " + str(userdata))
 print("flags= " + str(flags))
 print("")
 client.subscribe(topic)

def on_message(client, userdata, message):
 print("Mensaje recibido=", str(message.payload.decode("utf-8")))
 print("Topic=", message.topic)
 print("Nivel de calidad [0|1|2]=", message.qos)
 print("Flag de retención=", message.retain)
 print("---------------------------------------------")
 print("")

client = mqtt.Client('Cliente1', userdata="UsuarioDePrueba") 
client.on_connect = on_connect 
client.on_message = on_message 
client.connect(broker_address, broker_port, 60) 
client.loop_forever()

Tras la ejecución del subscriptor_ejem3.py y tras la publicación de un mensaje en el consola Mosquitto, conforme a lo descrito en el apartado anterior, la salida es la siguiente:

Connected with result code 0
UserData= UsuarioDePrueba
flags= {'session present': 0}

Mensaje recibido= PRUEBA
Topic= casa/habitaciones/hab1/luz
Nivel de calidad [0|1|2]= 0
Flag de retención= 0
---------------------------------------------

La definición de componentes software con la librería Paho-mqtt para la comunicación con el broker Mosquitto, es una tarea sencilla teniendo claro el modelo productor/consumidor. En los ejemplos descritos, se centran en la comunicación con el broker faltando el desarrollo de captura de datos de los sensores o componentes los cuales han sido simulados desde la consola de Mosquitto.

Mosquitto

amonsalves1 comentario

Mosquitto es un broker de mensajería Open Source(licencia EPL/EDL) que implementa el protocolo MQTT para las versiones 3.1 y 3.1.1. Mosquitto es parte de Eclipse foundation y es un proyecto de Eclipse. Mosquitto es ligero y es adecuado para todos los dispositivos, desde computadoras de baja potencia hasta servidores complejos.

El protocolo MQTT (MQ Telemetry Transport or Message Queuing Telemetry Transport) es un estándar ISO basado en un método sencillo para realizar intercambio de mensajes conforme el modelo productor-consumidor en sistemas de Internet de las cosas ( IoT – Internet of the Thinks). Los dispositivos que se conectan pueden ser sensores, dispositivos móviles, microcontroladores o sistemas embebidos.

El sketchnote de la entrada es el definido en la siguiente imagen:

Instalación

La descripción del proceso de instalación está basada en plataformas Linux; pero, para el resto de plataformas (Windows, Mac,…), el proceso de instalación es el típico para dichas plataformas. La información de instalación para cada plataforma, se encuentra en el apartado Download de la documentación oficial.

Los comandos a ejecutar para la instalación de Mosquitto son los siguientes:

sudo apt-add-repository ppa:mosquitto-dev/mosquitto-ppa
sudo apt-get update
sudo apt-get install python-software-properties
sudo apt-get install mosquitto

Estructura de carpetas

El proceso de instalación nos creará una estructura de directorios como la siguiente:

  • /etc/mosquitto.- Carpeta con los ficheros de configuración del broker. El contenido del directorio es el siguiente:

-> directorio ca_certificates.-Directorio de certificados

-> certs.- Directorio de certificados

-> conf.d .- Directorio de configuración

-> mosquitto.conf .- Fichero de configuración

  • /usr/sbin .- En esta carpeta se localiza el fichero de arranque mosquitto.sh
  • /var/log/mosquitto .- Directorio en el que se encuentra el fichero mosquitto.log

Inicio del broker

Para iniciar el broker de mensajería Mosquitto es necesario la ejecución del comando mosquitto identificando la ubicación del fichero de configuración. El comando de ejecución del broker es el siguiente:

sudo /usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf

El flag -c indica al comando mosquitto la ubicación del fichero de configuración mosquitto.conf. Si se desea conocer la información del comando, es decir, la ayuda del comando, se puede ejecutar el comando:

/usr/sbin/mosquitto -h

El resultado de la ejecución del comando, será que el broker Mosquitto está ejecutándose en la máquina en el puerto por defecto 1883.

Cliente del Broker

Una vez instalado e iniciado el broker es necesario definir el mecanismo por el cual poder conectarse y realizar una comunicación. Para realizar dichas operaciones, es necesario la instalación de un cliente específico MQTT; dicho cliente, servirá para la realización de simulaciones de dispositivos MQTT. El nombre del dispositivo es mosquitto-clients y, el comando de instalación en la plataforma Linux, es el siguiente:

sudo apt-get install mosquitto-clients

El cliente instalado es aquel cliente que permite simular el funcionamiento de los productores, entidades que generan información MQTT; y, consumidores, entidades que reciben los datos suministrados por los productores.

Para el broker Mosquitto, los productores de datos se denominan publicadores y, los que consumen los datos, subscriptores.

Topic

Llegado a este punto, disponemos del broker MQTT instalado y ejecutándose; tenemos instalado el cliente para definir los publicadores y los subscriptores; pero, no tenemos definido el mecanismos de interconexión entre los clientes. El mecanismo en cuestión son los topics. Los topics son aquellos buzones en los cuales los publicadores dejan sus mensajes. Así, un publicador dejan en un topic aquel mensaje que quiere transmitir al subscritor; y, el subscriptor, en el instante de la publicación de un mensaje, recibe dicho mensaje.

Como he comentado antes, los dispositivos que se pueden conectar son múltiples: sensores, sistemas embedidos, dispositivos móviles; con lo cual, es necesario una organización de todos los elememtos. Así, para el supuesto de un sistema IoT de los sensores de una casa, podemos definir los dispositivos en una estructura jerárquica de la siguiente forma:

– casa

– habitaciones

– hab1

– luz: sensor de luz

– temperatura: sensor de temperatura

– hab2

– luz: sensor de luz

– temperatura: sensor de temperatura

– trastero

– luz: sensor de luz

– temperatura: sensor de temperatura

– humedad: sensor de humedad

Dada la estructura anterior, definimos los siguientes topic como ejemplos en el broker de la siguiente manera:

  • casa/habitaciones/hab1/luz.- Topic del sensor de luz de la habitación 1
  • casa/habitaciones/hab2/luz.- Topic del sensor de luz de la habitación 2
  • casa/trastero/humedad.- Topic del sensor de humedad del Trastero.

Ejemplos

Los clientes del broker MQTT Mosquitto pueden ser: subscriptores, entidades que reciben datos de sensores; y, publicadores, los sensores que envían datos al broker. Para realizar la simulación desde consola, utilizamos los comandos siguientes comandos: mosquitto_sub, comando para la simulación de subscriptores; y, mosquitto_pub, comando para la simulación de sensores.

En los siguientes apartados, describiré la ejecución de cada uno de los comados.

Subscriptor

El comando para la simulación de subscriptores es el comando mosquitto_sub. Un ejemplo básico de subscripción en el topic «casa/habitaciones/hab1/luz» es el siguiente:

mosquitto_sub -t "casa/habitaciones/hab1/luz" -v

El flag -t identifica el topic de subscripción y, el flag -v, indica que sea verboso. Para visualizar la ayuda del comando se ejecuta el comando con los flag –help.

Publicador

El comando para la simulación de publicadores de mensajes es el comando mosquitto_pub. En ejemplo básico de publicación del mensaje «ON» en el topic «casa/habitaciones/hab1/luz» es el siguiente:

mosquitto_pub -t "casa/habitaciones/hab1/luz" -m "ON"

El flag -t identifica el topic de subscripción y, el flag -m, identifica el mensaje a enviar al broker.Para visualizar la ayuda del comando se ejecuta el comando con los flag –help.

La publicación del mensaje «ON» produce la salida por consola de subscriptor. Así, la salida de la consola del subscriptor es la siguiente:

casa/habitaciones/hab1/luz ON

Conclusiones

El broker MQTT Mosquitto es un broker ligero y sencillo de utilizar. En la presente entrada, me he centrado en la instalación y casos de uso básicos, no he tratado en esta entrada los aspectos orientados a la seguridad los cuáles en los sistemas IoT son importantes.

Desde un punto de vista genérico, el funcionamiento de Mosquitto es el típico de un broker que implementa un modelo productor/consumidor.

En la siguiente entrada, me centraré en la utilización del broker Mosquitto desde una aplicación en Python con el cliente paho-mqtt.