Comment configurer JITP avec AWS IoT Core ?

Date de la dernière mise à jour : 15/02/2021

Je souhaite configurer un environnement d'allocation juste-à-temps (JITP) qui a une autorité de certification (CA) racine personnalisée enregistrée auprès d'AWS IoT Core. Comment puis-je procéder ?

Brève description

Pour configurer un environnement d'allocation juste-à-temps (JITP) avec AWS IoT Core, enregistrez d'abord votre autorité de certification auprès d'AWS IoT Core, puis joignez un modèle d'allocation à votre autorité de certification.

Résolution

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

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

1.    Si vous ne l'avez pas déjà fait, installez OpenSSL.

2.    Exécutez la commande OpenSSL suivante pour créer une clé privée d'autorité de certification racine d'appareil :

$ openssl genrsa -out deviceRootCA.key 2048

3.    À l'aide de l'éditeur de texte VIM, créez un fichier OpenSSL.conf personnalisé en procédant comme suit : exécutez la commande VIM suivante pour créer un fichier OpenSSL.conf personnalisé :

$ 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 : Vous pouvez ensuite exécuter la commande Linux suivante pour confirmer la création du fichier OpenSSL.conf :

$ cat deviceRootCA_openssl.conf

4.    Exécutez la commande OpenSSL suivante pour créer une demande de signature de certificat (CSR) d'une autorité de certification racine :

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

5.    Exécutez la commande OpenSSL suivante pour créer un certificat d'autorité de certification racine d'appareil :

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

6.    Exécutez la commande AWS CLI suivante pour obtenir le code d'enregistrement pour la région AWS dans laquelle vous souhaitez utiliser JITP :

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

Remarque : assurez-vous de remplacer us-east-2 par la région dans laquelle vous souhaitez utiliser JITP.

7.    Exécutez la commande OpenSSL suivante pour créer une clé de vérification :

$ openssl genrsa -out verificationCert.key 2048

8.    Exécutez la commande OpenSSL suivante pour créer une demande de signature de certificat de vérification :

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

Remarque : entrez le code d'enregistrement dans le champ Nom commun. Par exemple : Nom commun (nom de domaine commun du serveur ou VOTRE nom) [] : xxxxxxxx8a33da. Laissez les autres champs vides.

9.    Exécutez la commande OpenSSL suivante pour créer le certificat de vérification :

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

Remarque : 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, voir Allocation 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 consulter la procédure détaillée, reportez-vous à la section Créer un rôle de journalisation (étapes 1 et 2).
Remarque : 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 :
Exécutez la commande VIM suivante pour créer un fichier JSON de modèle JITP :

$ vi jitp_template.json

Important : veillez à 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 du rôle IAM de 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 stratégies IAM suivantes sont incluses dans l'exemple de modèle JITP :
AWSIoTLogging
AWSIoTRuleActions
AWSIoTThingsRegistration

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

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

Exécutez la commande register-ca-certificate suivante pour enregistrer l'autorité de certification racine de l'appareil en tant que certificat d'une autorité de certification dans AWS IoT Core :

Remarque : assurez-vous de remplacer us-east-2 par la région dans laquelle vous souhaitez 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 joint le modèle JITP que vous avez créé au certificat d'une autorité de certification. La réponse de la commande va renvoyer l'ARN du certificat d'une autorité de certification.

Pour plus d'informations, voir Enregistrer votre certificat d'une 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 : RootCA1 sert à l'authentification côté serveur des demandes de publication vers AWS IoT Core. Pour plus d'informations, consultez Certificats d'une autorité de certification pour l'authentification du serveur.

2.    Exécutez la commande OpenSSL suivante pour créer une clé privée de périphérique :

$ openssl genrsa -out deviceCert.key 2048

3.    Exécutez la commande OpenSSL suivante pour créer une demande de signature de certificat d'appareil :

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

Remarque : l'exemple de modèle JITP nécessite 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'une 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 sont les suivants :
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.    Exécutez la commande OpenSSL suivante pour créer un certificat d'appareil :

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

5.    Exécutez la commande suivante pour associer le certificat d'une autorité de certification racine et le certificat d'appareil :

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

6.    Utilisez Eclipse Mosquitto pour lancer un appel de publication factice vers AWS IoT Core et lancer le processus JITP. Assurez-vous d'entrer des valeurs pour les champs suivants avant d'exécuter la commande : ClientID (entrez le texte factice) Topic Name (entrez le texte factice) AWS Root CA 1 Certificate Device private key rootCA + deviceCert AWS IoT -ats Endpoint 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 factice Eclipse Mosquitto

$ 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

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, sélectionnez Paramètres. Votre point de terminaison est répertorié dans le volet Point de terminaison personnalisé.

Exemple de réponse de la commande d'appel de publication factice 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 factice échoue la première fois. Lorsqu'AWS IoT Core reçoit l'appel de publication factice, il crée un certificat, une stratégie et un objet. Il joint également la stratégie au certificat, puis le certificat à l'objet. La prochaine fois que vous exécutez JITP, la stratégie IoT qui a été créée en premier lieu est celle qui sera utilisée. Une stratégie IoT ne sera pas créée.

7.    Pour confirmer la création de ressources, procédez comme suit :
Ouvrez la console AWS IoT Core.
Sélectionnez Gérer.
Sélectionnez Objets.
Sélectionnez DemoThing.
Vérifiez que le certificat a été créé et qu'il est à l'état 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 :

$ 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

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, sélectionnez 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.

Après avoir exécuté la commande, vous verrez que le message est reçu sur la console 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.


Cet article vous a-t-il été utile ?


Besoin d'aide pour une question technique ou de facturation ?