Como configuro o provisionamento just‑in‑time com o AWS IoT Core?

Breve descrição

Para configurar um ambiente de provisionamento just‑in‑time com o AWS IoT Core, registre sua AC no AWS IoT Core primeiro. Em seguida, anexe um modelo de provisionamento à sua AC.

Resolução

Observação: se você receber erros ao executar comandos da AWS Command Line Interface (AWS CLI), verifique se está usando sua versão mais recente.

Criar um certificado de AC raiz autoassinado e um certificado de verificação

1.    Instale oOpenSSL, se ainda não instalou.

2.    Gere a chave privada da AC raiz do dispositivo. Execute o comando OpenSSL a seguir:

$ openssl genrsa -out deviceRootCA.key 2048

3.    Crie um arquivo OpenSSL.conf personalizado usando o editor de texto VIM. Para criar e editar um arquivo OpenSSL.conf personalizado, siga as instruções:
Crie um arquivo OpenSSL.conf personalizado executando o comando VIM a seguir:

$ vi deviceRootCA_openssl.conf

Pressione a tecla i para editar o arquivo.conf. Em seguida, copie e cole o seguinte dentro do arquivo:

[ req ]
distinguished_name       = req_distinguished_name
extensions               = v3_ca
req_extensions           = v3_ca

[ v3_ca ]
basicConstraints         = CA:TRUE

[ req_distinguished_name ]
countryName              = Country Name (2 letter code)
countryName_default      = IN
countryName_min          = 2
countryName_max          = 2
organizationName         = Organization Name (eg, company)
organizationName_default = AMZ

Pressione a tecla Esc e digite :wq! para salvar o arquivo .conf. Em seguida, pressione Enter para sair do arquivo.
Observação: para confirmar que o arquivo OpenSSL.conf foi criado, execute o comando do Linux a seguir:

$ cat deviceRootCA_openssl.conf

4.    Gere a solicitação de assinatura de certificado (CSR) da AC raiz do dispositivo. Execute o comando OpenSSL a seguir:

$ openssl req -new -sha256 -key deviceRootCA.key -nodes -out deviceRootCA.csr -config deviceRootCA_openssl.conf

5.    Crie o certificado da AC raiz do dispositivo. Execute o comando OpenSSL a seguir:

$ openssl x509 -req -days 3650 -extfile deviceRootCA_openssl.conf -extensions v3_ca -in deviceRootCA.csr -signkey deviceRootCA.key -out deviceRootCA.pem

6.    Recupere o código de registro da região da AWS em que o provisionamento JIT será usado. Execute o comando da AWS CLI a seguir:

Importante: substitua us-east-2 pela região em que o provisionamento JIT será usado.

$ aws iot get-registration-code --region us-east-2

7.    Crie uma chave de verificação. Execute o comando OpenSSL a seguir:

$ openssl genrsa -out verificationCert.key 2048

8.    Gere a CSR do certificado de verificação. Execute o comando OpenSSL a seguir:

$ openssl req -new -key verificationCert.key -out verificationCert.csr

Em seguida, insira o código de registro no campo Common Name. Por exemplo: Common Name (server FQDN or YOUR name) []: xxxxxxxx8a33da. Deixe os outros campos em branco.

9.    Crie o certificado de verificação. Execute o comando OpenSSL a seguir:

$ openssl x509 -req -in verificationCert.csr -CA deviceRootCA.pem -CAkey deviceRootCA.key -CAcreateserial -out verificationCert.crt -days 500 -sha256

Importante: é necessário informar o código de registro da região da AC raiz para que o certificado de verificação seja certificado pelo AWS IoT Core.

Para mais informações, consulte Provisionamento just‑in‑time.

Crie um modelo de provisionamento JIT

1.    Crie um perfil do AWS Identity and Access Management (IAM) para o serviço do AWS IoT Core e chame‑o de JITPRole. Se quiser instruções, consulte Criar um perfil de registro em log (primeira e segunda etapa).

Importante: é necessário inserir o nome do recurso da Amazon (ARN) do perfil do IAM neste modelo de provisionamento JIT.

2.    Crie um arquivo JSON do modelo de provisionamento JIT usando o editor de texto VIM. Siga as instruções abaixo:
Crie um arquivo JSON do modelo de provisionamento JIT executando o comando VIM a seguir:

$ vi jitp_template.json

Importante: salve o nome do arquivo do modelo como jitp_template.json.
Pressione a tecla i para editar o modelo de provisionamento JIT. Em seguida, copie e cole o modelo a seguir dentro do arquivo:

{
 "templateBody":"{ \"Parameters\" : { \"AWS::IoT::Certificate::CommonName\" : { \"Type\" : \"String\" },\"AWS::IoT::Certificate::Country\" : { \"Type\" : \"String\" }, \"AWS::IoT::Certificate::Id\" : { \"Type\" : \"String\" }}, \"Resources\" : { \"thing\" : { \"Type\" : \"AWS::IoT::Thing\", \"Properties\" : { \"ThingName\" : {\"Ref\" : \"AWS::IoT::Certificate::CommonName\"}, \"AttributePayload\" : { \"version\" : \"v1\", \"country\" : {\"Ref\" : \"AWS::IoT::Certificate::Country\"}} } }, \"certificate\" : { \"Type\" : \"AWS::IoT::Certificate\", \"Properties\" : { \"CertificateId\": {\"Ref\" : \"AWS::IoT::Certificate::Id\"}, \"Status\" : \"ACTIVE\" } }, \"policy\" : {\"Type\" : \"AWS::IoT::Policy\", \"Properties\" : { \"PolicyDocument\" : \"{ \\\"Version\\\": \\\"2012-10-17\\\", \\\"Statement\\\": [ { \\\"Effect\\\": \\\"Allow\\\", \\\"Action\\\": [ \\\"iot:Connect\\\" ], \\\"Resource\\\": [ \\\"arn:aws:iot:us-east-2:<ACCOUNT_ID>:client\\\/${iot:Connection.Thing.ThingName}\\\" ] }, { \\\"Effect\\\": \\\"Allow\\\", \\\"Action\\\": [ \\\"iot:Publish\\\", \\\"iot:Receive\\\" ], \\\"Resource\\\": [ \\\"arn:aws:iot:us-east-2:<ACCOUNT_ID>:topic\\\/${iot:Connection.Thing.ThingName}\\\/*\\\" ] }, { \\\"Effect\\\": \\\"Allow\\\", \\\"Action\\\": [ \\\"iot:Subscribe\\\" ], \\\"Resource\\\": [ \\\"arn:aws:iot:us-east-2:<ACCOUNT_ID>:topicfilter\\\/${iot:Connection.Thing.ThingName}\\\/*\\\" ] } ] }\" } } } }",
 "roleArn":"arn:aws:iam::<ACCOUNT_ID>:role/JITPRole"
}

Importante: substitua o valor de roleArn pelo ARN do perfil do IAM que você criou para o serviço do AWS IoT Core. Substitua <ACCOUNT_ID> pelo ID da sua conta da AWS. Substitua us-east-2 pela região da AWS que você está usando. Pressione a tecla Esc e digite :wq! para salvar o arquivo do modelo de provisionamento JIT. Pressione Enter para sair do arquivo.

Observação: as políticas do IAM incluídas neste exemplo de modelo são estas:

• AWSIoTLogging
• AWSIoTRuleActions
• AWSIoTThingsRegistration

Você precisa estar conectado à sua conta da AWS para conseguir abrir os links das políticas acima. Para mais informações, consulte Modelos de provisionamento.

Registre o certificado de AC raiz autoassinado no AWS IoT Core

Registre a AC raiz do dispositivo como um certificado de AC no AWS IoT Core. Execute o comando da AWS CLIregister-ca-certificate a seguir:

Importante: substitua us-east-2 pela região em que o provisionamento JIT será usado.

$ aws iot register-ca-certificate --ca-certificate file://deviceRootCA.pem --verification-cert file://verificationCert.crt --set-as-active --allow-auto-registration --registration-config file://jitp_template.json --region us-east-2

Observação: adicionar o parâmetro --registration-config anexa o modelo de provisionamento JIT que você criou ao certificado da AC. A resposta do comando retorna o ARN do certificado da AC.

Para mais informações, consulte Registrar um certificado de AC.

Criar certificados para o dispositivo e execute o provisionamento JIT

Importante: use o mesmo diretório em que foram criados os arquivos originais da AC raiz do dispositivo.

1.    Baixe o RootCA1 e salve o nome do arquivo como awsRootCA.pem.
Observação: o RootCA1 é usado para autenticar no lado do servidor as solicitações de publicação feitas para o AWS IoT Core. Para obter mais informações, consulte Certificados de AC para autenticação do servidor.

2.    Gere a chave privada do dispositivo. Execute o comando OpenSSL a seguir:

$ openssl genrsa -out deviceCert.key 2048

3.    Gere a CSR do dispositivo. Execute o comando OpenSSL a seguir:

$ openssl req -new -key deviceCert.key -out deviceCert.csr

Importante: o modelo de provisionamento JIT dado como exemplo exige que o valor de ThingName seja igual ao valor de CommonName do certificado. Também é necessário que o valor de CountryName seja igual ao valor de Country do certificado da AC. Por exemplo:

Country Name (two-letter code) []:IN
Common Name (eg. server FQDN or YOUR name) []: DemoThing

O modelo de provisionamento JIT deste artigo também usa o parâmetro AWS::IoT::Certificate::Country do certificado. Esse parâmetro exige que você adicione um valor. Outros possíveis parâmetros do certificado são: AWS::IoT::Certificate::Country AWS::IoT::Certificate::Organization AWS::IoT::Certificate::OrganizationalUnit AWS::IoT::Certificate::DistinguishedNameQualifier AWS::IoT::Certificate::StateName AWS::IoT::Certificate::CommonName AWS::IoT::Certificate::SerialNumber AWS::IoT::Certificate::Id

4.    Crie um certificado para o dispositivo. Execute o comando OpenSSL a seguir:

$ openssl x509 -req -in deviceCert.csr -CA deviceRootCA.pem -CAkey deviceRootCA.key -CAcreateserial -out deviceCert.crt -days 365 -sha256

5.    Combine o certificado da AC raiz e o certificado do dispositivo. Execute o comando a seguir:

$ cat deviceCert.crt deviceRootCA.pem > deviceCertAndCACert.crt

6.    Use o Eclipse Mosquitto para fazer uma chamada de publicação para o AWS IoT Core como teste e iniciar o processo de provisionamento JIT.

Observação: você também pode usar o AWS Device SDK para fazer chamadas de publicação para o AWS IoT Core.

Exemplo de comando do Eclipse Mosquitto usado para fazer uma chamada de publicação como teste

Importante: substitua a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com pelo seu próprio endpoint antes de executar o comando. Para verificar qual é seu endpoint, abra o console do AWS IoT Core. Em seguida, escolha Configurações. Seu endpoint estará listado no painel Endpoint personalizado.

$ mosquitto_pub --cafile awsRootCA.pem --cert deviceCertAndCACert.crt --key deviceCert.key -h a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com -p 8883 -q 1 -t  foo/bar -i  anyclientID --tls-version tlsv1.2 -m "Hello" -d

Exemplo de resposta do comando

Client anyclientID sending CONNECT  
  Error: The connection was lost. // The error is expected for the first connect call

Observação: a chamada de publicação falha na primeira vez. Quando o AWS IoT Core recebe a chamada de publicação usada para teste, ele cria um Certificado, uma Política e uma Coisa. Ele também anexa a Política ao Certificado e o Certificado à Coisa. Na próxima vez que você executar o provisionamento JIT, a política de IoT que foi criada primeiro será usada. Isto é, não será criada uma nova política de IoT.

7.    Confirme se os recursos necessários foram criados seguindo estas instruções: Abra o console do AWS IoT Core. Escolha Gerenciar. Escolha Coisas. Escolha DemoThing.
Verifique se o certificado foi criado e se está no estado ATIVO.
Em seguida, escolha Políticas e verifique se a política do IAM está anexada.

Use certificados de dispositivo em operações diversas

Observação: o valor de ID do cliente adicionado ao comando de publicação deve ser o mesmo do ThingName que foi criado durante o processo de provisionamento JIT. O Nome do tópico adicionado ao comando de publicação também deve seguir o formato ThingName/*. Na próxima chamada de publicação, você pode usar deviceCert.crt em vez de deviceCertAndCACert.crt.

1.    Abra o console do AWS IoT Core.

2.    Escolha Teste.

3.    Em Tópico de assinatura, digite DemoThing/test.

4.    Execute o seguinte comando do Eclipse Mosquitto para fazer uma chamada de publicação para o AWS IoT Core:

Importante: substitua a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com pelo seu próprio endpoint antes de executar o comando. Para verificar qual é seu endpoint, abra o console do AWS IoT Core. Em seguida, escolha Configurações. Seu endpoint aparecerá no painel Endpoint personalizado. Lembre de usar os certificados de dispositivo personalizados que foram gerados pela AC raiz personalizada.

$ mosquitto_pub --cafile awsRootCA.pem --cert deviceCert.crt --key deviceCert.key -h a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com -p 8883 -q 1 -t  DemoThing/test -i  DemoThing --tls-version tlsv1.2 -m "Hello" -d

Depois de executar o comando, você verá que a mensagem foi recebida na seção Teste do console do AWS IoT Core.

Criar mais certificados para o dispositivo

Para criar mais certificados para o dispositivo e registrá-los no AWS IoT Core, repita as etapas descritas na seção Crie certificados para o dispositivo e execute o provisionamento JIT.

Outros modelos de provisionamento JIT

Para recuperar o valor de ThingName a partir do campo CommonName do certificado e adicionar permissões de administrador na política, use o modelo de provisionamento JIT a seguir:

{
 "templateBody":"{ \"Parameters\" : { \"AWS::IoT::Certificate::CommonName\" : { \"Type\" : \"String\" },\"AWS::IoT::Certificate::Country\" : { \"Type\" : \"String\" }, \"AWS::IoT::Certificate::Id\" : { \"Type\" : \"String\" }}, \"Resources\" : { \"thing\" : { \"Type\" : \"AWS::IoT::Thing\", \"Properties\" : { \"ThingName\" : {\"Ref\" : \"AWS::IoT::Certificate::CommonName\"}, \"AttributePayload\" : { \"version\" : \"v1\", \"country\" : {\"Ref\" : \"AWS::IoT::Certificate::Country\"}} } }, \"certificate\" : { \"Type\" : \"AWS::IoT::Certificate\", \"Properties\" : { \"CertificateId\": {\"Ref\" : \"AWS::IoT::Certificate::Id\"}, \"Status\" : \"ACTIVE\" } }, \"policy\" : {\"Type\" : \"AWS::IoT::Policy\", \"Properties\" : { \"PolicyDocument\" : \"{\\\"Version\\\":\\\"2012-10-17\\\",\\\"Statement\\\":[{\\\"Effect\\\":\\\"Allow\\\",\\\"Action\\\":\\\"iot:*\\\",\\\"Resource\\\":\\\"*\\\"}]}\" } } } }",
 "roleArn":"arn:aws:iam::<ACCOUNT_ID>:role/JITPRole"
}

Para recuperar o valor de ThingName a partir do campo CommonName do certificado e adicionar uma política predefinida, use o modelo de provisionamento JIT a seguir:

{
 "templateBody":"{ \"Parameters\" : { \"AWS::IoT::Certificate::CommonName\" : { \"Type\" : \"String\" },\"AWS::IoT::Certificate::Country\" : { \"Type\" : \"String\" }, \"AWS::IoT::Certificate::Id\" : { \"Type\" : \"String\" }}, \"Resources\" : { \"thing\" : { \"Type\" : \"AWS::IoT::Thing\", \"Properties\" : { \"ThingName\" : {\"Ref\" : \"AWS::IoT::Certificate::CommonName\"}, \"AttributePayload\" : { \"version\" : \"v1\", \"country\" : {\"Ref\" : \"AWS::IoT::Certificate::Country\"}} } }, \"certificate\" : { \"Type\" : \"AWS::IoT::Certificate\", \"Properties\" : { \"CertificateId\": {\"Ref\" : \"AWS::IoT::Certificate::Id\"}, \"Status\" : \"ACTIVE\" } }, \"policy\" :  {\"Type\" : \"AWS::IoT::Policy\", \"Properties\" : { \"PolicyName\" :  \"Policy_Name\"} } } }",
 "roleArn":"arn:aws:iam::<ACCOUNT_ID>:role/JITPRole"
}

Importante: substitua Policy_Name pelo nome da política de sua escolha.

---