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: Demonstre a comunicação de mensagens MQTT com o AWS IoT Device Client
Este tutorial demonstra como o AWS IoT Device Client pode assinar e publicar mensagens MQTT, que são comumente usadas em soluções de IoT.
**Para iniciar este tutorial:**
+ Configure seu computador host local e Raspberry Pi como [na seção anterior](iot-dc-install-dc.md).
Se você salvou a imagem do cartão microSD depois de instalar o AWS IoT Device Client, você pode usar um cartão microSD com essa imagem com seu Raspberry Pi.
+ Se você já executou essa demonstração antes, revise [Etapa 2: Limpar suas demonstrações Conta da AWS após a criação com o AWS IoT Device Client](iot-dc-cleanup.md#iot-dc-cleanup-cloud) para excluir todos os AWS IoT recursos que você criou em execuções anteriores para evitar erros de recursos duplicados.
Este tutorial leva cerca de 45 minutos para ser concluído.
**Quando você concluir este tópico:**
+ Você terá demonstrado diferentes maneiras pelas quais seu dispositivo de IoT pode assinar mensagens MQTT AWS IoT e publicar mensagens MQTT em. AWS IoT
**Equipamentos necessários:**
+ O ambiente local de desenvolvimento e teste da [seção anterior](iot-dc-install-dc.md)
+ O Raspberry Pi usado na [seção anterior](iot-dc-install-dc.md)
+ O cartão de memória microSD do Raspberry Pi usado na [seção anterior](iot-dc-install-dc.md)
**Topics**
+ [Preparar o Raspberry Pi para demonstrar a comunicação de mensagens MQTT](iot-dc-testconn-provision.md)
+ [Demonstre a publicação de mensagens com o AWS IoT Device Client](iot-dc-testconn-publish.md)
+ [Demonstre a assinatura de mensagens com o AWS IoT Device Client](iot-dc-testconn-subscribe.md)
# Preparar o Raspberry Pi para demonstrar a comunicação de mensagens MQTT
Esse procedimento cria os recursos no AWS IoT e no Raspberry Pi para demonstrar a comunicação de mensagens MQTT usando o AWS IoT Device Client.
**Topics**
+ [Criar os arquivos de certificado para demonstrar a comunicação MQTT](#iot-dc-testconn-provision-certs)
+ [Provisione seu dispositivo para demonstrar a comunicação MQTT](#iot-dc-testconn-provision-aws)
+ [Configure o arquivo de configuração do AWS IoT Device Client e o cliente de teste MQTT para demonstrar a comunicação MQTT](#iot-dc-testconn-provision-dc-config)
## Criar os arquivos de certificado para demonstrar a comunicação MQTT
Este procedimento cria os arquivos de certificado de dispositivo para esta demonstração.
**Para criar e baixar os arquivos de certificado de dispositivo para o Raspberry Pi**
1. Na janela do terminal do computador host local, insira o comando a seguir para criar os arquivos de certificado de dispositivo para o dispositivo.
```
mkdir ~/certs/pubsub
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "~/certs/pubsub/device.pem.crt" \
--public-key-outfile "~/certs/pubsub/public.pem.key" \
--private-key-outfile "~/certs/pubsub/private.pem.key"
```
O comando retorna uma resposta como a seguinte. Salve o valor de `certificateArn` para uso posterior.
```
{
"certificateArn": "arn:aws:iot:us-west-2:57EXAMPLE833:cert/76e7e4edb3e52f52334be2f387a06145b2aa4c7fcd810f3aea2d92abc227d269",
"certificateId": "76e7e4edb3e52f5233EXAMPLE7a06145b2aa4c7fcd810f3aea2d92abc227d269",
"certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCCAkGgAwIBAgI_SHORTENED_FOR_EXAMPLE_Lgn4jfgtS\n-----END CERTIFICATE-----\n",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BA_SHORTENED_FOR_EXAMPLE_ImwIDAQAB\n-----END PUBLIC KEY-----\n",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQE_SHORTENED_FOR_EXAMPLE_T9RoDiukY\n-----END RSA PRIVATE KEY-----\n"
}
}
```
1. Insira os comandos a seguir para definir as permissões no diretório de certificados e arquivos.
```
chmod 700 ~/certs/pubsub
chmod 644 ~/certs/pubsub/*
chmod 600 ~/certs/pubsub/private.pem.key
```
1. Execute este comando para examinar as permissões nos diretórios e arquivos do certificado.
```
ls -l ~/certs/pubsub
```
A saída do comando deve ser a mesma vista aqui, com exceção das datas e horários do arquivo, que serão diferentes.
```
-rw-r--r-- 1 pi pi 1220 Oct 28 13:02 device.pem.crt
-rw------- 1 pi pi 1675 Oct 28 13:02 private.pem.key
-rw-r--r-- 1 pi pi 451 Oct 28 13:02 public.pem.key
```
1. Digite esses comandos para criar os diretórios para os arquivos de log.
```
mkdir ~/.aws-iot-device-client
mkdir ~/.aws-iot-device-client/log
chmod 745 ~/.aws-iot-device-client/log
echo " " > ~/.aws-iot-device-client/log/aws-iot-device-client.log
echo " " > ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
chmod 600 ~/.aws-iot-device-client/log/*
```
## Provisione seu dispositivo para demonstrar a comunicação MQTT
Esta seção cria os AWS IoT recursos que provisionam seu Raspberry Pi em AWS IoT.
**Para provisionar seu dispositivo no AWS IoT:**
1. Na janela do terminal do computador host local, insira o comando a seguir para obter o endereço do endpoint de dados do dispositivo da sua Conta da AWS.
```
aws iot describe-endpoint --endpoint-type IoT:Data-ATS
```
O valor do endpoint não foi alterado desde quando este comando foi executado no tutorial anterior. Uma nova execução deste comando facilita localizar e colar o valor do endpoint de dados no arquivo de configuração usado neste tutorial.
O comando das etapas anteriores retorna uma resposta como a seguir. Registre o valor de `endpointAddress` para uso posterior.
```
{
"endpointAddress": "a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com"
}
```
1. Digite este comando para criar um novo recurso para AWS IoT o seu Raspberry Pi.
```
aws iot create-thing --thing-name "PubSubTestThing"
```
Como um recurso de AWS IoT coisas é uma representação *virtual* do seu dispositivo na nuvem, podemos criar vários recursos de coisas AWS IoT para serem usados para finalidades diferentes. Todos os recursos de objetos podem ser usados pelo mesmo dispositivo físico de IoT para representar aspectos diferentes do dispositivo.
Estes tutoriais usarão apenas um recurso de objeto por vez para representar o Raspberry Pi. Dessa forma, nesses tutoriais, eles representam as diferentes demonstrações para que, depois de criar os AWS IoT recursos para uma demonstração, você possa voltar e repetir a demonstração usando os recursos criados especificamente para cada uma.
Se seu recurso AWS IoT Thing foi criado, o comando retornará uma resposta como essa.
```
{
"thingName": "PubSubTestThing",
"thingArn": "arn:aws:iot:us-west-2:57EXAMPLE833:thing/PubSubTestThing",
"thingId": "8ea78707-32c3-4f8a-9232-14bEXAMPLEfd"
}
```
1. Na janela do terminal:
1. Abra um editor de texto, como o `nano`.
1. Copie este documento JSON e cole-o no editor de texto aberto.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:client/PubSubTestThing"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topic/test/dc/pubtopic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topicfilter/test/dc/subtopic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topic/test/dc/subtopic"
]
}
]
}
```
1. No editor, em cada `Resource` seção do documento de política, *us-west-2:57EXAMPLE833* substitua por seu Região da AWS, um caractere de dois pontos (:)) e seu número de 12 dígitos Conta da AWS .
1. Salve o arquivo no editor de texto como **\$1/policies/pubsub\$1test\$1thing\$1policy.json**.
1. Execute esse comando para usar o documento de política das etapas anteriores para criar uma AWS IoT política.
```
aws iot create-policy \
--policy-name "PubSubTestThingPolicy" \
--policy-document "file://~/policies/pubsub_test_thing_policy.json"
```
Se a política for criada, o comando retornará uma resposta como esta.
```
{
"policyName": "PubSubTestThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/PubSubTestThingPolicy",
"policyDocument": "{\n\"Version\": \"2012-10-17\", \n\"Statement\": [\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Connect\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Publish\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Subscribe\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Receive\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n]\n}\n]\n}\n",
"policyVersionId": "1"
}
```
1. Execute este comando para anexar a política ao certificado do dispositivo. Substitua `certificateArn` pelo valor de `certificateArn` salvo anteriormente nesta seção.
```
aws iot attach-policy \
--policy-name "PubSubTestThingPolicy" \
--target "certificateArn"
```
Se houver êxito, o comando não retornará nada.
1. Execute o comando a seguir para anexar o certificado de dispositivo ao recurso de objeto do AWS IoT . Substitua `certificateArn` pelo valor de `certificateArn` salvo anteriormente nesta seção.
```
aws iot attach-thing-principal \
--thing-name "PubSubTestThing" \
--principal "certificateArn"
```
Se houver êxito, o comando não retornará nada.
Depois de provisionar seu dispositivo com sucesso AWS IoT, você estará pronto para continuar[Configure o arquivo de configuração do AWS IoT Device Client e o cliente de teste MQTT para demonstrar a comunicação MQTT](#iot-dc-testconn-provision-dc-config).
## Configure o arquivo de configuração do AWS IoT Device Client e o cliente de teste MQTT para demonstrar a comunicação MQTT
Esse procedimento cria um arquivo de configuração para testar o AWS IoT Device Client.
**Para criar o arquivo de configuração para testar o AWS IoT Device Client**
1. Na janela do terminal do computador host local conectado ao Raspberry Pi:
1. Abra um editor de texto, como o `nano`.
1. Copie este documento JSON e cole-o no editor de texto aberto.
```
{
"endpoint": "a3qEXAMPLEaffp-ats.iot.us-west-2.amazonaws.com",
"cert": "~/certs/pubsub/device.pem.crt",
"key": "~/certs/pubsub/private.pem.key",
"root-ca": "~/certs/AmazonRootCA1.pem",
"thing-name": "PubSubTestThing",
"logging": {
"enable-sdk-logging": true,
"level": "DEBUG",
"type": "STDOUT",
"file": ""
},
"jobs": {
"enabled": false,
"handler-directory": ""
},
"tunneling": {
"enabled": false
},
"device-defender": {
"enabled": false,
"interval": 300
},
"fleet-provisioning": {
"enabled": false,
"template-name": "",
"template-parameters": "",
"csr-file": "",
"device-key": ""
},
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
}
},
"config-shadow": {
"enabled": false
},
"sample-shadow": {
"enabled": false,
"shadow-name": "",
"shadow-input-file": "",
"shadow-output-file": ""
}
}
```
1. Substitua o *endpoint* valor pelo endpoint de dados do dispositivo Conta da AWS que você encontrou em[Provisione seu dispositivo em AWS IoT Core](iot-dc-install-provision.md#iot-dc-install-dc-provision).
1. Salve o arquivo no editor de texto como **\$1/dc-configs/dc-pubsub-config.json**.
1. Execute este comando para definir permissões no novo arquivo de configuração.
```
chmod 644 ~/dc-configs/dc-pubsub-config.json
```
1. Para preparar o **cliente de teste MQTT** para assinar todas as mensagens MQTT:
1. No computador host local, no [console da AWS IoT](https://console.aws.amazon.com//iot/home#/test), selecione o **cliente de teste MQTT**.
1. Na guia **Assinar um tópico**, em **Filtro de tópicos**, insira **\$1** (um único sinal de jogo da velha) e selecione **Assinar**.
1. Abaixo do rótulo **Assinaturas**, confirme que pode ver **\$1** (um único sinal de jogo da velha).
Deixe a janela com o **cliente de teste MQTT** aberta enquanto prossegue com este tutorial.
Depois de salvar o arquivo e configurar o **cliente de teste MQTT**, você estará pronto para avançar para [Demonstre a publicação de mensagens com o AWS IoT Device Client](iot-dc-testconn-publish.md).
# Demonstre a publicação de mensagens com o AWS IoT Device Client
Os procedimentos nesta seção demonstram como o AWS IoT Device Client pode enviar mensagens MQTT padrão e personalizadas.
As seguintes declarações de política na política criada na etapa anterior para esses exercícios concedem ao Raspberry Pi permissão para realizar estas ações:
+
**`iot:Connect`**
Fornece o nome do cliente`PubSubTestThing`, seu Raspberry Pi executando o AWS IoT Device Client, para se conectar.
```
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing"
]
}
```
+
**`iot:Publish`**
Permite que o Raspberry Pi publique mensagens com um tópico MQTT de `test/dc/pubtopic`.
```
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic"
]
}
```
A ação `iot:Publish` concede permissão para publicar em tópicos MQTT listados na matriz de recursos. A declaração de política não controla o *conteúdo* dessas mensagens.
## Publique a mensagem padrão usando o AWS IoT Device Client
Esse procedimento executa o AWS IoT Device Client para que ele publique uma única mensagem MQTT padrão que o **cliente de teste MQTT** recebe e exibe.
**Para enviar a mensagem MQTT padrão do AWS IoT Device Client**
1. Certifique-se de que a janela do terminal do computador host local conectado ao Raspberry Pi e a janela com o **cliente de teste MQTT** estejam visíveis enquanto você realiza esse procedimento.
1. Na janela do terminal, insira esses comandos para executar o AWS IoT Device Client usando o arquivo de configuração criado em[Crie o arquivo de configuração](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1).
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-config.json
```
Na janela do terminal, o AWS IoT Device Client exibe mensagens informativas e quaisquer erros que ocorram durante a execução.
Caso nenhum erro seja exibido na janela do terminal, examine o **cliente de teste do MQTT**.
1. No **cliente de teste do MQTT**, na janela **Assinaturas**, consulte a mensagem *Olá, mundo\$1* enviada ao tópico de mensagem `test/dc/pubtopic`.
1. Se o AWS IoT Device Client não exibir erros e você ver *Hello World\$1* enviada para a `test/dc/pubtopic` mensagem no **cliente de teste do MQTT**, você demonstrou uma conexão bem-sucedida.
1. Na janela do terminal, digite **^C** (Ctrl-C) para parar o AWS IoT Device Client.
Depois de demonstrar que o AWS IoT Device Client publicou a mensagem padrão do MQTT, você pode continuar com o. [Publique uma mensagem personalizada usando o AWS IoT Device Client](#iot-dc-testconn-publish-custom)
## Publique uma mensagem personalizada usando o AWS IoT Device Client
Os procedimentos desta seção criam uma mensagem MQTT personalizada e, depois, executam o AWS IoT Device Client para que ele publique a mensagem MQTT personalizada uma vez para que o **cliente de teste MQTT** a receba e exiba.
### Crie uma mensagem MQTT personalizada para o AWS IoT Device Client
Realize as seguintes etapas na janela do terminal do computador host local que está conectado ao Raspberry Pi.
**Para criar uma mensagem personalizada para o AWS IoT Device Client publicar**
1. Na janela do terminal, abra um editor de texto, como o `nano`.
1. No editor de texto, copie e cole o seguinte documento JSON. Essa será a carga útil da mensagem MQTT que o AWS IoT Device Client publica.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Salve o conteúdo do editor de texto como **\$1/messages/sample-ws-message.json**.
1. Digite o comando a seguir para definir as permissões do arquivo de mensagem que você acabou de criar.
```
chmod 600 ~/messages/*
```
**Para criar um arquivo de configuração para o AWS IoT Device Client usar para enviar a mensagem personalizada**
1. Na janela do terminal, em um editor de texto como`nano`, abra o arquivo de configuração existente do AWS IoT Device Client:**\$1/dc-configs/dc-pubsub-config.json**.
1. Edite o objeto `samples` para que ele fique assim. Não são necessárias alterações em outras partes deste arquivo.
```
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
```
1. Salve o conteúdo do editor de texto como **\$1/dc-configs/dc-pubsub-custom-config.json**.
1. Execute este comando para definir permissões no novo arquivo de configuração.
```
chmod 644 ~/dc-configs/dc-pubsub-custom-config.json
```
### Publique a mensagem MQTT personalizada usando o AWS IoT Device Client
Essa alteração afeta somente o *conteúdo* da carga da mensagem MQTT, então a política atual permanecerá funcionando. No entanto, se o *tópico MQTT* (conforme definido pelo valor de `publish-topic` em`~/dc-configs/dc-pubsub-custom-config.json`) fosse alterado, a declaração de política `iot::Publish` também precisaria ser modificada para permitir que o Raspberry Pi publique no novo tópico do MQTT.
**Para enviar a mensagem MQTT do AWS IoT Device Client**
1. Certifique-se de que a janela do terminal e a janela com o **cliente de teste MQTT** estejam visíveis enquanto você realiza esse procedimento. Além disso, certifique-se de que o **cliente de teste MQTT** ainda seja assinante no filtro de tópicos **\$1**. Se não o for, assine novamente o filtro de tópicos **\$1**.
1. Na janela do terminal, digite os seguintes comandos para executar o AWS IoT Device Client usando o arquivo de configuração criado em [Crie o arquivo de configuração](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1).
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json
```
Na janela do terminal, o AWS IoT Device Client exibe mensagens informativas e quaisquer erros que ocorram durante a execução.
Caso nenhum erro seja exibido na janela do terminal, examine o cliente de teste do MQTT.
1. No **cliente de teste MQTT**, na janela **Assinaturas**, examine a carga de mensagem personalizada enviada ao tópico de mensagem `test/dc/pubtopic`.
1. Se o AWS IoT Device Client não exibir erros e você ver a carga da mensagem personalizada que você publicou na `test/dc/pubtopic` mensagem no **cliente de teste do MQTT**, você publicou uma mensagem personalizada com sucesso.
1. Na janela do terminal, digite **^C** (Ctrl-C) para parar o AWS IoT Device Client.
Depois de demonstrar que o AWS IoT Device Client publicou uma carga de mensagem personalizada, você pode continuar[Demonstre a assinatura de mensagens com o AWS IoT Device Client](iot-dc-testconn-subscribe.md).
# Demonstre a assinatura de mensagens com o AWS IoT Device Client
Nesta seção, você demonstrará dois tipos de assinaturas de mensagens:
+ Assinatura de tópico único
+ Assinatura de tópicos curinga
As seguintes declarações de política na política criada para esses exercícios concedem ao Raspberry Pi permissão para realizar estas ações:
+
**`iot:Receive`**
Permite que o AWS IoT Device Client receba tópicos do MQTT que correspondam aos nomeados no `Resource` objeto.
```
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/subtopic"
]
}
```
+
**`iot:Subscribe`**
Permite que o AWS IoT Device Client assine filtros de tópicos do MQTT que correspondam aos nomeados no `Resource` objeto.
```
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic"
]
}
```
## Assinatura de um único tópico de mensagem MQTT
Este procedimento demonstra como o AWS IoT Device Client pode assinar e registrar mensagens MQTT.
Na janela do terminal do computador host local que está conectado ao Raspberry Pi, liste o conteúdo de **\$1/dc-configs/dc-pubsub-custom-config.json** ou abra o arquivo em um editor de texto para examinar seu conteúdo. Localize o objeto `samples`, que deve ser semelhante ao seguinte.
```
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
```
Observe que o valor de `subscribe-topic` é o tópico MQTT que o AWS IoT Device Client assinará quando for executado. O AWS IoT Device Client grava as cargas de mensagens que recebe dessa assinatura no arquivo nomeado no `subscribe-file` valor.
**Para assinar um tópico de mensagem MQTT a partir do AWS IoT Device Client**
1. Certifique-se de que a janela do terminal e a janela com o cliente de teste MQTT estejam visíveis enquanto você realiza esse procedimento. Além disso, certifique-se de que o **cliente de teste MQTT** ainda seja assinante no filtro de tópicos **\$1**. Se não o for, assine novamente o filtro de tópicos **\$1**.
1. Na janela do terminal, insira esses comandos para executar o AWS IoT Device Client usando o arquivo de configuração criado em[Crie o arquivo de configuração](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1).
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json
```
Na janela do terminal, o AWS IoT Device Client exibe mensagens informativas e quaisquer erros que ocorram durante a execução.
Caso nenhum erro seja exibido na janela do terminal, continue no console do AWS IoT .
1. No AWS IoT console, no **cliente de teste do MQTT**, escolha a guia **Publicar em um tópico**.
1. Em **Nome do tópico**, digite **test/dc/subtopic**
1. Em **Carga da mensagem**, examine o conteúdo da mensagem.
1. Selecione **Publicar** para publicar a mensagem MQTT.
1. Na janela do terminal, observe a entrada da *mensagem recebida* do AWS IoT Device Client que se parece com esta.
```
2021-11-10T16:02:20.890Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 45 bytes
```
1. Depois de ver a entrada da *mensagem recebida* que mostra que a mensagem foi recebida, digite **^C** (Ctrl-C) para interromper o AWS IoT Device Client.
1. Insira o seguinte comando para visualizar o final do arquivo de log de mensagens e ver a mensagem que foi publicada no **cliente de teste MQTT**.
```
tail ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
```
Ao visualizar a mensagem no arquivo de log, demonstrou-se que o AWS IoT Device Client recebeu a mensagem publicada a partir do cliente de teste MQTT.
## Assinar diversos tópicos de mensagens MQTT usando caracteres curinga
Esses procedimentos demonstram como o AWS IoT Device Client pode assinar e registrar mensagens MQTT usando caracteres curinga. Para fazer isso, você deve:
1. Atualize o filtro de tópicos que o AWS IoT Device Client usa para assinar tópicos do MQTT.
1. Atualizar a política usada pelo dispositivo para permitir novas assinaturas.
1. Execute o AWS IoT Device Client e publique mensagens do console de teste do MQTT.
**Para criar um arquivo de configuração para assinar diversos tópicos de mensagens MQTT com um filtro de tópicos MQTT curinga**
1. Na janela do terminal do computador host local que está conectado ao Raspberry Pi, abra **\$1/dc-configs/dc-pubsub-custom-config.json** para edição e localize o objeto `samples`.
1. No editor de texto, localize o objeto `samples` e atualize o valor de `subscribe-topic` para que se assemelhe a isto.
```
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/#",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
```
O novo valor de `subscribe-topic` é um [filtro de tópicos MQTT](topics.md#topicfilters) com um caractere curinga MQTT no final. Isso descreve uma assinatura de todos os tópicos MQTT que começam com `test/dc/`. O AWS IoT Device Client grava as cargas de mensagens que recebe dessa assinatura no arquivo nomeado em`subscribe-file`.
1. Salve o arquivo de configuração modificado como **\$1/dc-configs/dc-pubsub-wild-config.json** e saia do editor de texto.
**Para modificar a política usada pelo Raspberry Pi para permitir a assinatura e recebimento de diversos tópicos de mensagens MQTT**
1. Na janela do terminal do seu computador host local conectado ao Raspberry Pi, em seu editor de texto favorito, abra **\$1/policies/pubsub\$1test\$1thing\$1policy.json** para edição e, depois, localize as declarações de política `iot::Subscribe` e `iot::Receive` no arquivo.
1. Na declaração de política `iot::Subscribe`, atualize a string no objeto Resource para substituir `subtopic` por `*`, de modo que fique semelhante ao seguinte.
```
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/*"
]
}
```
**nota**
Os [caracteres curinga do filtro de tópicos MQTT](topics.md#topicfilters) são `+` (sinal de adição) e `#` (sinal de jogo da velha). Uma solicitação de assinatura com `#` no final assina todos os tópicos que começam com a string que precede o caractere `#` (como, nesse caso, `test/dc/`).
Entretanto, o valor do recurso na declaração de política autorizando essa assinatura deve usar `*` (asterisco) no lugar de `#` (sinal de jogo da velha) no ARN do filtro de tópicos. Isso ocorre porque o processador de políticas usa um caractere curinga diferente daquele usado pelo MQTT.
Para acessar mais informações sobre como usar caracteres curinga para tópicos e filtros de tópicos em políticas, consulte [Usando caracteres curinga no MQTT e nas políticas AWS IoT Core](pub-sub-policy.md#pub-sub-policy-cert).
1. Na declaração de política `iot::Receive`, atualize a string no objeto Resource para substituir `subtopic` por `*`, de modo que fique semelhante ao seguinte.
```
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*"
]
}
```
1. Salve o documento de política atualizado como **\$1/policies/pubsub\$1wild\$1test\$1thing\$1policy.json** e saia do editor.
1. Insira o seguinte comando para atualizar a política deste tutorial para usar as novas definições de recursos.
```
aws iot create-policy-version \
--set-as-default \
--policy-name "PubSubTestThingPolicy" \
--policy-document "file://~/policies/pubsub_wild_test_thing_policy.json"
```
Em caso de êxito, ele retornará uma resposta como a seguinte. Observe que `policyVersionId` agora é `2`, o que indica que esta é a segunda versão desta política.
Se você obteve êxito em atualizar a política, avance para o próximo procedimento.
```
{
"policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/PubSubTestThingPolicy",
"policyDocument": "{\n \"Version\": \"2012-10-17\", \n \"Statement\": [\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Connect\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Publish\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Subscribe\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/*\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Receive\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n ]\n }\n ]\n}\n",
"policyVersionId": "2",
"isDefaultVersion": true
}
```
Caso receba um erro informando que há versões da política demais para que uma nova seja salva, insira o seguinte comando para listar as versões atuais da política. Examine a lista retornada pelo comando a seguir para encontrar uma versão da política que possa ser excluída.
```
aws iot list-policy-versions --policy-name "PubSubTestThingPolicy"
```
Digite o comando a seguir para excluir uma versão que não é mais necessária. Não é possível excluir a versão padrão da política. A versão padrão da política é aquela com um valor de `isDefaultVersion` de `true`.
```
aws iot delete-policy-version \
--policy-name "PubSubTestThingPolicy" \
--policy-version-id policyId
```
Depois de excluir uma versão da política, tente a etapa novamente.
Com o arquivo de configuração e a política atualizados, você está pronto para demonstrar assinaturas curinga com o AWS IoT Device Client.
**Para demonstrar como o AWS IoT Device Client assina e recebe vários tópicos de mensagens do MQTT**
1. No **cliente de teste MQTT**, verifique as assinaturas. Se o **cliente de teste MQTT** for assinante do filtro de tópicos **\$1**, avance para a próxima etapa. Caso contrário, no **cliente de teste do MQTT**, na guia **Assinar um tópico**, em **Filtro de tópicos**, insira **\$1** (caractere de cerquilha) e escolha **Assinar** para assinar.
1. Na janela do terminal do computador host local conectado ao Raspberry Pi, execute os comandos a seguir para iniciar o AWS IoT Device Client.
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-wild-config.json
```
1. Enquanto observa a saída do AWS IoT Device Client na janela do terminal no computador host local, retorne ao **cliente de teste MQTT**. Na guia **Publicar em um tópico**, em **Nome do tópico**, insira **test/dc/subtopic** e selecione **Publicar**.
1. Na janela do terminal, confirme se a mensagem foi recebida procurando uma mensagem como:
```
2021-11-10T16:34:20.101Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 76 bytes
```
1. Enquanto observa a saída do AWS IoT Device Client na janela do terminal do computador host local, retorne ao **cliente de teste MQTT**. Na guia **Publicar em um tópico**, em **Nome do tópico**, insira **test/dc/subtopic2** e selecione **Publicar**.
1. Na janela do terminal, confirme se a mensagem foi recebida procurando uma mensagem como:
```
2021-11-10T16:34:32.078Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 77 bytes
```
1. Depois de ver as mensagens que confirmam que ambas foram recebidas, digite **^C** (Ctrl-C) para interromper o AWS IoT Device Client.
1. Insira o seguinte comando para visualizar o final do arquivo de log de mensagens e ver a mensagem que foi publicada no **cliente de teste MQTT**.
```
tail -n 20 ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
```
**nota**
O arquivo de log contém somente cargas de mensagens. Os tópicos de mensagens não são registrados no arquivo de log de mensagens recebidas.
Você também pode ver a mensagem publicada pelo AWS IoT Device Client no registro recebido. Isso ocorre porque o filtro de tópicos curinga inclui esse tópico de mensagem e, por vezes, a solicitação de assinatura pode ser processada pelo agente de mensagens antes que a mensagem publicada seja enviada aos assinantes.
As entradas no arquivo de log apontam que as mensagens foram recebidas. É possível repetir esse procedimento usando outros nomes de tópicos. Todas as mensagens com um nome de tópico que comece com `test/dc/` devem ser recebidas e registradas em log. Mensagens com nomes de tópicos começando com outro texto são ignoradas.
Depois de demonstrar como o AWS IoT Device Client pode publicar e assinar mensagens MQTT, continue. [Tutorial: Demonstre ações remotas (trabalhos) com o AWS IoT Device Client](iot-dc-runjobs.md)