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 Device 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. **Topics** + [Pré-requisitos](#sdk-tutorials-prereq) + [Prepare seu dispositivo para AWS IoT](#sdk-tutorials-prepare) + [Revisar o protocolo MQTT](#sdk-tutorials-mqtt-review) + [Revise o aplicativo de amostra do SDK do dispositivo pubsub.py](#sdk-tutorials-explore-sample) + [Conecte seu dispositivo e comunique-se com AWS IoT Core](#sdk-tutorials-experiment) + [Reveja os resultados](#sdk-tutorials-conclusion) + [Tutorial: Usar a AWS IoT Device SDK para C incorporado](iot-embedded-c-sdk.md) ## Pré-requisitos Antes de começar este tutorial, verifique se você tem o seguinte: + **Concluído [Introdução aos AWS IoT Core tutoriais](iot-gs.md)** Na seção desse tutorial em que você deve [Configurar o dispositivo](configure-device.md), selecione a opção [Conectar um Raspberry Pi ou outro dispositivo](connecting-to-existing-device.md) para seu dispositivo e use as opções da linguagem Python para configurá-lo. **nota** Mantenha aberta a janela do terminal que você usa nesse tutorial porque você também vai usá-la. + **Um dispositivo que pode executar o AWS IoT Device SDK v2 para Python.** Este tutorial mostra como conectar um dispositivo AWS IoT Core usando exemplos de código Python, que exigem um dispositivo relativamente poderoso. Se você estiver trabalhando com dispositivos com recursos limitados, esses exemplos de código podem não funcionar com eles. Nesse caso, talvez você tenha mais êxito com o tutorial [Tutorial: Usar a AWS IoT Device SDK para C incorporado](iot-embedded-c-sdk.md). + **Recebeu as informações necessárias para se conectar ao dispositivo** Para conectar seu dispositivo a AWS IoT, você deve ter informações sobre o nome da coisa, o nome do host e o número da porta. **nota** Também é possível usar a autenticação personalizada para conectar dispositivos ao AWS IoT Core. Os dados de conexão transmitidos para a função do Lambda do autorizador dependem do protocolo usado. + **Nome da coisa**: O nome da AWS IoT coisa à qual você deseja se conectar. Você deve ter se registrado como seu dispositivo como uma AWS IoT coisa. Para obter mais informações, consulte [Gerenciando dispositivos com AWS IoT](iot-thing-management.md). + **Nome do host**: o nome do host do endpoint de IoT específico da conta. + **Número da porta**: o número da porta à qual se conectar. Você pode usar o `configureEndpoint` método no SDK do AWS IoT Python para configurar o nome do host e o número da porta. ``` myAWSIoTMQTTClient.configureEndpoint("random.iot.region.amazonaws.com", 8883) ``` ## Prepare seu dispositivo para AWS IoT Em [Introdução aos AWS IoT Core tutoriais](iot-gs.md), 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: 1. É necessário ter uma **Conta da AWS**. O procedimento em [Configurar Conta da AWS](setting-up.md) descreve como criar um, Conta da AWS se você ainda não tiver um. 1. Nessa conta, você deve ter os seguintes **AWS IoT recursos** definidos para o dispositivo em sua Conta da AWS região. O procedimento em [Crie AWS IoT recursos](create-iot-resources.md) descreve como criar esses recursos para o dispositivo em sua Conta da AWS e Região. + Um **certificado de dispositivo** registrado AWS IoT e ativado para autenticar o dispositivo. O certificado geralmente é criado com e anexado a um **AWS IoT objeto**. Embora um objeto não seja necessário para a conexão de um dispositivo AWS IoT, ele disponibiliza AWS IoT recursos adicionais para o dispositivo. + Uma **política** anexada ao certificado do dispositivo que o autoriza a se conectar AWS IoT Core e realizar todas as ações desejadas. 1. Uma **conexão com a Internet** que pode acessar os endpoints Conta da AWS do seu dispositivo. Os endpoints do dispositivo estão descritos [AWS IoT dados do dispositivo e endpoints de serviço](iot-connect-devices.md#iot-connect-device-endpoints) e podem ser vistos na [página de configurações do AWS IoT console](https://console.aws.amazon.com/iot/home#/settings). 1. **Software de comunicação**, como o SDKs fornecido pelo AWS IoT dispositivo. Este tutorial usa o [AWS IoT Device SDK v2 para Python](https://github.com/aws/aws-iot-device-sdk-python-v2#aws-iot-device-sdk-v2-for-python). ## Revisar o protocolo MQTT Antes de falarmos sobre o aplicativo de exemplo, é útil entender o protocolo MQTT.​ O protocolo MQTT oferece algumas vantagens sobre outros protocolos de comunicação de rede, como o HTTP, o que o torna uma escolha popular para dispositivos IoT. Esta seção analisa os principais aspectos do MQTT que se aplicam a este tutorial. Para obter informações sobre como o MQTT se compara ao HTTP, consulte [Escolher um protocolo de aplicativo para a comunicação do dispositivo](protocols.md#protocol-selection). **O MQTT usa um modelo de publish/subscribe comunicação** O protocolo MQTT usa um modelo publish/subscribe de comunicação com seu host. Esse modelo difere do request/response modelo usado pelo HTTP. Com o MQTT, os dispositivos estabelecem uma sessão com o host que é identificado 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. **O MQTT é compatível com sessões persistentes** O agente de mensagens recebe mensagens de dispositivos e publica mensagens em dispositivos que as assinaram. Com [sessões persistentes](mqtt.md#mqtt-persistent-sessions) —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, o MQTT é compatível com níveis de Qualidade de Serviço ([QoS](mqtt.md#mqtt-qos)) que garantem que o host receba mensagens enviadas pelo dispositivo. ## Revise o aplicativo de amostra do SDK do dispositivo pubsub.py Esta seção analisa o aplicativo de amostra `pubsub.py` do **AWS IoT Device SDK v2 para Python** usado neste tutorial. Aqui, analisaremos como ele se conecta AWS IoT Core para publicar e assinar mensagens do MQTT. 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. **O aplicativo `pubsub.py` de amostra demonstra esses aspectos de uma conexão MQTT com: AWS IoT Core** + [Protocolos de comunicação](#sdk-tutorials-explore-protocols) + [Sessões persistentes](#sdk-tutorials-explore-persistent) + [Qualidade do serviço](#sdk-tutorials-explore-qos) + [Publicação de mensagens](#sdk-tutorials-explore-publish) + [Assinatura de mensagens](#sdk-tutorials-explore-subscribe) + [Desconexão e reconexão do dispositivo](#sdk-tutorials-explore-connect) ### Protocolos de comunicação A amostra `pubsub.py` demonstra uma conexão MQTT usando os protocolos MQTT e MQTT via WSS. A biblioteca [AWS common runtime (AWS CRT)](https://github.com/awslabs/aws-crt-python#aws-crt-python) fornece suporte ao protocolo de comunicação de baixo nível e está incluída no AWS IoT Device SDK v2 para Python. #### MQTT As chamadas de `pubsub.py` exemplo `mtls_from_path` (mostradas aqui) no [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py)para estabelecer uma conexão AWS IoT Core usando o protocolo MQTT. `mtls_from_path`usa certificados X.509 e TLS v1.2 para autenticar o dispositivo. A biblioteca AWS CRT 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 ) ``` `endpoint` O Conta da AWS endpoint do seu dispositivo de IoT No aplicativo de amostra, esse valor é passado pela linha de comando. `cert_filepath` O caminho para o arquivo de certificado do dispositivo No aplicativo de amostra, esse valor é passado pela linha de comando. `pri_key_filepath` O caminho para o arquivo de chave privada do dispositivo que foi criado com seu arquivo de certificado No aplicativo de amostra, esse valor é passado pela linha de comando. `ca_filepath` O caminho para o arquivo CA Raiz. Obrigatório somente se o servidor MQTT usar um certificado que ainda não esteja em seu armazenamento confiável. No aplicativo de amostra, esse valor é passado pela linha de comando. `client_bootstrap` O objeto de runtime comum que trata as atividades de comunicação por soquete No aplicativo de amostra, esse objeto é instanciado antes da chamada para `mqtt_connection_builder.mtls_from_path`. `on_connection_interrupted``on_connection_resumed` As funções de retorno de chamada para chamar quando a conexão do dispositivo for interrompida e retomada `client_id` O ID que identifica exclusivamente esse dispositivo no Região da AWS No aplicativo de amostra, esse valor é passado pela linha de comando. `clean_session` Se deve iniciar uma nova sessão persistente ou, se houver uma, se reconectar a uma existente `keep_alive_secs` O valor keep alive, em segundos, a ser enviado na `CONNECT` solicitação. Um ping será enviado automaticamente nesse intervalo. Se o servidor não receber um ping após 1,5 vezes esse valor, ele assume que a conexão foi perdida. #### MQTT via WSS Os exemplos de chamada `pubsub.py` `websockets_with_default_aws_signing` (mostrados aqui) no [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py) para estabelecer conexão com o AWS IoT Core usando o protocolo MQTT via WSS. `websockets_with_default_aws_signing` cria uma conexão do MQTT via WSS usando o [Signature V4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) 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 ) ``` `endpoint` O Conta da AWS endpoint do seu dispositivo de IoT No aplicativo de amostra, esse valor é passado pela linha de comando. `client_bootstrap` O objeto de runtime comum que trata as atividades de comunicação por soquete No aplicativo de amostra, esse objeto é instanciado antes da chamada para `mqtt_connection_builder.websockets_with_default_aws_signing`. `region` A região de AWS assinatura usada pela autenticação Signature V4. Em `pubsub.py`, ele passa o parâmetro inserido na linha de comando. No aplicativo de amostra, esse valor é passado pela linha de comando. `credentials_provider` As AWS credenciais fornecidas para uso na autenticação No aplicativo de amostra, esse objeto é instanciado antes da chamada para `mqtt_connection_builder.websockets_with_default_aws_signing`. `websocket_proxy_options` Opções de proxy HTTP, se estiver usando um host proxy No aplicativo de amostra, esse valor é inicializado antes da chamada para `mqtt_connection_builder.websockets_with_default_aws_signing`. `ca_filepath` O caminho para o arquivo CA Raiz. Obrigatório somente se o servidor MQTT usar um certificado que ainda não esteja em seu armazenamento confiável. No aplicativo de amostra, esse valor é passado pela linha de comando. `on_connection_interrupted``on_connection_resumed` As funções de retorno de chamada para chamar quando a conexão do dispositivo for interrompida e retomada `client_id` O ID que identifica exclusivamente esse dispositivo no Região da AWS. No aplicativo de amostra, esse valor é passado pela linha de comando. `clean_session` Se deve iniciar uma nova sessão persistente ou, se houver uma, se reconectar a uma existente `keep_alive_secs` O valor keep alive, em segundos, a ser enviado na `CONNECT` solicitação. Um ping será enviado automaticamente nesse intervalo. Se o servidor não receber um ping após 1,5 vezes esse valor, ele presume que a conexão foi perdida. #### HTTPS E quanto ao HTTPS? AWS IoT Core oferece suporte a dispositivos que publicam solicitações HTTPS. Do ponto de vista da programação, os dispositivos enviam solicitações HTTPS para AWS IoT Core o mesmo que qualquer outro aplicativo. Para ver um exemplo de um programa em Python que envia uma mensagem HTTP de um dispositivo, consulte o [exemplo de código HTTPS](http.md#codeexample) usando a biblioteca do Python. `requests` Este exemplo envia uma mensagem para AWS IoT Core usar HTTPS de forma que a AWS IoT Core interprete como uma mensagem MQTT. Embora AWS IoT Core ofereça suporte a solicitações HTTPS 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](protocols.md#protocol-selection) ### 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](mqtt.md#mqtt-persistent-sessions). ### 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](mqtt.md#mqtt-qos) O tempo de execução do AWS CRT para Python define essas constantes para os níveis de QoS que ele suporta: **Níveis de qualidade de serviço do Python** | Nível de QoS do MQTT | Valor simbólico do Python usado pelo SDK | Descrição | | --- | --- | --- | | QoS nível 0 | mqtt.QoS.AT\$1MOST\$1ONCE | Somente uma tentativa de enviar a mensagem será feita, seja ela recebida ou não. A mensagem pode não ser enviada, por exemplo, se o dispositivo não estiver conectado ou houver um erro na rede. | | QoS nível 1 | mqtt.QoS.AT\$1LEAST\$1ONCE | A mensagem é enviada repetidamente até que uma PUBACK confirmação seja recebida. | 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`). + **QoS na publicação** Quando um dispositivo publica uma mensagem com QoS nível 1, ele envia a mensagem repetidamente até receber uma `PUBACK` resposta do agente de mensagens. Se o dispositivo não estiver conectado, a mensagem será colocada na fila para ser enviada após a reconexão. + **QoS na assinatura** Quando um dispositivo assina uma mensagem com QoS nível 1, o agente de mensagens salva as mensagens nas quais o dispositivo está inscrito até que elas possam ser enviadas ao dispositivo. O agente de mensagens reenvia as mensagens até receber uma resposta `PUBACK` do dispositivo. ### 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 ) ``` `topic` O nome do tópico da mensagem que identifica a mensagem No aplicativo de amostra, esse valor é passado pela linha de comando. `payload` A carga útil da mensagem formatada como uma string (por exemplo, um documento JSON) No aplicativo de amostra, esse valor é passado pela linha de comando. Um documento JSON é um formato de carga útil comum e reconhecido por outros AWS IoT serviços; no entanto, o formato de dados da carga útil da mensagem pode ser qualquer coisa com a qual os editores e assinantes concordem. Outros AWS IoT serviços, no entanto, reconhecem apenas JSON e CBOR, em alguns casos, para a maioria das operações. `qos` O nível de QoS para esta mensagem ### 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](topics.md#topicnames) e em um grupo de mensagens especificando um [filtro de tópico](topics.md#topicfilters), 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() ``` `topic` Como assinar um tópico do. Pode ser um nome de tópico ou um filtro de tópico. No aplicativo de amostra, esse valor é passado pela linha de comando. `qos` Se o agente de mensagens deve armazenar essas mensagens enquanto o dispositivo está desconectado. Um valor de `mqtt.QoS.AT_LEAST_ONCE` (QoS nível 1) exige que uma sessão persistente seja especificada (`clean_session=False`) quando a conexão é criada. `callback` A função a ser chamada para processar a mensagem assinada. 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() ``` `topic` O tópico da mensagem Esse é o nome do tópico específico da mensagem recebida, mesmo que você tenha se inscrito em um filtro de tópicos. `payload` Carga útil da mensagem O formato para isso é específico do aplicativo. `kwargs` Possíveis argumentos adicionais, conforme descrito em [https://awslabs.github.io/aws-crt-python/api/mqtt.html#awscrt.mqtt.Connection.subscribe](https://awslabs.github.io/aws-crt-python/api/mqtt.html#awscrt.mqtt.Connection.subscribe). 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 teste MQTT](https://console.aws.amazon.com/iot/home#/test) no AWS IoT console para ver o que seu dispositivo publica e publicar mensagens em seu dispositivo. Esses exercícios usam o exemplo [https://github.com/aws/aws-iot-device-sdk-python-v2/blob/master/samples/pubsub.py](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/master/samples/pubsub.py) do [AWS IoT Device SDK v2 para Python](https://github.com/aws/aws-iot-device-sdk-python-v2/tree/master/samples#sample-apps-for-the-aws-iot-device-sdk-v2-for-python) e se baseiam na sua experiência com tutoriais do [Introdução aos AWS IoT Core tutoriais](iot-gs.md). **Topics** + [Inscreva-se nos filtros de tópicos curinga](#sdk-tutorials-experiment-wild) + [Processar assinaturas de filtros de tópicos](#sdk-tutorials-experiment-process) + [Publique mensagens do seu dispositivo](#sdk-tutorials-experiment-publish) Para esses exercícios, você começará com o programa `pubsub.py` de amostra. **nota** Esses exercícios pressupõem que você concluiu os [Introdução aos AWS IoT Core tutoriais](iot-gs.md) tutoriais e usou a janela do terminal do seu dispositivo a partir desse tutorial. ### 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. 1. Antes de iniciar o exercício, tente executar esse comando nos [Introdução aos AWS IoT Core tutoriais](iot-gs.md) tutoriais do seu dispositivo para garantir que tudo esteja pronto para o exercício. ``` cd ~/aws-iot-device-sdk-python-v2/samples python3 pubsub.py --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint ``` Você deve ver a mesma saída que viu no [tutorial de introdução](connecting-to-existing-device.md#gs-device-node-app-run). 1. Para este exercício, altere esses parâmetros da linha de comando. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/sdk-tutorials.html) Fazer essas alterações na linha de comando inicial resulta nessa linha de comando. Digite esse comando na janela do terminal do seu dispositivo. ``` python3 pubsub.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint ``` O programa deve exibir algo semelhante ao seguinte: ``` Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-24d7cdcc-cc01-458c-8488-2d05849691e1'... Connected! Subscribing to topic 'device/+/details'... Subscribed with QoS.AT_LEAST_ONCE Waiting for all messages to be received... ``` Se você vir algo assim em seu terminal, seu dispositivo está pronto e ouvindo mensagens onde os nomes dos tópicos começam com `device` e terminam com `/detail`. Então, vamos testar isso. 1. Aqui estão algumas mensagens que seu dispositivo pode receber. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/sdk-tutorials.html) 1. Usando o cliente de teste MQTT no AWS IoT console, envie as mensagens descritas na etapa anterior para o seu dispositivo. 1. Abra o [cliente de teste MQTT](https://console.aws.amazon.com/iot/home#/test) no AWS IoT console. 1. Em **Inscrever-se em um tópico**, no **campo assinatura do tópico**, insira o filtro do tópico: **device/\$1/details** e, em seguida, selecione **Assinar um tópico**. 1. Na coluna **Assinaturas** do cliente de teste MQTT, selecione **dispositivo/\$1/detalhes**. 1. Para cada um dos tópicos na tabela anterior, faça o seguinte no cliente de teste do MQTT: 1. Em **Publicar**, insira o valor da coluna **Nome do tópico** na tabela. 1. No campo de carga útil da mensagem abaixo do nome do tópico, insira o valor da coluna **Carga útil da mensagem** na tabela. 1. Observe a janela do terminal em que `pubsub.py` está sendo executada e, no cliente de teste do MQTT, escolha **Publicar no tópico**. Você deve ver que a mensagem foi recebida `pubsub.py` na janela do terminal. #### 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 **Para avaliar o tópico da mensagem** 1. Copie `pubsub.py` para `pubsub2.py`. 1. Abra `pubsub2.py` no seu editor de texto favorito ou IDE. 1. Em `pubsub2.py`, encontre a função `on_message_received`. 1. Em `on_message_received`, insira o código a seguir após a linha que começa com `print("Received message` e antes da linha que começa com `global received_count`. ``` topic_parsed = False if "/" in topic: parsed_topic = topic.split("/") if len(parsed_topic) == 3: # this topic has the correct format if (parsed_topic[0] == 'device') and (parsed_topic[2] == 'details'): # this is a topic we care about, so check the 2nd element if (parsed_topic[1] == 'temp'): print("Received temperature request: {}".format(payload)) topic_parsed = True if (parsed_topic[1] == 'light'): print("Received light request: {}".format(payload)) topic_parsed = True if not topic_parsed: print("Unrecognized message topic.") ``` 1. Salve suas alterações e execute o programa modificado usando essa linha de comando. ``` python3 pubsub2.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint ``` 1. No AWS IoT console, abra o [cliente de teste MQTT](https://console.aws.amazon.com/iot/home#/test). 1. Em **Inscrever-se em um tópico**, no **campo assinatura do tópico**, insira o filtro do tópico: **device/\$1/details** e, em seguida, selecione **Assinar um tópico**. 1. Na coluna **Assinaturas** do cliente de teste MQTT, selecione **dispositivo/\$1/detalhes**. 1. Para cada um dos tópicos nesta tabela, faça o seguinte no cliente de teste do MQTT: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/sdk-tutorials.html) 1. Em **Publicar**, insira o valor da coluna **Nome do tópico** na tabela. 1. No campo de carga útil da mensagem abaixo do nome do tópico, insira o valor da coluna **Carga útil da mensagem** na tabela. 1. Observe a janela do terminal em que `pubsub.py` está sendo executada e, no cliente de teste do MQTT, escolha **Publicar no tópico**. Você deve ver que a mensagem foi recebida `pubsub.py` na janela do terminal. 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 documentos JSON. Este exercício modifica o aplicativo de amostra para poder publicar documentos JSON na carga da mensagem que podem 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 } ] } ``` **Para preparar seu cliente de teste MQTT para monitorar as mensagens deste exercício** 1. Em **Inscrever-se em um tópico**, no **campo assinatura do tópico**, insira o filtro do tópico: **device/data** e, em seguida, selecione **IAssinar um tópico**. 1. Na coluna **Assinaturas** do cliente de teste MQTT, selecione **dispositivo/dados**. 1. Mantenha a janela do cliente de teste MQTT aberta para aguardar as mensagens do seu dispositivo. **Para enviar documentos JSON com o aplicativo de amostra pubsub.py** 1. No seu dispositivo, copie `pubsub.py` para `pubsub3.py`. 1. Edite `pubsub3.py` para alterar a forma como ele formata as mensagens que publica. 1. Abra `pubsub3.py` em um editor de texto. 1. Localize esta linha de código: `message = "{} [{}]".format(message_string, publish_count)` 1. Altere para: `message = "{}".format(message_string)` 1. Localize esta linha de código: `message_json = json.dumps(message)` 1. Altere para: `message = "{}".json.dumps(json.loads(message))` 1. Salve as alterações. 1. No seu dispositivo, execute esse comando para enviar a mensagem duas vezes. ``` python3 pubsub3.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --topic device/data --count 2 --message '{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}' --endpoint your-iot-endpoint ``` 1. No cliente de teste MQTT, verifique se ele interpretou e formatou o documento JSON na carga útil da mensagem, da seguinte forma: ![\[Imagem mostrando como a carga útil de uma mensagem JSON é exibida no cliente MQTT do console. AWS IoT\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/mqtt-test-client-output.png) 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: + [Tutorial:r Como enviar uma notificação do Amazon SNS](iot-sns-rule.md) + [Tutorial: Armazenamento de dados do dispositivo em uma tabela do DynamoDB](iot-ddb-rule.md) + [Tutorial: Formatando uma notificação usando uma função AWS Lambda](iot-lambda-rule.md) # Tutorial: Usar a AWS IoT Device SDK para C incorporado Esta seção descreve como executar o AWS IoT Device SDK para C incorporado. **Topics** + [Etapa 1: instalar a AWS IoT Device SDK para C incorporado](#install-embedded-c-sdk) + [Etapa 2: configurar uma aplicação de amostra](#iot-c-sdk-app-config) + [Etapa 3: criar e executar a aplicação de exemplo](#iot-c-sdk-app-run) ## Etapa 1: instalar a AWS IoT Device SDK para C incorporado Em geral, o AWS IoT Device SDK para C incorporado destina-se a dispositivos com restrição de recursos que exigem um runtime de linguagem C otimizado. É possível usar o SDK em qualquer sistema operacional e hospedá-lo em qualquer tipo de processador (p. ex., MCUs e MPUs). Se você tiver mais memória e recursos de processamento disponíveis, recomendamos usar um dos SDKs de dispositivos e dispositivos móveis do AWS IoT de ordem superior (por exemplo, C\$1\$1, Java, JavaScript e Python). Em geral, o AWS IoT Device SDK para C incorporado destina-se a sistemas que usam MCUs ou MPUs low-end que executam sistemas operacionais incorporados. Para o exemplo de programação nesta seção, presumimos que o dispositivo usa Linux. **Example** 1. Faça o download de AWS IoT Device SDK para C incorporado para o dispositivo no [GitHub](https://github.com/aws/aws-iot-device-sdk-embedded-C). ``` git clone https://github.com/aws/aws-iot-device-sdk-embedded-c.git --recurse-submodules ``` Isso cria um diretório chamado `aws-iot-device-sdk-embedded-c` no diretório atual. 1. Navegue até esse diretório e confira a versão mais recente. Consulte [github.com/aws/aws-iot-device-sdk-embedded-C/tags](https://github.com/aws/aws-iot-device-sdk-embedded-C/tags) para ver a tag de lançamento mais recente. ``` cd aws-iot-device-sdk-embedded-c git checkout latest-release-tag ``` 1. Instale o OpenSSL versão 1.1.0 ou posterior. As bibliotecas de desenvolvimento do OpenSSL geralmente são chamadas de “libssl-dev” ou “openssl-devel” quando instaladas por meio de um gerenciador de pacotes. ``` sudo apt-get install libssl-dev ``` ## Etapa 2: configurar uma aplicação de amostra O AWS IoT Device SDK para C incorporado inclui aplicativos de exemplo para você experimentar. Para simplificar, este tutorial usa a aplicação `mqtt_demo_mutual_auth`, que ilustra como se conectar ao agente de mensagens do AWS IoT Core e assinar e publicar em tópicos MQTT. 1. Copie o certificado e a chave privada que você criou em [Introdução aos AWS IoT Core tutoriais](iot-gs.md) no diretório `build/bin/certificates`. **nota** Os certificados CA raiz e de dispositivo estão sujeitos a expiração ou revogação. Se esses certificados expirarem ou forem revogados, você deverá copiar um novo certificado da CA ou uma chave privada e um certificado do dispositivo no dispositivo. 1. É necessário configurar o exemplo com sua chave privada, certificado, certificado CA raiz e endpoint pessoal do AWS IoT Core. Navegue até o diretório `aws-iot-device-sdk-embedded-c/demos/mqtt/mqtt_demo_mutual_auth`. Se você tiver a AWS CLI instalada, será possível usar o comando para localizar o URL do endpoint da sua conta. ``` aws iot describe-endpoint --endpoint-type iot:Data-ATS ``` Se você não tiver a AWS CLI instalada, abra o [console do AWS IoT](https://console.aws.amazon.com/iot/home). No painel de navegação, escolha **Gerenciar** e **Objetos**. Escolha o objeto de IoT para o dispositivo e escolha **Interagir**. Seu endpoint é exibido na seção **HTTPS** da página de detalhes do objeto. 1. Abra o arquivo `demo_config.h` e atualize os valores para o seguinte: AWS\$1IOT\$1ENDPOINT Seu endpoint pessoal. CLIENT\$1CERT\$1PATH O caminho do arquivo de certificado, por exemplo `certificates/device.pem.crt"`. CLIENT\$1PRIVATE\$1KEY\$1PATH O nome do arquivo de chave privada, por exemplo `certificates/private.pem.key`. Por exemplo: ``` // Get from demo_config.h // ================================================= #define AWS_IOT_ENDPOINT "my-endpoint-ats.iot.us-east-1.amazonaws.com" #define AWS_MQTT_PORT 8883 #define CLIENT_IDENTIFIER "testclient" #define ROOT_CA_CERT_PATH "certificates/AmazonRootCA1.crt" #define CLIENT_CERT_PATH "certificates/my-device-cert.pem.crt" #define CLIENT_PRIVATE_KEY_PATH "certificates/my-device-private-key.pem.key" // ================================================= ``` 1. Verifique se você tem a CMake instalada no dispositivo usando este comando. ``` cmake --version ``` Se vir as informações de versão para o compilador, você poderá continuar para a próxima seção. Se receber um erro ou não vir nenhuma informação, você deverá instalar o pacote cmake usando este comando. ``` sudo apt-get install cmake ``` Execute o comando **cmake --version** novamente e confirme se a CMake foi instalada e que você está pronto para continuar. 1. Verifique se você tem as ferramentas de desenvolvimento instaladas em seu dispositivo usando este comando. ``` gcc --version ``` Se vir as informações de versão para o compilador, você poderá continuar para a próxima seção. Se receber um erro ou não vir nenhuma informação do compilador, você deverá instalar o pacote `build-essential` usando este comando. ``` sudo apt-get install build-essential ``` Execute o comando **gcc --version** novamente e confirme se as ferramentas de compilação foram instaladas e que você está pronto para continuar. ## Etapa 3: criar e executar a aplicação de exemplo Este procedimento explica como gerar a aplicação `mqtt_demo_mutual_auth` em seu dispositivo e conectá-la ao [console de AWS IoT](https://console.aws.amazon.com/iot/home) usando o AWS IoT Device SDK para C incorporado. **Como executar os aplicativos de exemplo do AWS IoT Device SDK para C incorporado** 1. Navegue até `aws-iot-device-sdk-embedded-c` e crie um diretório de compilação. ``` mkdir build && cd build ``` 1. Insira o comando CMake a seguir para gerar os arquivos de Makefiles necessários para compilação. ``` cmake .. ``` 1. Digite o comando a seguir para compilar o arquivo de aplicação executável. ``` make ``` 1. Execute o aplicativo `mqtt_demo_mutual_auth` com este comando. ``` cd bin ./mqtt_demo_mutual_auth ``` Você deve ver uma saída semelhante a: ![\[Saída de linha de comando para executar a aplicação de amostra AWS IoT Device SDK para C incorporado.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/successful-run2.png) O dispositivo está conectado à AWS IoT agora usando o AWS IoT Device SDK para C incorporado. Também é possível usar o console da AWS IoT para visualizar as mensagens MQTT que a aplicação de exemplo está publicando. Para obter informações sobre como usar o cliente MQTT no [console do AWS IoT](https://console.aws.amazon.com/iot/home), consulte [Exibir mensagens MQTT com o cliente AWS IoT MQTT](view-mqtt-messages.md).