¿Cómo puedo usar un JITP con AWS IoT Core?

Descripción corta

Para configurar un entorno JITP con AWS IoT Core, primero registre su certificado CA en AWS IoT Core. A continuación, adjunte una plantilla de aprovisionamiento a su CA.

Resolución

Nota: Si se muestran errores al poner en marcha comandos de Interfaz de la línea de comandos de AWS (AWS CLI), consulta Troubleshooting errors for the AWS CLI (Solución de problemas de la AWS CLI). Además, asegúrese de utilizar la versión más reciente de AWS CLI.

Creación de una CA raíz y un certificado de verificación autofirmados

Requisito previo:

Instale OpenSSL.

Para crear una CA raíz autofirmada y un certificado de verificación, haga lo siguiente:

1. Cree una clave privada para la CA raíz de dispositivo y ponga en marcha el siguiente comando de OpenSSL:

   $ openssl genrsa -out deviceRootCA.key 2048

2. Abra el editor de texto VIM y, a continuación, cree un archivo OpenSSL.conf personalizado. Para obtener más información sobre el editor de texto de VIM, consulte Tutorial en el sitio web wiki de consejos de Vim.

3. Para crear un archivo OpenSSL.conf personalizado, ponga en marcha el siguiente comando de VIM:

   $ vi deviceRootCA_openssl.conf

4. Para editar el archivo .conf, presione i en el teclado. A continuación, copie y pegue lo siguiente en el archivo:

   [ 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 guardar el archivo.conf, presione Esc en el teclado y, a continuación, :wq!. Para salir del archivo, pulse Intro.

6. Para confirmar que se creó el archivo OpenSSL.conf, ponga en marcha el siguiente comando de Linux:

   $ cat deviceRootCA_openssl.conf

7. Cree una solicitud de firma de certificado (CSR) de CA raíz del dispositivo. Ponga en marcha el siguiente comando de OpenSSL:

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

8. Cree un certificado de CA raíz del dispositivo. Ponga en marcha el siguiente comando de OpenSSL:

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

9. Obtenga el código de registro de la región de AWS en la que desea usar JITP. Luego, ponga en marcha el siguiente comando de AWS CLI:

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

   Nota: Sustituya us-east-2 por la región en la que desee utilizar JITP.

10. Cree una clave de verificación. Ponga en marcha el siguiente comando de OpenSSL:

$ openssl genrsa -out verificationCert.key 2048

11. Cree un certificado de verificación CSR. Ponga en marcha el siguiente comando de OpenSSL:

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

A continuación, introduzca el Código de registro en el campo Nombre común. Por ejemplo: Nombre común (FQDN del servidor o SU nombre) []: xxxxxxxx8a33da.

Deje los demás campos en blanco.

12. Cree el certificado de verificación. Ponga en marcha el siguiente comando de OpenSSL:

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

Importante: El código de registro de la región de su CA raíz es obligatorio cuando AWS IoT Core certifica el certificado de verificación.

Para obtener más información, consulte Just-in-time: aprovisionamiento.

Creación de una plantilla JITP

1. Cree un rol de AWS Identity and Access Management (AWS IAM) para su servicio AWS IoT Core. Llámelo JITPRole. Para obtener instrucciones, consulte Create a logging role.

   Importante: Debe incluir el nombre de recurso de Amazon (ARN) del rol de IAM en la siguiente plantilla JITP.

2. Utilice el editor de texto VIM para crear un archivo JSON de plantilla JITP. Siga estos pasos:

3. Cree un archivo JSON de plantilla JITP. Ponga en marcha el siguiente comando de VIM:

   $ vi jitp_template.json

   Nota: Asegúrese de guardar la plantilla con el nombre de archivo jitp_template.json.

4. Presione i en el teclado para editar la plantilla JITP. A continuación, copie y pegue la siguiente plantilla JITP en el archivo:

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

   Nota: Sustituya el valor roleArn por el ARN del rol de IAM para su servicio de AWS IoT Core. Sustituya el valor por el ID de su cuenta de AWS. Sustituya us-east-2 por su región de AWS.

5. Pulse Esc en el teclado, seguido de :wq!, para guardar el archivo de la plantilla JITP.

6. Pulse Intro para salir del archivo.

Nota: Las siguientes políticas de IAM se incluyen en la plantilla JITP de ejemplo:

• AWSIoTLogging
• AWSIoTRuleActions
• AWSIoTThingsRegistration

Debe iniciar sesión en su cuenta de AWS para ver los enlaces a la política. Para obtener más información, consulte Plantillas de aprovisionamiento.

Registro del certificado de CA raíz autofirmado en AWS IoT Core

1. Registre la CA raíz del dispositivo como certificado de CA en AWS IoT Core.

2. Ponga en marcha el siguiente comando register-ca-certificate de 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

   Nota: Sustituya us-east-2 por la región en la que desee utilizar JITP.

Nota: Use el parámetro --registration-config para adjuntar la plantilla JITP creada al certificado de CA. Para devolver el ARN del certificado de CA, utilice la respuesta del comando.

Para obtener más información, consulte Register your CA certificate.

Creación de certificados de dispositivo y realización del JITP

Importante: Asegúrese de utilizar el mismo directorio en el que creó los archivos CA raíz del dispositivo original.

1. Descargue RootCA1 y guárdelo con el nombre de archivo awsRootCA.pem.

   Nota: El RootCA1 se utiliza para la autenticación del servidor de las solicitudes de publicación en AWS IoT Core. Para obtener más información, consulte CA certificates for server authentication.

2. Cree una clave privada del dispositivo. Ponga en marcha el siguiente comando de OpenSSL:

   $ openssl genrsa -out deviceCert.key 2048

3. Cree un dispositivo CSR. Ponga en marcha el siguiente comando de OpenSSL:

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

   Importante: La plantilla JITP de ejemplo requiere que el valor ThingName sea igual al valor CommonName del certificado. La plantilla también requiere que el valor CountryName sea igual al valor Country del certificado de CA. Por ejemplo:

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

   La plantilla JITP que se proporciona en este artículo también utiliza el parámetro de certificado AWS::IoT::Certificate::Country, que requiere que añada un valor. Otros posibles parámetros de certificado incluyen: 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. Cree un certificado de dispositivo. Ponga en marcha el siguiente comando de OpenSSL:

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

5. Combine el certificado de CA raíz y el certificado de dispositivo. Ponga en marcha el siguiente comando:

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

6. Use Eclipse Mosquitto para realizar una llamada de publicación de prueba a AWS IoT Core e iniciar el proceso JITP.

   Nota: También puede utilizar el AWS Device SDK para realizar llamadas de publicación a AWS IoT Core.

   Ejemplo de comando de llamada de publicación de prueba de Eclipse Mosquitto

   Importante: Sustituya a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com por su propio punto de enlace antes de poner en marcha el comando. Para confirmar su propio punto de enlace, abra la consola de AWS IoT Core. A continuación, seleccione Configuración. Su punto de enlace aparece en el panel Punto de enlace 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

   Ejemplo de respuesta del comando de llamada de publicación de prueba de Eclipse Mosquitto

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

   Nota: La llamada de publicación de prueba falla la primera vez. Cuando AWS IoT Core recibe la llamada de publicación de prueba, crea un certificado, una política y un objeto. También adjunta la Política al Certificado y, a continuación, adjunta el Certificado al Objeto. La próxima vez que realice el JITP, la Política de AWS IoT Core que se creó por primera vez será la que se utilizará. No se crea una nueva política de AWS IoT Core.

7. Confirme que se han creado los recursos necesarios de la siguiente manera:
   Abra la consola de AWS IoT Core.
   Elija Administrar.
   Elija Objetos.
   Elija DemoThing.

8. Compruebe que el certificado se creó y que está en estado ACTIVO. A continuación, seleccione Políticas y compruebe que la política de IAM esté adjunta.

Uso de los certificados de dispositivo en la operación general

Nota: El valor de ID de cliente que se añade al comando de publicación debe coincidir con el valor de ThingName que se creó durante el proceso de JITP. El Nombre del tema agregado al comando de publicación también debe seguir el formato ThingName/*. En la siguiente llamada de publicación, puede usar deviceCert.crt en lugar de deviceCertAndCACert.crt.

1. Abra la consola de AWS IoT Core.

2. Elija Pruebas.

3. En Tema de suscripción, escriba DemoThing/test.

4. Ponga en marcha el siguiente comando de llamada de publicación de Eclipse Mosquitto a AWS IoT Core:

   Importante: Sustituya a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com por su propio punto de enlace antes de poner en marcha el comando. Para confirmar su propio punto de enlace, abra la consola de AWS IoT Core. A continuación, seleccione Configuración. Su punto de conexión aparece en el panel Punto de conexión personalizado. Además, asegúrese de utilizar los certificados de dispositivo personalizados que generó su CA raíz 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

   Tras poner en marcha el comando, el mensaje se recibe en la consola de prueba de AWS IoT Core.

Creación de certificados de dispositivo adicionales

Para crear certificados de dispositivo adicionales y registrarlos en AWS IoT Core, repita los pasos que se describen en la sección Creación de certificados de dispositivo y realización del JITP.

Otras plantillas de JITP

Para obtener el valor de ThingName del campo CommonName del certificado y proporcionar permisos de administrador en la política, utilice la siguiente plantilla JITP:

{
 "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 obtener el valor de ThingName del campo CommonName del certificado y proporcionar un nombre de política predefinido, utilice la siguiente plantilla JITP:

{
 "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: Sustituya Policy_Name por el nombre de la política que desea usar.