As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Tutorial: Conectando um dispositivo AWS IoT Core usando o AWS IoT dispositivo SDK

Este tutorial demonstra como conectar um dispositivo para AWS IoT Core que ele possa enviar e receber dados de AWS IoT e para. Depois de concluir este tutorial, seu dispositivo será configurado para se conectar AWS IoT Core e você entenderá como os dispositivos se comunicam com ele AWS IoT.

Pré-requisitos

Antes de começar este tutorial, verifique se você tem o seguinte:

Prepare seu dispositivo para AWS IoT

Em Introdução aos AWS IoT Core tutoriais, você preparou seu dispositivo e conta AWS para que eles pudessem se comunicar. Esta seção analisa os aspectos dessa preparação que se aplicam a qualquer conexão de dispositivo com AWS IoT Core o.

Para que um dispositivo se conecte a AWS IoT Core:

Revise o MQTT protocolo

Antes de falarmos sobre o aplicativo de amostra, é útil entender o MQTT protocolo. O MQTT protocolo oferece algumas vantagens em relação a outros protocolos de comunicação de rede, comoHTTP, por exemplo, o que o torna uma escolha popular para dispositivos de IoT. Esta seção analisa os principais aspectos MQTT que se aplicam a este tutorial. Para obter informações sobre como MQTT se compara comHTTP, consulteEscolher um protocolo de aplicativo para a comunicação do dispositivo.

MQTTusa um modelo de comunicação de publicação/assinatura

O MQTT protocolo usa um publish/subscribe communication model with its host. This model differs from the request/response modelo que HTTP usa. ComMQTT, os dispositivos estabelecem uma sessão com o host que é identificada por um ID de cliente exclusivo. Para enviar dados, os dispositivos publicam mensagens identificadas por tópicos para um agente de mensagens no host. Para receber mensagens do agente de mensagens, os dispositivos assinam tópicos enviando filtros de tópicos em solicitações de assinatura ao agente de mensagens.

MQTTsuporta sessões persistentes

O agente de mensagens recebe mensagens de dispositivos e publica mensagens em dispositivos que as assinaram. Com sessões persistentes —sessões que permanecem ativas mesmo quando o dispositivo iniciador está desconectado — os dispositivos podem recuperar mensagens que foram publicadas enquanto estavam desconectados. No lado do dispositivo, MQTT suporta níveis de qualidade de serviço (QoS) que garantem que o host receba mensagens enviadas pelo dispositivo.

Analise o aplicativo de SDK amostra de dispositivo pubsub.py

Esta seção analisa o aplicativo de pubsub.py amostra do AWS IoT Device SDK v2 para Python usado neste tutorial. Aqui, analisaremos como ele se conecta AWS IoT Core para publicar e assinar MQTT mensagens. A próxima seção apresenta alguns exercícios para ajudar você a explorar como um dispositivo se conecta e se comunica com AWS IoT Core ele.

Protocolos de comunicação

O pubsub.py exemplo demonstra uma MQTT conexão usando os WSS protocolos MQTT e MQTT over. A biblioteca AWS common runtime (AWS CRT) fornece suporte ao protocolo de comunicação de baixo nível e está incluída no AWS IoT Device SDK v2 for Python.

MQTT

As chamadas de pubsub.py exemplo mtls_from_path (mostradas aqui) no mqtt_connection_builderpara estabelecer uma conexão AWS IoT Core usando o MQTT protocolo. mtls_from_pathusa certificados X.509 e TLS v1.2 para autenticar o dispositivo. A AWS CRT biblioteca lida com os detalhes de nível inferior dessa conexão.

mqtt_connection = mqtt_connection_builder.mtls_from_path(
    endpoint=args.endpoint,
    cert_filepath=args.cert,
    pri_key_filepath=args.key,
    ca_filepath=args.ca_file,
    client_bootstrap=client_bootstrap,
    on_connection_interrupted=on_connection_interrupted,
    on_connection_resumed=on_connection_resumed,
    client_id=args.client_id,
    clean_session=False,
    keep_alive_secs=6
)

MQTTterminado WSS

O pubsub.py exemplo de chamadas websockets_with_default_aws_signing (mostrado aqui) no mqtt_connection_builderpara estabelecer uma conexão com o AWS IoT Core uso do MQTT protocolo overWSS. websockets_with_default_aws_signingcria uma MQTT conexão WSS usando o Signature V4 para autenticar o dispositivo.

mqtt_connection = mqtt_connection_builder.websockets_with_default_aws_signing(
    endpoint=args.endpoint,
    client_bootstrap=client_bootstrap,
    region=args.signing_region,
    credentials_provider=credentials_provider,
    websocket_proxy_options=proxy_options,
    ca_filepath=args.ca_file,
    on_connection_interrupted=on_connection_interrupted,
    on_connection_resumed=on_connection_resumed,
    client_id=args.client_id,
    clean_session=False,
    keep_alive_secs=6
)

HTTPS

Sobre o quêHTTPS? AWS IoT Core oferece suporte a dispositivos que publicam HTTPS solicitações. Do ponto de vista da programação, os dispositivos enviam HTTPS solicitações para AWS IoT Core o mesmo que qualquer outro aplicativo. Para ver um exemplo de um programa em Python que envia uma HTTP mensagem de um dispositivo, consulte o exemplo de HTTPS código usando a biblioteca do Python. requests Este exemplo envia uma mensagem para AWS IoT Core usar HTTPS tal que a AWS IoT Core interpreta como uma MQTT mensagem.

Embora AWS IoT Core ofereça suporte a HTTPS solicitações de dispositivos, certifique-se de revisar as informações para que você possa tomar uma decisão informada sobre qual protocolo usar para as comunicações do seu dispositivo. Escolher um protocolo de aplicativo para a comunicação do dispositivo

Sessões persistentes

No aplicativo de amostra, definir o parâmetro clean_session como False indica que a conexão deve ser persistente. Na prática, a conexão aberta por essa chamada se reconecta a uma sessão persistente existente, se houver. Caso contrário, ela cria e se conecta a uma nova sessão persistente.

Com uma sessão persistente, as mensagens enviadas ao dispositivo são armazenadas pelo agente de mensagens enquanto o dispositivo não está conectado. Quando um dispositivo se reconecta a uma sessão persistente, o agente de mensagens envia ao dispositivo todas as mensagens armazenadas nas quais ele se inscreveu.

Sem uma sessão persistente, o dispositivo não receberá mensagens enviadas enquanto o dispositivo não estiver conectado. A opção a ser usada depende do seu aplicativo e se as mensagens que ocorrem enquanto um dispositivo não está conectado devem ser comunicadas. Para obter mais informações, consulte Sessões persistentes do MQTT.

Qualidade do serviço

Quando o dispositivo publica e assina mensagens, a Qualidade de Serviço (QoS) preferida pode ser definida. AWS IoT suporta os níveis de QoS 0 e 1 para operações de publicação e assinatura. Para obter mais informações sobre os níveis de QoS em AWS IoT, consulte. Opções de Qualidade de serviço (QoS) do MQTT

O AWS CRT tempo de execução do Python define essas constantes para os níveis de QoS que ele suporta:

No aplicativo de amostra, as solicitações de publicação e assinatura são feitas com um nível de QoS de 1 (mqtt.QoS.AT_LEAST_ONCE).

Publicação de mensagens

Depois de estabelecer com sucesso uma conexão com AWS IoT Core, os dispositivos podem publicar mensagens. A amostra pubsub.py faz isso chamando a operação publish do mqtt_connection objeto.

mqtt_connection.publish(
    topic=args.topic,
    payload=message,
    qos=mqtt.QoS.AT_LEAST_ONCE
)

Assinatura de mensagens

Para receber mensagens de AWS IoT outros serviços e dispositivos, os dispositivos assinam essas mensagens pelo nome do tópico. Os dispositivos podem assinar mensagens individuais especificando um nome de tópico e em um grupo de mensagens especificando um filtro de tópico, que pode incluir caracteres curinga. A amostra pubsub.py usa o código mostrado aqui para assinar mensagens e registrar as funções de retorno de chamada para processar a mensagem depois de recebida.

subscribe_future, packet_id = mqtt_connection.subscribe(
    topic=args.topic,
    qos=mqtt.QoS.AT_LEAST_ONCE,
    callback=on_message_received
)
subscribe_result = subscribe_future.result()

A função mqtt_connection.subscribe retorna um future e um ID de pacote. Se a solicitação de assinatura foi iniciada com sucesso, o ID do pacote retornado será maior que 0. Para garantir que a assinatura tenha sido recebida e registrada pelo agente de mensagens, você deve aguardar o retorno do resultado da operação assíncrona, conforme mostrado no exemplo de código.

Função de retorno de chamada

O retorno de chamada na amostra pubsub.py processa as mensagens assinadas à medida que o dispositivo as recebe.

def on_message_received(topic, payload, **kwargs):
    print("Received message from topic '{}': {}".format(topic, payload))
    global received_count
    received_count += 1
    if received_count == args.count:
        received_all_event.set()

Na amostra pubsub.py, on_message_received exibe somente o tópico e sua carga útil. Ele também conta as mensagens recebidas para finalizar o programa após o limite ser atingido.

Seu aplicativo avaliaria o tópico e a carga para determinar quais ações realizar.

Desconexão e reconexão do dispositivo

A amostra pubsub.py inclui funções de retorno de chamada que são chamadas quando o dispositivo é desconectado e quando a conexão é restabelecida. As ações que seu dispositivo executa nesses eventos são específicas do aplicativo.

Quando um dispositivo se conecta pela primeira vez, ele precisa se inscrever nos tópicos para receber. Se a sessão de um dispositivo estiver presente quando ele se reconectar, suas assinaturas serão restauradas e todas as mensagens armazenadas dessas assinaturas serão enviadas ao dispositivo após a reconexão.

Se a sessão de um dispositivo não existir mais quando ele se reconectar, ele deverá assinar novamente suas assinaturas. As sessões persistentes têm uma vida útil limitada e podem expirar quando o dispositivo é desconectado por muito tempo.

Conecte seu dispositivo e comunique-se com AWS IoT Core

Esta seção apresenta alguns exercícios para ajudá-lo a explorar diferentes aspectos da conexão do seu dispositivo a AWS IoT Core. Para esses exercícios, você usará o cliente de MQTT teste no AWS IoT console para ver o que seu dispositivo publica e publicar mensagens em seu dispositivo. Esses exercícios usam a pubsub.pyamostra do AWS IoT Device SDK v2 for Python e se baseiam em sua experiência Introdução aos AWS IoT Core tutoriais com tutoriais.

Para esses exercícios, você começará com o programa pubsub.py de amostra.

Inscreva-se nos filtros de tópicos curinga

Neste exercício, você modificará a linha de comando usada para chamar pubsub.py para assinar um filtro de tópico curinga e processará as mensagens recebidas com base no tópico da mensagem.

Procedimento de exercício

Para este exercício, imagine que seu dispositivo contenha um controle de temperatura e um controle de luz. Ele usa esses nomes de tópicos para identificar as mensagens sobre eles.

Resultado do exercício

Com isso, pubsub.py, assinou as mensagens usando um filtro de tópico curinga, recebeu-as e as exibiu na janela do terminal. Observe como você se inscreveu em um único filtro de tópico e a função de retorno de chamada foi chamada para processar mensagens com dois tópicos distintos.

Processar assinaturas de filtros de tópicos

Com base no exercício anterior, modifique o aplicativo de pubsub.py amostra para avaliar os tópicos da mensagem e processar as mensagens inscritas com base no tópico.

Procedimento de exercício

Você deverá ver algo semelhante a isso na janela do seu terminal.

Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-af794be0-7542-45a0-b0af-0b0ea7474517'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...
Received message from topic 'device/light/details': b'{ "desiredLight": 100, "currentLight": 50 }'
Received light request: b'{ "desiredLight": 100, "currentLight": 50 }'
Received message from topic 'device/temp/details': b'{ "desiredTemp": 20, "currentTemp": 15 }'
Received temperature request: b'{ "desiredTemp": 20, "currentTemp": 15 }'
2 message(s) received.
Disconnecting...
Disconnected!

Resultado do exercício

Neste exercício, você adicionou código para que o aplicativo de amostra reconheça e processe várias mensagens na função de retorno de chamada. Com isso, seu dispositivo pode receber mensagens e agir conforme elas.

Outra forma de seu dispositivo receber e processar várias mensagens é assinar mensagens diferentes separadamente e atribuir a cada assinatura sua própria função de retorno de chamada.

Publique mensagens do seu dispositivo

Você pode usar o aplicativo de amostra pubsub.py para publicar mensagens do seu dispositivo. Embora publique as mensagens como estão, elas não podem ser lidas como JSON documentos. Este exercício modifica o aplicativo de amostra para poder publicar JSON documentos na carga da mensagem que possam ser lidos por. AWS IoT Core

Procedimento de exercício

Neste exercício, a seguinte mensagem será enviada com o tópico device/data.

{
    "timestamp": 1601048303,
    "sensorId": 28,
    "sensorData": [
        {
        "sensorName": "Wind speed",
        "sensorValue": 34.2211224
        }
    ]
}

Por padrão, pubsub3.py também assina as mensagens que envia. Você deve ver que ele recebeu as mensagens na saída do aplicativo. A janela do terminal deve parecer com algo semelhante ao seguinte.

Connecting to a3qEXAMPLEsffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-5cff18ae-1e92-4c38-a9d4-7b9771afc52f'...
Connected!
Subscribing to topic 'device/data'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 2 message(s)
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
2 message(s) received.
Disconnecting...
Disconnected!

Resultado do exercício

Com isso, seu dispositivo pode gerar mensagens para enviar AWS IoT Core para testar a conectividade básica e fornecer mensagens do dispositivo AWS IoT Core para processamento. Por exemplo, você pode usar esse aplicativo para enviar dados de teste do seu dispositivo para testar ações de AWS IoT regras.

Reveja os resultados

Os exemplos deste tutorial proporcionaram a você uma experiência prática com os conceitos básicos de como os dispositivos podem se comunicar AWS IoT Core— uma parte fundamental de sua solução. AWS IoT Quando seus dispositivos conseguem se comunicar AWS IoT Core, eles podem passar mensagens para AWS serviços e outros dispositivos nos quais possam atuar. Da mesma forma, AWS serviços e outros dispositivos podem processar informações que resultam em mensagens enviadas de volta aos seus dispositivos.

Quando estiver pronto para explorar AWS IoT Core mais, experimente estes tutoriais: