Gateway MQTT: Conecte um dispositivo com autenticação FC - IoT Platform: Central de Documentação do Alibaba Cloud

Ao conectar um dispositivo à IoT Platform por meio de um gateway MQTT, use um certificado personalizado para verificar a identidade do dispositivo e registrá-lo com o Common Name (CN) do certificado. Este tópico demonstra como conectar um dispositivo à IoT Platform usando verificação de terceiros com o Alibaba Cloud Function Compute (FC).

Observações importantes

Execute as etapas deste tópico como usuário comum. Se uma operação exigir permissões administrativas, adicione o prefixo sudo ao comando.

Pré-requisitos

Adquira uma instância Exclusive Enterprise Edition. Este tópico usa uma instância na região China (Shanghai) como exemplo. Para mais informações, consulte Adquirir uma instância Enterprise Edition.

Informações básicas

A IoT Platform oferece um recurso de gateway MQTT que permite a conexão e a comunicação de dispositivos. Use funcionalidades como verificação de terceiros com Function Compute, certificados personalizados, Online Certificate Status Protocol (OCSP) e tópicos de comunicação personalizados para autenticação e suporte a diversos cenários de negócios.

Para obter mais detalhes sobre autenticação e comunicação de dispositivos via gateway MQTT, consulte Visão geral do gateway MQTT.

Preparações

Este tópico utiliza o Ubuntu 22.04 como ambiente de desenvolvimento.

Etapa 1: Gerar certificados personalizados

Faça logon no sistema operacional Ubuntu.

Execute o comando abaixo para gerar o certificado raiz root-ca.crt tanto para o lado do dispositivo quanto para o lado do 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

Gere um certificado personalizado para o servidor com base no certificado raiz root-ca.crt.

Execute o seguinte comando para criar o arquivo de chave do servidor server.key:
```
openssl genrsa -out server.key 2048
```
Execute o comando touch openssl.cnf para criar um arquivo chamado openssl.cnf.

Execute o comando vi openssl.cnf, adicione o conteúdo abaixo ao arquivo, pressione a tecla Esc e insira :wq para salvar e sair.

[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

Execute o comando a seguir para gerar o arquivo de solicitação do servidor server.csr:
```
openssl req -new -key server.key -config openssl.cnf -out server.csr
```

Execute o comando abaixo para criar o arquivo de certificado do 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

Verifique o certificado do servidor executando este comando:
```
openssl verify -CAfile root-ca.crt server.crt
```

Crie um certificado personalizado para o dispositivo com base no certificado raiz root-ca.crt.
1. Gere o arquivo de chave do dispositivo client.key com o seguinte comando:
```
openssl genrsa -out client.key 2048
```
2. Gere o arquivo de solicitação de certificado do dispositivo client.csr executando o comando abaixo. Defina o CN como Client_123.
```
openssl req -new -key client.key -out client.csr -subj "/CN=Client_123"
```
3. Use o comando a seguir para gerar o arquivo de certificado do 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. Valide o certificado do dispositivo executando este comando:
```
openssl verify -CAfile root-ca.crt client.crt
```

Etapa 2: Criar uma função FC para autenticação

Acesse o console do Function Compute. No painel de navegação à esquerda, clique em Services & Functions.
Na barra de navegação superior, selecione a região China (Shanghai). Na página Services, clique em Create Service.
No painel Create Service, insira um Service Name, como IoT_Service, e clique em OK.
Na página Functions, clique em Create Function.
Configure os parâmetros abaixo na página Create Function e clique em Create.

Selecione Create with Built-in Runtime como método de criação. Em Function Name, insira three_party_auth. Para Request Handler Type, escolha Event Handler. No campo Runtime, selecione Python 3.6.

Substitua o código de exemplo pelo código abaixo na página Function Details e clique em Deploy Code.

A função de autenticação retorna o CN do certificado do dispositivo como o 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)

Etapa 3: Criar um gateway

Faça logon no console da IoT Platform. No canto superior esquerdo da página, selecione a região China (Shanghai).
Na página Instance Overview, clique na instância Exclusive Enterprise Edition desejada.
No painel de navegação à esquerda, escolha Device Management > Gateway e clique em Add Gateway.
Defina os seguintes parâmetros e clique em OK.

Em Server Certificate, utilize o conteúdo de server.crt. Para Server Certificate Private Key, use o conteúdo de server.key. No campo Device Root Certificate, insira o conteúdo de root-ca.crt. Para mais detalhes sobre os parâmetros, consulte Adicionar um gateway.

Em Protocol, selecione MQTT. Em Custom Port, insira 1883. Em Authentication Type, escolha Third-party Authentication. Em Enable Data Passthrough, selecione No. Em Enable Device X.509 Certificate Authentication, selecione No. Em Enable OCSP, mantenha Disabled. Em Device Authentication FC Service, escolha IoT_Service. Em Device Authentication FC Function, selecione three_party_auth. Em Authorization, escolha AliyunIOTAccessingFCRole.
Na lista de gateways, copie e salve a Gateway URL.

Etapa 4: Desenvolver o programa do lado do dispositivo

Retorne ao sistema operacional Ubuntu.

Instale as bibliotecas necessárias executando os comandos abaixo:

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

Instale a biblioteca open source Paho MQTT com os seguintes comandos:

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

Crie um arquivo de simulador de dispositivo chamado aiot_mqtt_demo.c usando o comando touch aiot_mqtt_demo.c.

Abra o arquivo com o comando vi aiot_mqtt_demo.c e adicione o conteúdo a seguir:

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

Modifique os parâmetros no código conforme as informações reais do seu dispositivo. Pressione a tecla Esc e insira :wq para salvar o arquivo aiot_mqtt_demo.c.

Parâmetro	Descrição
host	Endpoint do gateway MQTT para conexão do dispositivo. O formato é `ssl://${Gateway-Endpoint}:${Port-Number}`. `${Gateway-Endpoint}` e `${Port-Number}` correspondem ao nome de domínio e à porta personalizada obtidos na Gateway URL da Etapa 3.
client_id	(Opcional) ID do cliente. Deve ser um valor personalizado de até 64 caracteres. Recomenda-se usar o endereço MAC ou o número de série (SN) do dispositivo para facilitar a identificação.
ssl_opts.trustStore	Caminho para o arquivo do certificado raiz do dispositivo `root-ca.crt`.
ssl_opts.privateKey	Caminho para o arquivo de chave do dispositivo `client.key`.
ssl_opts.keyStore	Caminho para o arquivo de certificado do dispositivo `client.crt`.
conn_opts.username	Nome de usuário para a conexão MQTT. Deve ter entre 4 e 32 caracteres, contendo letras, dígitos, hifens (-), sublinhados (_), arrobas (@), pontos (.) e dois-pontos (:). Precisa ser único dentro do produto.
conn_opts.password	Senha para a conexão MQTT. Deve ter entre 1 e 32 caracteres, podendo incluir letras, dígitos, hifens (-), sublinhados (_), arrobas (@), pontos (.) e dois-pontos (:).

Após concluir as etapas anteriores, seu diretório conterá os seguintes arquivos:

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

Etapa 5: Compilar e executar

Compile e execute o arquivo do programa do dispositivo aiot_mqtt_demo.c com os comandos abaixo:
```
gcc -o aiot_mqtt_demo aiot_mqtt_demo.c -lpaho-mqtt3cs
./aiot_mqtt_demo
```
Após a execução bem-sucedida do programa, o deviceName (Client_123) retornado pela função de autenticação FC será usado como DeviceName do dispositivo na IoT Platform. Um dispositivo chamado Client_123 é criado automaticamente na página Device Management > Devices da sua instância no console da IoT Platform. O status do dispositivo aparecerá como Online.
(Opcional) Para visualizar os dados reportados pelo dispositivo, acesse o console da IoT Platform e abra a página Monitoring and Operations > Device Log da sua instância. Navegue até Monitoring and Operations > Device Log e clique na aba Cloud Runtime Log. Selecione o produto do gateway na lista suspensa Product. Na coluna Actions, clique em View. Na caixa de diálogo View Details, confirme se o Topic é /user/aiot_mqtt_demo_upraw e se o conteúdo é Hello Service!. O status 200 indica que a mensagem foi reportada com sucesso.