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á.
# Configurar o dispositivo
Esta seção descreve como configurar seu dispositivo para se conectar ao AWS IoT Core. Se quiser começar, AWS IoT Core mas ainda não tiver um dispositivo, você pode criar um dispositivo virtual usando o Amazon EC2 ou usar seu PC Windows ou Mac como um dispositivo de IoT.
Selecione a melhor opção de dispositivo para você experimentar AWS IoT Core. Evidente, é possível testar todos eles, mas o faça com apenas um de cada vez. Se não tiver certeza sobre qual a melhor opção de dispositivo para você, leia sobre como decidir [qual opção de dispositivo é a melhor](iot-gs-first-thing.md#choosing-a-gs-system) e volte para esta página.
**Opções do dispositivo**
+ [Criar um dispositivo virtual com o Amazon EC2](creating-a-virtual-thing.md)
+ [Use seu PC Windows ou Linux ou Mac como um AWS IoT dispositivo](using-laptop-as-device.md)
+ [Conectar um Raspberry Pi ou outro dispositivo](connecting-to-existing-device.md)
# Criar um dispositivo virtual com o Amazon EC2
Neste tutorial, você criará uma instância do Amazon EC2 para atuar como seu dispositivo virtual na nuvem.
Para concluir este tutorial, você precisa de um Conta da AWS. Se você não possuir uma, conclua as etapas descritas em [Configurar Conta da AWS](setting-up.md) antes de continuar.
**Topics**
+ [Configurar uma instância do Amazon EC2](#set-up-ec2)
+ [Instale o Git, Node.js e configure o AWS CLI](#install-git-node)
+ [Crie AWS IoT recursos para seu dispositivo virtual](#ec2-create-certificate)
+ [Instale o AWS IoT Device SDK para JavaScript](#ec2-sdk)
+ [Executar os aplicativos de exemplo](#ec2-run-app)
+ [Exibir mensagens do aplicativo de amostra no AWS IoT console](#ec2-view-msg)
## Configurar uma instância do Amazon EC2
As etapas a seguir demonstram como criar uma instância do Amazon EC2 que atuará como seu dispositivo virtual no lugar de um dispositivo físico.
Se esta é a primeira vez que você cria uma instância do Amazon EC2, você pode achar que as instruções em [Comece a usar as instâncias do Amazon EC2 Linux](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/EC2_GetStarted.html) são mais úteis.
**Como iniciar uma instância**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. A partir do menu do console à esquerda, expanda a seção **Instâncias** e selecione **Instâncias**. A partir do painel **Instâncias**, selecione **Iniciar instâncias** à direita para exibir uma lista de configurações básicas.
1. Na seção **Nome e tags**, digite um nome para a instância e, opcionalmente, adicione tags.
1. Na seção **Imagens de aplicações e sistemas operacionais (imagem de máquina da Amazon)**, selecione um modelo de AMI para a sua instância, como *AMI do Amazon Linux 2 (HVM)*. Observe que essas AMIs estão marcadas como “Qualificáveis para nível gratuito”.
1. Na página **Selecione um tipo de instância**, você pode selecionar a configuração de hardware da instância. Selecione o tipo `t2.micro`, que é selecionado por padrão. Observe que este tipo de instância está qualificado para o nível gratuito.
1. Na seção **Par de chaves (login)**, selecione um nome de par de chaves na lista suspensa ou selecione **Criar um novo par de chaves** para criar um novo. Quando criar um novo par de chaves, certifique-se de baixar o arquivo de chave privada e salvá-lo em um local seguro, pois essa é sua única oportunidade de baixá-lo e salvá-lo. Você precisará fornecer o nome do par de chaves ao iniciar uma instância e a chave privada correspondente sempre que se conectar à instância.
**Atenção**
Não selecione a opção **Prosseguir sem um par de chaves**. Se você executar sua instância sem um par de chaves, você não poderá conectá-la.
1. Você pode manter as configurações padrão da seção **Configurações de rede** e da seção **Configurar armazenamento**. Quando tudo estiver pronto, selecione **Iniciar instância**.
1. Uma página de confirmação informa que sua instância está sendo executada. Selecione **Visualizar instâncias** para fechar a página de confirmação e voltar ao console.
1. Na tela **Instances**, é possível visualizar o status da execução. Demora um pouco para executar uma instância. Ao executar uma instância, seu estado inicial é `pending`. Após a inicialização da instância, seu estado muda para `running` e ela recebe um nome DNS público. (Se a coluna **DNS público (IPv4)** estiver oculta, escolha **Mostrar/ocultar colunas** (o ícone em forma de engrenagem) no canto superior direito da página e selecione DNS **público** ().) IPv4
1. Pode levar alguns minutos até que a instância esteja pronta para que você possa se conectar a ela. Certifique-se de que sua instância tenha sido aprovada nas verificações de status. É possível visualizar essas informações na coluna **Status Checks**.
Quando a nova instância passar pelas verificações de status, prossiga para o próximo procedimento e conecte-se a ela.
**Para se conectar à sua instância**
Você pode se conectar a uma instância usando o cliente baseado em navegador selecionando a instância no console do Amazon EC2 e optando por se conectar usando o Amazon EC2 Instance Connect. O Instance Connect lida com as permissões e fornece uma conexão bem-sucedida.
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No menu esquerdo, selecione **Instâncias**.
1. Selecione a instância e escolha **Conectar**.
1. Selecione **Amazon EC2 Instance Connect**, **Connect**.
Agora você deve poder ver uma janela do **Amazon EC2 Instance Connect** conectada à nova instância do Amazon EC2.
## Instale o Git, Node.js e configure o AWS CLI
Nesta seção, você instalará o Git e o Node.js em sua instância do Linux.
**Para instalar o Git**
1. Na janela do **Amazon EC2 Instance Connect**, atualize sua instância com o seguinte comando.
```
sudo yum update -y
```
1. Na janela do **Amazon EC2 Instance Connect**, instale o Git com o seguinte comando.
```
sudo yum install git -y
```
1. Para verificar se o Git foi instalado e a versão atual do Git, execute o comando a seguir:
```
git --version
```
**Para instalar o Node.js**
1. Na janela do **Amazon EC2 Instance Connect**, instale o gerenciador de versão do node (nvm) com o seguinte comando.
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.34.0/install.sh | bash
```
Usaremos o nvm para instalar o Node.js, pois o nvm pode instalar várias versões do Node.js e permitir que você alterne entre elas.
1. Na janela do **Amazon EC2 Instance Connect**, ative o nvm com o seguinte comando.
```
. ~/.nvm/nvm.sh
```
1. Na janela do **Amazon EC2 Instance Connect**, use o nvm para instalar a versão mais recente do Node.js com o seguinte comando.
```
nvm install 16
```
**nota**
Isso instalará a versão LTS mais recente do Node.js.
Instalar Node.js também instala o gerenciador de pacotes do nó (npm, do inglês "node package manager") para que você possa instalar módulos adicionais, conforme necessário.
1. Na janela do **Amazon EC2 Instance Connect**, teste se o Node.js está instalado e funcionando corretamente com o seguinte comando.
```
node -e "console.log('Running Node.js ' + process.version)"
```
Este tutorial requer o Node v10.0 ou uma versão posterior. Para acessar mais informações, consulte [Tutorial: configuração do Node.js em uma instância do Amazon EC2](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-up-node-on-ec2-instance.html).
**Para configurar AWS CLI**
Sua instância do Amazon EC2 vem pré-carregada com a AWS CLI. No entanto, você deve preencher seu AWS CLI perfil. Para acessar mais informações sobre como configurar a CLI, consulte [Configurar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).
1. O exemplo a seguir mostra valores de exemplo. Substitua os valores pelos seus próprios valores. É possível encontrar esses valores no [AWS console nas informações da sua conta em **Credenciais de segurança**](https://console.aws.amazon.com//iam/home#/security_credentials).
Na janela do **Amazon EC2 Instance Connect**, insira este comando:
```
aws configure
```
Depois, insira os valores da sua conta nas solicitações exibidas.
```
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-west-2
Default output format [None]: json
```
1. Você pode testar sua AWS CLI configuração com este comando:
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Se o seu AWS CLI estiver configurado corretamente, o comando deverá retornar um endereço de endpoint do seu Conta da AWS.
## Crie AWS IoT recursos para seu dispositivo virtual
Esta seção descreve como usar o AWS CLI para criar o objeto objeto e seus arquivos de certificado diretamente no dispositivo virtual. Isso é realizado diretamente no dispositivo para evitar possíveis complicações que possam surgir ao copiá-los para o dispositivo de outro computador. Nesta seção, você criará os recursos a seguir para o dispositivo virtual:
+ Um objeto em que representar seu dispositivo virtual AWS IoT.
+ Um certificado para autenticar um dispositivo virtual.
+ Um documento de política autorizando seu dispositivo virtual a se conectar ao AWS IoT e publicar, receber e assinar mensagens.
**Para criar um objeto de AWS IoT coisa na sua instância Linux**
Os dispositivos conectados AWS IoT são representados por *objetos de coisas* no AWS IoT registro. Um *objeto* representa um dispositivo específico ou uma entidade lógica. Neste caso, seu *objeto* representará seu dispositivo virtual, esta instância do Amazon EC2.
1. Na janela do **Amazon EC2 Instance Connect**, execute o seguinte comando para criar seu objeto.
```
aws iot create-thing --thing-name "MyIotThing"
```
1. O resultado do JSON deve ser semelhante a esta:
```
{
"thingArn": "arn:aws:iot:your-region:your-aws-account:thing/MyIotThing",
"thingName": "MyIotThing",
"thingId": "6cf922a8-d8ea-4136-f3401EXAMPLE"
}
```
**Para criar e anexar AWS IoT chaves e certificados em sua instância Linux**
O comando **[create-keys-and-certificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/create-keys-and-certificate.html)** cria certificados de cliente assinados pela autoridade de certificação raiz da Amazon. Esse certificado é usado para autenticar a identidade do dispositivo virtual.
1. Na janela do **Amazon EC2 Instance Connect**, crie um diretório para armazenar os arquivos de certificado e chave.
```
mkdir ~/certs
```
1. Na janela do **Amazon EC2 Instance Connect**, baixe uma cópia do certificado da autoridade de certificação (CA) da Amazon com o comando a seguir.
```
curl -o ~/certs/Amazon-root-CA-1.pem \
https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
1. Na janela do **Amazon EC2 Instance Connect**, execute o seguinte comando para criar sua chave privada, chave pública e arquivos de certificado X.509. Esse comando também registra e ativa o certificado com. AWS IoT
```
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "~/certs/device.pem.crt" \
--public-key-outfile "~/certs/public.pem.key" \
--private-key-outfile "~/certs/private.pem.key"
```
A resposta é semelhante à seguinte. Salve o `certificateArn` para usá-lo em comandos subsequentes. Você precisará dele para anexar seu certificado à suo objeto e anexar a política ao certificado em etapas futuras.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/9894ba17925e663f1d29c23af4582b8e3b7619c31f3fbd93adcb51ae54b83dc2",
"certificateId": "9894ba17925e663f1d29c23af4582b8e3b7619c31f3fbd93adcb51ae54b83dc2",
"certificatePem": "
-----BEGIN CERTIFICATE-----
MIICiTCCEXAMPLE6m7oRw0uXOjANBgkqhkiG9w0BAQUFADCBiDELMAkGA1UEBhMC
VVMxCzAJBgNVBAgEXAMPLEAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6
b24xFDASBgNVBAsTC0lBTSEXAMPLE2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAd
BgkqhkiG9w0BCQEWEG5vb25lQGFtYEXAMPLEb20wHhcNMTEwNDI1MjA0NTIxWhcN
MTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBhMCEXAMPLEJBgNVBAgTAldBMRAwDgYD
VQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDAEXAMPLEsTC0lBTSBDb25z
b2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEXAMPLE25lQGFt
YXpvbi5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMaK0dn+aEXAMPLE
EXAMPLEfEvySWtC2XADZ4nB+BLYgVIk60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9T
rDHudUZEXAMPLELG5M43q7Wgc/MbQITxOUSQv7c7ugFFDzQGBzZswY6786m86gpE
Ibb3OhjZnzcvQAEXAMPLEWIMm2nrAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4
nUhVVxYUntneD9+h8Mg9qEXAMPLEyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0Fkb
FFBjvSfpJIlJ00zbhNYS5f6GuoEDEXAMPLEBHjJnyp378OD8uTs7fLvjx79LjSTb
NYiytVbZPQUQ5Yaxu2jXnimvw3rrszlaEXAMPLE=
-----END CERTIFICATE-----\n",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\nMMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\n59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\nhJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\nFQIDAQAB\n-----END PUBLIC KEY-----\n",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nkey omitted for security reasons\n-----END RSA PRIVATE KEY-----\n"
}
}
```
1. Na janela do **Amazon EC2 Instance Connect**, anexe seu objeto ao certificado que você acabou de criar usando o comando a seguir e a *certificateArn* resposta do comando anterior.
```
aws iot attach-thing-principal \
--thing-name "MyIotThing" \
--principal "certificateArn"
```
Se obtiver êxito, esse comando não retornará nenhuma saída.
**Para criar e anexar uma política**
1. Na janela do **Amazon EC2 Instance Connect**, crie o arquivo de política copiando e colando este documento de política em um arquivo nomeado **\$1/policy.json**.
Se você não tiver um editor do Linux de preferência, pode abrir **nano** usando o seguinte comando.
```
nano ~/policy.json
```
Cole o documento de política para `policy.json` nele. Pressione ctrl\$1x para sair do editor **nano** e salve o arquivo.
Conteúdo do documento de política para `policy.json`.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect"
],
"Resource": [
"*"
]
}
]
}
```
1. Na janela do **Amazon EC2 Instance Connect**, crie sua política com o comando a seguir.
```
aws iot create-policy \
--policy-name "MyIotThingPolicy" \
--policy-document "file://~/policy.json"
```
Saída:
****
```
{
"policyName": "MyIotThingPolicy",
"policyArn": "arn:aws:iot:us-east-1:your-aws-account:policy/MyIotThingPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Receive\",
\"iot:Subscribe\",
\"iot:Connect\"
],
\"Resource\": [
\"*\"
]
}
]
}",
"policyVersionId": "1"
}
```
1. Na janela do **Amazon EC2 Instance Connect**, anexe a política ao certificado do dispositivo virtual com o comando a seguir.
```
aws iot attach-policy \
--policy-name "MyIotThingPolicy" \
--target "certificateArn"
```
Se obtiver êxito, esse comando não retornará nenhuma saída.
## Instale o AWS IoT Device SDK para JavaScript
Nesta seção, você instalará o AWS IoT Device SDK for JavaScript, que contém o código que os aplicativos podem usar para se comunicar AWS IoT e os programas de amostra. Para obter mais informações, consulte o [AWS IoT Device SDK para JavaScript GitHub repositório](https://github.com/aws/aws-iot-device-sdk-js-v2).
**Para instalar o AWS IoT Device SDK JavaScript em sua instância Linux**
1. Na janela do **Amazon EC2 Instance Connect**, clone o AWS IoT Device SDK para JavaScript repositório no `aws-iot-device-sdk-js-v2` diretório do seu diretório inicial usando este comando.
```
cd ~
git clone https://github.com/aws/aws-iot-device-sdk-js-v2.git
```
1. Navegue até o diretório `aws-iot-device-sdk-js-v2` criado na etapa anterior.
```
cd aws-iot-device-sdk-js-v2
```
1. Use npm para instalar o SDK.
```
npm install
```
## Executar os aplicativos de exemplo
Os comandos das próximas seções pressupõem que seus arquivos de chave e certificado estão armazenados em seu dispositivo virtual, conforme mostrado na seguinte tabela.
**Nomes de arquivos de certificado**
| Arquivo | Caminho do arquivo |
| --- | --- |
| Chave privada | `~/certs/private.pem.key` |
| Certificado de dispositivo | `~/certs/device.pem.crt` |
| Certificado CA raiz | `~/certs/Amazon-root-CA-1.pem` |
Nesta seção, você instalará e executará o aplicativo de `pub-sub.js` amostra encontrado no `aws-iot-device-sdk-js-v2/samples/node` diretório do AWS IoT Device SDK for JavaScript. Este aplicativo mostra a maneira como um dispositivo, sua instância do Amazon EC2, usa a biblioteca MQTT para publicar e assinar mensagens MQTT. O aplicativo de exemplo `pub-sub.js` assina um tópico, `topic_1`, publica 10 mensagens no tópico e exibe as mensagens à medida que elas são recebidas do agente de mensagens.
**Para instalar e executar o aplicativo de exemplo**
1. Na janela do **Amazon EC2 Instance Connect**, navegue até o diretório `aws-iot-device-sdk-js-v2/samples/node/pub_sub` criado pelo SDK e instale o aplicativo de exemplo com os seguintes comandos.
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
npm install
```
1. Em sua janela do **Amazon EC2 Instance Connect**, obtenha *your-iot-endpoint* AWS IoT usando este comando.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
1. Na janela do **Amazon EC2 Instance Connect**, insira *your-iot-endpoint* conforme indicado e execute esse comando.
```
node dist/index.js --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
```
O aplicativo de exemplo:
1. Conecta-se AWS IoT Core à sua conta.
1. Assina o tópico de mensagens **topic\$11** e exibe as mensagens recebidas sobre esse tópico.
1. Publica 10 mensagens no tópico **topic\$11**.
1. Exibe uma saída semelhante à seguinte:
```
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":1}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":2}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":3}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":4}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":5}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":6}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":7}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":8}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":9}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":10}
```
Se você estiver com problemas para executar a aplicação de exemplo, examine [Solucionar problemas com a aplicação de amostra](gs-device-troubleshoot.md).
Também é possível adicionar o parâmetro `--verbosity debug` à linha de comando para que o aplicativo de exemplo exiba mensagens detalhadas sobre sua operação. Essas informações podem fornecer a ajuda necessária para você corrigir o problema.
## Exibir mensagens do aplicativo de amostra no AWS IoT console
É possível ver as mensagens do aplicativo de exemplo à medida que elas passam pelo agente de mensagens usando o **cliente de teste MQTT** no **console do AWS IoT **.
**Para visualizar as mensagens MQTT publicadas pelo aplicativo de exemplo**
1. Consulte [Exibir mensagens MQTT com o cliente AWS IoT MQTT](view-mqtt-messages.md). Isso ajudará você a aprender a usar o **cliente de teste MQTT** no **console do AWS IoT ** para visualizar as mensagens MQTT à medida que elas passam pelo agente de mensagens.
1. Abra o **cliente de teste MQTT** no **console do AWS IoT **.
1. Em **Assinar um tópico**, assine o tópico **topic\$11**.
1. Na janela do **Amazon EC2 Instance Connect**, execute o aplicativo de exemplo novamente e observe as mensagens no **cliente de teste MQTT** no **console do AWS IoT **.
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
node dist/index.js --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
```
Para obter mais informações sobre o MQTT e como é AWS IoT Core compatível com o protocolo, consulte [MQTT](https://docs.aws.amazon.com//iot/latest/developerguide/mqtt.html).
# Use seu PC Windows ou Linux ou Mac como um AWS IoT dispositivo
Neste tutorial, você configurará um computador pessoal para uso com AWS IoT. Essas instruções são compatíveis com Windows, Linux PCs e Macs. Para concluir este tutorial, você precisará instalar alguns softwares no seu computador. Se não quiser instalar software no seu computador, você pode tentar [Criar um dispositivo virtual com o Amazon EC2](creating-a-virtual-thing.md) e instalar todos os softwares em uma máquina virtual.
**Topics**
+ [Configurar seu computador pessoal](#gs-pc-prereqs)
+ [Instale o Git, o Python e o Device SDK para Python AWS IoT](#gs-pc-sdk-node)
+ [Configurar a política e executar o aplicativo de exemplo](#gs-pc-python-app-run)
+ [Exibir mensagens do aplicativo de amostra no AWS IoT console](#gs-pc-view-msg)
+ [Execute o exemplo de assinatura compartilhada em Python](#gs-pc-shared-subscription-example)
## Configurar seu computador pessoal
Para concluir este tutorial, será preciso um PC com Windows ou Linux ou de um Mac com conexão à Internet.
Antes de avançar para a próxima etapa, verifique se você pode abrir uma janela de linha de comando no computador. Em um PC com Windows, use **cmd.exe**. Em um PC com Linux ou em um Mac, use **Terminal**.
## Instale o Git, o Python e o Device SDK para Python AWS IoT
Nesta seção, você instalará o Python e o AWS IoT Device SDK for Python em seu computador.
### Instalar a versão mais recente do Git e do Python
Este procedimento explica como instalar a versão mais recente do Git e do Python em seu computador pessoal.
**Para baixar e instalar o Git e o Python em seu computador**
1. Verifique se você possui o Git já instalado no computador. Insira este comando na linha de comando.
```
git --version
```
Se o comando exibir a versão do Git, o Git está instalado e você pode avançar para a próxima etapa.
Caso o comando exiba um erro, abra [https://git-scm.com/download](https://git-scm.com/download) e instale o Git em seu computador.
1. Verifique se você já possui o Python instalado. Insira o seguinte comando na linha de comando.
```
python -V
```
**nota**
Se esse comando exibir um erro: `Python was not found`, pode ser que seu sistema operacional chame o executável Python v3.x como `Python3`. Nesse caso, substitua todas as instâncias de `python` com `python3` e siga com o resto deste tutorial.
Se o comando exibir a versão do Python, então o Python já está instalado. Este tutorial requer o Python v3.7 ou uma versão posterior.
1. Se o Python já estiver instalado, você pode ignorar o restante das etapas desta seção. Se não estiver, então continue.
1. Abra [https://www.python.org/downloads/](https://www.python.org/downloads/) e baixe o instalador para o seu computador.
1. Se o download não começar a instalação automaticamente, execute o programa baixado para instalar o Python.
1. Verifique a instalação do Python.
```
python -V
```
Confirme se o comando exibe a versão do Python. Se a versão do Python não for exibida, tente baixar e instalar novamente.
### Instale o AWS IoT Device SDK para Python
**Para instalar o AWS IoT Device SDK para Python em seu computador**
1. Instale a v2 do AWS IoT Device SDK para Python.
```
python3 -m pip install awsiotsdk
```
1. Clone o repositório AWS IoT Device SDK for Python no diretório aws-iot-device-sdk -python-v2 do seu diretório inicial. Esse procedimento se refere ao diretório base dos arquivos como os quais você está instalando*home*.
A localização real do *home* diretório depende do seu sistema operacional.
------
#### [ Linux/macOS ]
No macOS e no Linux, o *home* diretório é. `~`
```
cd ~
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
#### [ Windows ]
No Windows, você pode encontrar o caminho do *home* diretório executando esse comando na `cmd` janela.
```
echo %USERPROFILE%
cd %USERPROFILE%
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
**nota**
Se você estiver usando PowerShell o Windows em vez de**cmd.exe**, use o comando a seguir.
```
echo $home
```
Para obter mais informações, consulte o repositório [AWS IoT Device SDK for GitHub Python](https://github.com/aws/aws-iot-device-sdk-python-v2).
### Preparar-se para executar os aplicativos de exemplo
**Para preparar seu sistema para executar o aplicativo de exemplo**
+ Crie o diretório `certs`. No diretório `certs`, copie a chave privada, o certificado do dispositivo e os arquivos do certificado CA raiz salvos ao criar e registrar o objeto em [Crie AWS IoT recursos](create-iot-resources.md). Os nomes de cada arquivo no diretório de destino devem corresponder àqueles na tabela.
Os comandos na próxima seção pressupõem que seus arquivos de chave e certificado estão armazenados em seu dispositivo, conforme mostrado nesta tabela.
------
#### [ Linux/macOS ]
Execute o seguinte comando para criar o subdiretório `certs` que você usará ao executar os aplicativos de exemplo.
```
mkdir ~/certs
```
No novo subdiretório, copie os arquivos para os caminhos de arquivo de destino exibidos na seguinte tabela.
**Nomes de arquivos de certificado**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/using-laptop-as-device.html)
Execute o seguinte comando para listar os arquivos no diretório `certs` e compare-os com aqueles listados na tabela.
```
ls -l ~/certs
```
------
#### [ Windows ]
Execute o seguinte comando para criar o subdiretório `certs` que você usará ao executar os aplicativos de exemplo.
```
mkdir %USERPROFILE%\certs
```
No novo subdiretório, copie os arquivos para os caminhos de arquivo de destino exibidos na seguinte tabela.
**Nomes de arquivos de certificado**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/using-laptop-as-device.html)
Execute o seguinte comando para listar os arquivos no diretório `certs` e compare-os com aqueles listados na tabela.
```
dir %USERPROFILE%\certs
```
------
## Configurar a política e executar o aplicativo de exemplo
Nesta seção, você configurará sua política e executará o script de exemplo `pubsub.py` encontrado no diretório `aws-iot-device-sdk-python-v2/samples` do AWS IoT Device SDK for Python. Este script mostra a maneira como seu dispositivo usa a biblioteca MQTT para publicar e assinar mensagens MQTT.
O aplicativo de exemplo `pubsub.py` assina um tópico, `test/topic`, publica 10 mensagens no tópico e exibe as mensagens à medida que elas são recebidas do agente de mensagens.
Para executar o script de exemplo `pubsub.py`, você precisa das seguintes informações:
**Valores de parâmetros de aplicação**
| Parâmetro | Onde encontrar o valor |
| --- | --- |
| your-iot-endpoint | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/using-laptop-as-device.html) |
O *your-iot-endpoint* valor tem um formato de:`endpoint_id-ats.iot.region.amazonaws.com`, por exemplo,`a3qj468EXAMPLE-ats.iot.us-west-2.amazonaws.com`.
Antes de executar o script, certifique-se de que a política da suo objeto forneça permissões para o script de exemplo se conectar, assinar, publicar e receber.
**Para encontrar e examinar o documento de política de um recurso de objeto**
1. No [console do AWS IoT](https://console.aws.amazon.com//iot/home#/thinghub), na lista **Objetos**, localize o recurso de objeto que representa o seu dispositivo.
1. Escolha o link **Nome** do recurso de objeto que representa o seu dispositivo para abrir a página de **Detalhes do objeto**.
1. Na página **Detalhes do objeto**, na guia **Certificados**, selecione o certificado anexado ao recurso de objeto. Deve haver apenas um certificado na lista. Se houver mais de um, selecione o certificado cujos arquivos estão instalados no seu dispositivo e que serão usados para se conectar ao AWS IoT Core.
Na página de detalhes do **Certificado**, na guia **Políticas**, selecione a política anexada ao certificado. Deve haver apenas uma. Caso haja mais de uma, repita a próxima etapa para cada uma delas para garantir que ao menos uma política conceda o acesso necessário.
1. Na página de visão geral da **Política**, localize o editor JSON e selecione **Editar documento de política** para revisar e editar o documento de política conforme necessário.
1. O JSON da política é exibido no exemplo a seguir. No `"Resource"` elemento, `region:account` substitua por seu Região da AWS e Conta da AWS em cada um dos `Resource` valores.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/test/topic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/test/topic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:client/test-*"
]
}
]
}
```
------
#### [ Linux/macOS ]
**Para executar o script de exemplo no Linux/macOS**
1. Na janela de linha de comando, navegue até o diretório `~/aws-iot-device-sdk-python-v2/samples/node/pub_sub` criado pelo SDK usando os seguintes comandos.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. Na janela da linha de comando, substitua *your-iot-endpoint* conforme indicado e execute esse comando.
```
python3 pubsub.py --endpoint your-iot-endpoint --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key
```
------
#### [ Windows ]
**Para executar o aplicativo de exemplo em um PC com Windows**
1. Na janela de linha de comando, navegue até o diretório `%USERPROFILE%\aws-iot-device-sdk-python-v2\samples` criado pelo SDK e instale o aplicativo de exemplo usando os seguintes comandos.
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
```
1. Na janela da linha de comando, substitua *your-iot-endpoint* conforme indicado e execute esse comando.
```
python3 pubsub.py --endpoint your-iot-endpoint --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\certs\private.pem.key
```
------
O script de exemplo:
1. Conecta-se ao AWS IoT Core para sua conta.
1. Assina o tópico de mensagens **test/topic** e exibe as mensagens recebidas sobre esse tópico.
1. Publica 10 mensagens no tópico **test/topic**.
1. Exibe uma saída semelhante à seguinte:
```
Connected!
Subscribing to topic 'test/topic'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 10 message(s)
Publishing message to topic 'test/topic': Hello World! [1]
Received message from topic 'test/topic': b'"Hello World! [1]"'
Publishing message to topic 'test/topic': Hello World! [2]
Received message from topic 'test/topic': b'"Hello World! [2]"'
Publishing message to topic 'test/topic': Hello World! [3]
Received message from topic 'test/topic': b'"Hello World! [3]"'
Publishing message to topic 'test/topic': Hello World! [4]
Received message from topic 'test/topic': b'"Hello World! [4]"'
Publishing message to topic 'test/topic': Hello World! [5]
Received message from topic 'test/topic': b'"Hello World! [5]"'
Publishing message to topic 'test/topic': Hello World! [6]
Received message from topic 'test/topic': b'"Hello World! [6]"'
Publishing message to topic 'test/topic': Hello World! [7]
Received message from topic 'test/topic': b'"Hello World! [7]"'
Publishing message to topic 'test/topic': Hello World! [8]
Received message from topic 'test/topic': b'"Hello World! [8]"'
Publishing message to topic 'test/topic': Hello World! [9]
Received message from topic 'test/topic': b'"Hello World! [9]"'
Publishing message to topic 'test/topic': Hello World! [10]
Received message from topic 'test/topic': b'"Hello World! [10]"'
10 message(s) received.
Disconnecting...
Disconnected!
```
Se você estiver com problemas para executar a aplicação de exemplo, examine [Solucionar problemas com a aplicação de amostra](gs-device-troubleshoot.md).
Também é possível adicionar o parâmetro `--verbosity Debug` à linha de comando para que o aplicativo de exemplo exiba mensagens detalhadas sobre sua operação. Essas informações podem ajudar você a corrigir o problema.
## Exibir mensagens do aplicativo de amostra no AWS IoT console
É possível ver as mensagens do aplicativo de exemplo à medida que elas passam pelo agente de mensagens usando o **cliente de teste MQTT** no **console do AWS IoT **.
**Para visualizar as mensagens MQTT publicadas pelo aplicativo de exemplo**
1. Consulte [Exibir mensagens MQTT com o cliente AWS IoT MQTT](view-mqtt-messages.md). Isso ajudará você a aprender a usar o **cliente de teste MQTT** no **console do AWS IoT ** para visualizar as mensagens MQTT à medida que elas passam pelo agente de mensagens.
1. Abra o **cliente de teste MQTT** no **console do AWS IoT **.
1. Em **Assinar um tópico**, assine o tópico **test/topic**.
1. Na janela de linha de comando, execute o aplicativo de exemplo novamente e observe as mensagens no **cliente MQTT** no **console do AWS IoT **.
------
#### [ Linux/macOS ]
```
cd ~/aws-iot-device-sdk-python-v2/samples
python3 pubsub.py --topic test/topic --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
------
#### [ Windows ]
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
python3 pubsub.py --topic test/topic --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\certs\private.pem.key --endpoint your-iot-endpoint
```
------
Para obter mais informações sobre o MQTT e como é AWS IoT Core compatível com o protocolo, consulte [MQTT](https://docs.aws.amazon.com//iot/latest/developerguide/mqtt.html).
## Execute o exemplo de assinatura compartilhada em Python
AWS IoT Core suporta [assinaturas compartilhadas](mqtt.md#mqtt5-shared-subscription) para MQTT 3 e MQTT 5. As assinaturas compartilhadas permitem que vários clientes compartilhem uma assinatura de um tópico e somente um cliente receberá mensagens publicadas nesse tópico usando uma distribuição randomizada. Para usar assinaturas compartilhadas, os clientes assinam o [filtro de tópicos](https://docs.aws.amazon.com//iot/latest/developerguide/topics.html#topicfilters) de uma assinatura compartilhada: `$share/{ShareName}/{TopicFilter}`.
**Para configurar a política e executar o exemplo de assinatura compartilhada**
1. Para executar o exemplo de assinatura compartilhada, é preciso configurar a política da suo objeto conforme documentado em [Assinatura compartilhada do MQTT 5](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/main/samples/mqtt5_shared_subscription.md#mqtt5-shared-subscription).
1. Para executar o exemplo de assinatura compartilhada, execute os comandos a seguir.
------
#### [ Linux/macOS ]
**Para executar o script de exemplo no Linux/macOS**
1. Na janela de linha de comando, navegue até o diretório `~/aws-iot-device-sdk-python-v2/samples` criado pelo SDK usando os seguintes comandos.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. Na janela da linha de comando, substitua *your-iot-endpoint* conforme indicado e execute esse comando.
```
python3 mqtt5_shared_subscription.py --endpoint your-iot-endpoint --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --group_identifier consumer
```
------
#### [ Windows ]
**Para executar o aplicativo de exemplo em um PC com Windows**
1. Na janela de linha de comando, navegue até o diretório `%USERPROFILE%\aws-iot-device-sdk-python-v2\samples` criado pelo SDK e instale o aplicativo de exemplo usando os seguintes comandos.
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
```
1. Na janela da linha de comando, substitua *your-iot-endpoint* conforme indicado e execute esse comando.
```
python3 mqtt5_shared_subscription.py --endpoint your-iot-endpoint --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\certs\private.pem.key --group_identifier consumer
```
------
**nota**
Você pode, opcionalmente, especificar um identificador de grupo com base nas suas necessidades ao executar o exemplo (por exemplo, `--group_identifier consumer`). `python-sample` será o identificador de grupo padrão se você não especificar nenhum.
1. A saída na linha de comando pode se assemelhar ao seguinte:
```
Publisher]: Lifecycle Connection Success
[Publisher]: Connected
Subscriber One]: Lifecycle Connection Success
[Subscriber One]: Connected
Subscriber Two]: Lifecycle Connection Success
[Subscriber Two]: Connected
[Subscriber One]: Subscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber One]: Full subscribed topic is: '$share/consumer/test/topic' with SubAck code: []
[Subscriber Two]: Subscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber Two]: Full subscribed topic is: '$share/consumer/test/topic' with SubAck code: []
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [1]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [2]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [3]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [4]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [5]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [6]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [7]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [8]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [9]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [10]"'
[Subscriber One]: Unsubscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber One]: Full unsubscribed topic is: '$share/consumer/test/topic' with UnsubAck code: []
[Subscriber Two]: Unsubscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber Two]: Full unsubscribed topic is: '$share/consumer/test/topic' with UnsubAck code []
Publisher]: Lifecycle Disconnected
[Publisher]: Lifecycle Stopped
[Publisher]: Fully stopped
Subscriber One]: Lifecycle Disconnected
[Subscriber One]: Lifecycle Stopped
[Subscriber One]: Fully stopped
Subscriber Two]: Lifecycle Disconnected
[Subscriber Two]: Lifecycle Stopped
[Subscriber Two]: Fully stopped
Complete!
```
1. Abra o **cliente de teste MQTT** no **console do AWS IoT **. Em **Assinar um tópico**, assine o tópico da assinatura compartilhada, como: `$share/consumer/test/topic`. Você pode especificar um identificador de grupo com base nas suas necessidades ao executar o exemplo (por exemplo, `--group_identifier consumer`). Se você não especificar um identificador de grupo, o valor padrão será `python-sample`. Para obter mais informações, consulte o [exemplo em Assinatura compartilhada do MQTT 5 em Python](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/main/samples/mqtt5_shared_subscription.md#mqtt5-shared-subscription) e [Assinaturas compartilhadas](mqtt.md#mqtt5-shared-subscription) do *Guia do desenvolvedor do AWS IoT Core *.
Na janela de linha de comando, execute o aplicativo de exemplo novamente e observe a distribuição de mensagens no **cliente de teste MQTT** do **console do AWS IoT ** e na linha de comando.
![\[A página de saída de assinaturas compartilhadas.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/shared-subscription-output.png)
# Conectar um Raspberry Pi ou outro dispositivo
Nesta seção, configuraremos um Raspberry Pi para uso com AWS IoT. Caso tenha outro dispositivo que gostaria de conectar, as instruções do Raspberry Pi incluem referências para ajudá-lo a adaptar essas instruções ao seu dispositivo.
Em geral, isso leva cerca de 20 minutos, mas pode levar mais tempo se você tiver muitas atualizações de software do sistema a serem instaladas.
**Topics**
+ [Configure seu dispositivo](#gs-device-prereqs)
+ [Instale as ferramentas e bibliotecas necessárias para o AWS IoT Device SDK](#gs-device-sdk-tools)
+ [Instale o AWS IoT Device SDK](#gs-device-install-sdk)
+ [Instalar e executar o aplicativo de exemplo](#gs-device-node-app-run)
+ [Exibir mensagens do aplicativo de amostra no AWS IoT console](#gs-device-view-msg)
**Importante**
Adaptar estas instruções a outros dispositivos e sistemas operacionais pode ser um desafio. Você precisará conhecer seu dispositivo o bastante para interpretar estas instruções e aplicá-las ao seu dispositivo.
Se você encontrar dificuldades ao configurar seu dispositivo para AWS IoT, tente uma das outras opções do dispositivo como alternativa, como [Criar um dispositivo virtual com o Amazon EC2](creating-a-virtual-thing.md) ou[Use seu PC Windows ou Linux ou Mac como um AWS IoT dispositivo](using-laptop-as-device.md).
## Configure seu dispositivo
O objetivo desta etapa é coletar o que é preciso para configurar seu dispositivo para que ele possa iniciar o sistema operacional (SO), conectar-se à Internet e permitir que você interaja com ele em uma interface de linha de comando.
Para concluir este tutorial, você precisará do seguinte:
+ Um Conta da AWS. Se você não possuir uma, conclua as etapas descritas em [Configurar Conta da AWS](setting-up.md) antes de continuar.
+ Um [Modelo B do Raspberry Pi 3](https://www.raspberrypi.com/products/) ou modelo mais recente. Pode ser que isso funcione em versões anteriores do Raspberry Pi, mas elas não foram testadas.
+ [Raspberry Pi OS (32 bits)](https://www.raspberrypi.com/software/operating-systems/) ou uma versão posterior. Recomendamos usar a versão mais recente do SO do Raspberry Pi. Versões anteriores do SO podem funcionar, mas não foram testadas.
Para executar este exemplo, não é preciso instalar a área de trabalho com a interface gráfica do usuário (GUI); entretanto, se você é novo ao Raspberry Pi e seu hardware do Raspberry Pi for compatível, usar a área de trabalho com a GUI pode ser mais fácil.
+ Uma Ethernet ou WiFi conexão.
+ Teclado, mouse, monitor, cabos, fontes de alimentação e outros itens de hardware necessários ao seu dispositivo.
**Importante**
Antes de avançar para a próxima etapa, seu dispositivo deve ter o sistema operacional instalado, configurado e em execução. O dispositivo deve estar conectado à Internet e você precisa ser capaz de acessá-lo usando sua interface de linha de comando. O acesso à linha de comando pode ser realizado através de um teclado, mouse e monitor conectados diretamente ou usando uma interface remota do terminal SSH.
Se estiver executando um sistema operacional em seu Raspberry Pi que possua uma interface gráfica de usuário (GUI), abra uma janela de terminal no dispositivo e conclua as instruções a seguir nessa janela. Caso contrário, se estiver se conectando ao seu dispositivo usando um terminal remoto, como o PuTTY, abra um terminal remoto no seu dispositivo e use-o.
## Instale as ferramentas e bibliotecas necessárias para o AWS IoT Device SDK
Antes de instalar o AWS IoT Device SDK e o código de amostra, verifique se o sistema está atualizado e tem as ferramentas e bibliotecas necessárias para instalar o. SDKs
1.
**Atualize o sistema operacional e instale as bibliotecas necessárias**
Antes de instalar um AWS IoT Device SDK, execute esses comandos em uma janela de terminal em seu dispositivo para atualizar o sistema operacional e instalar as bibliotecas necessárias.
```
sudo apt-get update
```
```
sudo apt-get upgrade
```
```
sudo apt-get install cmake
```
```
sudo apt-get install libssl-dev
```
1.
**Instale o Git**
Se o sistema operacional do seu dispositivo não vem com o Git instalado, você deve instalá-lo para instalar o AWS IoT Device SDK for. JavaScript
1. Teste para verificar se o Git já está instalado executando o seguinte comando.
```
git --version
```
1. Se o comando anterior retornar a versão do Git, então o Git já está instalado e você pode avançar para a Etapa 3.
1. Se for exibido um erro ao executar o comando **git**, instale o Git executando o seguinte comando.
```
sudo apt-get install git
```
1. Teste novamente para verificar se o Git está instalado executando o seguinte comando.
```
git --version
```
1. Se o Git estiver instalado, avance para a próxima seção. Caso contrário, solucione o problema e corrija o erro antes de prosseguir. Você precisa do Git para instalar o AWS IoT Device SDK para. JavaScript
## Instale o AWS IoT Device SDK
Instale o AWS IoT Device SDK.
------
#### [ Python ]
Nesta seção, você instalará o Python, suas ferramentas de desenvolvimento e o AWS IoT Device SDK for Python em seu dispositivo. Estas instruções são para um Raspberry Pi executando o sistema operacional mais recente do Raspberry Pi. Caso tenha outro dispositivo ou esteja usando outro sistema operacional, pode ser preciso adaptar estas instruções para o dispositivo.
1.
**Instale o Python e suas ferramentas de desenvolvimento**
O AWS IoT Device SDK para Python exige que o Python v3.5 ou posterior esteja instalado no seu Raspberry Pi.
Em uma janela de terminal do seu dispositivo, execute os comandos a seguir.
1. Execute o seguinte comando para determinar a versão do Python que está instalada no dispositivo.
```
python3 --version
```
Se o Python estiver instalado, ele exibirá a versão.
1. Se a versão exibida for `Python 3.5` ou superior, você pode avançar para a Etapa 2.
1. Se a versão exibida for inferior a `Python 3.5`, você pode instalar a versão correta executando o comando a seguir.
```
sudo apt install python3
```
1. Execute o seguinte comando para confirmar que a versão correta do Python foi instalada.
```
python3 --version
```
1.
**Teste para pip3**
Em uma janela de terminal do seu dispositivo, execute os comandos a seguir.
1. Execute o seguinte comando para verificar se **pip3** está instalado.
```
pip3 --version
```
1. Se o comando retornar um número de versão, então o **pip3** está instalado e você pode avançar para a Etapa 3.
1. Se o comando anterior retornar um erro, execute o seguinte comando para instalar o **pip3**.
```
sudo apt install python3-pip
```
1. Execute o seguinte comando para verificar se **pip3** está instalado.
```
pip3 --version
```
1.
**Instale o AWS IoT Device SDK atual para Python**
Instale o AWS IoT Device SDK para Python e baixe os aplicativos de amostra em seu dispositivo.
No seu dispositivo, execute os comandos a seguir.
```
cd ~
python3 -m pip install awsiotsdk
```
```
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
#### [ JavaScript ]
Nesta seção, você instalará o Node.js, o gerenciador de pacotes npm e o AWS IoT Device SDK for JavaScript em seu dispositivo. Estas instruções são para um Raspberry Pi executando o sistema operacional do Raspberry Pi. Caso tenha outro dispositivo ou esteja usando outro sistema operacional, pode ser preciso adaptar estas instruções para o dispositivo.
1.
**Instalar a versão mais recente do Node.js**
O AWS IoT Device SDK for JavaScript requer que o Node.js e o gerenciador de pacotes npm estejam instalados no seu Raspberry Pi.
1. Baixe a versão mais recente do repositório do Node digitando o seguinte comando.
```
cd ~
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
```
1. Instale o Node e o npm.
```
sudo apt-get install -y nodejs
```
1. Verifique a instalação do Node.
```
node -v
```
Confirme se o comando exibe a versão do Node. Este tutorial requer o Node v10.0 ou uma versão posterior. Se a versão do Node não for exibida, tente baixar o repositório do Node mais uma vez.
1. Verifique a instalação do npm.
```
npm -v
```
Confirme se o comando exibe a versão do npm. Se a versão do npm não for exibida, tente instalar o Node e o npm mais uma vez.
1. Reinicie o dispositivo.
```
sudo shutdown -r 0
```
Continue depois que o dispositivo for reiniciado.
1.
**Instale o AWS IoT Device SDK para JavaScript**
Instale o AWS IoT Device SDK para JavaScript em seu Raspberry Pi.
1. Clone o AWS IoT Device SDK for JavaScript repository no `aws-iot-device-sdk-js-v2` diretório do seu diretório. *home* No Raspberry Pi, o *home* diretório é`~/`, que é usado como *home* diretório nos comandos a seguir. Se o seu dispositivo usa um caminho diferente para o *home* diretório, você deve `~/` substituir pelo caminho correto para o seu dispositivo nos comandos a seguir.
Estes comandos criam o diretório `~/aws-iot-device-sdk-js-v2` e copiam o código do SDK para ele.
```
cd ~
git clone https://github.com/aws/aws-iot-device-sdk-js-v2.git
```
1. Vá para o diretório `aws-iot-device-sdk-js-v2` criado na etapa anterior e execute `npm install` para instalar o SDK. O comando `npm install` invocará a criação da biblioteca `aws-crt`, que pode levar alguns minutos para ser concluída.
```
cd ~/aws-iot-device-sdk-js-v2
npm install
```
------
## Instalar e executar o aplicativo de exemplo
Nesta seção, você instalará e executará o aplicativo de `pubsub` amostra encontrado no AWS IoT Device SDK. Este aplicativo mostra a maneira como seu dispositivo usa a biblioteca MQTT para publicar e assinar mensagens MQTT. O aplicativo de exemplo assina um tópico, `topic_1`, publica 10 mensagens no tópico e exibe as mensagens à medida que elas são recebidas do agente de mensagens.
**Instale os arquivos de certificado**
O aplicativo de exemplo exige que os arquivos de certificado que autenticam o dispositivo estejam instalados no dispositivo.
**Para instalar os arquivos de certificado do dispositivo para o aplicativo de exemplo**
1. Crie um `certs` subdiretório em seu *home* diretório executando esses comandos.
```
cd ~
mkdir certs
```
1. No diretório `~/certs`, copie a chave privada, certificado do dispositivo e certificado CA raiz criados anteriormente em [Crie AWS IoT recursos](create-iot-resources.md).
A forma de copiar os arquivos do certificado para o dispositivo depende do dispositivo e do sistema operacional e não está descrita aqui. Entretanto, se o dispositivo for compatível com uma interface gráfica de usuário (GUI) e tiver um navegador da Web, será possível executar o procedimento descrito em [Crie AWS IoT recursos](create-iot-resources.md) a partir do navegador da Web do dispositivo para baixar os arquivos resultantes diretamente no dispositivo.
Os comandos na próxima seção pressupõem que seus arquivos de chave e certificado estão armazenados no dispositivo, conforme mostrado nesta tabela.
**Nomes de arquivos de certificado**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/connecting-to-existing-device.html)
Para executar o aplicativo de exemplo, você precisa das seguintes informações:
**Valores de parâmetros de aplicação**
| Parâmetro | Onde encontrar o valor |
| --- | --- |
| your-iot-endpoint | No [console do AWS IoT](https://console.aws.amazon.com/iot/home), selecione **Todos os dispositivos** e, depois, selecione **Objetos**. Na página **Configurações** no menu AWS IoT . Seu endpoint é exibido na seção **Endpoint de dados do dispositivo**. |
O *your-iot-endpoint* valor tem um formato de:`endpoint_id-ats.iot.region.amazonaws.com`, por exemplo,`a3qj468EXAMPLE-ats.iot.us-west-2.amazonaws.com`.
------
#### [ Python ]
**Para instalar e executar o aplicativo de exemplo**
1. Navegue até o diretório do aplicativo de exemplo.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. Na janela da linha de comando, substitua *your-iot-endpoint* conforme indicado e execute esse comando.
```
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
```
1. Observe que o aplicativo de exemplo:
1. Conecta-se ao AWS IoT serviço da sua conta.
1. Assina o tópico de mensagens **topic\$11** e exibe as mensagens recebidas sobre esse tópico.
1. Publica 10 mensagens no tópico **topic\$11**.
1. Exibe uma saída semelhante à seguinte:
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to topic 'topic_1'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 10 message(s)
Publishing message to topic 'topic_1': Hello World! [1]
Received message from topic 'topic_1': b'Hello World! [1]'
Publishing message to topic 'topic_1': Hello World! [2]
Received message from topic 'topic_1': b'Hello World! [2]'
Publishing message to topic 'topic_1': Hello World! [3]
Received message from topic 'topic_1': b'Hello World! [3]'
Publishing message to topic 'topic_1': Hello World! [4]
Received message from topic 'topic_1': b'Hello World! [4]'
Publishing message to topic 'topic_1': Hello World! [5]
Received message from topic 'topic_1': b'Hello World! [5]'
Publishing message to topic 'topic_1': Hello World! [6]
Received message from topic 'topic_1': b'Hello World! [6]'
Publishing message to topic 'topic_1': Hello World! [7]
Received message from topic 'topic_1': b'Hello World! [7]'
Publishing message to topic 'topic_1': Hello World! [8]
Received message from topic 'topic_1': b'Hello World! [8]'
Publishing message to topic 'topic_1': Hello World! [9]
Received message from topic 'topic_1': b'Hello World! [9]'
Publishing message to topic 'topic_1': Hello World! [10]
Received message from topic 'topic_1': b'Hello World! [10]'
10 message(s) received.
Disconnecting...
Disconnected!
```
Se você estiver com problemas para executar a aplicação de exemplo, examine [Solucionar problemas com a aplicação de amostra](gs-device-troubleshoot.md).
Também é possível adicionar o parâmetro `--verbosity Debug` à linha de comando para que o aplicativo de exemplo exiba mensagens detalhadas sobre sua operação. Essas informações podem fornecer a ajuda necessária para você corrigir o problema.
------
#### [ JavaScript ]
**Para instalar e executar o aplicativo de exemplo**
1. Na janela de linha de comando, navegue até o diretório `~/aws-iot-device-sdk-js-v2/samples/node/pub_sub` criado pelo SDK e instale o aplicativo de exemplo usando os seguintes comandos. O comando `npm install` invocará a criação da biblioteca `aws-crt`, que pode levar alguns minutos para ser concluída.
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
npm install
```
1. Na janela da linha de comando, substitua *your-iot-endpoint* conforme indicado e execute esse comando.
```
node dist/index.js --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
```
1. Observe que o aplicativo de exemplo:
1. Conecta-se ao AWS IoT serviço da sua conta.
1. Assina o tópico de mensagens **topic\$11** e exibe as mensagens recebidas sobre esse tópico.
1. Publica 10 mensagens no tópico **topic\$11**.
1. Exibe uma saída semelhante à seguinte:
```
Publish received on topic topic_1
{"message":"Hello world!","sequence":1}
Publish received on topic topic_1
{"message":"Hello world!","sequence":2}
Publish received on topic topic_1
{"message":"Hello world!","sequence":3}
Publish received on topic topic_1
{"message":"Hello world!","sequence":4}
Publish received on topic topic_1
{"message":"Hello world!","sequence":5}
Publish received on topic topic_1
{"message":"Hello world!","sequence":6}
Publish received on topic topic_1
{"message":"Hello world!","sequence":7}
Publish received on topic topic_1
{"message":"Hello world!","sequence":8}
Publish received on topic topic_1
{"message":"Hello world!","sequence":9}
Publish received on topic topic_1
{"message":"Hello world!","sequence":10}
```
Se você estiver com problemas para executar a aplicação de exemplo, examine [Solucionar problemas com a aplicação de amostra](gs-device-troubleshoot.md).
Também é possível adicionar o parâmetro `--verbosity Debug` à linha de comando para que o aplicativo de exemplo exiba mensagens detalhadas sobre sua operação. Essas informações podem fornecer a ajuda necessária para você corrigir o problema.
------
## Exibir mensagens do aplicativo de amostra no AWS IoT console
É possível ver as mensagens do aplicativo de exemplo à medida que elas passam pelo agente de mensagens usando o **cliente de teste MQTT** no **console do AWS IoT **.
**Para visualizar as mensagens MQTT publicadas pelo aplicativo de exemplo**
1. Consulte [Exibir mensagens MQTT com o cliente AWS IoT MQTT](view-mqtt-messages.md). Isso ajudará você a aprender a usar o **cliente de teste MQTT** no **console do AWS IoT ** para visualizar as mensagens MQTT à medida que elas passam pelo agente de mensagens.
1. Abra o **cliente de teste MQTT** no **console do AWS IoT **.
1. Assine o tópico **topic\$11**.
1. Na janela de linha de comando, execute o aplicativo de exemplo novamente e observe as mensagens no **cliente MQTT** no **console do AWS IoT **.
------
#### [ Python ]
```
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
```
------
#### [ JavaScript ]
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
node dist/index.js --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
```
------
# Solucionar problemas com a aplicação de amostra
Se encontrar um erro ao tentar executar o aplicativo de exemplo, veja a seguir algumas objetos a serem verificadas.
## Verifique o certificado
Se o certificado não estiver ativo, não AWS IoT aceitará nenhuma tentativa de conexão que o use para autorização. Na criação do certificado, é fácil ignorar o botão **Ativar**. Felizmente, você pode ativar seu certificado no [console do AWS IoT](https://console.aws.amazon.com/iot/home).
**Para verificar a ativação do certificado**
1. No [console do AWS IoT](https://console.aws.amazon.com/iot/home), no menu esquerdo, selecione **Segurança** e, depois, selecione **Certificados**.
1. Na lista de certificados, localize o certificado criado para o exercício e verifique seu status na coluna **Status**.
Caso você não se lembre do nome do certificado, verifique se há algum que esteja **Inativo** para ver se pode ser o que você está usando.
Selecione o certificado na lista para abrir sua página de detalhes. Na página de detalhes, é possível ver a **Data de criação** para ajudá-lo a identificar o certificado.
1. **Para ativar um certificado inativo**, na página de detalhes do certificado, selecione **Ações** e, depois, selecione **Ativar**.
Se você encontrou o certificado correto e ele está ativo, mas continua com problemas para executar o aplicativo de exemplo, verifique sua política conforme descrito pela próxima etapa.
Também é possível tentar criar um objeto nova e um novo certificado seguindo as etapas de [Criar um objeto](create-iot-resources.md#create-aws-thing). Se criar um objeto nova, será preciso criar um novo nome para ela e baixar os novos arquivos de certificado em seu dispositivo.
## Verifique a política anexada ao certificado
As políticas autorizam ações em AWS IoT. Se o certificado usado para se conectar ao AWS IoT não tiver uma política, ou se não tiver uma política que permita a conexão, a conexão será recusada mesmo se o certificado estiver ativo.
**Para verificar as políticas que estão anexadas a um certificado**
1. Localize o certificado conforme descrito no item anterior e abra sua página de detalhes.
1. No menu esquerdo da página de detalhes do certificado, selecione **Políticas** para visualizar as políticas que estão anexadas ao certificado.
1. Caso não haja políticas anexadas ao certificado, adicione uma selecionando o menu **Ações** e, depois, selecionando **Anexar política**.
Selecione a política criada anteriormente em [Crie AWS IoT recursos](create-iot-resources.md).
1. Se houver uma política anexada, selecione o bloco da política para abrir sua página de detalhes.
Na página de detalhes, examine o **Documento da política** para se certificar de que ele contém as mesmas informações criadas em [Crie uma AWS IoT política](create-iot-resources.md#create-iot-policy).
## Verifique a linha de comando
Certifique-se de ter usado a linha de comando correta para o seu sistema. Os comandos usados em sistemas Linux e macOS são, em geral, diferentes dos usados em sistemas Windows.
## Verifique o endereço do endpoint
Revise o comando inserido e verifique novamente se o endereço do endpoint em seu comando coincide com aquele do [console do AWS IoT](https://console.aws.amazon.com/iot/home).
## Verifique os nomes dos arquivos de certificado
Compare os nomes dos arquivos no comando digitado com os nomes dos arquivos de certificado no diretório `certs`.
Alguns sistemas podem exigir que nomes de arquivos estejam entre aspas para funcionar corretamente.
## Verifique a instalação do SDK
Verifique de a instalação do SDK está completa e correta.
Em caso de dúvida, instale o SDK novamente no dispositivo. Na maioria dos casos, basta encontrar a seção do tutorial intitulada **Instalar o SDK do AWS IoT dispositivo **SDK language**** e seguir o procedimento novamente.
Se você estiver usando o **AWS IoT Device SDK para JavaScript**, lembre-se de instalar os aplicativos de amostra antes de tentar executá-los. A instalação do SDK não instala os aplicativos de exemplo de forma automática. Os aplicativos de exemplo devem ser instalados manualmente depois da instalação do SDK.