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. Come faccio a configurare JITP con AWS IoT Core?

Breve descrizione

Per configurare un ambiente JITP con AWS IoT Core, registra innanzitutto la tua CA con AWS IoT Core. Quindi, allega un modello di provisioning alla CA.

Risoluzione

Nota: se ricevi errori durante l'esecuzione dei comandi dell'Interfaccia a riga di comando di AWS (AWS CLI), assicurati di utilizzare la versione più recente di AWS CLI.

Crea una CA root autofirmata e un certificato di verifica

  1. Se non l'hai già fatto, installa OpenSSL.

  2. Crea una chiave privata CA root del dispositivo eseguendo il seguente comando OpenSSL:

$ openssl genrsa -out deviceRootCA.key 2048
  1. Utilizzando l’editor di testo VIM, crea un file OpenSSL.conf personalizzato. Per creare e modificare un file OpenSSL.conf personalizzato, effettua le seguenti operazioni:
    Crea un file OpenSSL.conf personalizzato eseguendo il seguente comando VIM:
$ vi deviceRootCA_openssl.conf

Premi i sulla tastiera per modificare il file.conf. Quindi, copia e incolla quanto segue nel file:

[ 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

Premi esc sulla tastiera, seguito da**:wq!** per salvare il file.conf. Quindi, premi Invio per uscire dal file.
**Nota:**Per confermare che il file OpenSSL.conf è stato creato, puoi eseguire il seguente comando Linux:

$ cat deviceRootCA_openssl.conf
  1. Crea una richiesta di firma del certificato CA root (CSR) del dispositivo eseguendo il seguente comando OpenSSL:
$ openssl req -new -sha256 -key deviceRootCA.key -nodes -out deviceRootCA.csr -config deviceRootCA_openssl.conf
  1. Crea un certificato CA root del dispositivo eseguendo 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
  1. Recupera il codice di registrazione per la regione AWS in cui desideri utilizzare JITP eseguendo il seguente comando AWS CLI:

**Importante:**assicurati di sostituire us-east-2 con la regione in cui desideri utilizzare JITP.

$ aws iot get-registration-code --region us-east-2
  1. Crea una chiave di verifica eseguendo il seguente comando OpenSSL:
$ openssl genrsa -out verificationCert.key 2048
  1. Crea un certificato di verifica CSR eseguendo 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 eseguendo 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 CA root è necessario affinché il certificato di verifica sia certificato da AWS IoT Core.

Per ulteriori informazioni, consulta Just-in-time provisioning.

Crea un modello JITP

  1. Crea un ruolo AWS Identity and Access Management (IAM)per il tuo servizio AWS IoT Core e chiamalo jitProle. Per istruzioni, consulta Creare un ruolo di registrazione (passaggi uno e due).

**Importante:**devi includere l'Amazon Resource Name (ARN) del ruolo IAM nel seguente modello JITP.

  1. Utilizzando l'editor di testo VIM, crea un file JSON modello JITP effettuando le seguenti operazioni:
    Crea un file JSON modello JITP eseguendo il seguente comando VIM:
$ vi jitp_template.json

**Importante:assicurati di salvare il modello con il nome di file ** jitp\ _template.json.
Premi i sulla tastiera per modificare il modello JITP. Quindi, copia e incolla il seguente modello 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"
}

**Importante:**sostituisci il valore RolEarn con IAM Role ARN per il tuo servizio AWS IoT Core. Sostituisci il valore <ACCOUNT\ _ID> con l'ID del tuo account AWS. Sostituisci us-east-2 con la regione AWS che stai utilizzando. Premi esc sulla tastiera, seguito da :wq! per salvare il file modello JITP. Scegli Invio per uscire dal 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.

Registra il tuo certificato CA root autofirmato con AWS IoT Core

Registra la CA root del dispositivo come certificato CA in AWS IoT Core eseguendo il seguente comando register-ca-certificate AWS CLI:

**Importante:**assicurati di sostituire us-east-2 con la regione in cui desideri utilizzare JITP.

$ 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:**l'aggiunta del parametro --registration-config allega il modello JITP creato al certificato CA. La risposta al comando restituisce l'ARN del certificato CA.

Per ulteriori informazioni, consulta Registrare il certificato CA.

Crea certificati di dispositivo ed esegui JITP

**Importante:**assicurati di utilizzare la stessa directory in cui hai creato i file CA root del dispositivo originale.

  1. Scarica RootCA1 e salvalo con il nome del file AWSRootCA.pem.
    **Nota:**il RootCA1 viene utilizzato per l'autenticazione lato server delle richieste di pubblicazione su AWS IoT Core. Per ulteriori informazioni, consulta Certificati CA per l'autenticazione del server.

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

$ openssl genrsa -out deviceCert.key 2048
  1. Crea un CSR del dispositivo eseguendo il seguente comando OpenSSL:
$ openssl req -new -key deviceCert.key -out deviceCert.csr

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

Country Name (two-letter code) []:IN
Common Name (eg. 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

  1. Crea un certificato del dispositivo eseguendo il seguente comando OpenSSL:
$ openssl x509 -req -in deviceCert.csr -CA deviceRootCA.pem -CAkey deviceRootCA.key -CAcreateserial -out deviceCert.crt -days 365 -sha256
  1. Combina il certificato CA root e il certificato del dispositivo eseguendo il seguente comando:
$ cat deviceCert.crt deviceRootCA.pem > deviceCertAndCACert.crt
  1. Usa Eclipse Mosquitto per effettuare una chiamata di pubblicazione 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 Eclipse Mosquitto test publish call

**Importante:**sostituisci a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com con il tuo endpoint prima di eseguire il comando. Per confermare il tuo endpoint, apri la console AWS IoT Core. Quindi, scegli Impostazioni. Il tuo endpoint è elencato 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 Eclipse Mosquitto test publish call

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

**Nota:**La chiamata di pubblicazione del test non riesce la prima volta. Quando AWS IoT Core riceve la chiamata di pubblicazione del test, crea un certificato, una policy e un oggetto. Inoltre, allega la Policy al Certificato e quindi allega il Certificato all'Oggetto. La prossima volta che eseguirai JITP, la policy IoT che è stata creata per la prima volta sarà quella utilizzata. Non è stata creata una nuova policy IoT.

  1. Conferma che le risorse richieste sono state create effettuando le seguenti operazioni: Apri la console AWS IoT Core. Scegli Gestisci. Scegli **Oggetti.**Scegli DemoThing.
    Verifica che il certificato sia stato creato e sia nello stato ATTIVO.
    Quindi, scegli Policy e verifica che la policy IAM sia allegata.

Usa i certificati dei dispositivi durante il funzionamento generale

**Nota:**il valore del Client ID aggiunto nel comando publish deve essere lo stesso di ThingName creato durante il processo JITP. Anche il Nome dell'argomento aggiunto al comando publish deve seguire il formato ThingName/*. Nella successiva chiamata di pubblicazione, potete utilizzare deviceCert.crt anziché deviceCertAndCACert.crt.

  1. Apri la console AWS IoT Core.

  2. Scegli Test.

  3. Per l'argomento dell'abbonamento, inserisci Demothing/test.

  4. Esegui il seguente comando di chiamata di pubblicazione 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 il tuo 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, vedrai che il messaggio viene ricevuto sulla console di AWS IoT Core Test.

Crea certificati per dispositivi aggiuntivi

Per creare altri certificati di dispositivo e registrarli su AWS IoT Core, ripeti i passaggi descritti nella sezione Crea certificati di dispositivo ed esegui 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 di tua scelta.


AWS UFFICIALE
AWS UFFICIALEAggiornata 2 anni fa