Configurar uma instância do Amazon EC2 Instalar o Git, Node.js e configurar a AWS CLI Crie AWS IoT recursos para seu dispositivo virtual Instale o AWS IoT Device SDK para JavaScript Executar os aplicativos de exemplo Visualizar mensagens do aplicativo de exemplo no console do AWS IoT

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 Configure seu Conta da AWS antes de continuar.

Neste tutorial, você vai:

Configurar uma instância do Amazon EC2
Instalar o Git, Node.js e configurar a AWS CLI
Crie AWS IoT recursos para seu dispositivo virtual
Instale o AWS IoT Device SDK para JavaScript
Executar os aplicativos de exemplo
Visualizar mensagens do aplicativo de exemplo no console do AWS IoT

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 é sua primeira vez criando uma instância do Amazon EC2, as instruções de Comece a usar as instâncias do Amazon EC2 Linux podem ser mais úteis.

Como iniciar uma instância

Abra o console do Amazon EC2 em https://console.aws.amazon.com/ec2/.
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.
Na seção Nome e tags, digite um nome para a instância e, opcionalmente, adicione tags.
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”.
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.
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.
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.
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.
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 Public DNS (IPv4) estiver oculta, escolha Mostrar/ocultar colunas (o ícone de engrenagem) no canto superior direito da página e selecione Public DNS (IPv4).)
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.

Abra o console do Amazon EC2 em https://console.aws.amazon.com/ec2/.
No menu esquerdo, selecione Instâncias.
Selecione a instância e escolha Conectar.
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.

Instalar o Git, Node.js e configurar a AWS CLI

Nesta seção, você instalará o Git e o Node.js em sua instância do Linux.

Para instalar o Git

Na janela do Amazon EC2 Instance Connect, atualize sua instância com o seguinte comando.
```
sudo yum update -y
```
Na janela do Amazon EC2 Instance Connect, instale o Git com o seguinte comando.
```
sudo yum install git -y
```
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

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.
Na janela do Amazon EC2 Instance Connect, ative o nvm com o seguinte comando.
```
. ~/.nvm/nvm.sh
```
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.
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.

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.

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.

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

Na janela do Amazon EC2 Instance Connect, execute o seguinte comando para criar seu objeto.
```
aws iot create-thing --thing-name "MyIotThing"
```

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 cria certificados de cliente assinados pela autoridade de certificação raiz da Amazon. Esse certificado é usado para autenticar a identidade do dispositivo virtual.

Na janela do Amazon EC2 Instance Connect, crie um diretório para armazenar os arquivos de certificado e chave.
```
mkdir ~/certs
```
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 
```

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"
    }
}

Na janela do Amazon EC2 Instance Connect, anexe seu objeto ao certificado criado usando o seguinte comando e o certificateArn na 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

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 ~/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+x 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": [
                "*"
            ]
        }
    ]
}
```

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:your-region: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"
}

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.

Para instalar o AWS IoT Device SDK JavaScript em sua instância Linux

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
```
Navegue até o diretório aws-iot-device-sdk-js-v2 criado na etapa anterior.
```
cd aws-iot-device-sdk-js-v2
```
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

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
```
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
```

Na janela do Amazon EC2 Instance Connect, insira your-iot-endpointconforme 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:

Conecta-se AWS IoT Core à sua conta.
Assina o tópico de mensagens topic_1 e exibe as mensagens recebidas sobre esse tópico.
Publica 10 mensagens no tópico topic_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 o aplicativo de exemplo.

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.

Visualizar mensagens do aplicativo de exemplo no console do AWS IoT

É 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

Consulte Exibir mensagens MQTT com o cliente AWS IoT MQTT. 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.
Abra o cliente de teste MQTT no console do AWS IoT .
Em Assinar um tópico, assine o tópico topic_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.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Configurar o dispositivo

Use seu PC Windows ou Linux ou Mac como um AWS IoT dispositivo