Comment puis-je utiliser JITP avec AWS IoT Core ?

Brève description

Pour configurer un environnement JITP avec AWS IoT Core, enregistrez d'abord votre autorité de certification auprès d'AWS IoT Core. Ensuite, attachez un modèle d'approvisionnement à votre autorité de certification.

Solution

Remarque : si vous recevez des erreurs lors de l'exécution de commandes depuis l'interface de ligne de commande AWS (AWS CLI), assurez-vous d'utiliser la version la plus récente de l'AWS CLI.

Créer une autorité de certification racine auto-signée et un certificat de vérification

1.    Si vous ne l'avez pas encore fait, installez OpenSSL.

2.    Créez une clé privée d'autorité de certification racine d'appareil en exécutant la commande OpenSSL suivante :

$ openssl genrsa -out deviceRootCA.key 2048

3.    À l'aide de l'éditeur de texte VIM, créez un fichier OpenSSL.conf personnalisé. Pour créer et modifier un fichier OpenSSL.conf personnalisé, procédez comme suit :
Créez un fichier OpenSSL.conf personnalisé en exécutant la commande VIM suivante :

$ vi deviceRootCA_openssl.conf

Appuyez sur la touche i du clavier pour modifier le fichier .conf. Ensuite, copiez et collez ce qui suit dans le fichier :

[ 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

Appuyez sur Échap sur votre clavier, suivi de :wq! pour enregistrer le fichier .conf. Appuyez ensuite sur Entrée pour fermer le fichier.
Remarque : pour confirmer la création du fichier OpenSSL.conf, vous pouvez exécuter la commande Linux suivante :

$ cat deviceRootCA_openssl.conf

4.    Créez une demande de signature de certificat (CSR) d'une autorité de certification racine d'appareil en exécutant la commande OpenSSL suivante :

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

5.    Créez un certificat d'autorité de certification racine d'appareil en exécutant la commande OpenSSL suivante :

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

6.    Récupérez le code d'enregistrement pour la Région AWS dans laquelle vous voulez utiliser JITP en exécutant la commande AWS CLI suivante :

Important : assurez-vous de remplacer us-east-2 par la Région dans laquelle vous voulez utiliser JITP.

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

7.    Créez une clé de vérification en exécutant la commande OpenSSL suivante :

$ openssl genrsa -out verificationCert.key 2048

8.    Créez un certificat de vérification CSR en exécutant la commande OpenSSL suivante :

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

Saisissez ensuite le Registration Code (Code d'enregistrement) dans le champ Common Name (Nom commun). Par exemple : nom commun [FQDN (nom de domaine pleinement qualifié) du serveur ou VOTRE nom] [] : xxxxxxxx8a33da. Laissez les autres champs vides.

9.    Créez le certificat de vérification en exécutant la commande OpenSSL suivante :

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

Important : le code d'enregistrement de la Région de votre autorité de certification racine est requis pour que le certificat de vérification soit certifié par AWS IoT Core.

Pour plus d'informations, consultez Approvisionnement juste-à-temps.

Créer un modèle JITP

1.    Créez un rôle AWS Identity and Access Management (IAM) pour votre service AWS IoT Core et nommez-le JITPRole. Pour obtenir des instructions, consultez la section Créer un rôle de journalisation (étapes un et deux).

Important : vous devez inclure l'Amazon Resource Name (ARN) du rôle IAM dans le modèle JITP suivant.

2.    À l'aide de l'éditeur de texte VIM, créez un fichier JSON de modèle JITP en procédant comme suit :
Créez un fichier JSON de modèle JITP en exécutant la commande VIM suivante :

$ vi jitp_template.json

Important : assurez-vous d'enregistrer le modèle sous le nom de fichier jitp_template.json.
Appuyez sur la touche i du clavier pour modifier le modèle JITP. Ensuite, copiez et collez le modèle JITP suivant dans le fichier :

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

Important : remplacez la valeur roleArn par l'ARN de rôle IAM pour votre service AWS IoT Core. Remplacez la valeur <ACCOUNT_ID> par votre ID de compte AWS. Remplacez us-east-2 par la Région AWS que vous utilisez. Appuyez sur la touche Échap de votre clavier, puis sur :wq! pour enregistrer le fichier de modèle JITP. Appuyez sur Entrée pour fermer le fichier.

Remarque : les politiques IAM suivantes sont incluses dans modèle JITP d'exemple :

• AWSIoTLogging
• AWSIoTRuleActions
• AWSIoTThingsRegistration

Vous devez être connecté à votre compte AWS pour afficher les liens de stratégie. Pour plus d'information, consultez Modèles d'approvisionnement.

Enregistrez votre certificat d'autorité de certification racine auto-signé auprès d'AWS IoT Core

Enregistrez l'autorité de certification racine de l'appareil en tant que certificat d'une autorité de certification dans AWS IoT Core en exécutant la commande AWS CLI register-ca-certificate suivante :

Important : assurez-vous de remplacer us-east-2 par la Région dans laquelle vous voulez utiliser 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

Remarque : l'ajout du paramètre --registration-config attache le modèle JITP que vous avez créé au certificat de l'autorité de certification. La réponse à la commande renvoie l'ARN du certificat d'autorité de certification.

Pour plus d'informations, consultez la section Enregistrer votre certificat d'autorité de certification.

Créer des certificats d'appareil et exécuter JITP

Important : assurez-vous d'utiliser le même répertoire que celui où vous avez créé les fichiers d'autorité de certification racine de l'appareil d'origine.

1.    Téléchargez RootCA1 et enregistrez-le avec le nom de fichier awsRootCA.pem.
Remarque : Le RootCA1 sert à l'authentification côté serveur des demandes de publication vers AWS IoT Core. Pour plus d'informations, consultez Certificats d'autorité de certification pour l'authentification du serveur.

2.    Créez une clé privée d'appareil en exécutant la commande OpenSSL suivante :

$ openssl genrsa -out deviceCert.key 2048

3.    Créez une demande de signature de certificat d'appareil en exécutant la commande OpenSSL suivante :

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

Important : l'exemple de modèle JITP requiert que la valeur ThingName soit égale à la valeur CommonName du certificat. Le modèle requiert également que la valeur CountryName soit égale à la valeur Country dans le certificat d'autorité de certification. Par exemple :

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

Le modèle JITP fourni dans cet article utilise également le paramètre de certificat AWS::IoT::Certificate::Country, ce qui vous oblige à ajouter une valeur. D'autres paramètres de certificat potentiels incluent : 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.    Créez un certificat d'appareil en exécutant la commande OpenSSL suivante :

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

5.    Associez le certificat d'autorité de certification racine et le certificat d'appareil en exécutant la commande suivante :

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

6.    Utilisez Eclipse Mosquitto pour lancer un appel de publication de test vers AWS IoT Core et lancer le processus JITP.

Remarque : vous pouvez également utiliser le kit SDK pour les appareils AWS pour effectuer des appels de publication vers AWS IoT Core.

Exemple de commande d'appel de publication de test Eclipse Mosquitto

Important : remplacez a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com par votre propre point de terminaison avant d'exécuter la commande. Pour confirmer votre propre point de terminaison, ouvrez la console AWS IoT Core. Ensuite, choisissez Settings (Paramètres). Votre point de terminaison est répertorié dans le panneau Point de terminaison personnalisé.

$ 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

Exemple de réponse de la commande d'appel de publication de test Eclipse Mosquitto

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

Remarque : l'appel de publication de test échoue la première fois. Lorsqu'AWS IoT Core reçoit l'appel de publication de test, il crée un certificat, une politique et un objet. Il attache également la politique au certificat, puis le certificat à l'objet. La prochaine fois que vous exécutez JITP, la politique IoT qui a été créée en premier lieu est celle qui est utilisée. Une nouvelle politique IoT n'est pas créée.

7.    Assurez-vous que les ressources requises ont été créées en procédant comme suit : Ouvrez la console AWS IoT Core. Choisissez Manage (Gérer). Choisissez Things (Objets). Choisissez DemoThing.
Vérifiez que le certificat a été créé et qu'il est à l'état ACTVE (ACTIF).
Ensuite, sélectionnez Stratégies et vérifiez que la stratégie IAM est jointe.

Utiliser les certificats d'appareil en général

Remarque : la valeur Client ID qui est ajoutée dans la commande de publication doit être la même que ThingName, qui a été créé au cours du processus JITP. La valeur Topic Name ajoutée à la commande de publication doit également suivre le format ThingName/*. Dans le prochain appel de publication, vous pouvez utiliser deviceCert.crt au lieu de deviceCertAndCACert.crt.

1.    Ouvrez la console AWS IoT Core.

2.    Sélectionnez Test.

3.    Pour Rubrique d'abonnement, entrez DemoThing/test.

4.    Exécutez la commande d'appel de publication Eclipse Mosquitto suivante sur AWS IoT Core :

Important : remplacez a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com par votre propre point de terminaison avant d'exécuter la commande. Pour confirmer votre propre point de terminaison, ouvrez la console AWS IoT Core. Ensuite, choisissez Settings (Paramètres). Votre point de terminaison apparaît dans le volet Point de terminaison personnalisé. Assurez-vous également d'utiliser les certificats d'appareil personnalisés qui ont été générés par votre autorité de certification racine personnalisée.

$ 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

Après avoir exécuté la commande, vous verrez que le message est reçu sur la console AWS IoT Core Test.

Créer des certificats d'appareil supplémentaires

Pour créer d'autres certificats d'appareil et les enregistrer dans AWS IoT Core, répétez les étapes décrites dans la section Créer des certificats d'appareil et exécuter JITP.

Autres modèles JITP

Pour extraire la valeur ThingName du champ CommonName du certificat et pour fournir des autorisations d'admin dans la stratégie, utilisez le modèle JITP suivant :

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

Pour extraire la valeur ThingName du champ CommonName du certificat et fournir un nom de stratégie prédéfini, utilisez le modèle JITP suivant :

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

Important : remplacez Policy_Name par le nom de stratégie de votre choix.

---