

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

# Preparar o Raspberry Pi para demonstrar a comunicação de mensagens MQTT
<a name="iot-dc-testconn-provision"></a>

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
<a name="iot-dc-testconn-provision-certs"></a>

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
<a name="iot-dc-testconn-provision-aws"></a>

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
<a name="iot-dc-testconn-provision-dc-config"></a>

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