

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

# Criar um dispositivo virtual com o Amazon EC2
<a name="creating-a-virtual-thing"></a>

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
<a name="set-up-ec2"></a>

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
<a name="install-git-node"></a>

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
<a name="ec2-create-certificate"></a>

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
<a name="ec2-sdk"></a>

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
<a name="ec2-run-app"></a>

 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
<a name="ec2-view-msg"></a>

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