Come posso usare JITP con AWS IoT Core?

10 minuti di lettura
0

Desidero configurare un ambiente JITP (just-in-time provisioning) con un'autorità di certificazione root (CA) personalizzata registrata con AWS IoT Core.

Breve descrizione

Per configurare un ambiente JITP con AWS IoT Core, registra il certificato CA con AWS IoT Core. Quindi, collega un modello di provisioning alla CA.

Risoluzione

Nota: se ricevi messaggi di errore durante l'esecuzione dei comandi dell'interfaccia della linea di comando AWS (AWS CLI), consulta Troubleshooting errors for the AWS CLI (Risoluzione degli errori per AWS CLI). Inoltre, assicurati di utilizzare la versione più recente di AWS CLI.

Creazione di una CA root autofirmata e un certificato di verifica

Prerequisito:

Installa OpenSSL.

Per creare una CA root autofirmata e un certificato di verifica, procedi come segue:

  1. Crea una chiave privata CA root del dispositivo ed esegui il seguente comando OpenSSL:

    $ openssl genrsa -out deviceRootCA.key 2048
  2. Apri l'editor di testo VIM, quindi crea un file OpenSSL.conf personalizzato. Per ulteriori informazioni sull'editor di testo VIM, consulta Tutorial sul sito Web di Vim Tips Wiki.

  3. Per creare un file OpenSSL.conf personalizzato, esegui il seguente comando VIM:

    $ vi deviceRootCA_openssl.conf
  4. Per modificare il file .conf, premi i sulla tastiera. Quindi, copia e incolla nel file il contenuto seguente:

    [ 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. Per salvare il file .conf, premi Esc sulla tastiera, quindi premi :wq! sulla tastiera. Per chiudere il file, premi Invio.

  6. Per confermare che il file OpenSSL.conf è stato creato, esegui il seguente comando Linux:

    $ cat deviceRootCA_openssl.conf
  7. Crea una richiesta di firma del certificato (CSR) della CA root del dispositivo. Esegui il seguente comando OpenSSL:

    $ openssl req -new -sha256 -key deviceRootCA.key -nodes -out deviceRootCA.csr -config deviceRootCA_openssl.conf
  8. Crea un certificato della CA root del dispositivo. Esegui il seguente comando OpenSSL:

    $ openssl x509 -req -days 3650 -extfile deviceRootCA_openssl.conf -extensions v3_ca -in deviceRootCA.csr -signkey deviceRootCA.key -out deviceRootCA.pem
  9. Recupera il codice di registrazione per la Regione AWS in cui desideri utilizzare JITP. Quindi, esegui il seguente comando AWS CLI:

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

    Nota: sostituisci us-east-2 con la Regione in cui desideri utilizzare JITP.

  10. Crea una chiave di verifica. Esegui il seguente comando OpenSSL:

$ openssl genrsa -out verificationCert.key 2048
  1. Crea una CSR del certificato di verifica. Esegui il seguente comando OpenSSL:
$ openssl req -new -key verificationCert.key -out verificationCert.csr

Quindi, inserisci il Codice di registrazione nel campo Nome comune. Ad esempio: Nome comune (FQDN del server o il TUO nome) []: xxxxxxxx8a33da.

Lascia gli altri campi vuoti.

  1. Crea il certificato di verifica. Esegui il seguente comando OpenSSL:
$ openssl x509 -req -in verificationCert.csr -CA deviceRootCA.pem -CAkey deviceRootCA.key -CAcreateserial -out verificationCert.crt -days 500 -sha256

Importante: il codice di registrazione della Regione della CA root è obbligatorio quando AWS IoT Core esegue la certificazione del certificato di verifica.

Per ulteriori informazioni, consulta Just-in-time provisioning (Provisioning just-in-time).

Creazione di un template JITP

  1. Crea un ruolo AWS Identity and Access Management (AWS IAM) per il servizio AWS IoT Core. Chiamalo JITPRole. Per istruzioni, consulta Create a logging role (Creazione di un ruolo di registrazione).

    Importante: nel seguente template JITP, devi includere il nome della risorsa Amazon (ARN) del ruolo IAM.

  2. Utilizza l'editori di testo VIM per creare un file JSON del template JITP. Completa i seguenti passaggi:

  3. Crea un file JSON del template JITP. Esegui il seguente comando VIM:

    $ vi jitp_template.json

    Nota: assicurati di salvare il template con il nome file jitp\ _template.json.

  4. Per modificare il template JITP, premi i sulla tastiera. Quindi, copia e incolla il seguente template JITP nel file:

    {
     "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: sostituisci il valore roleArn con l'ARN del ruolo IAM per il servizio AWS IoT Core. Sostituisci il valore con l'ID dell'account AWS. Sostituisci us-east-2 con la Regione AWS.

  5. Per salvare il file del template JITP, premi Esc sulla tastiera, seguito da :wq!.

  6. Scegli Invio per chiudere il file.

**Nota:**le seguenti policy IAM sono incluse nel modello JITP di esempio:

Devi accedere al tuo account AWS per visualizzare i link alle politiche. Per ulteriori informazioni, consulta Modelli di provisioning.

Registrazione del certificato CA root autofirmato con AWS IoT Core

  1. Registra la CA root del dispositivo come un certificato CA in AWS IoT Core.

  2. Esegui il seguente comando AWS CLI register-ca-certificate:

    $ 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: sostituisci us-east-2 con la Regione in cui desideri utilizzare JITP.

Nota: utilizza il parametro --registration-config per collegare il modello JITP creato al certificato CA. Per restituire l'ARN del certificato CA, utilizza la risposta al comando.

Per ulteriori informazioni, consulta Register your CA certificate (Registrazione del certificato CA).

Creazione di certificati di dispositivo ed esecuzione di JITP

Importante: assicurati di utilizzare la stessa directory in cui sono stati creati i file CA root del dispositivo originale.

  1. Scarica RootCA1 e salvalo con il nome file AWSRootCA.pem.

    Nota: RootCA1 viene utilizzato per l'autenticazione lato server delle richieste di pubblicazione su AWS IoT Core. Per ulteriori informazioni, consulta CA certificates for server authentication (Certificati CA per l'autenticazione del server).

  2. Crea una chiave privata del dispositivo. Esegui il seguente comando OpenSSL:

    $ openssl genrsa -out deviceCert.key 2048
  3. Crea un dispositivo CSR. Esegui il seguente comando OpenSSL:

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

    Importante: il template JITP di esempio richiede che il valore ThingName sia uguale al valore CommonName del certificato. Il template richiede inoltre che il valore CountryName sia uguale al valore Country nel certificato CA. Ad esempio:

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

    Il modello JITP fornito in questo articolo utilizza anche il parametro del certificatoAWS::IoT::Certificate: :Country, che richiede l'aggiunta di un valore. Altri potenziali parametri del certificato includono: 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. Crea un certificato del dispositivo. Esegui il seguente comando OpenSSL:

    $ openssl x509 -req -in deviceCert.csr -CA deviceRootCA.pem -CAkey deviceRootCA.key -CAcreateserial -out deviceCert.crt -days 365 -sha256
  5. Combina il certificato CA root e il certificato del dispositivo. Esegui il comando seguente:

    $ cat deviceCert.crt deviceRootCA.pem > deviceCertAndCACert.crt
  6. Utilizza Eclipse Mosquitto per effettuare una chiamata publish di prova su AWS IoT Core e avviare il processo JITP.

    Nota: puoi anche utilizzare AWS Device SDK per effettuare chiamate Publish verso AWS IoT Core.

    Esempio di comando test publish call di Eclipse Mosquitto

    Importante: prima di eseguire il comando, sostituisci a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com con il tuo endpoint. Per confermare l'endpoint, apri la console AWS IoT Core. Quindi, scegli Impostazioni. L'endpoint viene visualizzato nel riquadro Endpoint personalizzato.

    $ 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

    Esempio di risposta dal comando test publish call di Eclipse Mosquitto

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

    Nota: il comando test publish call non va a buon fine la prima volta. Quando AWS IoT Core riceve il comando test publish call, crea un certificato, una policy e un oggetto. Inoltre, collega la Policy al Certificato e quindi collega il Certificato all'Oggetto. La prossima volta che esegui JITP, viene utilizzata la policy AWS IoT creata per prima. Non viene creata una nuova policy AWS IoT Core.

  7. Conferma che le risorse richieste siano state create eseguendo le seguenti operazioni:
    Apri la console AWS IoT Core.
    Scegli Gestisci.
    Scegli Oggetti.
    Scegli DemoThing.

  8. Verifica che il certificato sia stato creato e sia in stato ATTIVO. Quindi, scegli Policy e verifica che la policy IAM sia collegata.

Utilizzo di certificati di dispositivo durante il funzionamento generale

Nota: il valore dell'ID client aggiunto nel comando publish deve corrispondere a ThingName creato durante il processo JITP. Anche il Nome argomento aggiunto al comando publish deve seguire il formato ThingName/*. Nella successiva chiamata di pubblicazione, puoi utilizzare deviceCert.crt anziché deviceCertAndCACert.crt.

  1. Apri la console AWS IoT Core.

  2. Scegli Test.

  3. Per Argomento sottoscrizione, inserisci DemoThing/test.

  4. Esegui il seguente comando publish call di Eclipse Mosquitto su AWS IoT Core:

    Importante: sostituisci a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com con il tuo endpoint prima di eseguire il comando. Per confermare l'endpoint, apri la console AWS IoT Core. Quindi, scegli Impostazioni. L'endpoint viene visualizzato nel riquadro Endpoint personalizzato. Inoltre, assicurati di utilizzare i certificati di dispositivo personalizzati generati dalla CA root personalizzata.

    $ 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

    Dopo aver eseguito il comando, il messaggio viene ricevuto sulla console di test di AWS IoT Core.

Creazione di certificati di dispositivo aggiuntivi

Per creare altri certificati di dispositivo e registrarli su AWS IoT Core, ripeti i passaggi descritti nella sezione Creazione di certificati di dispositivo ed esecuzione di JITP.

Altri modelli JITP

Per recuperare il valore ThingName dal campo CommonName del certificato e fornire le autorizzazioni di amministratore nella policy, utilizza il seguente modello 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"
}

Per recuperare il valore ThingName dal campo CommonName del certificato e fornire un nome di policy predefinito, utilizzate il seguente modello 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: sostituisci Policy\ _Name con il nome della policy che desideri utilizzare.

AWS UFFICIALE
AWS UFFICIALEAggiornata 3 mesi fa