Provisione o Raspberry Pi para trabalhos Configurar o Device Client para executar trabalhos

Prepare o Raspberry Pi para executar trabalhos

Os procedimentos nesta seção descrevem como preparar seu Raspberry Pi para executar trabalhos usando o AWS IoT Device Client.

nota

Estes procedimentos são específicos ao dispositivo. Caso queira realizar os procedimentos desta seção com mais de um dispositivo simultaneamente, cada dispositivo precisará de sua própria política e de um certificado e um nome de item exclusivos e específicos ao dispositivo. Para que cada dispositivo tenha seus recursos exclusivos, execute o procedimento uma vez para cada dispositivo enquanto modifica os elementos específicos do dispositivo, como descrito nos procedimentos.

Procedimentos deste tutorial

Provisione seu Raspberry Pi para demonstrar trabalhos
Configurar o AWS IoT Device Client para executar o agente de trabalhos

Provisione seu Raspberry Pi para demonstrar trabalhos

Os procedimentos nesta seção provisionam seu Raspberry Pi AWS IoT criando AWS IoT recursos e certificados de dispositivo para ele.

Tópicos

Crie e baixe arquivos de certificado de dispositivo para demonstrar AWS IoT trabalhos
Crie AWS IoT recursos para demonstrar AWS IoT empregos

Crie e baixe arquivos de certificado de dispositivo para demonstrar AWS IoT trabalhos

Este procedimento cria os arquivos de certificado de dispositivo para esta demonstração.

Se você estiver preparando mais de um dispositivo, esse procedimento deve ser executado em cada dispositivo.

Para criar e baixar os arquivos de certificado de dispositivo para o Raspberry Pi:

Na janela do terminal do computador host local conectado ao Raspberry Pi, digite os comandos a seguir.

Digite o comando a seguir para criar os arquivos de certificado de dispositivo.


aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "~/certs/jobs/device.pem.crt" \
--public-key-outfile "~/certs/jobs/public.pem.key" \
--private-key-outfile "~/certs/jobs/private.pem.key"

O comando retorna uma resposta como a seguinte. Salve o valor de certificateArn para uso posterior.


{
"certificateArn": "arn:aws:iot:us-west-2:57EXAMPLE833:cert/76e7e4edb3e52f52334be2f387a06145b2aa4c7fcd810f3aea2d92abc227d269",
"certificateId": "76e7e4edb3e52f5233EXAMPLE7a06145b2aa4c7fcd810f3aea2d92abc227d269",
"certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCCAkGgAwIBAgI_SHORTENED_FOR_EXAMPLE_Lgn4jfgtS\n-----END CERTIFICATE-----\n",
"keyPair": {
    "PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BA_SHORTENED_FOR_EXAMPLE_ImwIDAQAB\n-----END PUBLIC KEY-----\n",
    "PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQE_SHORTENED_FOR_EXAMPLE_T9RoDiukY\n-----END RSA PRIVATE KEY-----\n"
}
}

Insira os comandos a seguir para definir as permissões no diretório de certificados e arquivos.
```
chmod 700 ~/certs/jobs
chmod 644 ~/certs/jobs/*
chmod 600 ~/certs/jobs/private.pem.key
```
Execute este comando para examinar as permissões nos diretórios e arquivos do certificado.
```
ls -l ~/certs/jobs
```
A saída do comando deve ser a mesma vista aqui, com exceção das datas e horários do arquivo, que serão diferentes.
```
-rw-r--r-- 1 pi pi 1220 Oct 28 13:02 device.pem.crt
-rw------- 1 pi pi 1675 Oct 28 13:02 private.pem.key
-rw-r--r-- 1 pi pi  451 Oct 28 13:02 public.pem.key
```

Após baixar os arquivos de certificado de dispositivo para o Raspberry Pi, você estará pronto para avançar para Provisione seu Raspberry Pi para demonstrar trabalhos.

Crie AWS IoT recursos para demonstrar AWS IoT empregos

Crie os AWS IoT recursos para esse dispositivo.

Se você estiver preparando mais de um dispositivo, esse procedimento deve ser executado para todos os dispositivos.

Para provisionar seu dispositivo no AWS IoT:

Na janela do terminal do computador host local conectado ao Raspberry Pi:

Digite o seguinte comando para obter o endereço do endpoint de dados do dispositivo da sua Conta da AWS.
```
aws iot describe-endpoint --endpoint-type IoT:Data-ATS
```
O valor do endpoint não foi alterado desde a última vez que este comando foi executado. Executar o comando mais uma vez facilita localizar e colar o valor do endpoint de dados no arquivo de configuração usado neste tutorial.

O comando describe-endpoint retorna uma resposta como a seguinte. Registre o valor de endpointAddress para uso posterior.
```
{
"endpointAddress": "a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com"
}
```
Substituir uniqueThingName com um nome exclusivo para seu dispositivo. Caso queira realizar este tutorial com vários dispositivos, dê um nome único a cada dispositivo. Como, por exemplo, TestDevice01, TestDevice02, e assim por diante.

Digite este comando para criar um novo recurso para AWS IoT o seu Raspberry Pi.
```
aws iot create-thing --thing-name "uniqueThingName"
```
Como um recurso de AWS IoT coisas é uma representação virtual do seu dispositivo na nuvem, podemos criar vários recursos de coisas AWS IoT para serem usados em diferentes propósitos. Todos os recursos de objetos podem ser usados pelo mesmo dispositivo físico de IoT para representar aspectos diferentes do dispositivo.

nota
Para proteger a política para vários dispositivos, você pode usar ${iot:Thing.ThingName} em vez do nome do objeto estática, uniqueThingName.

Estes tutoriais usarão apenas um recurso de objeto por vez por dispositivo. Dessa forma, nesses tutoriais, eles representam as diferentes demonstrações para que, depois de criar os AWS IoT recursos para uma demonstração, você possa voltar e repetir as demonstrações usando os recursos criados especificamente para cada uma.

Se seu recurso AWS IoT Thing foi criado, o comando retornará uma resposta como essa. Registre o valor de thingArn para uso posterior quando for criar o trabalho a ser executado nesse dispositivo.
```
{
"thingName": "uniqueThingName",
"thingArn": "arn:aws:iot:us-west-2:57EXAMPLE833:thing/uniqueThingName",
"thingId": "8ea78707-32c3-4f8a-9232-14bEXAMPLEfd"
}
```

Na janela do terminal:

Abra um editor de texto, como o nano.

Copie este JSON documento e cole-o em seu editor de texto aberto.


{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "iot:Connect"
      ],
      "Resource": [
        "arn:aws:iot:us-west-2:57EXAMPLE833:client/uniqueThingName"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "iot:Publish"
      ],
      "Resource": [
        "arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic",
        "arn:aws:iot:us-west-2:57EXAMPLE833:topic/$aws/events/job/*",
        "arn:aws:iot:us-west-2:57EXAMPLE833:topic/$aws/events/jobExecution/*",
        "arn:aws:iot:us-west-2:57EXAMPLE833:topic/$aws/things/uniqueThingName/jobs/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "iot:Subscribe"
      ],
      "Resource": [
        "arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic",
        "arn:aws:iot:us-west-2:57EXAMPLE833:topic/$aws/events/jobExecution/*",
        "arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/$aws/things/uniqueThingName/jobs/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "iot:Receive"
      ],
      "Resource": [
        "arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/subtopic",
        "arn:aws:iot:us-west-2:57EXAMPLE833:topic/$aws/things/uniqueThingName/jobs/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "iot:DescribeJobExecution",
        "iot:GetPendingJobExecutions",
        "iot:StartNextPendingJobExecution",
        "iot:UpdateJobExecution"
      ],
      "Resource": [
        "arn:aws:iot:us-west-2:57EXAMPLE833:topic/$aws/things/uniqueThingName"
      ]
    }
  ]
}

No editor, na Resource seção de cada declaração de política, substitua us-west-2:57EXAMPLE833 com seu Região da AWS, um caractere de dois pontos (:) e seu número de 12 dígitos Conta da AWS .
No editor, em cada declaração de política, substitua uniqueThingName com o nome da coisa que você deu a essa coisa recurso.
Salve o arquivo no editor de texto como ~/policies/jobs_test_thing_policy.json.

Caso esteja executando esse procedimento para diversos dispositivos, salve o arquivo com esse nome de arquivo em cada dispositivo.

Substituir uniqueThingName com o nome da coisa para o dispositivo e, em seguida, execute esse comando para criar uma AWS IoT política personalizada para esse dispositivo.


aws iot create-policy \
--policy-name "JobTestPolicyForuniqueThingName" \
--policy-document "file://~/policies/jobs_test_thing_policy.json"

Se a política for criada, o comando retornará uma resposta como esta.


{
    "policyName": "JobTestPolicyForuniqueThingName",
    "policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/JobTestPolicyForuniqueThingName",
    "policyDocument": "{\n\"Version\": \"2012-10-17\",\n\"Statement\": [\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Connect\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Publish\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Subscribe\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Receive\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n]\n}\n]\n}\n",
    "policyVersionId": "1"

Substituir uniqueThingName com o nome da coisa para o dispositivo e certificateArn com o certificateArn valor que você salvou anteriormente nesta seção para esse dispositivo e, em seguida, execute esse comando para anexar a política ao certificado do dispositivo.
```
aws iot attach-policy \
--policy-name "JobTestPolicyForuniqueThingName" \
--target "certificateArn"
```
Se houver êxito, o comando não retornará nada.
Substituir uniqueThingName pelo nome da coisa para o dispositivo, certificateArn substitua pelo certificateArn valor que você salvou anteriormente nesta seção e, em seguida, execute esse comando para anexar o certificado do dispositivo ao recurso da AWS IoT coisa.
```
aws iot attach-thing-principal \
--thing-name "uniqueThingName" \
--principal "certificateArn"
```
Se houver êxito, o comando não retornará nada.

Após provisionar o Raspberry Pi com êxito, você estará pronto para repetir esta seção com outro Raspberry Pi em um teste ou, se todos os dispositivos tiverem sido provisionados, avançar para Configurar o AWS IoT Device Client para executar o agente de trabalhos.

Configurar o AWS IoT Device Client para executar o agente de trabalhos

Este procedimento cria um arquivo de configuração para o AWS IoT Device Client executar o agente de trabalhos:.

Nota: se você estiver preparando mais de um dispositivo, esse procedimento deve ser executado em cada dispositivo.

Para criar o arquivo de configuração para testar o AWS IoT Device Client:

Na janela do terminal do computador host local conectado ao Raspberry Pi:

Abra um editor de texto, como o nano.

Copie este JSON documento e cole-o em seu editor de texto aberto.


{
  "endpoint": "a3qEXAMPLEaffp-ats.iot.us-west-2.amazonaws.com",
  "cert": "~/certs/jobs/device.pem.crt",
  "key": "~/certs/jobs/private.pem.key",
  "root-ca": "~/certs/AmazonRootCA1.pem",
  "thing-name": "uniqueThingName",
  "logging": {
    "enable-sdk-logging": true,
    "level": "DEBUG",
    "type": "STDOUT",
    "file": ""
  },
  "jobs": {
    "enabled": true,
    "handler-directory": ""
  },
  "tunneling": {
    "enabled": false
  },
  "device-defender": {
    "enabled": false,
    "interval": 300
  },
  "fleet-provisioning": {
    "enabled": false,
    "template-name": "",
    "template-parameters": "",
    "csr-file": "",
    "device-key": ""
  },
  "samples": {
    "pub-sub": {
      "enabled": false,
      "publish-topic": "",
      "publish-file": "",
      "subscribe-topic": "",
      "subscribe-file": ""
    }
  },
  "config-shadow": {
    "enabled": false
  },
  "sample-shadow": {
    "enabled": false,
    "shadow-name": "",
    "shadow-input-file": "",
    "shadow-output-file": ""
  }
}

Substitua o endpoint valor com o valor do endpoint de dados do dispositivo para você Conta da AWS que você encontrou emProvisione seu dispositivo em AWS IoT Core.
Substituir uniqueThingName com o nome da coisa que você usou para este dispositivo.
Salve o arquivo no editor de texto como ~/dc-configs/dc-jobs-config.json.

Execute o comando a seguir para definir as permissões de arquivo do novo arquivo de configuração.
```
chmod 644 ~/dc-configs/dc-jobs-config.json
```

Você não usará o cliente MQTT de teste para esse teste. Embora o dispositivo troque MQTT mensagens relacionadas aos trabalhos AWS IoT, as mensagens de progresso do trabalho são trocadas somente com o dispositivo que está executando o trabalho. Como as mensagens de progresso do trabalho são trocadas somente com o dispositivo que está executando o trabalho, você não pode assiná-las de outro dispositivo, como o AWS IoT console.

Após salvar o arquivo de configuração, você estará pronto para avançar para Crie e execute o trabalho AWS IoT com o AWS IoT Device Client.

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

Execute trabalhos de IoT com o Device Client

Crie e execute trabalhos de IoT