Wie kann ich JITP mit AWS IoT Core verwenden?

Kurzbeschreibung

Um eine JITP-Umgebung mit AWS IoT Core einzurichten, registriere zunächst dein CA-Zertifikat bei AWS IoT Core. Anschließend musst du deiner Zertifizierungsstelle (CA) eine Bereitstellungsvorlage zuordnen.

Behebung

Hinweis: Wenn du beim Ausführen von AWS Command Line Interface (AWS CLI)-Befehlen Fehlermeldungen erhältst, findest du weitere Informationen dazu unter Problembehandlung bei der AWS CLI. Stelle außerdem sicher, dass du die neueste Version der AWS CLI verwendest.

Erstellen einer selbstsignierten Stammzertifizierungsstelle und eines Verifizierungszertifikats

Voraussetzung:

Installiere OpenSSL.

Gehe wie folgt vor, um eine selbstsignierte Stammzertifizierungsstelle und ein Verifizierungszertifikat zu erstellen:

1. Erstelle einen privaten Schlüssel einer Stammzertifizierungsstelle für Geräte und führe den folgenden OpenSSL-Befehl aus:

   $ openssl genrsa -out deviceRootCA.key 2048

2. Öffne den VIM-Texteditor und erstelle dann eine benutzerdefinierte OpenSSL.conf-Datei. Weitere Informationen zum VIM-Texteditor findest du im Tutorial auf der Vim Tips Wiki-Website.

3. Führe den folgenden VIM-Befehl aus, um eine benutzerdefinierte OpenSSL.conf-Datei zu erstellen:

   $ vi deviceRootCA_openssl.conf

4. Drücke i auf der Tastatur, um die .conf-Datei zu bearbeiten. Kopiere dann Folgendes und füge es in die Datei ein:

   [ 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. Um die .conf-Datei zu speichern, drücke Esc auf der Tastatur und drücke dann :wq! auf der Tastatur. Drücke die Eingabetaste, um die Datei zu beenden.

6. Führe den folgenden Linux-Befehl aus, um zu bestätigen, dass die Datei OpenSSL.conf erstellt wurde:

   $ cat deviceRootCA_openssl.conf

7. Erstelle für Geräte eine Zertifikatssignierungsanforderung (CSR) bei der Stammzertifizierungsstelle. Führe den folgenden OpenSSL-Befehl aus:

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

8. Erstelle ein Zertifikat der Stammzertifizierungsstelle für dein Gerät. Führe den folgenden OpenSSL-Befehl aus:

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

9. Rufe den Registrierungscode für die AWS-Region ab, in der du JITP verwenden möchtest. Führe den folgenden AWS CLI-Befehl aus:

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

   Hinweis: Ersetze us-east-2 durch die Region, in der du JITP verwenden möchtest.

10. Erstelle einen Verifizierungsschlüssel. Führe den folgenden OpenSSL-Befehl aus:

$ openssl genrsa -out verificationCert.key 2048

11. Erstelle einen Verifizierungszertifikat-CSR. Führe den folgenden OpenSSL-Befehl aus:

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

Gib dann den Registrierungscode in das Feld Allgemeiner Name ein. Beispiel: Allgemeiner Name (FQDN des Servers oder DEIN Name) []: xxxxxxxx8a33da.

Lasse die anderen Felder leer.

12. Erstelle das Verifizierungszertifikat. Führe den folgenden OpenSSL-Befehl aus:

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

Wichtig: Der Registrierungscode der Region deiner Stammzertifizierungsstelle ist erforderlich, wenn AWS IoT Core das Verifizierungszertifikat zertifiziert.

Weitere Informationen findest du unter Just-In-Time-Bereitstellung.

Erstellen einer JITP-Vorlage

1. Erstelle eine AWS Identity and Access Management (IAM, Identitäts- und Zugriffsmanagement)-Rolle für den AWS IoT Core-Service. Benenne sie JITPRole. Anweisungen findest du unter Erstellen einer Protokollierungsrolle.

   Wichtig: In der folgenden JITP-Vorlage musst du den Amazon-Ressourcennamen (ARN) der IAM-Rolle angeben.

2. Verwende den VIM-Texteditor, um eine JITP-Vorlagen-JSON-Datei zu erstellen. Führe die folgenden Schritte aus:

3. Erstelle eine JITP-Vorlagen-JSON-Datei. Führe den folgenden VIM-Befehl aus:

   $ vi jitp_template.json

   Hinweis: Stelle sicher, dass du die Vorlage unter dem Dateinamen jitp_template.json speicherst.

4. Drücke i auf der Tastatur, um die JITP-Vorlage zu bearbeiten. Kopiere dann die folgende JITP-Vorlage und füge sie in die Datei ein:

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

   Hinweis: Ersetze den Wert roleArn durch den ARN der IAM-Rolle für den AWS IoT Core-Service. Ersetze den Wert durch deine AWS-Konto-ID. Ersetze us-east-2 durch deine AWS-Region.

5. Drücke Esc auf deiner Tastatur, gefolgt von :wq!, um die JITP-Vorlagendatei zu speichern.

6. Drücke die Eingabetaste, um die Datei zu beenden.

Hinweis: Die JITP-Beispielvorlage enthält folgende IAM-Richtlinien:

• AWSIoTLogging
• AWSIoTRuleActions
• AWSIoTThingsRegistration

Du musst bei deinem AWS-Konto angemeldet sein, um die Links für die Richtlinien öffnen zu können. Weitere Informationen findest du unter Provisioning templates.

Registrierung des selbstsignierten Stammzertifizierungsstellen-Zertifikats bei AWS IoT Core

1. Registriere die Stamm-CA des Geräts als CA-Zertifikat in AWS IoT Core.

2. Führe den folgenden AWS-CLI-Befehl register-ca-certificate aus:

   $ 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

   Hinweis: Ersetze us-east-2 durch die Region, in der du JITP verwenden möchtest.

Hinweis: Verwende den Parameter**--registration-config**, um die von dir erstellte JITP-Vorlage an das CA-Zertifikat anzuhängen. Verwende die Befehlsantwort, um den ARN des CA-Zertifikats zurückzugeben.

Weitere Informationen findest du unter Registrierung deines CA-Zertifikats.

Erstellen von Gerätezertifikaten und Durchführen von JITP

Wichtig: Stelle sicher, dass du dasselbe Verzeichnis verwendest, in dem du die ursprünglichen Stamm-CA-Dateien für das Gerät erstellt hast.

1. Lade das Element RootCA1 herunter und speichere es unter dem Dateinamen awsRootCA.pem.

   Hinweis: RootCA1 wird für die serverseitige Authentifizierung von Veröffentlichungsanforderungen an AWS IoT Core verwendet. Weitere Informationen findest du unter CA-Zertifikate für die Serverauthentifizierung.

2. Erstelle einen privaten Geräteschlüssel. Führe den folgenden OpenSSL-Befehl aus:

   $ openssl genrsa -out deviceCert.key 2048

3. Erstelle ein CSR-Gerät. Führe den folgenden OpenSSL-Befehl aus:

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

   Wichtig: Für die JITP-Beispielvorlage muss der Wert ThingName dem Wert CommonName des Zertifikats entsprechen. Außerdem muss der Wert CountryName dem Wert Country aus dem Zertifizierungsstellenzertifikat entsprechen. Beispiel:

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

   Die in diesem Artikel bereitgestellte JITP-Vorlage enthält auch den Zertifikatparameter AWS::IoT::Certificate::Country, für den du einen Wert hinzufügen musst. Weitere mögliche Zertifikatparameter: 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. Erstelle ein Gerätezertifikat. Führe den folgenden OpenSSL-Befehl aus:

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

5. Kombiniere das Zertifikat der Stammzertifizierungsstelle und das Gerätezertifikat. Führe den folgenden Befehl aus:

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

6. Verwende Eclipse Mosquitto, um einen Testveröffentlichungsaufruf an AWS IoT Core zu übermitteln und den JITP-Prozess zu initiieren.

   Hinweis: Du kannst auch das AWS IoT Device SDK verwenden, um Veröffentlichungs-Aufrufe an AWS IoT Core zu übermitteln.

   Exemplarischer Eclipse-Mosquitto-Befehl zum Testen von Veröffentlichungsaufrufen

   Wichtig: Bevor du den Befehl ausführst, ersetze a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com durch deinen eigenen Endpunkt. Öffne zum Überprüfen deines eigenen Endpunkts die AWS IoT Core-Konsole. Wähle Settings aus. Dein Endpunkt wird im Bereich Benutzerdefinierter Endpunkt angezeigt.

   $ 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

   Exemplarische Antwort des Eclipse-Mosquitto-Befehls zum Testen von Veröffentlichungsaufrufen

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

   Hinweis: Der Testveröffentlichungsaufruf ist beim ersten Mal nicht erfolgreich. Wenn AWS IoT Core den Testveröffentlichungsaufruf empfängt, werden ein Zertifikat, eine Richtlinie und ein Objekt erstellt. Außerdem wird die Richtlinie dem Zertifikat und das Zertifikat anschließend dem Objekt zugeordnet. Wenn du das nächste Mal JITP ausführst, wird die zuerst erstellte AWS IoT Core-Richtlinie verwendet. Eine neue AWS IoT Core-Richtlinie wird nicht erstellt.

7. Vergewissere dich, dass die erforderlichen Ressourcen erstellt wurden, indem du wie folgt vorgehst:
   Öffne die AWS IoT Core-Konsole.
   Wähle Verwalten aus.
   Wähle Objekte.
   Wähle DemoThing aus.

8. Vergewissere dich, dass das Zertifikat erstellt wurde und sich im Zustand ACTIVE (AKTIV) befindet. Wähle dann Richtlinien aus und vergewissere dich, dass die IAM-Richtlinie angehängt ist.

Verwenden von Gerätezertifikaten im regulären Betrieb

Hinweis: Der Wert der Client-ID, der im Veröffentlichungsbefehl hinzugefügt wird, muss mit dem ThingName übereinstimmen, der während des JITP-Prozesses erstellt wurde. Der dem Veröffentlichungsbefehl hinzugefügte Themenname muss ebenfalls dem Format ThingName/* entsprechen. Beim nächsten Veröffentlichungsaufruf kannst du deviceCert.crt anstelle von deviceCertAndCACert.crt verwenden.

1. Öffne die AWS IoT Core-Konsole.

2. Wähle Testen aus.

3. Gib als Abonnementthema DemoThing/test ein.

4. Führe den folgenden Veröffentlichungsaufrufbefehl von Eclipse Mosquitto für AWS IoT Core aus:

   Wichtig: Ersetze a27icbrpsxxx-ats.iot.us-east-2.amazonaws.com durch deinen eigenen Endpunkt, bevor du den Befehl ausführst. Öffne zum Überprüfen deines eigenen Endpunkts die AWS IoT Core-Konsole. Wähle Settings aus. Dein Endpunkt wird im Bereich Custom endpoint (Benutzerdefinierter Endpunkt) angezeigt. Achte außerdem darauf, dass du die benutzerdefinierten Gerätezertifikate verwendest, die von deiner benutzerdefinierten Stammzertifizierungsstelle generiert wurden.

   $ 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

   Nachdem du den Befehl ausgeführt hast, wird die Nachricht auf der AWS IoT Core Testkonsole empfangen.

Erstellen zusätzlicher Gerätezertifikate

Wiederhole die Schritte, die im Abschnitt Erstellen von Gerätezertifikaten und Durchführen von JITP beschrieben sind, um weitere Gerätezertifikate zu erstellen und bei AWS IoT Core zu registrieren.

Weitere JITP-Vorlagen

Verwende die folgende JITP-Vorlage, um den Wert ThingName aus dem Feld CommonName des Zertifikats abzurufen und Administratorberechtigungen in der Richtlinie bereitzustellen:

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

Verwende die folgende JITP-Vorlage, um den Wert ThingName aus dem Feld CommonName des Zertifikats abzurufen und einen vordefinierten Richtliniennamen anzugeben:

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

Wichtig: Ersetze Policy_Name durch den Richtliniennamen, den du verwenden möchtest.