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 certificat CA auprès d'AWS IoT Core. Puis, joignez un modèle de provisionnement à votre autorité de certification.

Résolution

Remarque : Si des erreurs surviennent lorsque vous exécutez des commandes de l'interface de la ligne de commande AWS (AWS CLI), consultez la section Résoudre des erreurs liées à l’AWS CLI. Vérifiez également que vous utilisez bien 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

Prérequis :

Installez OpenSSL.

Pour créer une autorité de certification racine auto-signée et un certificat de vérification, procédez comme suit :

1. Créez une clé privée CA racine de l'appareil et exécutez la commande OpenSSL suivante :

   $ openssl genrsa -out deviceRootCA.key 2048

2. Ouvrez l'éditeur de texte VIM, puis créez un fichier OpenSSL.conf personnalisé. Pour plus d'informations sur l'éditeur de texte VIM, consultez le didacticiel sur le site web de Vim Tips Wiki.

3. Pour créer un fichier OpenSSL.conf personnalisé, exécutez la commande VIM suivante :

   $ vi deviceRootCA_openssl.conf

4. Pour modifier le fichier .conf, appuyez sur la touche i du clavier. Puis, copiez et collez les éléments suivants 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 (e.g., company)
   organizationName_default = AMZ

5. Pour enregistrer le fichier .conf, appuyez sur la touche Échap du clavier, puis appuyez sur :wq! sur le clavier. Pour quitter le fichier, appuyez sur Entrée.

6. Pour vérifier que le fichier OpenSSL.conf a bien été créé, exécutez la commande Linux suivante :

   $ cat deviceRootCA_openssl.conf

7. Créez une requête de signature de certificat (CSR) CA à la racine de l'appareil. Exécutez la commande OpenSSL suivante :

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

8. Créez un certificat CA racine de l'appareil. Exécutez 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

9. Récupérez le code d'enregistrement de la région AWS dans laquelle vous souhaitez utiliser JITP. Puis, exécutez la commande suivante de l'interface de ligne de commande AWS :

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

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

10. Créez une clé de vérification. Exécutez la commande OpenSSL suivante :

$ openssl genrsa -out verificationCert.key 2048

11. Créez un certificat de vérification CSR. Exécutez la commande OpenSSL suivante :

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

Puis, saisissez le code d'enregistrement dans le champ Nom commun. Exemple : Nom commun (nom de domaine complet du serveur ou VOTRE nom) []: xxxxxxxx8a33da.

Laissez les autres champs vides.

12. Créez le certificat de vérification. Exécutez 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 lorsqu'AWS IoT Core certifie le certificat de vérification.

Pour plus d'informations, consultez la section 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. Nommez-le JITPRole. Pour obtenir des instructions, consultez la section Créer un rôle de journalisation.

   Important : Dans le modèle JITP suivant, vous devez inclure le nom de ressource Amazon (ARN) du rôle IAM.

2. Utilisez l'éditeur de texte VIM pour créer un fichier JSON de modèle JTP. Effectuez les opérations suivantes :

3. Créez un fichier JSON de modèle JITP. Exécutez la commande VIM suivante :

   $ vi jitp_template.json

   Remarque : Assurez-vous d'enregistrer le modèle sous le nom de fichier jitp_template.json.

4. Pour modifier le modèle JITP, appuyez sur i sur le clavier. Puis, 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"
   }

   Remarque : Remplacez la valeur de roleArn par l'ARN du rôle IAM pour votre service AWS IoT Core. Remplacez la valeur par votre ID de compte AWS. Remplacez us-east-2 par votre région AWS.

5. Pour enregistrer le fichier modèle JITP, appuyez sur la touche Échap de votre clavier, puis sur :wq!.

6. Sélectionnez Entrée pour quitter 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 consulter les liens de stratégie. Pour plus d'informations, consultez la section Modèles de provisionnement.

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

1. Enregistrez l'autorité de certification racine de l'appareil en tant que certificat CA dans AWS IoT Core.

2. Exécutez la commande d'interface de ligne de commande AWS register-ca-certificate suivante :

   $ 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 : Remplacez us-east-2 par la région dans laquelle vous souhaitez utiliser JITP.

Remarque : Utilisez le paramètre --registration-config pour attacher le modèle JITP que vous avez créé au certificat CA. Pour renvoyer l'ARN du certificat CA, utilisez la réponse de commande.

Pour plus d'informations, consultez la section Enregistrer votre certificat CA.

Créer des certificats d'appareils et effectuer l’opération JITP

Important : Assurez-vous d'utiliser le même répertoire que celui dans lequel vous avez créé les fichiers CA racine de l’appareil d'origine.

1. Téléchargez le fichier RootCA1 et enregistrez-le sous le nom de fichier awsRootCA.pem.

   Remarque : Le fichier RootCA1 est utilisé pour l'authentification côté serveur des requêtes de publication adressées à AWS IoT Core. Pour plus d'informations, consultez la section Certificats CA pour l'authentification du serveur.

2. Créez une clé privée pour l'appareil. Exécutez la commande OpenSSL suivante :

   $ openssl genrsa -out deviceCert.key 2048

3. Créez un appareil CSR. Exécutez la commande OpenSSL suivante :

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

   Important : L'exemple de modèle JITP requiert que la valeur de ThingName soit égale à la valeur de CommonName du certificat. Le modèle requiert également que la valeur de CountryName soit égale à la valeur de Country dans le certificat CA. Exemple :

   Country Name (two-letter code) []:IN
   Common Name (e.g. 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 qui requiert l’ajout d’une valeur. Les 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. Exécutez la commande OpenSSL suivante :

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

5. Combinez le certificat CA racine et le certificat de l’appareil. Exécutez la commande suivante :

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

6. Utilisez Eclipse Mosquitto pour effectuer 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 afin d’effectuer des appels de publication vers AWS IoT Core.

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

   Important : Avant d'exécuter la commande, remplacez a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com par votre propre point de terminaison. Pour confirmer votre propre point de terminaison, ouvrez la console AWS IoT Core. Puis, sélectionnez Paramètres. Votre point de terminaison apparaît dans le volet 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 pour la première fois. Lorsqu'AWS IoT Core reçoit l'appel de publication de test, il crée un certificat, une stratégie et un objet. Il attache également la stratégie au certificat, puis attache le certificat à l’objet. La prochaine fois que vous exécutez JITP, la stratégie AWS IoT Core qui a été créée pour la première fois sera celle qui sera utilisée. Aucune nouvelle stratégie AWS IoT Core n'est créée.

7. Vérifiez que les ressources requises ont été créées en procédant comme suit :
   Ouvrez la console AWS IoT Core.
   Sélectionnez Gérer.
   Sélectionnez Objets.
   Sélectionnez DemoThing.

8. Vérifiez que le certificat a été créé et qu'il est à l’état ACTIVE. Puis, sélectionnez Stratégies et vérifiez que la stratégie IAM est attachée.

Utiliser les certificats d'appareils dans le cadre du fonctionnement général

Remarque : La valeur de l'identifiant du client ajoutée dans la commande de publication doit correspondre au ThingName créé lors du processus JITP. Le nom de la rubrique ajouté à la commande de publication doit également respecter le format ThingName/*. Lors du prochain appel de publication, vous pouvez utiliser deviceCert.crt plutôt que deviceCertAndCACert.crt.

1. Ouvrez la console AWS IoT Core.

2. Sélectionnez Tester.

3. Pour Rubrique d’abonnement, saisissez 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. Puis, 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’appareils 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, le message est reçu sur la console AWS IoT Core Test.

Créer des certificats d'appareils supplémentaires

Pour créer d'autres certificats d'appareils et les enregistrer dans AWS IoT Core, répétez les étapes décrites dans la section Créer des certificats d’appareils et effectuer l’opération JITP.

Autres modèles JITP

Pour récupérer la valeur de ThingName à partir du champ CommonName du certificat et pour fournir des autorisations d'administration 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 récupérer la valeur de ThingName à partir 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 la stratégie que vous souhaitez utiliser.