Passerelle MQTT : Connectez un appareil avec une authentification FC - IoT Platform

Lorsque vous connectez un appareil à IoT Platform via une passerelle MQTT, vous pouvez utiliser un certificat personnalisé pour vérifier son identité et l'enregistrer en utilisant le nom commun (CN) du certificat. Cette rubrique explique comment connecter un appareil à IoT Platform en utilisant la vérification tierce avec Alibaba Cloud Function Compute (FC).

Remarques importantes

Les étapes décrites dans cette rubrique sont effectuées en tant qu'utilisateur standard. Si une opération nécessite des autorisations d'administrateur, préfixez la commande avec sudo.

Prérequis

Vous avez acheté une instance Exclusive Enterprise Edition. Cette rubrique utilise une instance de la région Chine (Shanghai) à titre d'exemple. Pour plus d'informations, consultez Achat d'une instance Enterprise Edition.

Informations générales

IoT Platform propose une fonctionnalité de passerelle MQTT permettant aux appareils de se connecter et de communiquer. Vous pouvez utiliser des fonctionnalités telles que la vérification tierce avec Function Compute, les certificats personnalisés, le protocole OCSP (Online Certificate Status Protocol) et les sujets de communication personnalisés pour l'authentification, afin de prendre en charge divers scénarios métier.

Pour plus d'informations sur l'authentification et la communication des appareils via une passerelle MQTT, consultez Présentation de la passerelle MQTT.

Préparatifs

Cette rubrique utilise Ubuntu 22.04 comme environnement de développement.

Étape 1 : Générer des certificats personnalisés

Connectez-vous au système d'exploitation Ubuntu.

Exécutez la commande suivante pour générer le certificat racine root-ca.crt pour le côté appareil et le côté serveur :

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

Générez un certificat serveur personnalisé basé sur le certificat racine root-ca.crt.

Exécutez la commande suivante pour générer le fichier de clé serveur server.key :
```
openssl genrsa -out server.key 2048
```
Exécutez la commande touch openssl.cnf pour créer un fichier nommé openssl.cnf.

Exécutez la commande vi openssl.cnf. Ajoutez ensuite le contenu suivant au fichier, appuyez sur la touche Échap et saisissez :wq pour enregistrer et quitter.

[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

Exécutez la commande suivante pour générer le fichier de demande de certificat serveur server.csr :
```
openssl req -new -key server.key -config openssl.cnf -out server.csr
```

Exécutez la commande suivante pour générer le fichier de certificat serveur 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

Exécutez la commande suivante pour vérifier le certificat serveur :
```
openssl verify -CAfile root-ca.crt server.crt
```

Générez un certificat appareil personnalisé basé sur le certificat racine root-ca.crt.
1. Exécutez la commande suivante pour générer le fichier de clé appareil client.key :
```
openssl genrsa -out client.key 2048
```
2. Exécutez la commande suivante pour générer le fichier de demande de certificat appareil client.csr. Définissez le CN sur Client_123.
```
openssl req -new -key client.key -out client.csr -subj "/CN=Client_123"
```
3. Exécutez la commande suivante pour générer le fichier de certificat appareil client.crt :
```
openssl x509 -req -days 365 -sha256 -in client.csr -CA root-ca.crt -CAkey root-ca.key -CAcreateserial -out client.crt
```
4. Exécutez la commande suivante pour vérifier le certificat appareil :
```
openssl verify -CAfile root-ca.crt client.crt
```

Étape 2 : Créer une fonction FC pour l'authentification

Connectez-vous à la console Function Compute. Dans le volet de navigation de gauche, cliquez sur Services & Functions.
Dans la barre de navigation supérieure, sélectionnez la région China (Shanghai). Sur la page Services, cliquez sur Create Service.
Dans le panneau Create Service, saisissez un Service Name (par exemple, IoT_Service), puis cliquez sur OK.
Sur la page Functions, cliquez sur Create Function.
Sur la page Create Function, configurez les paramètres suivants et cliquez sur Create.

Sélectionnez Create with Built-in Runtime comme méthode de création. Pour Function Name, saisissez three_party_auth. Pour Request Handler Type, sélectionnez Event Handler. Pour Runtime, sélectionnez Python 3.6.

Sur la page Function Details, remplacez l'exemple de code par le code suivant et cliquez sur Deploy Code.

La fonction d'authentification renvoie le CN du certificat de l'appareil en tant que 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)

Étape 3 : Créer une passerelle

Connectez-vous à la console IoT Platform. Dans le coin supérieur gauche de la page, sélectionnez la région China (Shanghai).
Sur la page Instance Overview, cliquez sur votre instance Exclusive Enterprise Edition cible.
Dans le volet de navigation de gauche, choisissez Device Management > Gateway, puis cliquez sur Add Gateway.
Configurez les paramètres suivants et cliquez sur OK.

Pour Server Certificate, utilisez le contenu de server.crt. Pour Server Certificate Private Key, utilisez le contenu de server.key. Pour Device Root Certificate, utilisez le contenu de root-ca.crt. Pour plus d'informations sur les paramètres, consultez Ajout d'une passerelle.

Pour Protocol, sélectionnez MQTT. Pour Custom Port, saisissez 1883. Pour Authentication Type, sélectionnez Third-party Authentication. Pour Enable Data Passthrough, sélectionnez No. Pour Enable Device X.509 Certificate Authentication, sélectionnez No. Pour Enable OCSP, sélectionnez Disabled. Pour Device Authentication FC Service, sélectionnez IoT_Service. Pour Device Authentication FC Function, sélectionnez three_party_auth. Pour Authorization, sélectionnez AliyunIOTAccessingFCRole.
Dans la liste des passerelles, copiez et enregistrez l'Gateway URL.

Étape 4 : Développer le programme côté appareil

Revenez au système d'exploitation Ubuntu.

Exécutez les commandes suivantes pour installer les bibliothèques requises :

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

Exécutez les commandes suivantes pour installer la bibliothèque open source Paho MQTT :

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 ..

Exécutez la commande touch aiot_mqtt_demo.c pour créer un fichier de simulateur d'appareil nommé aiot_mqtt_demo.c.

Exécutez la commande vi aiot_mqtt_demo.c pour ouvrir le fichier et ajoutez le contenu suivant :

#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;
}

Dans le code, modifiez les paramètres en fonction des informations réelles de votre appareil. Appuyez ensuite sur la touche Échap et saisissez :wq pour enregistrer le fichier aiot_mqtt_demo.c.

Parameter	Description
host	Le point de terminaison de la passerelle MQTT pour la connexion de l'appareil. Le format est `ssl://${Gateway-Endpoint}:${Port-Number}`. `${Gateway-Endpoint}` et `${Port-Number}` correspondent au nom de domaine et au port personnalisé extraits de l'Gateway URL obtenue à l'étape 3.
client_id	(Facultatif) L'ID client. Il doit s'agir d'une valeur personnalisée d'une longueur maximale de 64 caractères. Utilisez l'adresse MAC ou le numéro de série (SN) de l'appareil pour faciliter l'identification du client.
ssl_opts.trustStore	Le chemin d'accès au fichier de certificat racine côté appareil `root-ca.crt`.
ssl_opts.privateKey	Le chemin d'accès au fichier de clé côté appareil `client.key`.
ssl_opts.keyStore	Le chemin d'accès au fichier de certificat côté appareil `client.crt`.
conn_opts.username	Le nom d'utilisateur pour la connexion MQTT. Le nom d'utilisateur doit comporter entre 4 et 32 caractères et peut contenir des lettres, des chiffres, des traits d'union (-), des traits de soulignement (_), des signes at (@), des points (.) et des deux-points (:). Le nom d'utilisateur doit être unique au sein du produit.
conn_opts.password	Le mot de passe pour la connexion MQTT. Le mot de passe doit comporter entre 1 et 32 caractères et peut contenir des lettres, des chiffres, des traits d'union (-), des traits de soulignement (_), des signes at (@), des points (.) et des deux-points (:).

Après avoir terminé les étapes précédentes, votre répertoire contient les fichiers suivants :

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

Étape 5 : Compiler et exécuter

Exécutez les commandes suivantes pour compiler et exécuter le fichier de programme de l'appareil aiot_mqtt_demo.c :
```
gcc -o aiot_mqtt_demo aiot_mqtt_demo.c -lpaho-mqtt3cs
./aiot_mqtt_demo
```
Une fois le programme exécuté avec succès, le deviceName (Client_123) renvoyé par la fonction d'authentification FC est utilisé comme DeviceName pour l'appareil dans IoT Platform. Un appareil nommé Client_123 est automatiquement créé sur la page Device Management > Devices de votre instance dans la console IoT Platform. Le statut de l'appareil est Online.
(Facultatif) Pour afficher les données signalées par l'appareil, accédez à la console IoT Platform et consultez la page Monitoring and Operations > Device Log de votre instance. Accédez à Monitoring and Operations > Device Log et cliquez sur l'onglet Cloud Runtime Log. Dans la liste déroulante Product, sélectionnez le produit de la passerelle. Dans la colonne Actions, cliquez sur View. Dans la boîte de dialogue View Details, vérifiez que le sujet est /user/aiot_mqtt_demo_upraw et que le contenu est Hello Service!. Un statut 200 confirme que le message a été signalé avec succès.