Archivo de la categoría: Mosquitto

Práctica 4: Instalar, Configurar y Securizar Mosquitto y Node-RED en Raspberry Pi

Esta práctica es un paso a paso para instalar, configurar y securizar Mosquitto y Node-RED en Raspberry Pi.

Un ejemplo de cómo usar esta instalación en Raspberry Pi una vez finalizada con Raspberry Pi.

Instalar Mosquitto

Comandos para instalar mosquitto:

  • wget http://repo.mosquitto.org/debian/mosquitto-repo.gpg.key – Para usar el nuevo repositorio, primero se debe importar la clave de firma del paquete del repositorio
  • sudo apt-key add mosquitto-repo.gpg.key – añade la clave de firma
  • cd /etc/apt/sources.list.d/ – Hacer que el repositorio esté disponible para apt
  • sudo wget http://repo.mosquitto.org/debian/mosquitto-buster.list – añadir el nuevo repositorio
  • sudo apt-get update – Actualizar información de apt
  • sudo apt-cache mosquitto – Comprobar paquetes
  • sudo apt-get install mosquitto – Instalar
  • sudo systemctl enable mosquitto.service – Configurar arranque al inicio

Documentación: https://mosquitto.org/blog/2013/01/mosquitto-debian-repository/ 

Configurar Mosquitto

NOTA para mosquitto 2.x: https://mosquitto.org/blog/2020/12/version-2-0-0-released/ 

Mosquitto 2.x ahora es más seguro de forma predeterminada y requiere que los usuarios tomen una decisión activa sobre cómo configurar la seguridad en su broker, en lugar de posiblemente depender del comportamiento anterior muy permisivo, así como eliminar el acceso privilegiado más rápidamente. 

Cuando Mosquitto se ejecuta sin un archivo de configuración, o sin configurar ningún listener, ahora se vinculará a las interfaces de loopback 127.0.0.1 y / o :: 1. Esto significa que solo serán posibles las conexiones desde el host local. 

La ejecución del broker con un listener definido se vinculará de forma predeterminada a 0.0.0.0 / :: y, por lo tanto, será accesible desde cualquier interfaz. 

Todos los listener ahora tienen el valor predeterminado allow_anonymous false a menos que se establezca explícitamente como verdadero en el archivo de configuración. Esto significa que al configurar un listener, el usuario debe configurar un método de control de acceso y autenticación, o establecer allow_anonymous como true.

Documentación: https://mosquitto.org/documentation/migrating-to-2-0/

Para que mosquitto 2.x pueda escuchar en todas las IPs añadir, ejecutar sudo nano /etc/mosquitto/mosquitto.conf y añadir las líneas:

  • # Note that this will not allow anonymous access by default.
  • listener 1883

Para activar el log de mosquito, ejecutar sudo nano /etc/mosquitto/mosquitto.conf y añadir las líneas:

  • # Save all log in file
  • log_dest file /var/log/mosquitto/mosquitto.log
  • log_type all
  • log_timestamp true

Reiniciar mosquitto: sudo systemctl restart mosquitto

NOTA para mosquitto 2.x: hasta no configurar los usuarios, aun no es posible conectarse al Broker fuera del localhost

Autenticación en Mosquitto

Crear fichero de contraseñas con: sudo mosquitto_passwd -c /etc/mosquitto/passwd curso_iot y poner contraseña. Esto crea el usuario curso_iot

Para añadir más usuarios: mosquitto_passwd -b passwordfile curso_iot_2 password Esto crea el usuario curso_iot_2 con la contraseña password

Reiniciar mosquitto: sudo systemctl restart mosquitto

Ahora es posible acceder al broker y probar conexión usando un cliente MQTT como http://mqtt-explorer.com/ 

Autorización en Mosquitto

Los usuarios creados tienen acceso a todos los topics, para limitar los permisos de acceso hay que configurar las ACLs (Listas de acceso).

Crear fichero aclfile:

  • cd /etc/mosquitto
  • sudo nano aclfile 

Añadir este contenido:

# This only affects clients with username 
user curso_iot
topic readwrite #
topic read $SYS/#

user curso_iot_2
topic readwrite curso_iot/#
topic read sololectura/#

# This affects all clients.
pattern write $SYS/broker/connection/%c/state

El usuario curso_iot tiene acceso completo y el usuario curso_iot_2 tiene acceso a los topics curso_iot/# y solo puede leer en los topics sololectura/#

Luego activar el fichero de ACL en la configuración de mosquitto. Ejecutar sudo nano /etc/mosquitto/mosquitto.conf y añadir la línea:

  • acl_file /etc/mosquitto/aclfile

Reiniciar mosquitto: sudo systemctl restart mosquitto

Comprobar con los usuarios creados los permisos usando un cliente MQTT como MQTT Explorer.

Más información sobre la configuración: https://mosquitto.org/man/mosquitto-conf-5.html 

Comunicación Segura

Generar Certificado Autofirmado

Mosquitto proporciona soporte TLS para conexiones de red cifradas y autenticación.

Es muy fácil crear sus propios certificados SSL y claves de cifrado utilizando herramientas de software libre. Estas claves y certificados son tan seguros como los comerciales.

Utilizaremos openssl para crear nuestra propia autoridad de certificación (CA), claves de servidor y certificados.

Estos pasos nos permitirán una conexión encriptada entre el broker MQTT y el cliente MQTT al igual que la que existe entre un cliente del navegador web y un servidor web. En este caso sólo necesitamos un certificado de servidor de confianza en el Cliente.

El servidor/broker necesita: 

  • Certificado CA de la CA (autoridad de certificación) que ha firmado el certificado del servidor en el Broker Mosquitto (ca.crt)
  • Certificado del servidor certificado por la CA. (srv.crt)
  • Clave privada del servidor para el descifrado. (server.key)

Pasos:

  • sudo apt-get install openssl – instalar openssl
  • Crear un directorio llamado certificados en /home/pi con: mkdir certificados y entrar en el directorio para guardar los certificados y claves
  • openssl genrsa -des3 -out ca.key 2048 – Genera una RSA key privada para la CA. Pide contraseña (opción -des3)
  • openssl req -new -x509 -days 1826 -key ca.key -out ca.crt – Crear un certificado para la CA utilizando la clave de la CA que creamos en el paso anterior. Poner en CN el nombre o IP del servidor (p.e. raspberrypi.local o 192.168.1.10)
  • openssl genrsa -out server.key 2048 – Genera una RSA key privada para el servidor que será utilizada por el broker
  • openssl req -new -out server.csr -key server.key – crear una solicitud de certificado .csr. Al rellenar el formulario, el nombre común (CN) es importante y suele ser el nombre de dominio del servidor, el resto se pueden dejar vacíos. Debe utilizar el mismo nombre cuando configure la conexión del cliente. Como somos la CA, no es necesario mandar la solicitud a la CA.
  • openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt -days 360 – Utilizar la clave de la CA para verificar y firmar el certificado del servidor. Esto crea el archivo server.crt. Pide la contraseña usada para la ca.key

Con estos pasos hemos obtenido los siguientes ficheros:

  • ca.crt – Certificado de la CA
  • ca.key – Par de claves para la CA. Solo usar para crear un nuevo certificado
  • server.crt – Certificado del servidor firmado por la CA
  • server.csr – Solicitud de certificado. No es necesario.
  • server.key – Par de claves del servidor
  • ca.srl – Cada certificado emitido debe contener un número de serie único asignado por la CA. Debe ser único para cada certificado emitido por una determinada CA. OpenSSL guarda los números de serie utilizados en un archivo, por defecto tiene el mismo nombre que el archivo del certificado de la CA con la extensión sustituida por srl. Así que se crea un archivo llamado ca.srlc

NOTA: Tenga en cuenta que los certificados y las claves creadas pueden utilizarse en el broker/servidor de Mosquitto, y también en un servidor web, por lo que en el manual de Mosquitto se utiliza el término servidor y no broker.

Para ver el contenido de un certificado en texto, porque están codificados en base64, usar: openssl x509 -in server.crt -text -noout

Más información:

Configurar Mosquitto con MQTT sobre TLS

Para configurar el broker mosquitto MQTT para usar la seguridad TLS, seguir los pasos:

  • Copiar los archivos server.crt y server.key en la carpeta /etc/mosquitto/certs. sudo cp server.crt server.key /etc/mosquitto/certs/
  • Copiar el archivo ca.crt en la carpeta /etc/mosquitto/ca_certificates. sudo cp ca.crt /etc/mosquitto/ca_certificates/

Dar permiso a mosquitto para ver el fichero (clave privada) server.key: sudo chown mosquitto:mosquitto server.key (Esto es necesario a partir de la versión 2.0 de Mosquitto)

Configurar fichero configuración mosquitto con sudo nano /etc/mosquitto/mosquitto.conf añadiendo estas líneas en la zona de extra listeners (para mantener acceso simultáneo al puerto 1883 no cifrado y al puerto 8883 cifrado):

listener 8883
cafile /etc/mosquitto/ca_certificates/ca.crt
certfile /etc/mosquitto/certs/server.crt
keyfile /etc/mosquitto/certs/server.key

Reiniciar el servidor: sudo systemctl restart mosquitto

Por último probar la conexión mediante puerto seguro 8883 desde MQTT Explorer y Node-RED, deshabilitando la opción de verificar certificado.

El fichero final de configuración de mosquitto mosquitto.conf queda:

# Place your local configuration in /etc/mosquitto/conf.d/
#
# A full description of the configuration file is at
# /usr/share/doc/mosquitto/examples/mosquitto.conf.example

pid_file /run/mosquitto/mosquitto.pid

listener 1883

persistence true
persistence_location /var/lib/mosquitto/

log_dest file /var/log/mosquitto/mosquitto.log
log_type all
log_timestamp true

include_dir /etc/mosquitto/conf.d

acl_file /etc/mosquitto/aclfile

listener 8883
cafile /etc/mosquitto/ca_certificates/ca.crt
certfile /etc/mosquitto/certs/server.crt
keyfile /etc/mosquitto/certs/server.key

Instalar Node-RED

La instalación recomendada para tener la última version de Node-RED en Raspberry Pi: https://nodered.org/docs/getting-started/raspberrypi

Ejecutar el script (le cuesta unos minutos ejecutarse por completo): 

Iniciar el servicio de Node-RED con: sudo systemctl start nodered.service 

Para ejecutar Node-RED como servicio y que se inicie en el boot de Raspberry PI ejecutar:

  • sudo systemctl enable nodered.service

Para comprobar que funciona abrir un navegador y enterar en: http://{your_pi_ip-address}:1880 

Configurar Node-RED

Para configurar Node-RED ver: https://nodered.org/docs/user-guide/runtime/configuration

El fichero de configuración se encuentra normalmente en $HOME/.node-red/settings.js

Vamos a dejar la configuración por defecto y no vamos cambiar nada, pero es posible añadir las mejoras:

  • logging en un lugar externo fuera de la consola
  • activar proyectos en Node-RED
  • activar almacenamiento persistente de las variables de contexto

Autenticación y Autorización en Node-RED

Por defecto, el editor Node-RED no está protegido: cualquier persona que pueda acceder a su dirección IP puede acceder al editor e implementar cambios.

Para securizar Node-RED a nivel de atenticación y autorización seguir: https://nodered.org/docs/user-guide/runtime/securing-node-red para añadir usuario y password, así como otras configuraciones de seguridad

Instalar node-red-admin (Una herramienta de línea de comandos para administrar remotamente Node-RED):

sudo npm install -g --unsafe-perm node-red-admin

Para habilitar la autenticación basada en usuario y password, descomentar la propiedad adminAuth del fichero de configuración. Editar el fichero settings.js con nano /home/pi/.node-red/settings.js y descomentar estas líneas:

adminAuth: {
        type: "credentials",
        users: [{
            username: "admin",
            password: "$2a$08$zZWtXTja0fB1pzD4OlKj7wCMYz2Z6dNbM6tl8sJogENOMcxWV9DN.",
            permissions: "*"
        }]
    },

Para calcular la contraseña se usa: node-red-admin hash-pw y una vez cifrada la contraseña pegar en password.

Reiniciar el servicio Node-RED:  sudo systemctl restart nodered.service 

Entrar en Node-RED de nuevo en http://{your_pi_ip-address}:1880 y comprobar que pide contraseña.

Si se quiere añadir un usuario de solo lectura configurar settings.js como:

adminAuth: {
    type: "credentials",
    users: [
        {
            username: "admin",
            password: "$2a$08$zZWtXTja0fB1pzD4sHCMyOCMYz2Z6dNbM6tl8sJogENOMcxWV9DN.",
            permissions: "*"
        },
        {
            username: "curso_iot",
            password: "$2b$08$wuAqPiKJlVN27eF5qJp.YKo98uy6ZYONW7a/UWYxDTtwKFCdB8F19y",
            permissions: "read"
        }
    ]
}

Reiniciar el servicio Node-RED:  sudo systemctl restart nodered.service

Comprobar que el usuario de solo lectura no puede hacer deploy.

Autenticación UI (Dashboard y Páginas Dinámicas)

Manual: https://nodered.org/docs/user-guide/runtime/securing-node-red#http-node-security

Para proteger las rutas HTTP expuestas por los nodos y el dashboard se puede usar una autenticación básica.

La propiedad httpNodeAuth en su archivo settings.js se puede usar para definir un nombre de usuario y contraseña únicos que podrán acceder a las rutas.

Editar el fichero settings.js con nano /home/pi/.node-red/settings.js y descomentar estas líneas y poner el usuario deseado:

  • httpNodeAuth: {user:”usuario“,pass:”$2a$08$zZWtXTja0fB1pzD4sHCMyOCMYz2Z6dNbM6tl8sJogENOMcxWV9DN.”},

La propiedad pass, usa el mismo formato que adminAuth utilizando el algoritmo bcrypt y la contraseña se puede generar con el comando node-red-admin hash-pw. Para calcular la contraseña se usa: node-red-admin hash-pw y una vez cifrada la contraseña pegar en password.

Reiniciar el servicio Node-RED:  sudo systemctl restart nodered.service 

Entrar en Node-RED de nuevo en http://{your_pi_ip-address}:1880/ui y comprobar que pide contraseña.

Comunicaciones Cifradas TLS Node-RED

Node-RED proporciona soporte TLS para conexiones de red cifradas y autenticación.

No es necesario generar el certificado autofirmado del servidor, porque ya lo hemos hecho para mosquitto y se usa el mismo.

Editar el fichero settings.js con nano /home/pi/.node-red/settings.js y descomentar estas líneas y poner los datos de los certificados:

var fs=require("fs")

https: {
        key: fs.readFileSync('/home/pi/certificados/server.key'),
        cert: fs.readFileSync('/home/pi/certificados/server.crt')
    },
requireHttps: true,

Reiniciar el servicio Node-RED: sudo systemctl restart nodered.service

Entrar en Node-RED de nuevo en https://{your_pi_ip-address}:1880 y comprobar que no funciona http://{your_pi_ip-address}:1880

La web aparecerá como no segura en el navegador, pero se puede añadir el fichero ca.crt como certificado raíz confiable en el ordenador y ya aparecerá como una web segura.

Material Prácticas Curso Node-RED Developer

Para el curso on-line “Node-RED Developer Nivel 1”, el material necesario por parte de los alumnos para realizarlo es:

  • 1 PC o Portátil con conexión a internet.
  • Para seguir el curso on-line es recomendable dos pantallas, una para seguir el vídeo y otra para programar en Node-RED.
  • Una cuenta en github o bitbucket.
  • Opcionalmente software de virtualización instalado para ejecutar Node-RED. p.e. VirtualBox, VMWare Fusion o Docker.
  • Opcionalmente una Raspberry Pi conectada a Internet. Estas Raspberry Pi podrían ser proporcionadas por el Think TIC y configurarlas para acceso remoto desde casa del alumno a los dispositivos ubicados en el Think TIC.
  • Opcionalmente los alumnos con dispositivos IoT podrían conectarse e interactuar con ellos.

Todo el software y documentación utilizado en el curso es libre con licencia creative commons o similar.

Toda la documentación generada para la impartición de este curso será liberada con licencia Creative Commons y podrá ser utilizada bajo sus términos. La documentación estará disponible en https://www.aprendiendoarduino.com/ 

Entorno On-Line de Prácticas

Arquitectura

Se dispone de tres servidores:

  • enriquecrespo.com (S.O. CentOS 8)
    • Mosquitto
    • Grafana
    • Docker
    • Otros servicios públicos
  • aprendiendoarduino.com
    • Documentación curso con WordPress
    • BBDD MySQL públicas

Servidor cloud con las siguientes características:

  • 1 vCPU
  • 2 GB RAM
  • 20 GB SSD

Node-RED

Cada alumno debe tener al menos una instancia de Node-RED instalada en el S.O. o virtualización que desee.

Opcionalmente se puede proporcionar una instancia en enriquecrespo.com. El usuario y contraseña se enviará por correo.

Broker MQTT. Mosquitto

Se usará un broker común para comunicar todos los dispositivos en la dirección: mqtt://enriquecrespo.com:1883

Los alumnos recibirán usuario y contraseña para acceder al broker con permisos de lectura y escritura en aprendiendonodered21/#

Opcionalmente hay una dirección de MQTT seguro en: mqtts://enriquecrespo.com:8883 y MQTT sobre websocket en ws://enriquecrespo.com:9001

Servicios

Base de datos MySQL en https://qaej225.aprendiendoarduino.com/ donde los alumnos podrán usar para almacenar datos. Recibirán por correo las credenciales de acceso.

Grupo de telegram para comunicarse y programar bots.

Hardware Usado para Interactuar

Para interactuar en el curso disponemos de diversos HW conectados.

M5stack: https://m5stack.com/collections/m5-core/products/basic-core-iot-development-kit 

M5Stick-C con sensor ENV:

Goodtimera M5STICKC IoT - Placa de Desarrollo (Bluetooth, WiFi, IoT, ESP32  Stem PYTHO): Amazon.es: Hogar

Arduino UNO + GSM Shield con conexión móvil: https://store.arduino.cc/arduino-gsm-shield-2-integrated-antenna 

Raspberry Pi Zero: Instalada en local con cámara y programada con Node-RED, usada como dispositivo remoto.

Raspberry Pi 3B: Instalada en local con Node-RED, Mosquitto y BBDD, usada como servidor.

Wibeee instalado y publicando datos.

Wibeee ONE 2W

Si el alumno tiene algún HW con que quiera interactuar, puede presentarlo y lo integramos en las prácticas.

Configuración de las Instancias de Node-RED Alumnos

Las instancias de Node-RED de los alumnos están desplegadas con Docker y con configuración personalizada y una serie de configuraciones adicionales  ya hechas.

El acceso es a través de https://enriquecrespo.com:188xx/ siendo xx el número de alumno asignado.

Los puertos 88xx y 83xx también estarán disponibles para cada alumno para exponer una API/Websocket y MQTT respectivamente.

También hay una red interna para comunicar son servicios internos no expuestos como BBDD a las instancias de Node-RED

Comando para levantar el contenedor:

docker run –restart always -d -p 188xx:1880 -p 88xx:80 -p 83xx:1883 –network ‘alumnos’ -v /opt/docker_volumes/nodered_dataxx:/data –name noderedxx nodered/node-red

El fichero de configuración settings.js tiene estas modificaciones:

  • password nodered:
 adminAuth: {
         type: "credentials",
         users: [{
             username: "admin",
             password: "password cifrada usando node-red admin hash-pw",
             permissions: "*"
         }]
     }, 
  • password dahsboard y web estática
 httpNodeAuth: {user:"user",pass:"password cifrada usando node-red admin hash-pw"},
 httpStaticAuth: {user:"user",pass:"password cifrada usando node-red admin hash-pw"}, 
  • activar SSL y certificados
 https: {
       key: require("fs").readFileSync('/data/certificates/privkey.pem'),
       cert: require("fs").readFileSync('/data/certificates/cert.pem')
     },
 requireHttps: true, 
  • activar proyectos
 editorTheme: {
         projects: {
             enabled: true
         }
     } 
  • activar grabar datos en local o en memoria (almacenamiento)
 contextStorage: {
         default: "memoryOnly",
         memoryOnly: { module: 'memory' },
         file: { module: 'localfilesystem' }
     }, 

Itinerario Formación IoT/Industria 4.0

En un acercamiento a esta disciplina, se busca conocer las tecnologías necesarias para el desarrollo de soluciones IoT/Industria Conectada y valiéndonos para ello de herramientas, tecnologías, protocolos y software libre/open source que hay a nuestra disposición, de forma que cualquier empresa por pequeña que sea pueda hacer un proyecto sencillo de IoT/Industria 4.0 con una inversión mínima, sea cual sea el sector al que pertenezca.

No solo las grandes empresas pueden dar el salto a IoT, la tecnologías libres permiten que sea factible la digitalización de las pymes con una inversión económica mínima y que surja la innovación desde las propias empresas con una formación adecuada a sus trabajadores.

Fundamentos IoT (Nivel 1)20 h
Dispositivos HW IoT (Nivel 2)20 h
Infraestructuras IoT (Nivel 3)20 h
Conectividad IoT (Nivel 3)20 h
Plataformas IoT (Nivel 4)20 h
Desarrollo Soluciones IoT con Herramientas Libres (Nivel 5)20 h

Ver Anexo I con el material necesario para impartir los cursos de este itinerario.

Fundamentos IoT (Nivel 1)

Objetivo

Describir los fundamentos de Internet de las Cosas e identificar los distintos mercados a los que el alumno puede orientar su actividad profesional.

Dado que las comunicaciones, la conexión a Internet y los dispositivos conectados es un aspecto importante actualmente y los conceptos de computación y comunicaciones van unidos de la mano cuando hablamos de las TIC (Tecnologías de la Información y de la Comunicación), vamos a tratar también en este curso las comunicaciones y la programación de los dispositivos conectados.

Toda la documentación del curso y el código usado es libre y accesible desde https://www.aprendiendoarduino.com/.

Al finalizar el curso el alumno será capaz de:

  • Conocer qué es IoT
  • Reconocer las tecnologías y arquitecturas de IoT
  • Capas en IoT
  • Saber los retos de IoT
  • Importancia de la seguridad den IoT
  • Empresas en IoT
  • Conocer los mercados verticales de IoT
  • Saber los servicios que ofrece IoT

Requisitos Alumnos

No son necesarios requisitos previos de los alumnos para asistir a este curso

Contenido del Curso

  • Qué es el IoT. Visión Holística
  • Ecosistema IoT
  • Retos de IoT
  • Industria 4.0. IIoT
  • Empresas en IoT
  • Mercados Verticales IoT
  • Campos Profesionales IoT
  • Aplicaciones IoT

Dispositivos HW IoT (Nivel 2)

Objetivo

Visión general del HW en el ecosistema IoT y puesta en práctica. Identificar la solución Hardware y Firmware más correcta para un proyecto IoT.

Analizar el hardware y el firmware utilizado dentro el ecosistema IoT y programar algunas las plataformas de prototipado más populares del mercado

Toda la documentación del curso y el código usado es libre y accesible desde https://www.aprendiendoarduino.com/.

Al finalizar el curso el alumno será capaz de:

  • Conocer las plataformas HW IoT 
  • Conocer el firmware usado en las plataformas HW
  • Identificar la solución Hardware y Firmware más correcta para un proyecto IoT
  • Utilizar plataformas de prototipado IoT

Requisitos Alumnos

Haber cursado el módulo de Fundamentos IoT o tener experiencia en HW y Firmware IoT.

Contenido del Curso

  • Dispositivos IoT
  • HW IoT Industrial
  • Firmware: SW de los dispositivos
  • Plataforma de Prototipado
  • Prácticas Firmware
  • HW IoT Comercial

Infraestructuras de Comunicaciones IoT (Nivel 3)

Objetivo

Visión detallada de las infraestructuras y conectividad en IoT con ejemplos prácticos en algunas tecnologías. El alumno será capaz de analizar las necesidades de una solución IoT, ofrecer la mejor solución e implementarla. 

Utilizar las Infraestructuras de comunicación que se usan hoy en día para IoT

Toda la documentación del curso y el código usado es libre y accesible desde https://www.aprendiendoarduino.com/.

Al finalizar el curso el alumno será capaz de:

  • Conocer las diferentes infraestructuras de comunicaciones IoT disponibles en el mercado
  • Comparar las tecnologías inalámbricas y saber elegir la más adecuada dependiendo del proyecto.
  • Ofrecer e implantar soluciones IoT a nivel de conectividad e infraestructuras IoT a partir del análisis de necesidades del proyecto
  • Utilizar algunas de las comunicaciones con placas de prototipado como Arduino y ESP8266

Requisitos Alumnos

Haber cursado el módulo de Fundamentos IoT o tener experiencia en infraestructuras y conectividad IoT.

Contenido del Curso

  • Conectividad IoT
  • Redes Inalámbricas IoT
  • Infraestructura de Comunicación IoT
  • Prácticas de Comunicaciones IoT

Conectividad IoT (Nivel 3)

Objetivo

Visión detallada de las infraestructuras y conectividad en IoT con ejemplos prácticos en algunas tecnologías. El alumno será capaz de analizar las necesidades de una solución IoT, ofrecer la mejor solución e implementarla. 

Analizar los protocolos más populares para dotar de conectividad a los dispositivos IoT y configurar el software

Toda la documentación del curso y el código usado es libre y accesible desde https://www.aprendiendoarduino.com/.

Al finalizar el curso el alumno será capaz de:

  • Conocer los protocolos más populares usados en IoT
  • Profundizar en el protocolo HTTP y el uso de API REST
  • Profundizar en el protocolo MQTT y su uso en aplicaciones IoT
  • Instalar, configurar y usar un broker MQTT
  • Ofrecer e implantar soluciones IoT a nivel de conectividad e infraestructuras IoT a partir del análisis de necesidades del proyecto

Requisitos Alumnos

Haber cursado el módulo de Fundamentos IoT o tener experiencia en infraestructuras y conectividad IoT.

Contenido del Curso

  • Protocolos IoT
  • Protocolo HTTP
  • Uso de API REST
  • Protocolo MQTT
  • Práctica MQTT

Plataformas IoT (Nivel 4)

Objetivo

Visión general de las plataformas IoT y trabajo detallado en algunas de ellas. Proponer, instalar y configurar la plataforma más adecuada para el desarrollo de soluciones IoT.

Analizar las  las plataformas existentes en IoT e instalar y configurar alguna de las más utilizadas.

Toda la documentación del curso y el código usado es libre y accesible desde https://www.aprendiendoarduino.com/.

Al finalizar el curso el alumno será capaz de:

  • Conocer las plataformas IoT Generalistas y especializadas más usadas
  • Conocer plataformas open source, instalar y configurar en un servidor
  • Encontrar la plataforma adecuada para una solución IoT, instalación y configuración
  • Programar servicios usando Node-Red
  • Uso de Bases de Datos para almacenamiento de datos
  • Configuración y uso de Dashboards
  • Analizar datos de forma visual

Requisitos Alumnos

Haber cursado el módulo de Fundamentos IoT o tener experiencia en plataformas IoT.

Contenido del Curso

  • Plataformas Cloud Generalistas
  • Plataformas Cloud Especializadas
  • Práctica de Plataformas Cloud
  • Plataformas Privadas/Libres
  • Práctica Plataformas Privadas/Libres
  • Servicios IoT
  • Node-Red
  • Bases de Datos
  • Dashboards
  • Ejemplos prácticos IoT

Desarrollo Soluciones IoT con Herramientas Libres (Nivel 5)

Objetivo

Este curso pretende unificar todos los conocimiento adquiridos en los anteriores cursos del itinerario IoT para hacer un proyecto “full stack” de IoT.

Unificar los conocimientos adquiridos en los otros cursos, identificar necesidades reales con respuestas desde el IoT y desarrollar una solución específica para una necesidad.

Toda la documentación del curso y el código usado es libre y accesible desde https://www.aprendiendoarduino.com/.

Al finalizar el curso el alumno será capaz de:

  • Proponer e implementar soluciones IoT como respuesta a necesidades específicas
  • Desarrollar un proyecto IoT  estructurado según las fases relacionadas en cada módulo  que de respuesta a una necesidad real del entorno del alumno

Requisitos Alumnos

Los alumnos deberán haber cursado todos los cursos del itinerario IoT o tener experiencia en el desarrollo de soluciones IoT

Contenido del Curso

  • Repaso de conceptos
  • Ejemplo de soluciones IoT Completas
  • Identificación de necesidades
  • Presentación preliminar
  • Desarrollo del Proyecto
  • Presentación del Proyecto

Instalación Software Raspberry Pi

Instalar servidor LAMP

El acrónimo LAMP está compuesto por las iniciales de sus cuatro componentes: Linux, Apache, MySQL y PHP. Estos forman la infraestructura en el servidor, que hace posible la creación y el alojamiento de páginas web dinámicas. Los componentes individuales se acumulan unos sobre otros, por lo que esta plataforma también recibe el nombre de LAMP stack (del inglés “apilar”).

Su funcionamiento es muy simple. Linux sirve como sistema operativo base para ejecutar el servidor web Apache. Este último no puede interpretar contenidos dinámicos, pero es aquí donde PHP entra a ejercer sus funciones de programación del lado del servidor. El proceso funciona entonces de la siguiente manera: Apache le envía un código fuente al intérprete PHP, incluyendo la información correspondiente sobre las acciones del visitante de la web, y permite el acceso a la base de datos MySQL. El resultado es devuelto a Apache y este se muestra finalmente en el navegador web del visitante.

El lenguaje de programación PHP es uno de los más extendidos para el desarrollo de páginas web. La ventaja de utilizar PHP para el desarrollo de páginas web es que nos permite crear páginas web dinámicas, es decir, que se generan cuando un usuario visita la página.

MySQL es un sistema de gestión de bases de datos relacional desarrollado bajo licencia dual: Licencia pública general/Licencia comercial por Oracle Corporation y está considerada como la base datos de código abierto más popular del mundo, y una de las más populares en general junto a Oracle y Microsoft SQL Server, sobre todo para entornos de desarrollo web.

La alternativa libre es mariaDB: https://mariadb.org/ 

Este proyecto monta un pequeño servidor web Apache con lo que podrías por ejemplo alojar tu propia página web entre otras cosas. Además, si despliegas alrededor de tu casa, por ejemplo, varios sensores y actuadores (temperatura, humedad, luces, etc…) comandados por Arduino, podrías utilizar la Raspberry Pi 3como centro de envío y recepción de datos a través de su red. Y por supuesto utilizar la página Web para mostrar y controlar los datos a través de Internet.

Instrucciones para su instalación:

#Update system

  • sudo apt-get update
  • sudo apt-get upgrade

#Install Apache2

  • sudo apt-get install apache2

Comprobar que accedemos entrando a la IP de la Raspberry Pi desde un navegador

La página web por defecto está en /var/www/html

Crear un fichero prueba.html en el directorio /var/www/html que contenga el texto: “HOLA MUNDO”

Para comprobar que funciona entrar desde un navegador a la dirección: http://ip_raspberry/prueba.html y ver que aparece el texto “HOLA MUNDO”

También podemos comprobar que funciona conectando un Arduino a la red de la Raspberry Pi y cargar este sketch: https://github.com/jecrespo/Curso-IoT-Open-Source/blob/master/Conecta_Raspberry/Conecta_Raspberry.ino 

#Install PHP

  • sudo apt-get install php libapache2-mod-php

La versión que se instala es la 7.

Para comprobar el funcionamiento crear un fichero llamado info.php y en su interior el código: <?php phpinfo(); ?>

Luego en un navegador ir a http://IP-raspberry/info.php

#Install MariaDB

  • sudo apt-get install mariadb-server mariadb-client php-mysql
  • sudo mysql_secure_installation
  • sudo service apache2 restart

Durante el proceso de instalación se pedirá el password de root de MySQL, poner el mismo que tiene el usuario pi de la Raspberry Pi y poner a Yes todas las opciones de mysql_secure_installation 

Estos comando instalan una BBDD MariaDB

Para comprobar que todo funciona ejecutar sudo mysql -u root -p y poner la contraseña, saldrá:

Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 61
Server version: 10.1.23-MariaDB-9+deb9u1 Raspbian 9.0
Copyright (c) 2000, 2017, Oracle, MariaDB Corporation Ab and others.
Type ‘help;’ or ‘\h’ for help. Type ‘\c’ to clear the current input statement.

#Install MySQL

En caso de quere instalar MySQL en lugar de MariaDB usar estos comandos:

Más información:

#Install PhpMyAdmin

  • sudo apt-get install phpmyadmin

Durante el proceso pide la contraseña del usuario phpmyadmin de MySQL y el servidor a instalar el apache y poner yes en dbconfig-common

En caso que no hayamos configurado el servidor web correctamente o queramos hacer una configuración de phpmyadmin después de la instalación, usar el comando: sudo dpkg-reconfigure -plow phpmyadmin

phpMyAdmin es una herramienta escrita en PHP con la intención de manejar la administración de MySQL a través de páginas web, utilizando Internet. Actualmente puede crear y eliminar Bases de Datos, crear, eliminar y alterar tablas, borrar, editar y añadir campos, ejecutar cualquier sentencia SQL, administrar claves en campos, administrar privilegios, exportar datos en varios formatos y está disponible en 72 idiomas. Se encuentra disponible bajo la licencia GPL Versión 2.

Para probar que funciona ver en un navegador: http://IP-raspberry/phpmyadmin con el usuario phpmyadmin y la contraseña usada.

El usuario phpmyadmin no tiene privilegios. Para crear un usuario “pi” con privilegios ejecutar:

  • sudo mysql -u root -p
  • CREATE USER ‘pi’@’localhost’ IDENTIFIED BY ‘tu_contrasena‘;
  • CREATE USER ‘pi’@’%’ IDENTIFIED BY ‘tu_contrasena‘;
  • GRANT ALL PRIVILEGES ON * . * TO ‘pi’@’localhost’; (Para acceso local)
  • GRANT ALL PRIVILEGES ON *.* TO ‘pi’@’%’;  (Para acceso remoto)
  • GRANT GRANT OPTION ON *.* TO ‘pi’@’localhost’; (Privilegios para dar permisos a otros usuarios)
  • FLUSH PRIVILEGES;

Para conectarnos desde otro servidor: mysql -h ip_raspberry -u root -p

#Install servidor ftp (VSFTPD)

  • sudo apt-get install vsftpd

Una vez instalado, configurar con: sudo nano /etc/vsftpd.conf 

Comentar estas dos opciones:

#local_enable=YES
#ssl_enable=NO

Y añadir al final del fichero:

# CUSTOM
ssl_enable=YES
local_enable=YES
chroot_local_user=YES
local_root=/var/www
user_sub_token=pi
write_enable=YES
local_umask=002
allow_writeable_chroot=YES
ftpd_banner=Welcome to my Raspberry Pi FTP service.

También necesitamos añadir el usuario pi al grupo www-data, dar la propiedad de la carpeta /var/www al usuario y al grupo www-data, cambiar la carpeta de inicio del usuario pi a la misma, y aflojar algunos permisos en la carpeta /var/www:

  • sudo usermod -a -G www-data pi
  • sudo usermod -m -d /var/www pi
  • sudo chown -R www-data:www-data /var/www
  • sudo chmod -R 775 /var/www

Y reiniciar el servicio: sudo service vsftpd restart 

Para comprobar que funciona usar un cliente ftp con https://filezilla-project.org/ y hacer una conexión con la siguiente configuración:

  • Host – 192.xxx.x.xxx (IP address)
  • Port – 21
  • Protocol – FTP (File Transfer Protocol)
  • Encryption – Use explicit FTP over TLS if available
  • Logon Type – Normal (username & password)
  • Username – pi
  • Password – [enter password]

Más información: 

Y si quisieramos instalar un wordpress: https://www.raspberrypi.org/learning/lamp-web-server-with-wordpress/

Con esto ya tenemos listo un servidor para recibir conexiones de arduino y guardar datos y mostrarlos

Recordar cada vez que se haga una modificación grande en Raspberry Pi hacer una copia de seguridad de la tarjeta SD con Win32DiskImager.

Descarga https://sourceforge.net/projects/win32diskimager/

Escribir el nombre de la imagen en la ruta donde los guardemos.

Y luego pulsar read. Una vez hecho esto, esperar a que el proceso finalice.

Probar LAMP con Arduino

Para probar el servidor LAMP que acabamos de instalar en nuestra Raspberry Pi vamos a usar Arduino y mandar datos de luminosidad de la sala usando un LDR.

Una fotorresistencia o LDR (por sus siglas en inglés “light-dependent resistor”) es un componente electrónico cuya resistencia varía en función de la luz.

Se trata de un sensor que actúa como una resistencia variable en función de la luz que capta. A mayor intensidad de luz, menor resistencia: el sensor ofrece una resistencia de 1M ohm en la oscuridad, alrededor de 10k ohm en exposición de luz ambiente, hasta menos de 1k ohm expuesto a la luz del sol. Aunque estos valores pueden depender del modelo de LDR.

El LDR actúa como una resistencia variable. Para conocer la cantidad de luz que el sensor capta en cierto ambiente, necesitamos medir la tensión de salida del mismo. Para ello utilizaremos un divisor de tensión, colocando el punto de lectura para Vout entre ambas resistencias. De esta forma:

Dónde Vout es el voltaje leído por el PIN analógico del Arduino y será convertido a un valor digital, Vin es el voltaje de entrada (5v), R2 será el valor de la resistencia fija colocada (10k ohm generalmente) y R1 es el valor resistivo del sensor LDR. A medida que el valor del sensor LDR varía, obtendremos una fracción mayor o menor del voltaje de entrada Vin.

Instalación:

Más información https://www.luisllamas.es/medir-nivel-luz-con-arduino-y-fotoresistencia-ldr/ 

Crear una base de datos llamada “DatosArduino” con una tabla llamada “luminosidad” que tenga 4 campos: “id” auto incremental y sea el campo clave, “fecha” de  tipo timestamp y que se actualice al actualizar, un campo “arduino” de tipo entero y un campo “IntensidadLuminosa” que sea de tipo entero.

O con la query:

CREATE TABLE `luminosidad` (
  `id` int(11) NOT NULL,
  `fecha` timestamp NOT NULL DEFAULT current_timestamp() ON UPDATE current_timestamp(),
  `arduino` int(11) NOT NULL,
  `IntensidadLuminosa` int(11) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
ALTER TABLE `luminosidad`
  ADD PRIMARY KEY (`id`);
ALTER TABLE `luminosidad`
  MODIFY `id` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=4;

Para insertar un dato:

INSERT INTO `luminosidad` (`arduino`, `IntensidadLuminosa`) VALUES (’22’, ’22’);

Subir por FTP seguro los ficheros Graba_GET.php y Graba_POST.php a Raspberry Pi al directorio /var/www/html o crearlos con el comando nano:

Se puede probar que funciona ejecutando desde el navegador: http://127.0.0.1/Graba_GET.php?arduino=2&IntensidadLuminosa=89 

Ejecutar en Arduino estos sketches para GET o POST para mandar cada 5 segundos el dato de luminosidad:

Ver en la web de phpmyadmin los datos que se están subiendo y descargar en formato csv los datos guardados en unos minutos.

NOTA: Para ver los errores de PHP activar en /etc/php/7.0/apache2/php.ini la línea:

  • Development Value: E_ALL

Instalar Node-RED

No instalar la versión que aparece en software recomendado de Raspberry Pi OS.

Seguir esta instalacióm: https://nodered.org/docs/getting-started/raspberrypi 

Ejecutar el comando para instalar y actualizar: bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)

Para ejecutar Node-RED en el arranque: sudo systemctl enable nodered.service

En caso de problemas ver el log con: node-red-log

Instalar Webmin

Webmin es una herramienta de configuración de sistemas accesible vía web para sistemas Unix, como GNU/Linux y OpenSolaris. Con él se pueden configurar aspectos internos de muchos sistemas operativos, como usuarios, cuotas de espacio, servicios, archivos de configuración, apagado del equipo, etcétera, así como modificar y controlar muchas aplicaciones libres, como el servidor web Apache, PHP, MySQL, DNS, Samba, DHCP, entre otros.

Web: http://www.webmin.com/

Instalación:

Para comprobar que se ha instalado acceder desde un navegador a https://ip_address:10000 con usuario pi y la contraseña

Más información:

Manejar GPIO Raspberry Pi

Blink Led

Antes de empezar recordar comprobar la posición de los pines porque en caso de error podemos dañar la Raspberry Pi ya que los GPIO no tienen ninguna protección.

  • Cuando conectes cables a los GPIO procura no equivocarte y fíjate bien.
  • Usa cables con recubrimiento del tipo Dupont Macho-hembra por ejemplo, y no acerques cables sin proteger a tus GPIO (Y mucho menos un destornillador) porque puedes hacer un corto con facilidad.
  • Una vez que conectes un cable hembra protegido, vuelve a mirar y asegúrate de que lo has conectado al pin que querías y no al de al lado.
  • Especial cuidado con los pines que uses para sacar 3V o 5V de tu Raspi. No dejes el otro extremo al aire: Asegúrate de conectarlo a algún sitio.
  • NO CONECTES NADA DE 5V si no estás seguro. Tu Raspberry funciona a 3.3V y meterle 5V en un pin puede suponer quemar el procesador central. 

Instalar las librerías para el uso de los pines GPIO desde Python, asegurandonos de tener actualizado Raspbian:

  • sudo apt-get update
  • sudo apt-get upgrade
  • sudo apt-get install python-dev
  • sudo apt-get install pyton-rpi.gpio

Tened en cuenta que en esta ocasión vamos a alimentar el LED con 3.3V (Que es lo que proporciona un pin de la Raspi) y que la intensidad que obtendremos será: 3.3 / 1K Ω = 3 mA, que no es mucho para iluminar un LED pero suficiente.

Esquema de GPIO:

Conectamos GND al pin 6 de la Raspberry y vamos a usar el pin 12 (GPIO 18) como control del encendido mediante una resistencia intermedia. El esquema de conexión es:

Abrir el IDLE de Python 3 para empezar nuestro programa:

Y copiar código:

import RPi.GPIO as gpio

import time

gpio.setmode(gpio.BOARD)
gpio.setup(12, gpio.OUT)

for  x in range ( 0, 10):
    gpio.output(12, True)
    time.sleep(0.5)
    gpio.output(12, False)
    time.sleep(0.5)

print “Ejecución finalizada”

Guardar el fichero con el nombre blink.py en /home/pi y ejecutarlo pulsando F5

Más información:

Mosquitto

Eclipse Mosquitto™ es un servidor de mensajes de código abierto (con licencia EPL/EDL) que implementa las versiones 3.1 y 3.1.1 del protocolo MQTT. MQTT proporciona un método ligero para llevar a cabo la mensajería utilizando un modelo de publicación/suscripción. Esto lo hace adecuado para la “Internet de los objetos” de mensajería como con sensores de baja potencia o dispositivos móviles como teléfonos, ordenadores embebidos o microcontroladores como el Arduino.

Mosquitto es un broker MQTT OpenSource ampliamente utilizado debido a su ligereza lo que nos permite, fácilmente, emplearlo en gran número de ambientes, incluso si éstos son de pocos recursos.

Web: https://mosquitto.org/

Testear Mosquitto: https://test.mosquitto.org/

Repositorio: https://github.com/eclipse/mosquitto

A través de esta página puedes descargar y seguir los pasos de instalación según cual sea tu sistema operativo.

Una vez que tenemos instalado Mosquito, podemos proceder a crear nuestro primer emisor y subscriptor siguiendo para ello una jerarquía que podría asemejarse a la empleada en una aplicación real como el de un edificio.

Proyectos Eclipse Open Source for IoT

Más información:

Otro MQTT broker: http://www.hivemq.com/

Para descargar e instalar mosquitto seguir las instrucciones de: https://mosquitto.org/download/

Buen tutorial de Luis del Valle: https://programarfacil.com/esp8266/mqtt-esp8266-raspberry-pi/

Instalar Mosquitto en Raspberry Pi

Mosquitto está disponible en el repositorio principal de Raspberry Pi. También hay repositorios Debian proporcionados por el proyecto mosquitto, tal y como se describe en  https://mosquitto.org/blog/2013/01/mosquitto-debian-repository/

Lo primero es descargar la signing key o clave de firma utilizando el comando wget. Este comando descarga el fichero indicado como parámetro en el directorio en el que te encuentras.

Añadimos la clave para a una lista para autenticar el paquete que vamos a descargar más tarde.

  • sudo apt-key add mosquitto-repo.gpg.key

Después descargamos la lista de repositorios de Mosquitto con wget en la carpeta adecuada.

Actualizamos la lista de paquetes disponibles y sus versiones

  • sudo apt-get update

Y finalmente instalamos Mosquitto y los clientes

  • sudo apt-get install mosquitto
  • sudo apt-get install mosquitto-clients

Para que mosquito se ejecute en el inicio de Raspberry Pi:

  • sudo systemctl enable mosquitto.service

Si va a utilizar MQTT en un proyecto de Python, tendrá que instalar paho-mqtt, que reemplaza al antiguo módulo de Mosquitto Python. Si python-pip no está instalado tendrá que instalarlo primero:

  • sudo apt-get install python-pip
  • sudo pip install paho-mqtt

NOTA para mosquitto 2.x: https://mosquitto.org/blog/2020/12/version-2-0-0-released/ 

Mosquitto is now more secure by default and requires users to take an active decision in how they configure security on their broker, instead of possibly relying on the older very permissive behaviour, as well as dropping privileged access more quickly. More details are in migrating from 1.x to 2.0.

When Mosquitto is run without a configuration file, or without configuring any listeners, it will now bind to the loopback interfaces 127.0.0.1 and/or ::1. This means that only connections from the local host will be possible. This mode allows automated or manual testing on a local machine without the need for a configuration file. In this mode only, anonymous/unauthenticated users are allowed by default.

Running the broker with a listener defined will bind by default to 0.0.0.0 / :: and so will be accessible from any interface. It is still possible to bind to a specific address/interface.

All listeners now default to allow_anonymous false unless explicitly set to true in the configuration file. This means that when configuring a listener the user must either configure an authentication and access control method, or set allow_anonymous true. 

From: https://mosquitto.org/documentation/migrating-to-2-0/

Para que mosquitto 2.x pueda escuchar en todas las IPs añadir en /etc/mosquitto/mosquitto.conf:

listener 1883
# Note that this will not allow anonymous access by default.

Para poder usar mosquitto sin usuarios añadir en /etc/mosquitto/mosquitto.conf:

allow_anonymous true

Más información:

Configurar mosquito

La configuración de mosquitto está el fichero /etc/mosquitto/mosquitto.conf. Recordar hacer copia del fichero antes de hacer alguna modificación

Para añadir todos los mensajes de log en el fichero de log añadir las líneas:

# Save all log in file
log_dest file /var/log/mosquitto/mosquitto.log
log_type all
log_timestamp true

Para más información sobre las opciones del fichero mosquitto.conf ver /usr/share/doc/mosquitto/examples/mosquitto.conf

Para reiniciar el servicio de mosquito usar:

  • sudo systemctl restart mosquitto

En Linux puede recargar los archivos de configuración sin reiniciar el broker enviando la señal HUP de la siguiente manera:

  • kill -HUP PID # where PID is the process ID

Más información:

Comprobar Funcionamiento de Mosquitto

El último paso es probar nuestra instalación. Vamos a usar dos terminales. Uno se suscribirá al tema “test-mosquitto”, y el otro publicará un mensaje sobre este tema. La prueba tendrá éxito si el mensaje enviado por el editor se registra en el terminal de abonado.

Abrir un terminal en el ordenador con PuTTY y para suscribirse al topic “test-mosquitto” poner el comando:

  • mosquitto_sub -d -t ‘test-mosquitto’ (d = debug mode, t = topic)

Las opciones del comando mosquitto_sub son: https://mosquitto.org/man/mosquitto_sub-1.html

Si quisiéramos conectarnos a otro mosquitto y no el de nuestra raspberry usar:

  • mosquitto_sub -d -h IP_BROKER -t ‘test-mosquitto’ (d = debug mode, t = topic, h = host)

Abrir otro terminal y para publicar en el topic “test-mosquitto” poner el comando:

  • mosquitto_pub -d -t ‘test-mosquitto’ -m ‘This is a test message’

Y recibiremos el mensaje en la consola donde nos hemos suscrito:

Probar a suscribirse o publicar a otros mosquitto. También puedes hacerlo instalando el cliente MQTT.fx de: https://mqttfx.jensd.de/

Más información:

Securizar Mosquitto – Autenticación y Autorización

Tenemos un servidor Mosquitto instalado y funcionando, pero cualquiera que pueda acceder al puerto 1883 de nuestra Raspberry Pi o servidor podrá publicar y suscribirse a topics y además los mensajes no están cifrados.

El objetivo es configurar un broker MQTT con autentificación para securizar un poco el acceso al mismo de forma que podamos exponerlo en un servidor público y aún así tengamos zonas privadas.

Vamos a configurar Mosquitto para que use contraseñas. Mosquitto incluye una utilidad para generar un archivo de contraseña especial llamado mosquitto_passwd. Este comando le pedirá que introduzca una contraseña para el nombre de usuario especificado y coloque los resultados en /etc/mosquitto/passwd. Ejecutar este comando y poner la contraseña.

  • sudo mosquitto_passwd -c /etc/mosquitto/passwd curso_iot

Ahora abriremos un nuevo archivo de configuración para Mosquitto y le diremos que use este archivo de contraseñas para requerir inicios de sesión para todas las conexiones:

  • sudo nano /etc/mosquitto/conf.d/default.conf

Y escribir en el fichero:

password_file /etc/mosquitto/passwd
allow_anonymous false

allow_anonymous false deshabilitará todas las conexiones no autenticadas, y la línea del archivo password_file le indica a Mosquitto dónde buscar información de usuario y contraseña.

Una vez modificado el fichero reiniciar mosquitto:

  • sudo systemctl restart mosquitto

En el directorio /etc/mosquitto/conf.d se guardan los ficheros de configuración adicionales.

Para publicar y suscribirse con usuario y contraseña usar:

  • mosquitto_pub -d -t “test” -m “hola_mundo” -u “curso_iot” -P “password”
  • mosquitto_sub -d -t “test” -u “curso_iot” -P “password”

ACLs Mosquitto

Topic restriction: http://www.steves-internet-guide.com/topic-restriction-mosquitto-configuration/

Modificar el fichero mosquitto.conf y añadir el fichero con las acls:

  • acl_file /etc/mosquitto/aclfile

Ejemplo de aclfile:

# This affects access control for clients with no username.
topic read $SYS/#

# This only affects clients with username "roger".
user enrique2
topic readwrite #
topic read $SYS/#

user enrique
topic readwrite cursocefire/#
topic read sololectura/#

# This affects all clients.
pattern write $SYS/broker/connection/%c/state

Securizar Mosquitto – Cifrado SSL

Desafortunadamente, estamos enviando contraseñas sin encriptar a través de Internet. Lo arreglaremos añadiendo cifrado SSL a Mosquitto.

MQTT and TLS

MQTT se basa en el protocolo de transporte TCP. De forma predeterminada, las conexiones TCP no utilizan una comunicación cifrada. Para encriptar toda la comunicación MQTT, muchos Brokers MQTT (como Mosquitto) permiten el uso de TLS en lugar de TCP simple. Si utiliza los campos de nombre de usuario y contraseña del paquete MQTT CONNECT para los mecanismos de autenticación y autorización, debería considerar seriamente el uso de TLS.

El puerto 8883 está estandarizado para una conexión MQTT segura. El nombre estandarizado en IANA es “secure-mqtt”. El puerto 8883 está reservado exclusivamente para MQTT a través de TLS.

TLS Overhead

El uso de MQTT sobre TLS tiene sus inconvenientes: la seguridad tiene un costo en términos de uso de la CPU y gastos generales de comunicación. Mientras que el uso adicional de la CPU es típicamente insignificante en el broker, puede ser un problema para los dispositivos muy restringidos que no están diseñados para tareas de computación intensiva. Técnicas como la reanudación de sesión pueden mejorar drásticamente el rendimiento de TLS.

La sobrecarga de comunicaciones del Handshake de TLS puede ser significativa si se espera que las conexiones de los clientes MQTT sean de corta duración. Aunque la cantidad de ancho de banda que necesita el handshake TLS depende de muchos factores, algunas mediciones muestran que establecer una nueva conexión TLS puede requerir hasta unos pocos kilobytes de ancho de banda. Dado que cada paquete está encriptado en TLS, los paquetes en el cable tienen una sobrecarga adicional en comparación con los paquetes no encriptados.

Si utiliza conexiones TCP de larga duración con MQTT (¡lo que debería hacer!), la sobrecarga de TLS, especialmente la sobrecarga de handshake de TLS, puede ser insignificante. Si trata con muchas reconexiones y no puede utilizar la reanudación de sesión, entonces la sobrecarga puede ser significativa, especialmente si está publicando mensajes MQTTT muy pequeños. Si cada byte del cable cuenta para su caso de uso, TLS puede no ser la mejor opción para usted debido a la sobrecarga. Asegúrese de medir cuánta sobrecarga de TLS crea para su caso de uso.

TLS en dispositivos limitados

A veces, TLS no es factible para dispositivos limitados debido a la insuficiencia de recursos. Dependiendo de las cifras utilizadas, TLS puede ser muy intensivo en el cálculo y puede requerir muchos kilobytes de memoria.

Para hacerlo seguir estos tutoriales:

Más información

Ejemplo con Mosquitto y Arduino

Conectar un Arduino al broker MQTT y suscribirse al topic “inTopic” y sacar por el monitor serie lo que lee.

Usar el código: https://github.com/jecrespo/Curso-IoT-Open-Source/blob/master/mqtt_auth_curso/mqtt_auth_curso.ino