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

Wählen Sie im Navigationsmenü der AWS IoT Greengrass Konsole die Option Core-Geräte aus.

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

Wählen Sie auf der Detailseite des Core-Geräts den Link zum Objekt des Core-Geräts aus. Dieser Link öffnet die Seite mit den Objektdetails in der -AWS IoTKonsole.

Wählen Sie auf der Seite mit den Objektdetails die Option Zertifikate aus.

Wählen Sie auf der Registerkarte Zertifikate das aktive Zertifikat des Objekts aus.

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

Wählen Sie auf der Registerkarte Richtlinien die zu überprüfende und zu aktualisierende AWS IoT Richtlinie aus. Sie können die erforderlichen Berechtigungen zu jeder Richtlinie hinzufügen, die dem aktiven Zertifikat des Core-Geräts angefügt ist.

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

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

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

Wählen Sie Als neue Version speichern aus.

Navigieren Sie zur AWS IoT Greengrass-Konsole.

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

Wählen Sie auf der Seite Core-Geräte das Core-Gerät aus, auf dem Sie die Client-Geräteunterstützung aktivieren möchten.

Wählen Sie auf der Detailseite des Core-Geräts die Registerkarte Client-Geräte aus.

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

Die Seite Core-Geräteerkennung 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 Core-Gerät für Sie in Schritt 1: Ziel-Core-Geräte auswählen ausgewählt.

Ordnen Sie in Schritt 2: Zuordnen von Client-Geräten das AWS IoT Objekt 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 Core-Geräts abzurufen. Gehen Sie wie folgt vor:

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

2. Geben Sie im Modal Client-Geräte dem Core-Gerät zuordnen den Namen des AWS IoT Objekts ein, das zugeordnet werden soll.

3. Wählen Sie Hinzufügen aus.

4. Wählen Sie Associate aus.

Stellen Sie in Schritt 3: Konfigurieren und Bereitstellen von Greengrass-Komponenten Komponenten bereit, um Client-Geräteunterstützung zu ermöglichen. Wenn das Ziel-Core-Gerät über eine frühere Bereitstellung verfügt, wird diese Bereitstellung auf dieser Seite geändert. Andernfalls erstellt diese Seite eine neue Bereitstellung für das Core-Gerät. Gehen Sie wie folgt vor, um die Komponenten des Client-Geräts zu konfigurieren und bereitzustellen:

1. Das Core-Gerät muss Greengrass-Kern v2.6.0 oder höher ausführen, um dieses Tutorial abzuschließen. Wenn auf dem Core-Gerät eine frühere Version ausgeführt wird, gehen Sie wie folgt vor:

   1. Aktivieren Sie das Kontrollkästchen, um die aws.greengrass.Nucleus Komponente bereitzustellen.

   2. Wählen Sie für die aws.greengrass.Nucleus Komponente Konfiguration bearbeiten aus.

   3. Wählen Sie für Komponentenversion Version 2.6.0 oder höher aus.

   4. Wählen Sie Bestätigen aus.

   Anmerkung

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

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

3. Konfigurieren Sie im Modal Konfiguration bearbeiten für die Authentifizierungskomponente des Client-Geräts eine Autorisierungsrichtlinie, die es Client-Geräten ermöglicht, den MQTT-Broker auf dem Core-Gerä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 Client-Geräteautorisierungsrichtlinie enthält. Jede Gerätegruppenautorisierungsrichtlinie gibt eine Reihe von Aktionen und die Ressourcen an, auf denen ein Client-Gerät diese Aktionen ausführen kann.

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

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

      • Diese Richtlinie verwendet einen OR Operator, um Client-Geräte, deren Namen mit beginnen, auch MyOtherClientDevice die Verbindung und Kommunikation zu allen MQTT-Themen zu ermöglichen. Sie können diese Klausel in der Auswahlregel entfernen oder sie so ändern, dass sie den Client-Geräten entspricht, die eine Verbindung herstellen möchten.

      • Diese Richtlinie ermöglicht es den Client-Geräten, alle MQTT-Themen zu veröffentlichen und zu abonnieren. Um bewährte Sicherheitsmethoden zu befolgen, beschränken Sie die - mqtt:publish und -mqtt:subscribeOperationen auf den minimalen Satz von 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 Client-Geräte-Authentifizierungskomponente .

   2. Wählen Sie Bestätigen aus.

4. Wählen Sie für die aws.greengrass.clientdevices.mqtt.Bridge Komponente Konfiguration bearbeiten aus.

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

   1. Geben Sie unter Konfiguration im Block Konfiguration zum Zusammenführen von Code die folgende Konfiguration ein. Diese Konfiguration gibt an, MQTT-Nachrichten auf dem clients/+/hello/world Themenfilter von Clientgeräten an den AWS IoT Core Cloud-Service weiterzuleiten. 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-Komponente .

   2. Wählen Sie Bestätigen aus.

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

Wenn Sie die Greengrass-Servicerolle noch nicht in dieser Region eingerichtet haben, öffnet die Konsole ein Modal, um die Servicerolle für Sie einzurichten. Die Authentifizierungskomponente des Client-Geräts verwendet diese Servicerolle, um die Identität von Client-Geräten zu überprüfen, und die IP-Detektorkomponente verwendet diese Servicerolle, um die Konnektivitätsinformationen des Core-Geräts zu verwalten. Klicken Sie aufGewähren von Berechtigungenaus.

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

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

Laden Sie AWS IoT Device SDK v2 für Python herunter und installieren Sie es auf dem AWS IoT Objekt, 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 für Python, um es herunterzuladen.

   git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git

2. Installieren Sie AWS IoT Device SDK v2 für Python.

   python3 -m pip install --user ./aws-iot-device-sdk-python-v2

Wechseln Sie in den Ordner Beispiele in AWS IoT Device SDK v2 für Python.

cd aws-iot-device-sdk-python-v2/samples

Führen Sie die Greengrass-Erkennungs-Beispielanwendung aus. Diese Anwendung erwartet Argumente, die den Objektnamen des Client-Geräts, 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.

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 10 Mal und trennt die Verbindung. Es abonniert auch dasselbe Thema, in dem es Nachrichten veröffentlicht. Wenn die Ausgabe angibt, dass die Anwendung MQTT-Nachrichten zum 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 Fehlerbehebung bei Greengrass-Erkennungsproblemen.

Sie können auch die Greengrass-Protokolle auf dem Core-Gerät anzeigen, 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.

Stellen Sie sicher, dass die MQTT-Brücke die Nachrichten vom Client-Gerät an weiterleitetAWS 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 MQTT-Testclient aus.

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

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

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

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

Überarbeiten Sie die Bereitstellung auf dem Core-Gerät und konfigurieren Sie die MQTT-Bridge-Komponente so, dass Nachrichten von Client-Geräten an das lokale Veröffentlichen/Abonnement weitergeleitet werden. Gehen Sie wie folgt vor:

1. Navigieren Sie zur AWS IoT Greengrass-Konsole.

2. Wählen Sie im linken Navigationsmenü Core-Geräte aus.

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

4. Wählen Sie auf der Detailseite des Core-Geräts die Registerkarte Client-Geräte aus.

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

   Die Seite Core-Geräteerkennung konfigurieren wird geöffnet. Auf dieser Seite können Sie ändern oder konfigurieren, welche Client-Gerätekomponenten auf dem Core-Gerät bereitgestellt werden.

6. Wählen Sie in Schritt 3 für die aws.greengrass.clientdevices.mqtt.Bridge Komponente die Option Konfiguration bearbeiten aus.

7. Konfigurieren Sie im Modal Konfiguration bearbeiten für die MQTT-Bridge-Komponente eine Themenzuordnung, die MQTT-Nachrichten von Client-Geräten an die lokale Veröffentlichungs-/Abonnementschnittstelle 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 gibt an, MQTT-Nachrichten zu Themen weiterzuleiten, die dem clients/+/hello/world Themenfilter von Clientgeräten an den AWS IoT Core Cloud-Service und den lokalen Greengrass-Publish/Subscribe-Broker entsprechen.

      {
        "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 MQTT-Bridge-Komponente .

   2. Wählen Sie Bestätigen aus.

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 Core-Gerä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 Core-Gerät. Um den Status der Bereitstellung auf dem Core-Gerät zu überprüfen, können Sie in der Bereitstellungsübersicht Ziel auswählen. Weitere Informationen finden Sie hier:

    • Prüfen des Bereitstellungsstatus

    • Überwachen von AWS IoT Greengrass Protokollen

Entwickeln und stellen Sie eine Greengrass-Komponente bereit, 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 Core-Gerä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

   Wichtig

   Sie müssen das folgende Format für den Pfad des Artefaktordners verwenden. Fügen Sie den Komponentennamen und die Version ein, die Sie im Rezept angeben.

   artifacts/componentName/componentVersion/

2. Verwenden Sie einen Texteditor, um ein Komponentenrezept mit dem folgenden Inhalt zu erstellen. Dieses Rezept gibt an, dass AWS IoT Device SDK v2 für Python installiert und ein Skript ausgeführt werden soll, das das Thema abonniert und Nachrichten druckt.

   Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um GNU Nano zum Erstellen der Datei zu verwenden.

   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-Skriptartefakt mit dem Namen hello_world_subscriber.py mit dem folgenden Inhalt zu erstellen. Diese Anwendung verwendet den IPC-Service zum Veröffentlichen/Abonnieren, um das clients/+/hello/world Thema zu abonnieren und Nachrichten zu drucken, die sie empfängt.

   Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um GNU Nano zum Erstellen der Datei zu verwenden.

   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 AWS IoT Device SDK v2 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 IPC in benutzerdefinierten Komponenten zu verwenden.

4. Verwenden Sie die Greengrass-CLI, 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"

Sehen Sie sich die Komponentenprotokolle an, um zu überprüfen, ob die Komponente erfolgreich installiert wurde und das Thema abonniert hat.

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

Führen Sie auf dem Client-Gerät die Greengrass-Erkennungsanwendung erneut aus, um Nachrichten an das Core-Gerä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

Zeigen Sie die Komponentenprotokolle erneut an, um zu überprüfen, ob die Komponente die Nachrichten vom Client-Gerät empfängt und druckt.

Überarbeiten Sie die Bereitstellung auf dem Core-Gerät, um die Shadow-Manager-Komponente bereitzustellen, und konfigurieren Sie die MQTT-Bridge-Komponente so, dass Schattennachrichten zwischen Client-Geräten und lokaler Veröffentlichung/Abonnement weitergeleitet werden, wo der Shadow Manager kommuniziert. Gehen Sie wie folgt vor:

1. Navigieren Sie zur AWS IoT Greengrass-Konsole.

2. Wählen Sie im linken Navigationsmenü Core-Geräte aus.

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

4. Wählen Sie auf der Detailseite des Core-Geräts die Registerkarte Client-Geräte aus.

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

   Die Seite Core-Geräteerkennung konfigurieren wird geöffnet. Auf dieser Seite können Sie ändern oder konfigurieren, welche Client-Gerätekomponenten auf dem Core-Gerät bereitgestellt werden.

6. Wählen Sie in Schritt 3 für die aws.greengrass.clientdevices.mqtt.Bridge Komponente die Option Konfiguration bearbeiten aus.

7. Konfigurieren Sie im Modal Konfiguration bearbeiten für die MQTT-Bridge-Komponente eine Themenzuordnung, die MQTT-Nachrichten an Geräteschattenthemen zwischen Client-Geräten und der lokalen Veröffentlichungs-/Abonnementschnittstelle weiterleitet. Sie bestätigen auch, dass die Bereitstellung eine kompatible MQTT-Bridge-Version angibt. Die Unterstützung des Client-Geräteschattens erfordert MQTT Bridge v2.2.0 oder höher. Gehen Sie wie folgt vor:

   1. Wählen Sie für 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 gibt an, dass MQTT-Nachrichten zu Schattenthemen weitergeleitet werden sollen.

      {
        "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-Komponente .

   3. Wählen Sie Bestätigen aus.

8. Wählen Sie in Schritt 3 die aws.greengrass.ShadowManager Komponente aus, die bereitgestellt werden soll.

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

10. Wählen Sie auf der Seite Überprüfen die Option Bereitstellen aus, um die Bereitstellung auf dem Core-Gerät zu starten.

11. Um zu überprüfen, ob die Bereitstellung erfolgreich ist, überprüfen Sie den Status der Bereitstellung und überprüfen Sie die Protokolle auf dem Core-Gerät. Um den Status der Bereitstellung auf dem Core-Gerät zu überprüfen, können Sie in der Bereitstellungsübersicht Ziel auswählen. Weitere Informationen finden Sie hier:

    • Prüfen des Bereitstellungsstatus

    • Überwachen von AWS IoT Greengrass Protokollen

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

1. Erstellen Sie einen Ordner mit den Artefakten der Komponente auf dem Core-Gerä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

   Wichtig

   Sie müssen das folgende Format für den Pfad des Artefaktordners verwenden. Fügen Sie den Komponentennamen und die Version ein, 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 v2 für Python installiert und ein Skript ausgeführt werden soll, das mit den Schatten von Smart Light Client-Geräten interagiert, um ihre Farben zu verwalten.

   Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um GNU Nano zum Erstellen der Datei zu verwenden.

   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-Skriptartefakt mit dem Namen smart_light_manager.py mit dem folgenden Inhalt zu erstellen. Diese Anwendung verwendet den Schatten-IPK-Service, um Schatten von Client-Geräten abzurufen und zu aktualisieren, und den lokalen Veröffentlichungs-/Abonnement-IPK-Service, um gemeldete Schattenaktualisierungen zu erhalten.

   Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um GNU Nano zum Erstellen der Datei zu verwenden.

   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 führt Folgendes aus:

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

   • Abonniert Konfigurationsaktualisierungsbenachrichtigungen mithilfe der SubscribeToConfigurationUpdate IPC-Operation. Die -AWS IoT GreengrassCore-Software sendet jedes Mal Benachrichtigungen, wenn sich die Konfiguration der Komponente ändert. Wenn die Komponente eine Benachrichtigung über die Konfigurationsaktualisierung erhält, aktualisiert sie die Liste der von ihr verwalteten Smart-Light-Client-Geräte.

   • Ruft den Schatten jedes Smart Light Client-Geräts ab, um seinen ursprünglichen Farbstatus zu erhalten.

   • Legt die Farbe jedes Smart Light Client-Geräts alle 15 Sekunden auf eine zufällige Farbe fest. Die Komponente aktualisiert den Objektschatten des Client-Geräts, um seine Farbe zu ändern. Dieser Vorgang sendet ein Schattendelta-Ereignis über MQTT an das Client-Gerät.

   • Abonniert die Shadow-Aktualisierung akzeptierter Nachrichten auf der lokalen Veröffentlichungs-/Abonnementschnittstelle mithilfe des SubscribeToTopic IPC-Vorgangs. Diese Komponente empfängt diese Nachrichten, um die Farbe jedes Smart-Light-Client-Geräts zu verfolgen. Wenn ein Smart Light Client-Gerät eine Schattenaktualisierung erhält, sendet es eine MQTT-Nachricht, um zu bestätigen, dass es die Aktualisierung erhalten hat. Die MQTT-Brücke leitet diese Nachricht an die lokale Veröffentlichungs-/Abonnementschnittstelle weiter.

4. Verwenden Sie die Greengrass-CLI, um die Komponente bereitzustellen. Wenn Sie diese Komponente bereitstellen, geben Sie die Liste der Client-Geräte an, smartLightDeviceNames, deren Schatten sie verwaltet. Ersetzen Sie MyClientDevice1 durch den Objektnamen des Clientgerä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"
           ]
         }
       }
     }'

Zeigen Sie die Komponentenprotokolle an, um zu überprüfen, ob die Komponente erfolgreich installiert wurde und ausgeführt wird.

Die Komponente sendet Anfragen zum Ändern der Farbe des Smart Light Client-Geräts. Der Schattenmanager empfängt die Anforderung und legt den desired Status des Schattens fest. Das Smart Light Client-Gerät wird jedoch noch nicht ausgeführt, sodass sich der reported Status des Schattens 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 Nachrichten druckt.

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

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

   cd aws-iot-device-sdk-python-v2/samples

2. Verwenden Sie einen Texteditor, um ein Python-Skript namens basic_discovery_shadow.py mit dem folgenden Inhalt zu erstellen. Diese Anwendung verwendet Greengrass-Erkennung und Schatten, 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 GNU Nano zum Erstellen der Datei zu verwenden.

   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 führt Folgendes aus:

   • Verwendet Greengrass Discovery, um das Core-Gerät zu erkennen und eine Verbindung mit ihm herzustellen.

   • Fordert das Schattendokument vom Core-Gerät an, den Anfangsstatus der Eigenschaft abzurufen.

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

   Diese Anwendung kombiniert die Greengrass-Erkennungs- und Schattenbeispiele aus vAWS IoT Device SDK2.

3. Führen Sie die Beispielanwendung aus. Diese Anwendung erwartet Argumente, die den Objektnamen des Client-Geräts, die zu verwendende Schatteneigenschaft und die Zertifikate angeben, die die Verbindung authentifizieren und sichern.

   • Ersetzen Sie MyClientDevice1 durch den Objektnamen des Client-Geräts.

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

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

   • Ersetzen Sie ~/certs/private.pem.key durch den Pfad zur Datei mit dem privaten Schlüssel auf dem Client-Gerät.

   • Ersetzen Sie us-east-1 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 Schattenthemen und wartet darauf, Schattendelta-Ereignisse vom Core-Gerät zu empfangen. Wenn die Ausgabe angibt, dass die Anwendung Schattendelta-Ereignisse empfängt und darauf reagiert, kann das Client-Gerät erfolgreich mit seinem Schatten auf dem Core-Gerä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 Fehlerbehebung bei Greengrass-Erkennungsproblemen.

   Sie können auch die Greengrass-Protokolle auf dem Core-Gerät anzeigen, 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.

Zeigen Sie die Komponentenprotokolle erneut an, um zu überprüfen, ob die Komponente Bestätigungen zur Schattenaktualisierung vom Smart Light Client-Gerät erhält.

Die Komponente protokolliert Nachrichten, 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}