Wählen Sie Ihre Cookie-Einstellungen aus

Wir verwenden essentielle Cookies und ähnliche Tools, die für die Bereitstellung unserer Website und Services erforderlich sind. Wir verwenden Performance-Cookies, um anonyme Statistiken zu sammeln, damit wir verstehen können, wie Kunden unsere Website nutzen, und Verbesserungen vornehmen können. Essentielle Cookies können nicht deaktiviert werden, aber Sie können auf „Anpassen“ oder „Ablehnen“ klicken, um Performance-Cookies abzulehnen.

Wenn Sie damit einverstanden sind, verwenden AWS und zugelassene Drittanbieter auch Cookies, um nützliche Features der Website bereitzustellen, Ihre Präferenzen zu speichern und relevante Inhalte, einschließlich relevanter Werbung, anzuzeigen. Um alle nicht notwendigen Cookies zu akzeptieren oder abzulehnen, klicken Sie auf „Akzeptieren“ oder „Ablehnen“. Um detailliertere Entscheidungen zu treffen, klicken Sie auf „Anpassen“.

Tutorial: Interagieren Sie mit lokalen IoT-Geräten über MQTT

Fokusmodus
Tutorial: Interagieren Sie mit lokalen IoT-Geräten über MQTT - AWS IoT Greengrass

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Sie können dieses Tutorial abschließen, um ein Kerngerät so zu konfigurieren, dass es mit lokalen IoT-Geräten, sogenannten Client-Geräten, interagiert, die eine Verbindung zum Kerngerät herstellenMQTT. In diesem Tutorial konfigurieren Sie AWS IoT Dinge, die Cloud Discovery verwenden, um als Client-Geräte eine Verbindung zum Kerngerät herzustellen. Wenn Sie Cloud Discovery konfigurieren, kann ein Client-Gerät eine Anfrage an den AWS IoT Greengrass Cloud-Dienst senden, um Kerngeräte zu erkennen. Die Antwort von AWS IoT Greengrass enthält Verbindungsinformationen und Zertifikate für die Kerngeräte, für deren Erkennung Sie das Client-Gerät konfigurieren. Anschließend kann das Client-Gerät diese Informationen verwenden, um eine Verbindung zu einem verfügbaren Core-Gerät herzustellen, über das es kommunizieren kannMQTT.

In diesem Tutorial führen Sie folgende Aufgaben aus:

  1. Überprüfen und aktualisieren Sie bei Bedarf die Berechtigungen des Kerngeräts.

  2. Ordnen Sie Client-Geräte dem Core-Gerät zu, sodass sie das Core-Gerät mithilfe der Cloud-Erkennung erkennen können.

  3. Stellen Sie Greengrass-Komponenten auf dem Kerngerät bereit, um die Unterstützung von Client-Geräten zu aktivieren.

  4. Connect die Client-Geräte mit dem Kerngerät und testen Sie die Kommunikation mit dem AWS IoT Core Cloud-Dienst.

  5. Entwickeln Sie eine benutzerdefinierte Greengrass-Komponente, die mit den Client-Geräten kommuniziert.

  6. Entwickeln Sie eine benutzerdefinierte Komponente, die mit den Geräteschatten der Client-Geräte AWS IoT interagiert.

In diesem Tutorial werden ein Single-Core-Gerät und ein einzelnes Client-Gerät verwendet. Sie können dem Tutorial auch folgen, um mehrere Client-Geräte zu verbinden und zu testen.

Sie können davon ausgehen, dass Sie für dieses Tutorial 30—60 Minuten aufwenden werden.

Voraussetzungen

Zum Durcharbeiten dieses Tutorials ist Folgendes erforderlich:

  • Ein. AWS-Konto Falls Sie noch keines haben, beachten Sie die Informationen unter Richten Sie eine ein AWS-Konto.

  • Ein AWS Identity and Access Management (IAM) Benutzer mit Administratorrechten.

  • Ein Greengrass-Core-Gerät. Weitere Informationen zur Einrichtung eines Core-Geräts finden Sie unterEinrichtung von AWS IoT Greengrass Kerngeräten.

    • Auf dem Kerngerät muss Greengrass Nucleus v2.6.0 oder höher ausgeführt werden. Diese Version bietet Unterstützung für Platzhalter in der lokalen Publish/Subscribe-Kommunikation und Unterstützung für Client-Geräteschatten.

      Anmerkung

      Für die Unterstützung von Client-Geräten ist Greengrass Nucleus v2.2.0 oder höher erforderlich. In diesem Tutorial werden jedoch neuere Funktionen untersucht, wie z. B. die Unterstützung von MQTT Platzhaltern beim lokalen Veröffentlichen/Abonnieren und die Unterstützung von Client-Geräteschatten. Für diese Funktionen ist Greengrass Nucleus v2.6.0 oder höher erforderlich.

    • Das Core-Gerät muss sich im selben Netzwerk wie die Client-Geräte befinden, um eine Verbindung herstellen zu können.

    • (Optional) Um die Module zu vervollständigen, in denen Sie benutzerdefinierte Greengrass-Komponenten entwickeln, muss das Kerngerät CLI Greengrass ausführen. Weitere Informationen finden Sie unter Installieren Sie das Greengrass CLI.

  • Eine AWS IoT Sache, die Sie in diesem Tutorial als Client-Gerät verbinden können. Weitere Informationen finden Sie im AWS IoT Core Entwicklerhandbuch unter AWS IoT Ressourcen erstellen.

    • Die AWS IoT Richtlinie des Client-Geräts muss die greengrass:Discover Genehmigung zulassen. Weitere Informationen finden Sie unter Minimale AWS IoT Richtlinie für Client-Geräte.

    • Das Client-Gerät muss sich im selben Netzwerk wie das Core-Gerät befinden.

    • Auf dem Client-Gerät muss Python 3 ausgeführt werden.

    • Auf dem Client-Gerät muss Git ausgeführt werden.

Schritt 1: Überprüfen und aktualisieren Sie die AWS IoT Core-Geräterichtlinie

Um Client-Geräte zu unterstützen, muss die AWS IoT Richtlinie eines Kerngeräts die folgenden Berechtigungen zulassen:

  • greengrass:PutCertificateAuthorities

  • greengrass:VerifyClientDeviceIdentity

  • greengrass:VerifyClientDeviceIoTCertificateAssociation

  • greengrass:GetConnectivityInfo

  • greengrass:UpdateConnectivityInfo— (Optional) Diese Berechtigung ist erforderlich, um die IP-Detektorkomponente zu verwenden, die die Netzwerkverbindungsinformationen des Kerngeräts an den AWS IoT Greengrass Cloud-Dienst meldet.

Weitere Informationen zu diesen Berechtigungen und AWS IoT Richtlinien für Kerngeräte finden Sie unter AWS IoT-Richtlinien für Operationen auf Datenebene undMinimale AWS IoT Richtlinie zur Unterstützung von Client-Geräten.

In diesem Abschnitt überprüfen Sie die AWS IoT Richtlinien für Ihr Hauptgerät und fügen alle erforderlichen Berechtigungen hinzu, die noch fehlen. Wenn Sie das AWS IoT Greengrass Core-Softwareinstallationsprogramm zur Bereitstellung von Ressourcen verwendet haben, verfügt Ihr Kerngerät über eine AWS IoT Richtlinie, die den Zugriff auf alle AWS IoT Greengrass Aktionen ermöglicht (greengrass:*). In diesem Fall müssen Sie die AWS IoT Richtlinie nur aktualisieren, wenn Sie planen, die Shadow Manager-Komponente so zu konfigurieren, dass Geräteschatten mit synchronisiert AWS IoT Core werden. Andernfalls können Sie diesen Abschnitt überspringen.

Um die AWS IoT Richtlinien eines Kerngeräts zu überprüfen und zu aktualisieren
  1. Wählen Sie im Navigationsmenü der AWS IoT Greengrass Konsole die Option Core-Geräte aus.

  2. Wählen Sie auf der Seite Core-Geräte das zu aktualisierende Core-Gerät aus.

  3. Wählen Sie auf der Seite mit den Details zum Kerngerät den Link zum Ding des Kerngeräts aus. Dieser Link öffnet die Seite mit den Ding-Details in der AWS IoT Konsole.

  4. Wählen Sie auf der Seite mit den Ding-Details die Option Zertifikate aus.

  5. Wählen Sie auf der Registerkarte Zertifikate das aktive Zertifikat der Sache aus.

  6. Wählen Sie auf der Seite mit den Zertifikatsdetails die Option Richtlinien aus.

  7. Wählen Sie auf der Registerkarte Richtlinien die AWS IoT Richtlinie aus, die Sie überprüfen und aktualisieren möchten. Sie können jeder Richtlinie, die mit dem aktiven Zertifikat des Kerngeräts verknüpft ist, die erforderlichen Berechtigungen hinzufügen.

    Anmerkung

    Wenn Sie das AWS IoT Greengrass Core-Softwareinstallationsprogramm zur Bereitstellung von Ressourcen verwendet haben, gibt es zwei AWS IoT Richtlinien. Wir empfehlen, dass Sie die Richtlinie mit dem Namen wählen GreengrassV2IoTThingPolicy, falls sie existiert. Kerngeräte, die Sie mit dem Schnellinstallationsprogramm erstellen, verwenden standardmäßig diesen Richtliniennamen. Wenn Sie dieser Richtlinie Berechtigungen hinzufügen, gewähren Sie diese Berechtigungen auch anderen Kerngeräten, die diese Richtlinie verwenden.

  8. Wählen Sie in der Richtlinienübersicht die Option Aktive Version bearbeiten aus.

  9. Überprüfen Sie die Richtlinie auf die erforderlichen Berechtigungen und fügen Sie alle fehlenden erforderlichen Berechtigungen hinzu.

  10. Um eine neue Richtlinienversion als aktive Version festzulegen, wählen Sie unter Status der Richtlinienversion die Option Die bearbeitete Version als aktive Version für diese Richtlinie festlegen aus.

  11. Wählen Sie Als neue Version speichern aus.

Schritt 2: Aktivieren Sie die Unterstützung für Client-Geräte

Damit ein Client-Gerät über Cloud Discovery eine Verbindung zu einem Core-Gerät herstellen kann, müssen Sie die Geräte verknüpfen. Wenn Sie ein Client-Gerät einem Core-Gerät zuordnen, ermöglichen Sie diesem Client-Gerät, die IP-Adressen und Zertifikate des Core-Geräts abzurufen, um die Verbindung herzustellen.

Damit Client-Geräte eine sichere Verbindung zu einem Kerngerät herstellen und mit den Greengrass-Komponenten kommunizieren können AWS IoT Core, stellen Sie die folgenden Greengrass-Komponenten auf dem Kerngerät bereit:

  • Authentifizierung auf Client-Geräten (aws.greengrass.clientdevices.Auth)

    Stellen Sie die Authentifizierungskomponente für Client-Geräte bereit, um Client-Geräte zu authentifizieren und Aktionen auf Client-Geräten zu autorisieren. Mit dieser Komponente können Ihre Geräte eine AWS IoT Verbindung zu einem Kerngerät herstellen.

    Für diese Komponente ist eine gewisse Konfiguration erforderlich, um sie verwenden zu können. Sie müssen Gruppen von Client-Geräten und die Vorgänge angeben, zu deren Ausführung jede Gruppe berechtigt ist, z. B. Verbindungen herzustellen und zu kommunizierenMQTT. Weitere Informationen finden Sie unter Konfiguration der Komponente für die Authentifizierung auf Clientgeräten.

  • MQTT 3.1.1-Broker (Moquette) (aws.greengrass.clientdevices.mqtt.Moquette)

    Stellen Sie die MQTT Moquette-Broker-Komponente bereit, um einen Lightweight-Broker auszuführen. MQTT Der MQTT Moquette-Broker entspricht MQTT 3.1.1 und bietet lokale Unterstützung für QoS 0, QoS 1, QoS 2, gespeicherte Nachrichten, Lastwill-Nachrichten und persistente Abonnements.

    Sie müssen diese Komponente nicht konfigurieren, um sie verwenden zu können. Sie können jedoch den Port konfigurieren, über den diese Komponente den MQTT Broker betreibt. Standardmäßig verwendet es Port 8883.

  • MQTT-Brücke (aws.greengrass.clientdevices.mqtt.Bridge)

    (Optional) Stellen Sie die MQTT Bridge-Komponente bereit, um Nachrichten zwischen Client-Geräten (lokalMQTT) weiterzuleiten, lokal zu veröffentlichen/abonnieren und. AWS IoT Core MQTT Konfigurieren Sie diese Komponente, um Client-Geräte mit Client-Geräten von Greengrass-Komponenten zu synchronisieren AWS IoT Core und mit diesen zu interagieren.

    Für die Verwendung dieser Komponente ist eine Konfiguration erforderlich. Sie müssen die Themenzuordnungen angeben, an die diese Komponente Nachrichten weiterleitet. Weitere Informationen finden Sie unter Konfiguration der MQTTBridge-Komponente.

  • IP-Detektor (aws.greengrass.clientdevices.IPDetector)

    (Optional) Stellen Sie die IP-Detektorkomponente bereit, um die MQTT Broker-Endpunkte des Kerngeräts automatisch an den AWS IoT Greengrass Cloud-Dienst zu melden. Sie können diese Komponente nicht verwenden, wenn Sie über eine komplexe Netzwerkkonfiguration verfügen, z. B. wenn ein Router den MQTT Broker-Port an das Kerngerät weiterleitet.

    Sie müssen diese Komponente nicht konfigurieren, um sie verwenden zu können.

In diesem Abschnitt verwenden Sie die AWS IoT Greengrass Konsole, um Client-Geräte zuzuordnen und Client-Gerätekomponenten auf einem Kerngerät bereitzustellen.

Um die Unterstützung von Client-Geräten zu aktivieren
  1. Wählen Sie im linken Navigationsmenü die Option Core-Geräte aus.

  2. Wählen Sie auf der Seite Core-Geräte das Core-Gerät aus, für das Sie die Unterstützung von Client-Geräten aktivieren möchten.

  3. Wählen Sie auf der Seite mit den Details zu den Kerngeräten die Registerkarte Client-Geräte aus.

  4. Wählen Sie auf der Registerkarte Client-Geräte die Option Cloud-Discovery konfigurieren aus.

    Die Seite „Erkennung von Kerngeräten konfigurieren“ wird geöffnet. Auf dieser Seite können Sie Client-Geräte einem Core-Gerät zuordnen und Client-Gerätekomponenten bereitstellen. Auf dieser Seite wird das Kerngerät für Sie in Schritt 1: Ziel-Core-Geräte auswählen ausgewählt.

    Anmerkung

    Sie können diese Seite auch verwenden, um die Kerngeräteerkennung für eine Dinggruppe zu konfigurieren. Wenn Sie diese Option wählen, können Sie Client-Gerätekomponenten auf allen Kerngeräten in einer Dinggruppe bereitstellen. Wenn Sie diese Option wählen, müssen Sie die Client-Geräte jedoch später, nachdem Sie die Bereitstellung erstellt haben, manuell jedem Kerngerät zuordnen. In diesem Tutorial konfigurieren Sie ein Single-Core-Gerät.

  5. Ordnen Sie in Schritt 2: Client-Geräte zuordnen das AWS IoT Ding des Client-Geräts dem Core-Gerät zu. Auf diese Weise kann das Client-Gerät die Cloud-Erkennung verwenden, um die Konnektivitätsinformationen und Zertifikate des Kerngeräts abzurufen. Gehen Sie wie folgt vor:

    1. Wählen Sie Client-Geräte zuordnen aus.

    2. Geben Sie im Modal Client-Geräte mit Kerngerät verknüpfen den Namen des Objekts ein, AWS IoT das Sie verknüpfen möchten.

    3. Wählen Sie Hinzufügen aus.

    4. Wählen Sie Associate aus.

  6. Stellen Sie in Schritt 3: Greengrass-Komponenten konfigurieren und bereitstellen Komponenten bereit, um die Unterstützung von Client-Geräten zu aktivieren. Wenn das Ziel-Core-Gerät schon einmal bereitgestellt wurde, wird diese Bereitstellung auf dieser Seite überarbeitet. Andernfalls erstellt diese Seite eine neue Bereitstellung für das Kerngerät. Gehen Sie wie folgt vor, um die Komponenten des Client-Geräts zu konfigurieren und bereitzustellen:

    1. Auf dem Kerngerät muss Greengrass Nucleus v2.6.0 oder höher ausgeführt werden, um dieses Tutorial abschließen zu können. Wenn auf dem Core-Gerät eine frühere Version ausgeführt wird, gehen Sie wie folgt vor:

      1. Wählen Sie das Feld für die Bereitstellung von aws.greengrass.NucleusKomponente.

      2. Für die aws.greengrass.NucleusWählen Sie für die Komponente Konfiguration bearbeiten aus.

      3. Wählen Sie als Komponentenversion Version 2.6.0 oder höher aus.

      4. Wählen Sie Bestätigen aus.

      Anmerkung

      Wenn Sie den Greengrass Nucleus von einer früheren Nebenversion aktualisieren und auf dem Core-Gerät vom Kern AWS bereitgestellte Komponenten ausgeführt werden, die vom Nucleus abhängen, müssen Sie auch die von AWS-bereitgestellten Komponenten auf neuere Versionen aktualisieren. Sie können die Version dieser Komponenten konfigurieren, wenn Sie sich die Bereitstellung später in diesem Tutorial ansehen. Weitere Informationen finden Sie unter Aktualisieren der AWS IoT Greengrass Core-Software (OTA).

    2. Für die aws.greengrass.clientdevices.AuthWählen Sie für die Komponente Konfiguration bearbeiten aus.

    3. Konfigurieren Sie im Modal „Konfiguration bearbeiten“ für die Komponente zur Authentifizierung auf Clientgeräten eine Autorisierungsrichtlinie, die es Client-Geräten ermöglicht, den MQTT Broker auf dem Kerngerät zu veröffentlichen und zu abonnieren. Gehen Sie wie folgt vor:

      1. Geben Sie unter Konfiguration im Block Konfiguration zum Zusammenführen von Code die folgende Konfiguration ein, die eine Autorisierungsrichtlinie für Client-Geräte enthält. Jede Autorisierungsrichtlinie für Gerätegruppen spezifiziert eine Reihe von Aktionen und die Ressourcen, auf denen ein Client-Gerät diese Aktionen ausführen kann.

        • Diese Richtlinie ermöglicht es Client-Geräten, deren Namen mit beginnenMyClientDevice, Verbindungen herzustellen und zu allen MQTT Themen zu kommunizieren. MyClientDevice*Ersetzen Sie es durch den Namen des AWS IoT Geräts, das als Client-Gerät verbunden werden soll. Sie können auch einen Namen mit dem * Platzhalter angeben, der dem Namen des Client-Geräts entspricht. Der * Platzhalter muss am Ende des Namens stehen.

          Wenn Sie ein zweites Client-Gerät verbinden möchten, MyOtherClientDevice* ersetzen Sie es durch den Namen dieses Client-Geräts oder durch ein Platzhaltermuster, das dem Namen dieses Client-Geräts entspricht. Andernfalls können Sie diesen Abschnitt der Auswahlregel entfernen oder beibehalten, der es Client-Geräten mit übereinstimmenden Namen ermöglicht, eine Verbindung herzustellen und MyOtherClientDevice* zu kommunizieren.

        • In dieser Richtlinie wird ein OR Operator verwendet, um auch Client-Geräten, deren Namen mit beginnen, die Möglichkeit MyOtherClientDevice zu geben, sich zu allen MQTT Themen zu verbinden und miteinander zu kommunizieren. Sie können diese Klausel aus der Auswahlregel entfernen oder sie so ändern, dass sie den Client-Geräten entspricht, für die eine Verbindung hergestellt werden soll.

        • Diese Richtlinie ermöglicht es den Client-Geräten, alle MQTT Themen zu veröffentlichen und zu abonnieren. Um sich an bewährte Sicherheitsverfahren zu halten, beschränken Sie die mqtt:subscribe Vorgänge mqtt:publish und auf die minimalen Themen, die die Client-Geräte für die Kommunikation verwenden.

        { "deviceGroups": { "formatVersion": "2021-03-05", "definitions": { "MyDeviceGroup": { "selectionRule": "thingName: MyClientDevice* OR thingName: MyOtherClientDevice*", "policyName": "MyClientDevicePolicy" } }, "policies": { "MyClientDevicePolicy": { "AllowConnect": { "statementDescription": "Allow client devices to connect.", "operations": [ "mqtt:connect" ], "resources": [ "*" ] }, "AllowPublish": { "statementDescription": "Allow client devices to publish to all topics.", "operations": [ "mqtt:publish" ], "resources": [ "*" ] }, "AllowSubscribe": { "statementDescription": "Allow client devices to subscribe to all topics.", "operations": [ "mqtt:subscribe" ], "resources": [ "*" ] } } } } }

        Weitere Informationen finden Sie unter Konfiguration der Komponente für die Client-Geräteauthentifizierung.

      2. Wählen Sie Bestätigen aus.

    4. Für den aws.greengrass.clientdevices.mqtt.BridgeWählen Sie für die Komponente Konfiguration bearbeiten aus.

    5. Konfigurieren Sie im Modal „Konfiguration bearbeiten“ für die MQTT Bridge-Komponente eine Themenzuordnung, an die MQTT Nachrichten von Client-Geräten weitergeleitet AWS IoT Core werden. Gehen Sie wie folgt vor:

      1. Geben Sie unter Konfiguration im Block Konfiguration zum Zusammenführen von Code die folgende Konfiguration ein. Diese Konfiguration legt fest, dass MQTT Nachrichten zum clients/+/hello/world Themenfilter von Client-Geräten an den AWS IoT Core Cloud-Dienst weitergeleitet werden. Dieser Themenfilter entspricht beispielsweise dem clients/MyClientDevice1/hello/world Thema.

        { "mqttTopicMapping": { "HelloWorldIotCoreMapping": { "topic": "clients/+/hello/world", "source": "LocalMqtt", "target": "IotCore" } } }

        Weitere Informationen finden Sie unter Konfiguration der MQTT Bridge-Komponenten.

      2. Wählen Sie Bestätigen aus.

  7. Wählen Sie Überprüfen und bereitstellen, um die Bereitstellung zu überprüfen, die diese Seite für Sie erstellt.

  8. Wenn Sie die Greengrass-Servicerolle in dieser Region noch nicht eingerichtet haben, öffnet die Konsole ein Modal, um die Servicerolle für Sie einzurichten. Die Authentifizierungskomponente für Clientgeräte verwendet diese Servicerolle, um die Identität von Client-Geräten zu überprüfen, und die IP-Detector-Komponente verwendet diese Servicerolle, um die Verbindungsinformationen der Kerngeräte zu verwalten. Klicken Sie aufGewähren von Berechtigungenaus.

  9. Wählen Sie auf der Seite Überprüfen die Option Bereitstellen aus, um die Bereitstellung auf dem Kerngerät zu starten.

  10. Um zu überprüfen, ob die Bereitstellung erfolgreich ist, überprüfen Sie den Status der Bereitstellung und überprüfen Sie die Protokolle auf dem Kerngerät. Um den Status der Bereitstellung auf dem Kerngerät zu überprüfen, können Sie in der Bereitstellungsübersicht die Option Target auswählen. Weitere Informationen finden Sie hier:

Schritt 3: Client-Geräte Connect

Client-Geräte können das verwenden, AWS IoT Device SDK um ein Kerngerät zu erkennen, eine Verbindung herzustellen und mit ihm zu kommunizieren. Das Client-Gerät muss ein AWS IoT Ding sein. Weitere Informationen finden Sie im AWS IoT Core Entwicklerhandbuch unter Ein Ding-Objekt erstellen.

In diesem Abschnitt installieren Sie AWS IoT Device SDK Version 2 für Python und führen die Greengrass Discovery-Beispielanwendung aus dem AWS IoT Device SDK aus.

Anmerkung

Das AWS IoT Device SDK ist auch in anderen Programmiersprachen verfügbar. In diesem Tutorial wird AWS IoT Device SDK Version 2 für Python verwendet, aber Sie können die andere Version SDKs für Ihren Anwendungsfall untersuchen. Weitere Informationen finden Sie unter AWS IoT Gerät SDKs im AWS IoT Core Entwicklerhandbuch.

So verbinden Sie ein Client-Gerät mit einem Core-Gerät
  1. Laden Sie die AWS IoT Device SDK Version v2 für Python herunter und installieren Sie sie auf dem AWS IoT Ding, um eine Verbindung als Client-Gerät herzustellen.

    Gehen Sie auf dem Client-Gerät wie folgt vor:

    1. Klonen Sie das Repository AWS IoT Device SDK v2 for Python, um es herunterzuladen.

      git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
    2. Installieren Sie die AWS IoT Device SDK Version v2 für Python.

      python3 -m pip install --user ./aws-iot-device-sdk-python-v2
  2. Wechseln Sie in den Samples-Ordner in der AWS IoT Device SDK Version v2 für Python.

    cd aws-iot-device-sdk-python-v2/samples
  3. Führen Sie die Greengrass-Discovery-Beispielanwendung aus. Diese Anwendung erwartet Argumente, die den Namen der Sache auf dem Client-Gerät, das zu verwendende MQTT Thema und die Nachricht sowie die Zertifikate angeben, die die Verbindung authentifizieren und sichern. Im folgenden Beispiel wird eine Hello World-Nachricht an das clients/MyClientDevice1/hello/world Thema gesendet.

    Anmerkung

    Dieses Thema entspricht dem Thema, in dem Sie AWS IoT Core zuvor die MQTT Bridge für die Weiterleitung von Nachrichten konfiguriert haben.

    • MyClientDevice1Ersetzen Sie es durch den Ding-Namen des Client-Geräts.

    • ~/certs/AmazonRootCA1.pemErsetzen Sie durch den Pfad zum Amazon-Root-CA-Zertifikat auf dem Client-Gerät.

    • ~/certs/device.pem.crtErsetzen Sie durch den Pfad zum Gerätezertifikat auf dem Client-Gerät.

    • ~/certs/private.pem.keyErsetzen Sie durch den Pfad zur privaten Schlüsseldatei auf dem Client-Gerät.

    • us-east-1Ersetzen Sie durch die AWS Region, in der Ihr Client-Gerät und Ihr Core-Gerät betrieben werden.

    python3 basic_discovery.py \\ --thing_name MyClientDevice1 \\ --topic 'clients/MyClientDevice1/hello/world' \\ --message 'Hello World!' \\ --ca_file ~/certs/AmazonRootCA1.pem \\ --cert ~/certs/device.pem.crt \\ --key ~/certs/private.pem.key \\ --region us-east-1 \\ --verbosity Warn

    Die Discovery-Beispielanwendung sendet die Nachricht zehnmal und trennt die Verbindung. Außerdem abonniert sie dasselbe Thema, in dem sie Nachrichten veröffentlicht. Wenn die Ausgabe anzeigt, dass die Anwendung MQTT Nachrichten zu diesem Thema erhalten hat, kann das Client-Gerät erfolgreich mit dem Core-Gerät kommunizieren.

    Performing greengrass discovery... awsiot.greengrass_discovery.DiscoverResponse(gg_groups=[awsiot.greengrass_discovery.GGGroup(gg_group_id='greengrassV2-coreDevice-MyGreengrassCore', cores=[awsiot.greengrass_discovery.GGCore(thing_arn='arn:aws:iot:us-east-1:123456789012:thing/MyGreengrassCore', connectivity=[awsiot.greengrass_discovery.ConnectivityInfo(id='203.0.113.0', host_address='203.0.113.0', metadata='', port=8883)])], certificate_authorities=['-----BEGIN CERTIFICATE-----\ MIICiT...EXAMPLE=\ -----END CERTIFICATE-----\ '])]) Trying core arn:aws:iot:us-east-1:123456789012:thing/MyGreengrassCore at host 203.0.113.0 port 8883 Connected! Published topic clients/MyClientDevice1/hello/world: {"message": "Hello World!", "sequence": 0} Publish received on topic clients/MyClientDevice1/hello/world b'{"message": "Hello World!", "sequence": 0}' Published topic clients/MyClientDevice1/hello/world: {"message": "Hello World!", "sequence": 1} Publish received on topic clients/MyClientDevice1/hello/world b'{"message": "Hello World!", "sequence": 1}' ... Published topic clients/MyClientDevice1/hello/world: {"message": "Hello World!", "sequence": 9} Publish received on topic clients/MyClientDevice1/hello/world b'{"message": "Hello World!", "sequence": 9}'

    Wenn die Anwendung stattdessen einen Fehler ausgibt, finden Sie weitere Informationen unter Behebung von Problemen mit der Greengrass-Erkennung.

    Sie können auch die Greengrass-Protokolle auf dem Kerngerät einsehen, um zu überprüfen, ob das Client-Gerät erfolgreich eine Verbindung herstellt und Nachrichten sendet. Weitere Informationen finden Sie unter Überwachen von AWS IoT Greengrass Protokollen.

  4. Stellen Sie sicher, dass die MQTT Bridge die Nachrichten vom Client-Gerät an weiterleitet. AWS IoT Core Sie können den MQTT Testclient in der AWS IoT Core Konsole verwenden, um einen MQTT Themenfilter zu abonnieren. Gehen Sie wie folgt vor:

    1. Navigieren Sie zur AWS IoT -Konsole.

    2. Wählen Sie im linken Navigationsmenü unter Test die Option MQTTTestclient aus.

    3. Geben Sie auf der Registerkarte Thema abonnieren für Themenfilter ein, clients/+/hello/world um Nachrichten auf dem Client-Gerät vom Hauptgerät zu abonnieren.

    4. Wählen Sie Subscribe (Abonnieren) aus.

    5. Führen Sie die Anwendung „Veröffentlichen/Abonnieren“ erneut auf dem Client-Gerät aus.

      Der MQTT Testclient zeigt die Nachrichten an, die Sie vom Client-Gerät zu Themen senden, die diesem Themenfilter entsprechen.

Schritt 4: Entwickeln Sie eine Komponente, die mit Client-Geräten kommuniziert

Sie können Greengrass-Komponenten entwickeln, die mit Client-Geräten kommunizieren. Komponenten verwenden die Interprozesskommunikation (IPC) und die lokale Publish/Subscribe-Schnittstelle, um auf einem Kerngerät zu kommunizieren. Um mit Client-Geräten zu interagieren, konfigurieren Sie die MQTT Bridge-Komponente so, dass sie Nachrichten zwischen Client-Geräten und der lokalen Publish/Subscribe-Schnittstelle weiterleitet.

In diesem Abschnitt aktualisieren Sie die MQTT Bridge-Komponente, um Nachrichten von Client-Geräten an die lokale Publish/Subscribe-Schnittstelle weiterzuleiten. Anschließend entwickeln Sie eine Komponente, die diese Nachrichten abonniert und die Nachrichten ausdruckt, wenn sie sie empfängt.

Um eine Komponente zu entwickeln, die mit Client-Geräten kommuniziert
  1. Überarbeiten Sie die Bereitstellung auf dem Kerngerät und konfigurieren Sie die MQTT Bridge-Komponente so, dass sie Nachrichten von Client-Geräten an das lokale Publish/Subscribe-System weiterleitet. Gehen Sie wie folgt vor:

    1. Wählen Sie im linken Navigationsmenü die Option Core-Geräte aus.

    2. Wählen Sie auf der Seite Core-Geräte das Core-Gerät aus, das Sie für dieses Tutorial verwenden.

    3. Wählen Sie auf der Seite mit den Details zum Kerngerät die Registerkarte Client-Geräte aus.

    4. Wählen Sie auf der Registerkarte Client-Geräte die Option Cloud-Discovery konfigurieren aus.

      Die Seite „Erkennung von Kerngeräten konfigurieren“ wird geöffnet. Auf dieser Seite können Sie ändern oder konfigurieren, welche Komponenten des Client-Geräts auf dem Kerngerät bereitgestellt werden.

    5. In Schritt 3 für aws.greengrass.clientdevices.mqtt.BridgeWählen Sie für die Komponente Konfiguration bearbeiten aus.

    6. Konfigurieren Sie im Modal „Konfiguration bearbeiten“ für die MQTT Bridge-Komponente eine Themenzuordnung, die MQTT Nachrichten von Client-Geräten an die lokale Publish/Subscribe-Schnittstelle weiterleitet. Gehen Sie wie folgt vor:

      1. Geben Sie unter Konfiguration im Block Konfiguration zum Zusammenführen von Code die folgende Konfiguration ein. Diese Konfiguration legt fest, dass MQTT Nachrichten zu Themen, die dem clients/+/hello/world Themenfilter entsprechen, von Client-Geräten an den AWS IoT Core Cloud-Dienst und den lokalen Publish/Subscribe-Broker von Greengrass weitergeleitet werden.

        { "mqttTopicMapping": { "HelloWorldIotCoreMapping": { "topic": "clients/+/hello/world", "source": "LocalMqtt", "target": "IotCore" }, "HelloWorldPubsubMapping": { "topic": "clients/+/hello/world", "source": "LocalMqtt", "target": "Pubsub" } } }

        Weitere Informationen finden Sie unter Konfiguration der Bridge-KomponentenMQTT.

      2. Wählen Sie Bestätigen aus.

    7. Wählen Sie Überprüfen und bereitstellen, um die Bereitstellung zu überprüfen, die diese Seite für Sie erstellt.

    8. Wählen Sie auf der Seite „Überprüfen“ die Option Bereitstellen aus, um die Bereitstellung auf dem Kerngerät zu starten.

    9. Um zu überprüfen, ob die Bereitstellung erfolgreich ist, überprüfen Sie den Status der Bereitstellung und überprüfen Sie die Protokolle auf dem Kerngerät. Um den Status der Bereitstellung auf dem Kerngerät zu überprüfen, können Sie in der Bereitstellungsübersicht die Option Target auswählen. Weitere Informationen finden Sie hier:

  2. Entwickeln und implementieren Sie eine Greengrass-Komponente, die Hello World-Nachrichten von Client-Geräten abonniert. Gehen Sie wie folgt vor:

    1. Erstellen Sie Ordner für Rezepte und Artefakte auf dem Kerngerät.

      Linux or Unix
      mkdir recipes mkdir -p artifacts/com.example.clientdevices.MyHelloWorldSubscriber/1.0.0
      Windows Command Prompt (CMD)
      mkdir recipes mkdir artifacts\com.example.clientdevices.MyHelloWorldSubscriber\1.0.0
      PowerShell
      mkdir recipes mkdir artifacts\com.example.clientdevices.MyHelloWorldSubscriber\1.0.0
      mkdir recipes mkdir -p artifacts/com.example.clientdevices.MyHelloWorldSubscriber/1.0.0
      Wichtig

      Sie müssen das folgende Format für den Artefaktordnerpfad verwenden. Geben Sie den Komponentennamen und die Version an, die Sie im Rezept angeben.

      artifacts/componentName/componentVersion/
    2. Verwenden Sie einen Texteditor, um ein Komponentenrezept mit dem folgenden Inhalt zu erstellen. Dieses Rezept legt fest, dass AWS IoT Device SDK Version 2 für Python installiert und ein Skript ausgeführt werden soll, das das Thema abonniert und Nachrichten ausgibt.

      Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.

      nano recipes/com.example.clientdevices.MyHelloWorldSubscriber-1.0.0.json

      Kopieren Sie das folgende Rezept in die Datei.

      { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.clientdevices.MyHelloWorldSubscriber", "ComponentVersion": "1.0.0", "ComponentDescription": "A component that subscribes to Hello World messages from client devices.", "ComponentPublisher": "Amazon", "ComponentConfiguration": { "DefaultConfiguration": { "accessControl": { "aws.greengrass.ipc.pubsub": { "com.example.clientdevices.MyHelloWorldSubscriber:pubsub:1": { "policyDescription": "Allows access to subscribe to all topics.", "operations": [ "aws.greengrass#SubscribeToTopic" ], "resources": [ "*" ] } } } } }, "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "install": "python3 -m pip install --user awsiotsdk", "Run": "python3 -u {artifacts:path}/hello_world_subscriber.py" } }, { "Platform": { "os": "windows" }, "Lifecycle": { "install": "py -3 -m pip install --user awsiotsdk", "Run": "py -3 -u {artifacts:path}/hello_world_subscriber.py" } } ] }
    3. Verwenden Sie einen Texteditor, um ein Python-Skript-Artefakt hello_world_subscriber.py mit dem folgenden Inhalt zu erstellen. Diese Anwendung verwendet den IPC Veröffentlichungs-/Abonnementdienst, um das clients/+/hello/world Thema zu abonnieren und die empfangenen Nachrichten zu drucken.

      Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mithilfe von GNU nano zu erstellen.

      nano artifacts/com.example.clientdevices.MyHelloWorldSubscriber/1.0.0/hello_world_subscriber.py

      Kopieren Sie den folgenden Python-Code in die Datei.

      import sys import time import traceback from awsiot.greengrasscoreipc.clientv2 import GreengrassCoreIPCClientV2 CLIENT_DEVICE_HELLO_WORLD_TOPIC = 'clients/+/hello/world' TIMEOUT = 10 def on_hello_world_message(event): try: message = str(event.binary_message.message, 'utf-8') print('Received new message: %s' % message) except: traceback.print_exc() try: ipc_client = GreengrassCoreIPCClientV2() # SubscribeToTopic returns a tuple with the response and the operation. _, operation = ipc_client.subscribe_to_topic( topic=CLIENT_DEVICE_HELLO_WORLD_TOPIC, on_stream_event=on_hello_world_message) print('Successfully subscribed to topic: %s' % CLIENT_DEVICE_HELLO_WORLD_TOPIC) # Keep the main thread alive, or the process will exit. try: while True: time.sleep(10) except InterruptedError: print('Subscribe interrupted.') operation.close() except Exception: print('Exception occurred when using IPC.', file=sys.stderr) traceback.print_exc() exit(1)
      Anmerkung

      Diese Komponente verwendet den IPC Client V2 in der Version AWS IoT Device SDK 2 für Python, um mit der AWS IoT Greengrass Core-Software zu kommunizieren. Im Vergleich zum ursprünglichen IPC Client reduziert der IPC Client V2 die Menge an Code, die Sie schreiben müssen, um ihn IPC in benutzerdefinierten Komponenten zu verwenden.

    4. Verwenden Sie GreengrassCLI, um die Komponente bereitzustellen.

      Linux or Unix
      sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir recipes \ --artifactDir artifacts \ --merge "com.example.clientdevices.MyHelloWorldSubscriber=1.0.0"
      Windows Command Prompt (CMD)
      C:\greengrass\v2/bin/greengrass-cli deployment create ^ --recipeDir recipes ^ --artifactDir artifacts ^ --merge "com.example.clientdevices.MyHelloWorldSubscriber=1.0.0"
      PowerShell
      C:\greengrass\v2/bin/greengrass-cli deployment create ` --recipeDir recipes ` --artifactDir artifacts ` --merge "com.example.clientdevices.MyHelloWorldSubscriber=1.0.0"
      sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir recipes \ --artifactDir artifacts \ --merge "com.example.clientdevices.MyHelloWorldSubscriber=1.0.0"
  3. Sehen Sie sich die Komponentenprotokolle an, um zu überprüfen, ob die Komponente erfolgreich installiert wurde und ob sie das Thema abonniert hat.

    Linux or Unix
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log
    PowerShell
    gc C:\greengrass\v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log -Tail 10 -Wait
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log

    Sie können den Protokoll-Feed geöffnet lassen, um zu überprüfen, ob das Kerngerät Nachrichten empfängt.

  4. Führen Sie auf dem Client-Gerät erneut die Greengrass-Discovery-Beispielanwendung aus, um Nachrichten an das Kerngerät zu senden.

    python3 basic_discovery.py \\ --thing_name MyClientDevice1 \\ --topic 'clients/MyClientDevice1/hello/world' \\ --message 'Hello World!' \\ --ca_file ~/certs/AmazonRootCA1.pem \\ --cert ~/certs/device.pem.crt \\ --key ~/certs/private.pem.key \\ --region us-east-1 \\ --verbosity Warn
  5. Sehen Sie sich die Komponentenprotokolle erneut an, um sicherzustellen, dass die Komponente die Nachrichten vom Client-Gerät empfängt und druckt.

    Linux or Unix
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log
    PowerShell
    gc C:\greengrass\v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log -Tail 10 -Wait
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log

Schritt 5: Entwickeln Sie eine Komponente, die mit Schatten auf Client-Geräten interagiert

Sie können Greengrass-Komponenten entwickeln, die mit den Geräteschatten des AWS IoT Client-Geräts interagieren. Ein Shadow ist ein JSON Dokument, in dem die aktuellen oder gewünschten Statusinformationen für ein Objekt gespeichert AWS IoT werden, z. B. für ein Client-Gerät. Benutzerdefinierte Komponenten können auf die Shadows von Client-Geräten zugreifen, um deren Status zu verwalten, auch wenn das Client-Gerät nicht mit dem Client-Gerät verbunden AWS IoT ist. Jedes AWS IoT Objekt hat einen unbenannten Schatten, und Sie können auch mehrere benannte Schatten für jedes Objekt erstellen.

In diesem Abschnitt stellen Sie die Shadow-Manager-Komponente bereit, um Schatten auf dem Kerngerät zu verwalten. Sie aktualisieren auch die MQTT Bridge-Komponente, um Shadow-Nachrichten zwischen Client-Geräten und der Shadow-Manager-Komponente weiterzuleiten. Anschließend entwickeln Sie eine Komponente, die die Shadows der Client-Geräte aktualisiert, und Sie führen auf den Client-Geräten eine Beispielanwendung aus, die auf Shadow-Updates von der Komponente reagiert. Diese Komponente stellt eine intelligente Lichtmanagement-Anwendung dar, bei der das Kerngerät den Farbstatus der intelligenten Lampen verwaltet, die als Client-Geräte mit dem Gerät verbunden sind.

Um eine Komponente zu entwickeln, die mit Schatten von Client-Geräten interagiert
  1. Überarbeiten Sie die Bereitstellung auf dem Kerngerät, um die Shadow-Manager-Komponente bereitzustellen, und konfigurieren Sie die MQTT Bridge-Komponente so, dass sie Shadow-Nachrichten zwischen Client-Geräten und dem lokalen Publish/Subscribe weiterleitet, wo der Shadow Manager kommuniziert. Gehen Sie wie folgt vor:

    1. Wählen Sie im linken Navigationsmenü die Option Core-Geräte aus.

    2. Wählen Sie auf der Seite Core-Geräte das Core-Gerät aus, das Sie für dieses Tutorial verwenden.

    3. Wählen Sie auf der Seite mit den Details zum Kerngerät die Registerkarte Client-Geräte aus.

    4. Wählen Sie auf der Registerkarte Client-Geräte die Option Cloud-Discovery konfigurieren aus.

      Die Seite „Erkennung von Kerngeräten konfigurieren“ wird geöffnet. Auf dieser Seite können Sie ändern oder konfigurieren, welche Komponenten des Client-Geräts auf dem Kerngerät bereitgestellt werden.

    5. In Schritt 3 für aws.greengrass.clientdevices.mqtt.BridgeWählen Sie für die Komponente Konfiguration bearbeiten aus.

    6. Konfigurieren Sie im Modal „Konfiguration bearbeiten“ für die MQTT Bridge-Komponente eine Themenzuordnung, die MQTT Nachrichten zu Device-Shadow-Themen zwischen Client-Geräten und der lokalen Publish/Subscribe-Schnittstelle weiterleitet. Sie bestätigen außerdem, dass die Bereitstellung eine kompatible Bridge-Version spezifiziert. MQTT Für die Unterstützung von Client-Geräteshadow ist MQTT Bridge v2.2.0 oder höher erforderlich. Gehen Sie wie folgt vor:

      1. Wählen Sie als Komponentenversion Version 2.2.0 oder höher aus.

      2. Geben Sie unter Konfiguration im Block Konfiguration zum Zusammenführen von Code die folgende Konfiguration ein. Diese Konfiguration legt fest, dass MQTT Nachrichten zu Schattenthemen weitergeleitet werden.

        { "mqttTopicMapping": { "HelloWorldIotCoreMapping": { "topic": "clients/+/hello/world", "source": "LocalMqtt", "target": "IotCore" }, "HelloWorldPubsubMapping": { "topic": "clients/+/hello/world", "source": "LocalMqtt", "target": "Pubsub" }, "ShadowsLocalMqttToPubsub": { "topic": "$aws/things/+/shadow/#", "source": "LocalMqtt", "target": "Pubsub" }, "ShadowsPubsubToLocalMqtt": { "topic": "$aws/things/+/shadow/#", "source": "Pubsub", "target": "LocalMqtt" } } }

        Weitere Informationen finden Sie unter Konfiguration der MQTT Bridge-Komponenten.

      3. Wählen Sie Bestätigen aus.

    7. Wählen Sie in Schritt 3 aws.greengrass.ShadowManagerKomponente, um sie bereitzustellen.

    8. Wählen Sie Überprüfen und bereitstellen, um die Bereitstellung zu überprüfen, die diese Seite für Sie erstellt.

    9. Wählen Sie auf der Seite „Überprüfen“ die Option Bereitstellen aus, um die Bereitstellung auf dem Kerngerät zu starten.

    10. Um zu überprüfen, ob die Bereitstellung erfolgreich ist, überprüfen Sie den Status der Bereitstellung und überprüfen Sie die Protokolle auf dem Kerngerät. Um den Status der Bereitstellung auf dem Kerngerät zu überprüfen, können Sie in der Bereitstellungsübersicht die Option Target auswählen. Weitere Informationen finden Sie hier:

  2. Entwickeln und implementieren Sie eine Greengrass-Komponente, die Smart-Light-Client-Geräte verwaltet. Gehen Sie wie folgt vor:

    1. Erstellen Sie einen Ordner mit den Artefakten der Komponente auf dem Kerngerät.

      Linux or Unix
      mkdir -p artifacts/com.example.clientdevices.MySmartLightManager/1.0.0
      Windows Command Prompt (CMD)
      mkdir artifacts\com.example.clientdevices.MySmartLightManager\1.0.0
      PowerShell
      mkdir artifacts\com.example.clientdevices.MySmartLightManager\1.0.0
      mkdir -p artifacts/com.example.clientdevices.MySmartLightManager/1.0.0
      Wichtig

      Sie müssen das folgende Format für den Artefaktordnerpfad verwenden. Geben Sie den Komponentennamen und die Version an, die Sie im Rezept angeben.

      artifacts/componentName/componentVersion/
    2. Verwenden Sie einen Texteditor, um ein Komponentenrezept mit dem folgenden Inhalt zu erstellen. Dieses Rezept legt fest, dass AWS IoT Device SDK Version 2 für Python installiert und ein Skript ausgeführt werden soll, das mit den Schatten von Smart-Light-Client-Geräten interagiert, um deren Farben zu verwalten.

      Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mithilfe von GNU nano zu erstellen.

      nano recipes/com.example.clientdevices.MySmartLightManager-1.0.0.json

      Kopieren Sie das folgende Rezept in die Datei.

      { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.clientdevices.MySmartLightManager", "ComponentVersion": "1.0.0", "ComponentDescription": "A component that interacts with smart light client devices.", "ComponentPublisher": "Amazon", "ComponentDependencies": { "aws.greengrass.Nucleus": { "VersionRequirement": "^2.6.0" }, "aws.greengrass.ShadowManager": { "VersionRequirement": "^2.2.0" }, "aws.greengrass.clientdevices.mqtt.Bridge": { "VersionRequirement": "^2.2.0" } }, "ComponentConfiguration": { "DefaultConfiguration": { "smartLightDeviceNames": [], "accessControl": { "aws.greengrass.ShadowManager": { "com.example.clientdevices.MySmartLightManager:shadow:1": { "policyDescription": "Allows access to client devices' unnamed shadows", "operations": [ "aws.greengrass#GetThingShadow", "aws.greengrass#UpdateThingShadow" ], "resources": [ "$aws/things/MyClientDevice*/shadow" ] } }, "aws.greengrass.ipc.pubsub": { "com.example.clientdevices.MySmartLightManager:pubsub:1": { "policyDescription": "Allows access to client devices' unnamed shadow updates", "operations": [ "aws.greengrass#SubscribeToTopic" ], "resources": [ "$aws/things/+/shadow/update/accepted" ] } } } } }, "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "install": "python3 -m pip install --user awsiotsdk", "Run": "python3 -u {artifacts:path}/smart_light_manager.py" } }, { "Platform": { "os": "windows" }, "Lifecycle": { "install": "py -3 -m pip install --user awsiotsdk", "Run": "py -3 -u {artifacts:path}/smart_light_manager.py" } } ] }
    3. Verwenden Sie einen Texteditor, um ein Python-Skript-Artefakt smart_light_manager.py mit dem folgenden Inhalt zu erstellen. Diese Anwendung verwendet den IPC Shadow-Dienst, um Shadows auf Client-Geräten abzurufen und zu aktualisieren, und den lokalen IPC Veröffentlichungs-/Abonnementdienst, um gemeldete Shadow-Updates zu empfangen.

      Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mithilfe von GNU nano zu erstellen.

      nano artifacts/com.example.clientdevices.MySmartLightManager/1.0.0/smart_light_manager.py

      Kopieren Sie den folgenden Python-Code in die Datei.

      import json import random import sys import time import traceback from uuid import uuid4 from awsiot.greengrasscoreipc.clientv2 import GreengrassCoreIPCClientV2 from awsiot.greengrasscoreipc.model import ResourceNotFoundError SHADOW_COLOR_PROPERTY = 'color' CONFIGURATION_CLIENT_DEVICE_NAMES = 'smartLightDeviceNames' COLORS = ['red', 'orange', 'yellow', 'green', 'blue', 'purple'] SHADOW_UPDATE_TOPIC = '$aws/things/+/shadow/update/accepted' SET_COLOR_INTERVAL = 15 class SmartLightDevice(): def __init__(self, client_device_name: str, reported_color: str = None): self.name = client_device_name self.reported_color = reported_color self.desired_color = None class SmartLightDeviceManager(): def __init__(self, ipc_client: GreengrassCoreIPCClientV2): self.ipc_client = ipc_client self.devices = {} self.client_tokens = set() self.shadow_update_accepted_subscription_operation = None self.client_device_names_configuration_subscription_operation = None self.update_smart_light_device_list() def update_smart_light_device_list(self): # Update the device list from the component configuration. response = self.ipc_client.get_configuration( key_path=[CONFIGURATION_CLIENT_DEVICE_NAMES]) # Identify the difference between the configuration and the currently tracked devices. current_device_names = self.devices.keys() updated_device_names = response.value[CONFIGURATION_CLIENT_DEVICE_NAMES] added_device_names = set(updated_device_names) - set(current_device_names) removed_device_names = set(current_device_names) - set(updated_device_names) # Stop tracking any smart light devices that are no longer in the configuration. for name in removed_device_names: print('Removing %s from smart light device manager' % name) self.devices.pop(name) # Start tracking any new smart light devices that are in the configuration. for name in added_device_names: print('Adding %s to smart light device manager' % name) device = SmartLightDevice(name) device.reported_color = self.get_device_reported_color(device) self.devices[name] = device print('Current color for %s is %s' % (name, device.reported_color)) def get_device_reported_color(self, smart_light_device): try: response = self.ipc_client.get_thing_shadow( thing_name=smart_light_device.name, shadow_name='') shadow = json.loads(str(response.payload, 'utf-8')) if 'reported' in shadow['state']: return shadow['state']['reported'].get(SHADOW_COLOR_PROPERTY) return None except ResourceNotFoundError: return None def request_device_color_change(self, smart_light_device, color): # Generate and track a client token for the request. client_token = str(uuid4()) self.client_tokens.add(client_token) # Create a shadow payload, which must be a blob. payload_json = { 'state': { 'desired': { SHADOW_COLOR_PROPERTY: color } }, 'clientToken': client_token } payload = bytes(json.dumps(payload_json), 'utf-8') self.ipc_client.update_thing_shadow( thing_name=smart_light_device.name, shadow_name='', payload=payload) smart_light_device.desired_color = color def subscribe_to_shadow_update_accepted_events(self): if self.shadow_update_accepted_subscription_operation == None: # SubscribeToTopic returns a tuple with the response and the operation. _, self.shadow_update_accepted_subscription_operation = self.ipc_client.subscribe_to_topic( topic=SHADOW_UPDATE_TOPIC, on_stream_event=self.on_shadow_update_accepted_event) print('Successfully subscribed to shadow update accepted topic') def close_shadow_update_accepted_subscription(self): if self.shadow_update_accepted_subscription_operation is not None: self.shadow_update_accepted_subscription_operation.close() def on_shadow_update_accepted_event(self, event): try: message = str(event.binary_message.message, 'utf-8') accepted_payload = json.loads(message) # Check for reported states from smart light devices and ignore desired states from components. if 'reported' in accepted_payload['state']: # Process this update only if it uses a client token created by this component. client_token = accepted_payload.get('clientToken') if client_token is not None and client_token in self.client_tokens: self.client_tokens.remove(client_token) shadow_state = accepted_payload['state']['reported'] if SHADOW_COLOR_PROPERTY in shadow_state: reported_color = shadow_state[SHADOW_COLOR_PROPERTY] topic = event.binary_message.context.topic client_device_name = topic.split('/')[2] if client_device_name in self.devices: # Set the reported color for the smart light device. self.devices[client_device_name].reported_color = reported_color print( 'Received shadow update confirmation from client device: %s' % client_device_name) else: print("Shadow update doesn't specify color") except: traceback.print_exc() def subscribe_to_client_device_name_configuration_updates(self): if self.client_device_names_configuration_subscription_operation == None: # SubscribeToConfigurationUpdate returns a tuple with the response and the operation. _, self.client_device_names_configuration_subscription_operation = self.ipc_client.subscribe_to_configuration_update( key_path=[CONFIGURATION_CLIENT_DEVICE_NAMES], on_stream_event=self.on_client_device_names_configuration_update_event) print( 'Successfully subscribed to configuration updates for smart light device names') def close_client_device_names_configuration_subscription(self): if self.client_device_names_configuration_subscription_operation is not None: self.client_device_names_configuration_subscription_operation.close() def on_client_device_names_configuration_update_event(self, event): try: if CONFIGURATION_CLIENT_DEVICE_NAMES in event.configuration_update_event.key_path: print('Received configuration update for list of client devices') self.update_smart_light_device_list() except: traceback.print_exc() def choose_random_color(): return random.choice(COLORS) def main(): try: # Create an IPC client and a smart light device manager. ipc_client = GreengrassCoreIPCClientV2() smart_light_manager = SmartLightDeviceManager(ipc_client) smart_light_manager.subscribe_to_shadow_update_accepted_events() smart_light_manager.subscribe_to_client_device_name_configuration_updates() try: # Keep the main thread alive, or the process will exit. while True: # Set each smart light device to a random color at a regular interval. for device_name in smart_light_manager.devices: device = smart_light_manager.devices[device_name] desired_color = choose_random_color() print('Chose random color (%s) for %s' % (desired_color, device_name)) if desired_color == device.desired_color: print('Desired color for %s is already %s' % (device_name, desired_color)) elif desired_color == device.reported_color: print('Reported color for %s is already %s' % (device_name, desired_color)) else: smart_light_manager.request_device_color_change( device, desired_color) print('Requested color change for %s to %s' % (device_name, desired_color)) time.sleep(SET_COLOR_INTERVAL) except InterruptedError: print('Application interrupted') smart_light_manager.close_shadow_update_accepted_subscription() smart_light_manager.close_client_device_names_configuration_subscription() except Exception: print('Exception occurred', file=sys.stderr) traceback.print_exc() exit(1) if __name__ == '__main__': main()

      Diese Python-Anwendung macht Folgendes:

      • Liest die Konfiguration der Komponente, um die Liste der zu verwaltenden Smart-Light-Client-Geräte abzurufen.

      • Abonniert mithilfe des SubscribeToConfigurationUpdate IPC Vorgangs Benachrichtigungen über Konfigurationsupdates. Die AWS IoT Greengrass Core-Software sendet jedes Mal Benachrichtigungen, wenn sich die Konfiguration der Komponente ändert. Wenn die Komponente eine Benachrichtigung über ein Konfigurationsupdate erhält, aktualisiert sie die Liste der von ihr verwalteten Smart-Light-Client-Geräte.

      • Ruft den Schatten jedes Smart-Light-Client-Geräts auf seinen ursprünglichen Farbstatus ab.

      • Stellt die Farbe jedes Smart-Light-Client-Geräts alle 15 Sekunden auf eine zufällige Farbe ein. Die Komponente aktualisiert den Dingschatten des Client-Geräts, um seine Farbe zu ändern. Bei diesem Vorgang wird ein Shadow-Delta-Ereignis an das Client-Gerät gesendetMQTT.

      • Abonniert mithilfe dieses Vorgangs Nachrichten, die vom Shadow Update akzeptiert wurden, auf der lokalen Schnittstelle zum Veröffentlichen und Abonnieren. SubscribeToTopic IPC Diese Komponente empfängt diese Nachrichten, um die Farbe der einzelnen Smart-Light-Client-Geräte zu verfolgen. Wenn ein Smart-Light-Client-Gerät ein Shadow-Update erhält, sendet es eine MQTT Nachricht, um zu bestätigen, dass es das Update erhalten hat. Die MQTT Bridge leitet diese Nachricht an die lokale Publish/Subscribe-Schnittstelle weiter.

    4. Verwenden Sie GreengrassCLI, um die Komponente bereitzustellen. Wenn Sie diese Komponente bereitstellen, geben Sie die Liste der Client-Geräte ansmartLightDeviceNames, deren Schatten sie verwaltet. MyClientDevice1Ersetzen Sie es durch den Ding-Namen des Client-Geräts.

      Linux or Unix
      sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir recipes \ --artifactDir artifacts \ --merge "com.example.clientdevices.MySmartLightManager=1.0.0" \ --update-config '{ "com.example.clientdevices.MySmartLightManager": { "MERGE": { "smartLightDeviceNames": [ "MyClientDevice1" ] } } }'
      Windows Command Prompt (CMD)
      C:\greengrass\v2/bin/greengrass-cli deployment create ^ --recipeDir recipes ^ --artifactDir artifacts ^ --merge "com.example.clientdevices.MySmartLightManager=1.0.0" ^ --update-config '{"com.example.clientdevices.MySmartLightManager":{"MERGE":{"smartLightDeviceNames":["MyClientDevice1"]}}}'
      PowerShell
      C:\greengrass\v2/bin/greengrass-cli deployment create ` --recipeDir recipes ` --artifactDir artifacts ` --merge "com.example.clientdevices.MySmartLightManager=1.0.0" ` --update-config '{ "com.example.clientdevices.MySmartLightManager": { "MERGE": { "smartLightDeviceNames": [ "MyClientDevice1" ] } } }'
      sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir recipes \ --artifactDir artifacts \ --merge "com.example.clientdevices.MySmartLightManager=1.0.0" \ --update-config '{ "com.example.clientdevices.MySmartLightManager": { "MERGE": { "smartLightDeviceNames": [ "MyClientDevice1" ] } } }'
  3. Sehen Sie sich die Komponentenprotokolle an, um zu überprüfen, ob die Komponente erfolgreich installiert und ausgeführt wurde.

    Linux or Unix
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MySmartLightManager.log
    PowerShell
    gc C:\greengrass\v2/logs/com.example.clientdevices.MySmartLightManager.log -Tail 10 -Wait
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MySmartLightManager.log

    Die Komponente sendet Anfragen, um die Farbe des Smart Light-Client-Geräts zu ändern. Der Shadow-Manager empfängt die Anfrage und legt den desired Status des Shadows fest. Das Smart-Light-Client-Gerät läuft jedoch noch nicht, sodass sich der reported Status des Shadows nicht ändert. Die Protokolle der Komponente enthalten die folgenden Meldungen.

    2022-07-07T03:49:24.908Z [INFO] (Copier) com.example.clientdevices.MySmartLightManager: stdout. Chose random color (blue) for MyClientDevice1. {scriptName=services.com.example.clientdevices.MySmartLightManager.lifecycle.Run, serviceName=com.example.clientdevices.MySmartLightManager, currentState=RUNNING} 2022-07-07T03:49:24.912Z [INFO] (Copier) com.example.clientdevices.MySmartLightManager: stdout. Requested color change for MyClientDevice1 to blue. {scriptName=services.com.example.clientdevices.MySmartLightManager.lifecycle.Run, serviceName=com.example.clientdevices.MySmartLightManager, currentState=RUNNING}

    Sie können den Protokoll-Feed geöffnet lassen, um zu sehen, wann die Komponente Meldungen druckt.

  4. Laden Sie eine Beispielanwendung herunter und führen Sie sie aus, die Greengrass Discovery verwendet und Device Shadow-Updates abonniert. Gehen Sie auf dem Client-Gerät wie folgt vor:

    1. Wechseln Sie in den Samples-Ordner in der AWS IoT Device SDK Version v2 für Python. Diese Beispielanwendung verwendet ein Befehlszeilen-Parsing-Modul im Beispielordner.

      cd aws-iot-device-sdk-python-v2/samples
    2. Verwenden Sie einen Texteditor, um ein Python-Skript basic_discovery_shadow.py mit dem folgenden Inhalt zu erstellen. Diese Anwendung verwendet Greengrass Discovery und Shadows, um eine Eigenschaft zwischen dem Client-Gerät und dem Core-Gerät synchron zu halten.

      Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mithilfe von GNU nano zu erstellen.

      nano basic_discovery_shadow.py

      Kopieren Sie den folgenden Python-Code in die Datei.

      # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0. from awscrt import io from awscrt import mqtt from awsiot import iotshadow from awsiot.greengrass_discovery import DiscoveryClient from awsiot import mqtt_connection_builder from concurrent.futures import Future import sys import threading import traceback from uuid import uuid4 # Parse arguments import utils.command_line_utils; cmdUtils = utils.command_line_utils.CommandLineUtils("Basic Discovery - Greengrass discovery example with device shadows.") cmdUtils.add_common_mqtt_commands() cmdUtils.add_common_topic_message_commands() cmdUtils.add_common_logging_commands() cmdUtils.register_command("key", "<path>", "Path to your key in PEM format.", True, str) cmdUtils.register_command("cert", "<path>", "Path to your client certificate in PEM format.", True, str) cmdUtils.remove_command("endpoint") cmdUtils.register_command("thing_name", "<str>", "The name assigned to your IoT Thing", required=True) cmdUtils.register_command("region", "<str>", "The region to connect through.", required=True) cmdUtils.register_command("shadow_property", "<str>", "The name of the shadow property you want to change (optional, default='color'", default="color") # Needs to be called so the command utils parse the commands cmdUtils.get_args() # Using globals to simplify sample code is_sample_done = threading.Event() mqtt_connection = None shadow_thing_name = cmdUtils.get_command_required("thing_name") shadow_property = cmdUtils.get_command("shadow_property") SHADOW_VALUE_DEFAULT = "off" class LockedData: def __init__(self): self.lock = threading.Lock() self.shadow_value = None self.disconnect_called = False self.request_tokens = set() locked_data = LockedData() def on_connection_interupted(connection, error, **kwargs): print('connection interrupted with error {}'.format(error)) def on_connection_resumed(connection, return_code, session_present, **kwargs): print('connection resumed with return code {}, session present {}'.format(return_code, session_present)) # Try IoT endpoints until we find one that works def try_iot_endpoints(): for gg_group in discover_response.gg_groups: for gg_core in gg_group.cores: for connectivity_info in gg_core.connectivity: try: print('Trying core {} at host {} port {}'.format(gg_core.thing_arn, connectivity_info.host_address, connectivity_info.port)) mqtt_connection = mqtt_connection_builder.mtls_from_path( endpoint=connectivity_info.host_address, port=connectivity_info.port, cert_filepath=cmdUtils.get_command_required("cert"), pri_key_filepath=cmdUtils.get_command_required("key"), ca_bytes=gg_group.certificate_authorities[0].encode('utf-8'), on_connection_interrupted=on_connection_interupted, on_connection_resumed=on_connection_resumed, client_id=cmdUtils.get_command_required("thing_name"), clean_session=False, keep_alive_secs=30) connect_future = mqtt_connection.connect() connect_future.result() print('Connected!') return mqtt_connection except Exception as e: print('Connection failed with exception {}'.format(e)) continue exit('All connection attempts failed') # Function for gracefully quitting this sample def exit(msg_or_exception): if isinstance(msg_or_exception, Exception): print("Exiting sample due to exception.") traceback.print_exception(msg_or_exception.__class__, msg_or_exception, sys.exc_info()[2]) else: print("Exiting sample:", msg_or_exception) with locked_data.lock: if not locked_data.disconnect_called: print("Disconnecting...") locked_data.disconnect_called = True future = mqtt_connection.disconnect() future.add_done_callback(on_disconnected) def on_disconnected(disconnect_future): # type: (Future) -> None print("Disconnected.") # Signal that sample is finished is_sample_done.set() def on_get_shadow_accepted(response): # type: (iotshadow.GetShadowResponse) -> None try: with locked_data.lock: # check that this is a response to a request from this session try: locked_data.request_tokens.remove(response.client_token) except KeyError: return print("Finished getting initial shadow state.") if locked_data.shadow_value is not None: print(" Ignoring initial query because a delta event has already been received.") return if response.state: if response.state.delta: value = response.state.delta.get(shadow_property) if value: print(" Shadow contains delta value '{}'.".format(value)) change_shadow_value(value) return if response.state.reported: value = response.state.reported.get(shadow_property) if value: print(" Shadow contains reported value '{}'.".format(value)) set_local_value_due_to_initial_query(response.state.reported[shadow_property]) return print(" Shadow document lacks '{}' property. Setting defaults...".format(shadow_property)) change_shadow_value(SHADOW_VALUE_DEFAULT) return except Exception as e: exit(e) def on_get_shadow_rejected(error): # type: (iotshadow.ErrorResponse) -> None try: # check that this is a response to a request from this session with locked_data.lock: try: locked_data.request_tokens.remove(error.client_token) except KeyError: return if error.code == 404: print("Thing has no shadow document. Creating with defaults...") change_shadow_value(SHADOW_VALUE_DEFAULT) else: exit("Get request was rejected. code:{} message:'{}'".format( error.code, error.message)) except Exception as e: exit(e) def on_shadow_delta_updated(delta): # type: (iotshadow.ShadowDeltaUpdatedEvent) -> None try: print("Received shadow delta event.") if delta.state and (shadow_property in delta.state): value = delta.state[shadow_property] if value is None: print(" Delta reports that '{}' was deleted. Resetting defaults...".format(shadow_property)) change_shadow_value(SHADOW_VALUE_DEFAULT) return else: print(" Delta reports that desired value is '{}'. Changing local value...".format(value)) if (delta.client_token is not None): print (" ClientToken is: " + delta.client_token) change_shadow_value(value, delta.client_token) else: print(" Delta did not report a change in '{}'".format(shadow_property)) except Exception as e: exit(e) def on_publish_update_shadow(future): #type: (Future) -> None try: future.result() print("Update request published.") except Exception as e: print("Failed to publish update request.") exit(e) def on_update_shadow_accepted(response): # type: (iotshadow.UpdateShadowResponse) -> None try: # check that this is a response to a request from this session with locked_data.lock: try: locked_data.request_tokens.remove(response.client_token) except KeyError: return try: if response.state.reported != None: if shadow_property in response.state.reported: print("Finished updating reported shadow value to '{}'.".format(response.state.reported[shadow_property])) # type: ignore else: print ("Could not find shadow property with name: '{}'.".format(shadow_property)) # type: ignore else: print("Shadow states cleared.") # when the shadow states are cleared, reported and desired are set to None except: exit("Updated shadow is missing the target property") except Exception as e: exit(e) def on_update_shadow_rejected(error): # type: (iotshadow.ErrorResponse) -> None try: # check that this is a response to a request from this session with locked_data.lock: try: locked_data.request_tokens.remove(error.client_token) except KeyError: return exit("Update request was rejected. code:{} message:'{}'".format( error.code, error.message)) except Exception as e: exit(e) def set_local_value_due_to_initial_query(reported_value): with locked_data.lock: locked_data.shadow_value = reported_value def change_shadow_value(value, token=None): with locked_data.lock: if locked_data.shadow_value == value: print("Local value is already '{}'.".format(value)) return print("Changed local shadow value to '{}'.".format(value)) locked_data.shadow_value = value print("Updating reported shadow value to '{}'...".format(value)) reuse_token = token is not None # use a unique token so we can correlate this "request" message to # any "response" messages received on the /accepted and /rejected topics if not reuse_token: token = str(uuid4()) # if the value is "clear shadow" then send a UpdateShadowRequest with None # for both reported and desired to clear the shadow document completely. if value == "clear_shadow": tmp_state = iotshadow.ShadowState(reported=None, desired=None, reported_is_nullable=True, desired_is_nullable=True) request = iotshadow.UpdateShadowRequest( thing_name=shadow_thing_name, state=tmp_state, client_token=token, ) # Otherwise, send a normal update request else: # if the value is "none" then set it to a Python none object to # clear the individual shadow property if value == "none": value = None request = iotshadow.UpdateShadowRequest( thing_name=shadow_thing_name, state=iotshadow.ShadowState( reported={ shadow_property: value } ), client_token=token, ) future = shadow_client.publish_update_shadow(request, mqtt.QoS.AT_LEAST_ONCE) if not reuse_token: locked_data.request_tokens.add(token) future.add_done_callback(on_publish_update_shadow) if __name__ == '__main__': tls_options = io.TlsContextOptions.create_client_with_mtls_from_path(cmdUtils.get_command_required("cert"), cmdUtils.get_command_required("key")) if cmdUtils.get_command(cmdUtils.m_cmd_ca_file): tls_options.override_default_trust_store_from_path(None, cmdUtils.get_command(cmdUtils.m_cmd_ca_file)) tls_context = io.ClientTlsContext(tls_options) socket_options = io.SocketOptions() print('Performing greengrass discovery...') discovery_client = DiscoveryClient(io.ClientBootstrap.get_or_create_static_default(), socket_options, tls_context, cmdUtils.get_command_required("region")) resp_future = discovery_client.discover(cmdUtils.get_command_required("thing_name")) discover_response = resp_future.result() print(discover_response) if cmdUtils.get_command("print_discover_resp_only"): exit(0) mqtt_connection = try_iot_endpoints() shadow_client = iotshadow.IotShadowClient(mqtt_connection) try: # Subscribe to necessary topics. # Note that is **is** important to wait for "accepted/rejected" subscriptions # to succeed before publishing the corresponding "request". print("Subscribing to Update responses...") update_accepted_subscribed_future, _ = shadow_client.subscribe_to_update_shadow_accepted( request=iotshadow.UpdateShadowSubscriptionRequest(thing_name=shadow_thing_name), qos=mqtt.QoS.AT_LEAST_ONCE, callback=on_update_shadow_accepted) update_rejected_subscribed_future, _ = shadow_client.subscribe_to_update_shadow_rejected( request=iotshadow.UpdateShadowSubscriptionRequest(thing_name=shadow_thing_name), qos=mqtt.QoS.AT_LEAST_ONCE, callback=on_update_shadow_rejected) # Wait for subscriptions to succeed update_accepted_subscribed_future.result() update_rejected_subscribed_future.result() print("Subscribing to Get responses...") get_accepted_subscribed_future, _ = shadow_client.subscribe_to_get_shadow_accepted( request=iotshadow.GetShadowSubscriptionRequest(thing_name=shadow_thing_name), qos=mqtt.QoS.AT_LEAST_ONCE, callback=on_get_shadow_accepted) get_rejected_subscribed_future, _ = shadow_client.subscribe_to_get_shadow_rejected( request=iotshadow.GetShadowSubscriptionRequest(thing_name=shadow_thing_name), qos=mqtt.QoS.AT_LEAST_ONCE, callback=on_get_shadow_rejected) # Wait for subscriptions to succeed get_accepted_subscribed_future.result() get_rejected_subscribed_future.result() print("Subscribing to Delta events...") delta_subscribed_future, _ = shadow_client.subscribe_to_shadow_delta_updated_events( request=iotshadow.ShadowDeltaUpdatedSubscriptionRequest(thing_name=shadow_thing_name), qos=mqtt.QoS.AT_LEAST_ONCE, callback=on_shadow_delta_updated) # Wait for subscription to succeed delta_subscribed_future.result() # The rest of the sample runs asynchronously. # Issue request for shadow's current state. # The response will be received by the on_get_accepted() callback print("Requesting current shadow state...") with locked_data.lock: # use a unique token so we can correlate this "request" message to # any "response" messages received on the /accepted and /rejected topics token = str(uuid4()) publish_get_future = shadow_client.publish_get_shadow( request=iotshadow.GetShadowRequest(thing_name=shadow_thing_name, client_token=token), qos=mqtt.QoS.AT_LEAST_ONCE) locked_data.request_tokens.add(token) # Ensure that publish succeeds publish_get_future.result() except Exception as e: exit(e) # Wait for the sample to finish (user types 'quit', or an error occurs) is_sample_done.wait()

      Diese Python-Anwendung macht Folgendes:

      • Verwendet Greengrass Discovery, um das Kerngerät zu erkennen und eine Verbindung herzustellen.

      • Fordert das Shadow-Dokument vom Kerngerät an, um den ursprünglichen Status der Eigenschaft abzurufen.

      • Abonniert Shadow-Delta-Ereignisse, die das Kerngerät sendet, wenn der Wert der Eigenschaft von ihrem desired reported Wert abweicht. Wenn die Anwendung ein Shadow-Delta-Ereignis empfängt, ändert sie den Wert der Eigenschaft und sendet eine Aktualisierung an das Kerngerät, um den neuen Wert als reported Wert festzulegen.

      Diese Anwendung kombiniert die Greengrass-Entdeckung und die Schattenproben aus der AWS IoT Device SDK Version 2.

    3. Führen Sie die Beispielanwendung aus. Diese Anwendung erwartet Argumente, die den Namen des Dings auf dem Client-Gerät, die zu verwendende Shadow-Eigenschaft und die Zertifikate angeben, mit denen die Verbindung authentifiziert und gesichert wird.

      • MyClientDevice1Ersetzen Sie es durch den Ding-Namen des Client-Geräts.

      • ~/certs/AmazonRootCA1.pemErsetzen Sie durch den Pfad zum Amazon-Root-CA-Zertifikat auf dem Client-Gerät.

      • ~/certs/device.pem.crtErsetzen Sie durch den Pfad zum Gerätezertifikat auf dem Client-Gerät.

      • ~/certs/private.pem.keyErsetzen Sie durch den Pfad zur privaten Schlüsseldatei auf dem Client-Gerät.

      • us-east-1Ersetzen Sie durch die AWS Region, in der Ihr Client-Gerät und Ihr Core-Gerät betrieben werden.

      python3 basic_discovery_shadow.py \ --thing_name MyClientDevice1 \ --shadow_property color \ --ca_file ~/certs/AmazonRootCA1.pem \ --cert ~/certs/device.pem.crt \ --key ~/certs/private.pem.key \ --region us-east-1 \ --verbosity Warn

      Die Beispielanwendung abonniert die Shadow-Themen und wartet auf den Empfang von Shadow-Delta-Ereignissen vom Kerngerät. Wenn die Ausgabe anzeigt, dass die Anwendung Shadow-Delta-Ereignisse empfängt und darauf reagiert, kann das Client-Gerät erfolgreich mit seinem Shadow auf dem Kerngerät interagieren.

      Performing greengrass discovery... awsiot.greengrass_discovery.DiscoverResponse(gg_groups=[awsiot.greengrass_discovery.GGGroup(gg_group_id='greengrassV2-coreDevice-MyGreengrassCore', cores=[awsiot.greengrass_discovery.GGCore(thing_arn='arn:aws:iot:us-east-1:123456789012:thing/MyGreengrassCore', connectivity=[awsiot.greengrass_discovery.ConnectivityInfo(id='203.0.113.0', host_address='203.0.113.0', metadata='', port=8883)])], certificate_authorities=['-----BEGIN CERTIFICATE-----\nMIICiT...EXAMPLE=\n-----END CERTIFICATE-----\n'])]) Trying core arn:aws:iot:us-east-1:123456789012:thing/MyGreengrassCore at host 203.0.113.0 port 8883 Connected! Subscribing to Update responses... Subscribing to Get responses... Subscribing to Delta events... Requesting current shadow state... Received shadow delta event. Delta reports that desired value is 'purple'. Changing local value... ClientToken is: 3dce4d3f-e336-41ac-aa4f-7882725f0033 Changed local shadow value to 'purple'. Updating reported shadow value to 'purple'... Update request published.

      Wenn die Anwendung stattdessen einen Fehler ausgibt, finden Sie weitere Informationen unter Behebung von Problemen mit der Greengrass-Erkennung.

      Sie können auch die Greengrass-Protokolle auf dem Kerngerät einsehen, um zu überprüfen, ob das Client-Gerät erfolgreich eine Verbindung herstellt und Nachrichten sendet. Weitere Informationen finden Sie unter Überwachen von AWS IoT Greengrass Protokollen.

  5. Sehen Sie sich die Komponentenprotokolle erneut an, um sicherzustellen, dass die Komponente Shadow-Update-Bestätigungen vom Smart-Light-Client-Gerät erhält.

    Linux or Unix
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MySmartLightManager.log
    PowerShell
    gc C:\greengrass\v2/logs/com.example.clientdevices.MySmartLightManager.log -Tail 10 -Wait
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MySmartLightManager.log

    Die Komponente protokolliert Meldungen, um zu bestätigen, dass das Smart-Light-Client-Gerät seine Farbe geändert hat.

    2022-07-07T03:49:24.908Z [INFO] (Copier) com.example.clientdevices.MySmartLightManager: stdout. Chose random color (blue) for MyClientDevice1. {scriptName=services.com.example.clientdevices.MySmartLightManager.lifecycle.Run, serviceName=com.example.clientdevices.MySmartLightManager, currentState=RUNNING} 2022-07-07T03:49:24.912Z [INFO] (Copier) com.example.clientdevices.MySmartLightManager: stdout. Requested color change for MyClientDevice1 to blue. {scriptName=services.com.example.clientdevices.MySmartLightManager.lifecycle.Run, serviceName=com.example.clientdevices.MySmartLightManager, currentState=RUNNING} 2022-07-07T03:49:24.959Z [INFO] (Copier) com.example.clientdevices.MySmartLightManager: stdout. Received shadow update confirmation from client device: MyClientDevice1. {scriptName=services.com.example.clientdevices.MySmartLightManager.lifecycle.Run, serviceName=com.example.clientdevices.MySmartLightManager, currentState=RUNNING}
Anmerkung

Der Schatten des Client-Geräts ist zwischen dem Core-Gerät und dem Client-Gerät synchronisiert. Das Core-Gerät synchronisiert den Shadow des Client-Geräts jedoch nicht mit AWS IoT Core. Sie können einen Shadow mit synchronisieren AWS IoT Core , um beispielsweise den Status aller Geräte in Ihrer Flotte anzuzeigen oder zu ändern. Weitere Informationen zur Konfiguration der Shadow-Manager-Komponente zum Synchronisieren von Schatten finden Sie unterLokale Geräteschatten mit synchronisieren AWS IoT Core. AWS IoT Core

Sie haben dieses Tutorial abgeschlossen. Das Client-Gerät stellt eine Verbindung zum Core-Gerät her, sendet MQTT Nachrichten an AWS IoT Core Greengrass-Komponenten und empfängt Shadow-Updates vom Core-Gerät. Weitere Informationen zu den in diesem Tutorial behandelten Themen finden Sie im Folgenden:

DatenschutzNutzungsbedingungen für die WebsiteCookie-Einstellungen
© 2025, Amazon Web Services, Inc. oder Tochtergesellschaften. Alle Rechte vorbehalten.