Puerta de enlace MQTT: Conexión de un dispositivo con autenticación de FC - IoT Platform

Al conectar un dispositivo a IoT Platform mediante una puerta de enlace MQTT, puede utilizar un certificado personalizado para verificar su identidad y registrarlo a partir del Common Name (CN) del certificado. Este tema explica cómo conectar un dispositivo a IoT Platform mediante verificación de terceros con Alibaba Cloud Function Compute (FC).

Notas importantes

Los pasos de este tema se ejecutan como usuario estándar. Si alguna operación requiere permisos administrativos, anteponga sudo al comando.

Requisitos previos

Debe haber adquirido una instancia Exclusive Enterprise Edition. En este tema se utiliza como ejemplo una instancia en la región China (Shanghai). Para obtener más información, consulte Purchase an Enterprise Edition instance.

Contexto

IoT Platform ofrece una función de puerta de enlace MQTT que permite la conexión y comunicación de dispositivos. Para admitir diversos escenarios empresariales, puede utilizar funciones como la verificación de terceros con Function Compute, certificados personalizados, el protocolo Online Certificate Status Protocol (OCSP) y temas de comunicación personalizados para la autenticación.

Para obtener más información sobre la autenticación y comunicación de dispositivos a través de una puerta de enlace MQTT, consulte MQTT gateway overview.

Preparativos

En este tema se utiliza Ubuntu 22.04 como entorno de desarrollo.

Paso 1: Generar certificados personalizados

Inicie sesión en el sistema operativo Ubuntu.

Ejecute el siguiente comando para generar el certificado raíz root-ca.crt tanto para el lado del dispositivo como para el lado del servidor:

openssl req \
    -new \
    -newkey rsa:2048 \
    -days 365 \
    -nodes \
    -x509 \
    -subj "/C=CN/O=Aliyun IOT/CN=IoT CA" \
    -keyout root-ca.key \
    -out root-ca.crt

Genere un certificado personalizado para el lado del servidor basado en el certificado raíz root-ca.crt.

Ejecute el siguiente comando para generar el archivo de clave del lado del servidor server.key:
```
openssl genrsa -out server.key 2048
```
Ejecute el comando touch openssl.cnf para crear un archivo llamado openssl.cnf.

Ejecute el comando vi openssl.cnf. A continuación, agregue el siguiente contenido al archivo, presione la tecla Esc e introduzca :wq para guardar y salir.

[policy_match]
countryName             = cn
stateOrProvinceName     = optional
organizationName        = optional
organizationalUnitName  = optional
commonName              = supplied
emailAddress            = optional
[req]
default_bits       = 2048
distinguished_name = req_distinguished_name
req_extensions     = req_ext
x509_extensions    = v3_req
prompt             = no
[req_distinguished_name]
commonName          = Server
[req_ext]
subjectAltName = @alt_names
[v3_req]
subjectAltName = @alt_names
[alt_names]
DNS.1 = *.mqtt.iothub.aliyuncs.com
DNS.2 = *.igw.iothub.aliyuncs.com

Ejecute el siguiente comando para generar el archivo de solicitud del lado del servidor server.csr:
```
openssl req -new -key server.key -config openssl.cnf -out server.csr
```

Ejecute el siguiente comando para generar el archivo de certificado del lado del servidor server.crt:

openssl x509 -req -days 365 -sha256 -in server.csr -CA root-ca.crt -CAkey root-ca.key -CAcreateserial -out server.crt -extensions v3_req -extfile openssl.cnf

Ejecute el siguiente comando para verificar el certificado del lado del servidor:
```
openssl verify -CAfile root-ca.crt server.crt
```

Genere un certificado personalizado para el lado del dispositivo basado en el certificado raíz root-ca.crt.
1. Ejecute el siguiente comando para generar el archivo de clave del lado del dispositivo client.key:
```
openssl genrsa -out client.key 2048
```
2. Ejecute el siguiente comando para generar el archivo de solicitud de certificado del lado del dispositivo client.csr. Establezca el CN como Client_123.
```
openssl req -new -key client.key -out client.csr -subj "/CN=Client_123"
```
3. Ejecute el siguiente comando para generar el archivo de certificado del lado del dispositivo client.crt:
```
openssl x509 -req -days 365 -sha256 -in client.csr -CA root-ca.crt -CAkey root-ca.key -CAcreateserial -out client.crt
```
4. Ejecute el siguiente comando para verificar el certificado del lado del dispositivo:
```
openssl verify -CAfile root-ca.crt client.crt
```

Paso 2: Crear una función de FC para la autenticación

Inicie sesión en la consola de Function Compute. En el panel de navegación izquierdo, haga clic en Services & Functions.
En la barra de navegación superior, seleccione la región China (Shanghai). En la página Services, haga clic en Create Service.
En el panel Create Service, introduzca un Service Name, por ejemplo IoT_Service, y luego haga clic en OK.
En la página Functions, haga clic en Create Function.
En la página Create Function, configure los siguientes parámetros y haga clic en Create.

Seleccione Create with Built-in Runtime como método de creación. En Function Name, introduzca three_party_auth. En Request Handler Type, seleccione Event Handler. En Runtime, seleccione Python 3.6.

En la página Function Details, reemplace el código de ejemplo con el siguiente código y haga clic en Deploy Code.

La función de autenticación devuelve el CN del certificado del dispositivo como deviceName.

# -*- coding: utf-8 -*-
import logging
import json
import time
import enum
import random
import string
class Request:
    def __init__(self, json_str):
        self.clientId = None
        self.username = None
        self.password = None
        self.certificateCommonName = None
        for key, value in json.loads(json_str).items():
            setattr(self, key, value)
class Response:
    def __init__(self):
        self.deviceName = None
        self.result = 'true'
        self.message = 'success'
    def handler(self, request):
        # Return the CN of the device certificate as the deviceName.
        self.deviceName = request.certificateCommonName
        return json.dumps(self.__dict__)
def handler(event, context):
    request = Request(event)
    return Response().handler(request)

Paso 3: Crear una puerta de enlace

Inicie sesión en la consola de IoT Platform. En la esquina superior izquierda de la página, seleccione la región China (Shanghai).
En la página Instance Overview, haga clic en la instancia Exclusive Enterprise Edition deseada.
En el panel de navegación izquierdo, vaya a Device Management > Gateway y haga clic en Add Gateway.
Configure los siguientes parámetros y haga clic en OK.

Para Server Certificate, utilice el contenido de server.crt. Para Server Certificate Private Key, utilice el contenido de server.key. Para Device Root Certificate, utilice el contenido de root-ca.crt. Para obtener más información sobre los parámetros, consulte Add a gateway.

En Protocol, seleccione MQTT. En Custom Port, introduzca 1883. En Authentication Type, seleccione Third-party Authentication. En Enable Data Passthrough, seleccione No. En Enable Device X.509 Certificate Authentication, seleccione No. En Enable OCSP, seleccione Disabled. En Device Authentication FC Service, seleccione IoT_Service. En Device Authentication FC Function, seleccione three_party_auth. En Authorization, seleccione AliyunIOTAccessingFCRole.
En la lista de puertas de enlace, copie y guarde la Gateway URL.

Paso 4: Desarrollar el programa del lado del dispositivo

Regrese al sistema operativo Ubuntu.

Ejecute los siguientes comandos para instalar las bibliotecas necesarias:

sudo apt-get install build-essential gcc make cmake cmake-gui cmake-curses-gui
sudo apt-get install libssl-dev

Ejecute los siguientes comandos para instalar la biblioteca Paho MQTT de código abierto:

git clone https://github.com/eclipse/paho.mqtt.c.git
mkdir build && cd build
cmake ../paho.mqtt.c -DPAHO_WITH_SSL=TRUE -DCMAKE_INSTALL_PREFIX="/usr/lib"
make -j
sudo make install && cd ..

Ejecute el comando touch aiot_mqtt_demo.c para crear un archivo de simulador de dispositivo llamado aiot_mqtt_demo.c.

Ejecute el comando vi aiot_mqtt_demo.c para abrir el archivo y agregar el siguiente contenido:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "MQTTClient.h"
int msgarrvd(void *context, char *topicName, int topicLen, MQTTClient_message *message)
{
    printf("message recv < topic [%s], payload [%s]\n", topicName, (char *)message->payload);
    MQTTClient_freeMessage(&message);
    MQTTClient_free(topicName);
    return 1;
}
int main(int argc, char* argv[])
{
    MQTTClient client;
    MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
    MQTTClient_SSLOptions ssl_opts = MQTTClient_SSLOptions_initializer;
    int rc;
    /* Create an MQTT client. Replace the placeholder values. */
    const char *host = "ssl://iot-0****.igw.iothub.aliyuncs.com:1883";
    const char *client_id = "12345";
    MQTTClient_create(&client, host, client_id, MQTTCLIENT_PERSISTENCE_NONE, NULL);
    MQTTClient_setCallbacks(client, NULL, NULL, msgarrvd, NULL);
    /* Configure connection parameters: certificate, username, and password. Replace the placeholder values. */
    ssl_opts.trustStore = "root-ca.crt";
    ssl_opts.privateKey = "client.key";
    ssl_opts.keyStore = "client.crt";
    conn_opts.ssl = &ssl_opts;
    conn_opts.username = "sdk_test01";
    conn_opts.password = "hello123";
    /* Establish an MQTT connection. */
    if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS) {
        printf("Failed to connect, return code %d\n", rc);
        exit(EXIT_FAILURE);
    }
    printf("connect success username %s, password %s\n", conn_opts.username, conn_opts.password);
    /* Subscribe to a topic. */
    MQTTClient_subscribe(client, "/user/aiot_mqtt_demo_downraw", 1);
    /* Generate and publish messages in a loop. */
    MQTTClient_message pubmsg = MQTTClient_message_initializer;
    const char *topic = "/user/aiot_mqtt_demo_upraw";
    pubmsg.payload = "Hello Service!";
    pubmsg.payloadlen = (int)strlen(pubmsg.payload);
    pubmsg.qos = 1;
    for(int i = 0; i < 100; i++) {
        MQTTClient_publishMessage(client, topic, &pubmsg, NULL);
        printf("message send > topic [%s], payload [%s]\n", topic, (char *)pubmsg.payload);
        sleep(10);
    }
    /* Disconnect and destroy the client. */
    MQTTClient_disconnect(client, 10000);
    MQTTClient_destroy(&client);
    return rc;
}

En el código, modifique los parámetros según la información real de su dispositivo. Luego, presione la tecla Esc e introduzca :wq para guardar el archivo aiot_mqtt_demo.c.

Parámetro	Descripción
host	El endpoint de la puerta de enlace MQTT para la conexión del dispositivo. El formato es `ssl://${Gateway-Endpoint}:${Port-Number}`. `${Gateway-Endpoint}` y `${Port-Number}` son el nombre de dominio y el puerto personalizado obtenidos de la Gateway URL en el Paso 3.
client_id	(Opcional) El ID del cliente. Debe ser un valor personalizado de hasta 64 caracteres. Utilice la dirección MAC o el número de serie (SN) del dispositivo para facilitar la identificación del cliente.
ssl_opts.trustStore	La ruta al archivo de certificado raíz del lado del dispositivo `root-ca.crt`.
ssl_opts.privateKey	La ruta al archivo de clave del lado del dispositivo `client.key`.
ssl_opts.keyStore	La ruta al archivo de certificado del lado del dispositivo `client.crt`.
conn_opts.username	El nombre de usuario para la conexión MQTT. El nombre de usuario debe tener entre 4 y 32 caracteres y puede contener letras, dígitos, guiones (-), guiones bajos (_), arrobas (@), puntos (.) y dos puntos (:). El nombre de usuario debe ser único dentro del producto.
conn_opts.password	La contraseña para la conexión MQTT. La contraseña debe tener entre 1 y 32 caracteres y puede contener letras, dígitos, guiones (-), guiones bajos (_), arrobas (@), puntos (.) y dos puntos (:).

Después de completar los pasos anteriores, su directorio contendrá los siguientes archivos:

build
paho.mqtt.c
aiot_mqtt_demo.c
client.crt
client.csr
client.key
openssl.cnf
root-ca.crt
root-ca.key
server.crt
server.csr
server.key

Paso 5: Compilar y ejecutar

Ejecute los siguientes comandos para compilar y ejecutar el archivo del programa del dispositivo aiot_mqtt_demo.c:
```
gcc -o aiot_mqtt_demo aiot_mqtt_demo.c -lpaho-mqtt3cs
./aiot_mqtt_demo
```
Una vez que el programa se ejecuta correctamente, el deviceName (Client_123) devuelto por la función de autenticación de FC se utiliza como DeviceName del dispositivo en IoT Platform. Se crea automáticamente un dispositivo llamado Client_123 en la página Device Management > Devices de su instancia en la consola de IoT Platform. El estado del dispositivo es Online.
(Opcional) Para consultar los datos reportados por el dispositivo, vaya a la consola de IoT Platform y revise la página Monitoring and Operations > Device Log de su instancia. Vaya a Monitoring and Operations > Device Log y haga clic en la pestaña Cloud Runtime Log. En la lista desplegable Product, seleccione el producto de la puerta de enlace. En la columna Actions, haga clic en View. En el cuadro de diálogo View Details, compruebe que el Topic sea /user/aiot_mqtt_demo_upraw y que el contenido sea Hello Service!. Un estado 200 confirma que el mensaje se reportó correctamente.