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 seu certificado 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), consulte Solução de erros da AWS CLI. Além disso, verifique se você está usando a versão mais recente da AWS CLI.

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

Pré-requisito:

Instale o OpenSSL.

Para criar uma CA raiz autoassinada e um certificado de verificação, faça o seguinte:

1. Gere a chave privada da AC raiz do dispositivo e execute o comando OpenSSL a seguir:

   $ openssl genrsa -out deviceRootCA.key 2048

2. Abra o editor de texto VIM e crie um arquivo OpenSSL.conf personalizado. Para obter mais informações sobre o editor de texto VIM, consulte Tutorial no site Wiki de dicas do Vim.

3. Para criar um arquivo OpenSSL.conf personalizado, execute o comando VIM a seguir:

   $ vi deviceRootCA_openssl.conf

4. Para editar o arquivo .conf, pressione a tecla i no teclado. 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 (e.g., company)
   organizationName_default = AMZ

5. Para salvar o arquivo.conf, pressione Esc no teclado e, em seguida, digite :wq!. Para sair do arquivo, pressione Enter.

6. Para confirmar que o arquivo OpenSSL.conf foi criado, execute o comando do Linux a seguir:

   $ cat deviceRootCA_openssl.conf

7. Crie uma solicitação de assinatura de certificado CA (CSR) raiz do dispositivo. Execute o seguinte comando OpenSSL:

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

8. Crie um certificado CA raiz do dispositivo. Execute o seguinte comando OpenSSL:

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

9. Recupere o código de registro da região da AWS em que você deseja usar o provisionamento JIT. Em seguida, execute o seguinte comando da AWS CLI:

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

   Observação: Substitua us-east-2 pela região em que você deseja usar o provisionamento JIT.

10. Crie uma chave de verificação. Execute o seguinte comando OpenSSL:

$ openssl genrsa -out verificationCert.key 2048

11. Crie um certificado de verificação CSR. Execute o seguinte comando OpenSSL:

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

Em seguida, insira o código de registro no campo Nome comum. Por exemplo: Nome comum (servidor FQDN ou SEU nome) []: xxxxxxxx8a33da.

Deixe os outros campos em branco.

12. Crie o certificado de verificação. Execute o seguinte comando OpenSSL:

$ 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 quando o AWS IoT Core certifica o certificado de verificação.

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 (AWS IAM) para o serviço do AWS IoT Core. Chame isso de JITPRole. Para obter instruções, consulte Criar uma função de registro.

   Importante: No modelo de provisionamento JIT a seguir, é necessário inserir o Amazon Resource Name (ARN) do perfil do IAM.

2. Use o editor de texto VIM para criar um arquivo JSON de modelo de provisionamento JIT. Conclua as seguintes etapas:

3. Crie um arquivo JSON de modelo de provisionamento JIT. Execute o seguinte comando VIM:

   $ vi jitp_template.json

   Observação: salve o nome do arquivo do modelo como jitp_template.json.

4. Para editar o modelo de provisionamento JIT, pressione a tecla i no teclado. 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"
   }

   Observação: substitua o valor de roleArn pelo ARN do perfil do IAM que você criou para o serviço do AWS IoT Core. Substitua o valor pelo ID da sua conta da AWS. Substitua us-east-2 pela sua região da AWS.

5. Para salvar o arquivo do modelo de provisionamento JIT, pressione a tecla Esc no teclado e digite :wq!.

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

1. Registre a CA raiz do dispositivo como um certificado CA no AWS IoT Core.

2. Execute o seguinte comando register-ca-certificate da AWS CLI:

   $ 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: Substitua us-east-2 pela região em que você deseja usar o provisionamento JIT.

Observação: Use o parâmetro --registration-config para anexar o modelo de provisionamento JIT que você criou ao certificado da AC. Para retornar o ARN do certificado CA, use a resposta do comando.

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. Crie uma chave privada do dispositivo. Execute o seguinte comando OpenSSL:

   $ openssl genrsa -out deviceCert.key 2048

3. Crie um dispositivo CSR. Execute o seguinte comando OpenSSL:

   $ 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 (e.g. 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 de dispositivo. Execute o seguinte comando OpenSSL:

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

5. Combine o certificado CA raiz e o certificado do dispositivo. Execute o seguinte comando:

   $ 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: Antes de executar o comando, substitua a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com pelo seu próprio endpoint. Para confirmar qual é seu endpoint, abra o console do AWS IoT Core. Em seguida, escolha Configurações. Seu endpoint aparecerá 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 do Eclipse Mosquitto usado para fazer uma chamada de publicação como teste

   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 do AWS IoT Core que foi criada primeiro será usada. Uma nova política do AWS IoT Core não foi criada.

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.

8. 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 corresponder ao 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 Testar.

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 confirmar 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, a mensagem é recebida no console de teste 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 que você deseja usar.