Tutorial: Interagisci con i dispositivi IoT locali tramite MQTT

Nel menu di navigazione della AWS IoT Greengrassconsole, scegli Dispositivi principali.

Nella pagina Dispositivi principali, scegli il dispositivo principale da aggiornare.

Nella pagina dei dettagli del dispositivo principale, scegli il link all'oggetto del dispositivo principale. Questo link apre la pagina dei dettagli dell'oggetto nella AWS IoT console.

Nella pagina dei dettagli dell'oggetto, scegli Certificati.

Nella scheda Certificati, scegli il certificato attivo dell'oggetto.

Nella pagina dei dettagli del certificato, scegli Politiche.

Nella scheda Politiche, scegli la AWS IoT politica da rivedere e aggiornare. Puoi aggiungere le autorizzazioni richieste a qualsiasi policy allegata al certificato attivo del dispositivo principale.

Nella panoramica della politica, scegli Modifica versione attiva.

Rivedi la politica per le autorizzazioni richieste e aggiungi le autorizzazioni richieste mancanti.

Per impostare una nuova versione della politica come versione attiva, in Stato della versione della politica, seleziona Imposta la versione modificata come versione attiva per questa politica.

Scegli Salva come nuova versione.

Passare alla console AWS IoT Greengrass.

Nel menu di navigazione a sinistra, scegli Dispositivi principali.

Nella pagina Dispositivi principali, scegli il dispositivo principale su cui desideri abilitare il supporto per i dispositivi client.

Nella pagina dei dettagli del dispositivo principale, scegli la scheda Dispositivi client.

Nella scheda Dispositivi client, scegli Configura cloud discovery.

Viene visualizzata la pagina Configura il rilevamento dei dispositivi principali. In questa pagina è possibile associare i dispositivi client a un dispositivo principale e distribuire i componenti dei dispositivi client. Questa pagina seleziona il dispositivo principale per te nel Passaggio 1: Seleziona i dispositivi principali di destinazione.

Nel passaggio 2: Associa i dispositivi client, associa l'AWS IoTelemento del dispositivo client al dispositivo principale. Ciò consente al dispositivo client di utilizzare il cloud discovery per recuperare le informazioni e i certificati di connettività del dispositivo principale. Esegui questa operazione:

1. Scegli Associa dispositivi client.

2. Nella modalità Associa i dispositivi client al dispositivo principale, inserisci il nome dell'AWS IoToggetto da associare.

3. Scegli Aggiungi.

4. Selezionare Associate (Associa).

Nel passaggio 3: Configurare e distribuire i componenti Greengrass, distribuire i componenti per abilitare il supporto dei dispositivi client. Se il dispositivo principale di destinazione ha una distribuzione precedente, questa pagina rivede tale distribuzione. Altrimenti, questa pagina crea una nuova distribuzione per il dispositivo principale. Effettua le seguenti operazioni per configurare e distribuire i componenti del dispositivo client:

1. Il dispositivo principale deve eseguire Greengrass nucleus v2.6.0 o versione successiva per completare questo tutorial. Se il dispositivo principale esegue una versione precedente, procedi come segue:

   1. Seleziona la casella per distribuire il aws.greengrass.Nucleuscomponente.

   2. Per il aws.greengrass.Nucleuscomponente, scegli Modifica configurazione.

   3. Per la versione del componente, scegli la versione 2.6.0 o successiva.

   4. Scegli Conferma.

   Nota

   Se si aggiorna il nucleo Greengrass da una versione secondaria precedente e il dispositivo principale esegue componenti AWS forniti che dipendono dal nucleo, è necessario aggiornare anche i componenti forniti alle AWS versioni più recenti. Puoi configurare la versione di questi componenti quando esaminerai la distribuzione più avanti in questo tutorial. Per ulteriori informazioni, consulta Aggiornamento del software AWS IoT Greengrass Core (OTA).

2. Per il aws.greengrass.clientdevices.Authcomponente, scegli Modifica configurazione.

3. Nella modalità Modifica configurazione per il componente di autenticazione del dispositivo client, configurate una politica di autorizzazione che consenta ai dispositivi client di pubblicare e sottoscrivere il broker MQTT sul dispositivo principale. Esegui questa operazione:

   1. In Configurazione, nel blocco Configurazione per unire codice, immettete la seguente configurazione, che contiene una politica di autorizzazione del dispositivo client. Ogni politica di autorizzazione del gruppo di dispositivi specifica una serie di azioni e le risorse su cui un dispositivo client può eseguire tali azioni.

      • Questa policy consente ai dispositivi client i cui nomi iniziano con di MyClientDevice connettersi e comunicare su tutti gli argomenti MQTT. Sostituisci MyClientDevice* con il nome dell'AWS IoToggetto da connettere come dispositivo client. Puoi anche specificare un nome con un carattere * jolly che corrisponda al nome del dispositivo client. Il * carattere jolly deve essere alla fine del nome.

        Se devi connettere un secondo dispositivo client, MyOtherClientDevicesostituisci* con il nome di quel dispositivo client o con un pattern di caratteri jolly che corrisponda al nome del dispositivo client. Altrimenti, puoi rimuovere o mantenere questa sezione della regola di selezione che consente ai dispositivi client con nomi corrispondenti di MyOtherClientDevice* connettersi e comunicare.

      • Questa politica utilizza un OR operatore per consentire anche ai dispositivi client i cui nomi iniziano con di MyOtherClientDevice connettersi e comunicare su tutti gli argomenti MQTT. È possibile rimuovere questa clausola nella regola di selezione o modificarla in modo che corrisponda ai dispositivi client da connettere.

      • Questa politica consente ai dispositivi client di pubblicare e sottoscrivere tutti gli argomenti MQTT. Per seguire le migliori pratiche di sicurezza, mqtt:subscribe limitate le operazioni mqtt:publish e al set minimo di argomenti utilizzati dai dispositivi client per comunicare.

      {
        "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": [
                  "*"
                ]
              }
            }
          }
        }
      }

      Per ulteriori informazioni, consulta Configurazione del componente di autenticazione del dispositivo client.

   2. Scegli Conferma.

4. Per il aws.greengrass.clientdevices.mqtt.Bridgecomponente, scegli Modifica configurazione.

5. Nella modalità Modifica configurazione per il componente bridge MQTT, configurate una mappatura degli argomenti che inoltri i messaggi MQTT dai dispositivi client a. AWS IoT Core Esegui questa operazione:

   1. In Configurazione, nel blocco Configurazione per unire codice, immettete la seguente configurazione. Questa configurazione specifica di inoltrare i messaggi MQTT sul filtro degli clients/+/hello/world argomenti dai dispositivi client al servizio cloud. AWS IoT Core Ad esempio, questo filtro per argomenti corrisponde all'argomento. clients/MyClientDevice1/hello/world

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

      Per ulteriori informazioni, vedere Configurazione dei componenti del bridge MQTT.

   2. Scegli Conferma.

Scegliete Review and deploy per esaminare la distribuzione creata da questa pagina per voi.

Se non hai precedentemente impostato il ruolo di servizio Greengrass in questa regione, la console apre una modalità per configurare il ruolo di servizio per te. Il componente di autenticazione dei dispositivi client utilizza questo ruolo di servizio per verificare l'identità dei dispositivi client e il componente del rilevatore IP utilizza questo ruolo di servizio per gestire le informazioni di base sulla connettività dei dispositivi. Scegli Concedi autorizzazioni.

Nella pagina di revisione, scegli Distribuisci per avviare la distribuzione sul dispositivo principale.

Per verificare che la distribuzione abbia esito positivo, controlla lo stato della distribuzione e controlla i log sul dispositivo principale. Per verificare lo stato della distribuzione sul dispositivo principale, puoi scegliere Target nella panoramica della distribuzione. Per ulteriori informazioni, consulta gli argomenti seguenti:

Scarica e installa la SDK per dispositivi AWS IoTversione 2 per Python AWS IoT sull'oggetto da connettere come dispositivo client.

Sul dispositivo client, procedi come segue:

1. Clona il repository SDK per dispositivi AWS IoT v2 for Python per scaricarlo.

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

2. Installa la SDK per dispositivi AWS IoT v2 per Python.

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

Passa alla cartella samples nella SDK per dispositivi AWS IoT v2 per Python.

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

Esegui l'applicazione Greengrass discovery di esempio. Questa applicazione prevede argomenti che specifichino il nome dell'oggetto del dispositivo client, l'argomento e il messaggio MQTT da utilizzare e i certificati che autenticano e proteggono la connessione. L'esempio seguente invia un messaggio Hello World all'argomento. clients/MyClientDevice1/hello/world

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

L'applicazione di esempio Discovery invia il messaggio 10 volte e si disconnette. Inoltre, sottoscrive lo stesso argomento in cui pubblica i messaggi. Se l'output indica che l'applicazione ha ricevuto messaggi MQTT sull'argomento, il dispositivo client può comunicare correttamente con il dispositivo principale.

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}'

Se invece l'applicazione genera un errore, consulta Risoluzione dei problemi di rilevamento di Greengrass.

Puoi anche visualizzare i log di Greengrass sul dispositivo principale per verificare se il dispositivo client si connette e invia messaggi correttamente. Per ulteriori informazioni, consulta Monitora AWS IoT Greengrass i registri.

Verificate che il bridge MQTT inoltri i messaggi dal dispositivo client a. AWS IoT Core È possibile utilizzare il client di test MQTT nella AWS IoT Core console per sottoscrivere un filtro per argomenti MQTT. Esegui questa operazione:

1. Passare alla console AWS IoT.

2. Nel menu di navigazione a sinistra, sotto Test, scegli MQTT test client.

3. Nella scheda Sottoscrivi a un argomento, per Filtro argomento, inserisci clients/+/hello/world per iscriverti ai messaggi del dispositivo client dal dispositivo principale.

4. Scegliere Subscribe (Effettua sottoscrizione).

5. Esegui nuovamente l'applicazione di pubblicazione/sottoscrizione sul dispositivo client.

   Il client di test MQTT visualizza i messaggi inviati dal dispositivo client su argomenti che corrispondono a questo filtro per argomenti.

Rivedi la distribuzione sul dispositivo principale e configura il componente bridge MQTT per inoltrare i messaggi dai dispositivi client alla pubblicazione/sottoscrizione locale. Esegui questa operazione:

1. Passare alla console AWS IoT Greengrass.

2. Nel menu di navigazione a sinistra, scegli Dispositivi principali.

3. Nella pagina Dispositivi principali, scegli il dispositivo principale che stai utilizzando per questo tutorial.

4. Nella pagina dei dettagli del dispositivo principale, scegli la scheda Dispositivi client.

5. Nella scheda Dispositivi client, scegli Configura cloud discovery.

   Viene visualizzata la pagina Configura il rilevamento dei dispositivi principali. In questa pagina è possibile modificare o configurare i componenti del dispositivo client da distribuire sul dispositivo principale.

6. Nel passaggio 3, per il aws.greengrass.clientdevices.mqtt.Bridgecomponente, scegli Modifica configurazione.

7. Nella modalità Modifica configurazione per il componente bridge MQTT, configurate una mappatura degli argomenti che inoltri i messaggi MQTT dai dispositivi client all'interfaccia di pubblicazione/sottoscrizione locale. Esegui questa operazione:

   1. In Configurazione, nella sezione Configurazione per unire il blocco di codice, immettete la seguente configurazione. Questa configurazione specifica di inoltrare messaggi MQTT su argomenti che corrispondono al filtro degli clients/+/hello/world argomenti dai dispositivi client al servizio AWS IoT Core cloud e al broker di pubblicazione/sottoscrizione Greengrass locale.

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

      Per ulteriori informazioni, vedere Configurazione dei componenti del bridge MQTT.

   2. Scegli Conferma.

8. Scegliete Review and deploy per esaminare la distribuzione creata da questa pagina per voi.

9. Nella pagina Revisione, scegli Implementa per avviare la distribuzione sul dispositivo principale.

10. Per verificare che la distribuzione abbia esito positivo, controlla lo stato della distribuzione e controlla i log sul dispositivo principale. Per verificare lo stato della distribuzione sul dispositivo principale, puoi scegliere Target nella panoramica della distribuzione. Per ulteriori informazioni, consulta gli argomenti seguenti:

    • Controllo dello stato di implementazione

    • Monitora AWS IoT Greengrass i registri

Sviluppa e distribuisci un componente Greengrass che sottoscrive i messaggi Hello World dai dispositivi client. Esegui questa operazione:

1. Crea cartelle per ricette e artefatti sul dispositivo principale.

   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

   Importante

   È necessario utilizzare il seguente formato per il percorso della cartella degli artefatti. Includete il nome e la versione del componente specificati nella ricetta.

   artifacts/componentName/componentVersion/

2. Utilizzate un editor di testo per creare una ricetta di componenti con i seguenti contenuti. Questa ricetta specifica di installare la SDK per dispositivi AWS IoT v2 per Python ed eseguire uno script che sottoscrive l'argomento e stampa i messaggi.

   Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.

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

   Copiate la seguente ricetta nel file.

   {
     "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. Usa un editor di testo per creare un artefatto di script Python denominato hello_world_subscriber.py con i seguenti contenuti. Questa applicazione utilizza il servizio IPC publish/subscribe per sottoscrivere l'clients/+/hello/worldargomento e stampare i messaggi che riceve.

   Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.

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

   Copia il seguente codice Python nel file.

   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)
   

   Nota

   Questo componente utilizza il client IPC V2 nella SDK per dispositivi AWS IoTv2 for Python per comunicare con il software Core. AWS IoT Greengrass Rispetto al client IPC originale, il client IPC V2 riduce la quantità di codice da scrivere per utilizzare IPC nei componenti personalizzati.

4. Usa la Greengrass CLI per distribuire il componente.

   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"

Visualizza i log dei componenti per verificare che il componente sia stato installato correttamente e che sottoscriva l'argomento.

È possibile mantenere aperto il feed di registro per verificare che il dispositivo principale riceva messaggi.

Sul dispositivo client, esegui nuovamente l'applicazione di rilevamento Greengrass di esempio per inviare messaggi al dispositivo principale.

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

Visualizzate nuovamente i registri dei componenti per verificare che il componente riceva e stampi i messaggi dal dispositivo client.

Rivedi la distribuzione sul dispositivo principale per implementare il componente shadow manager e configura il componente bridge MQTT per inoltrare i messaggi shadow tra i dispositivi client e la pubblicazione/sottoscrizione locali, dove lo shadow manager comunica. Esegui questa operazione:

1. Passare alla console AWS IoT Greengrass.

2. Nel menu di navigazione a sinistra, scegli Dispositivi principali.

3. Nella pagina Dispositivi principali, scegli il dispositivo principale che stai utilizzando per questo tutorial.

4. Nella pagina dei dettagli del dispositivo principale, scegli la scheda Dispositivi client.

5. Nella scheda Dispositivi client, scegli Configura cloud discovery.

   Viene visualizzata la pagina Configura il rilevamento dei dispositivi principali. In questa pagina è possibile modificare o configurare i componenti del dispositivo client da distribuire sul dispositivo principale.

6. Nel passaggio 3, per il aws.greengrass.clientdevices.mqtt.Bridgecomponente, scegli Modifica configurazione.

7. Nella modalità Modifica configurazione per il componente bridge MQTT, configurate una mappatura degli argomenti che inoltri i messaggi MQTT sugli argomenti shadow del dispositivo tra i dispositivi client e l'interfaccia di pubblicazione/sottoscrizione locale. Confermate inoltre che la distribuzione specifichi una versione del bridge MQTT compatibile. Il supporto shadow dei dispositivi client richiede MQTT bridge v2.2.0 o versione successiva. Esegui questa operazione:

   1. Per la versione Component, scegliete la versione 2.2.0 o successiva.

   2. In Configurazione, nel blocco Configurazione per unire codice, inserisci la seguente configurazione. Questa configurazione specifica di inoltrare messaggi MQTT su argomenti shadow.

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

      Per ulteriori informazioni, vedere Configurazione dei componenti del bridge MQTT.

   3. Scegli Conferma.

8. Nel passaggio 3, selezionate il aws.greengrass.ShadowManagercomponente per distribuirlo.

9. Scegliete Review and deploy per esaminare la distribuzione creata da questa pagina per voi.

10. Nella pagina Revisione, scegli Implementa per avviare la distribuzione sul dispositivo principale.

11. Per verificare che la distribuzione abbia esito positivo, controlla lo stato della distribuzione e controlla i log sul dispositivo principale. Per verificare lo stato della distribuzione sul dispositivo principale, puoi scegliere Target nella panoramica della distribuzione. Per ulteriori informazioni, consulta gli argomenti seguenti:

    • Controllo dello stato di implementazione

    • Monitora AWS IoT Greengrass i registri

Sviluppa e implementa un componente Greengrass che gestisce i dispositivi client smart light. Esegui questa operazione:

1. Crea una cartella con gli artefatti del componente sul dispositivo principale.

   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

   Importante

   È necessario utilizzare il seguente formato per il percorso della cartella degli artefatti. Includete il nome e la versione del componente specificati nella ricetta.

   artifacts/componentName/componentVersion/

2. Utilizzate un editor di testo per creare una ricetta di componenti con i seguenti contenuti. Questa ricetta specifica di installare la SDK per dispositivi AWS IoT v2 per Python ed eseguire uno script che interagisce con le ombre dei dispositivi client smart light per gestirne i colori.

   Ad esempio, su un sistema basato su Linux, è possibile eseguire il seguente comando per utilizzare GNU nano per creare il file.

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

   Copiate la seguente ricetta nel file.

   {
     "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. Usa un editor di testo per creare un artefatto di script Python denominato smart_light_manager.py con i seguenti contenuti. Questa applicazione utilizza il servizio IPC shadow per ottenere e aggiornare le ombre dei dispositivi client e il servizio IPC di pubblicazione/sottoscrizione locale per ricevere gli aggiornamenti shadow segnalati.

   Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.

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

   Copia il seguente codice Python nel file.

   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()
   

   Questa applicazione Python esegue le seguenti operazioni:

   • Legge la configurazione del componente per ottenere l'elenco dei dispositivi client smart light da gestire.

   • Sottoscrive le notifiche di aggiornamento della configurazione utilizzando l'operazione SubscribeToConfigurationUpdate IPC. Il software AWS IoT Greengrass Core invia notifiche ogni volta che la configurazione del componente cambia. Quando il componente riceve una notifica di aggiornamento della configurazione, aggiorna l'elenco dei dispositivi client smart light che gestisce.

   • Ottiene l'ombra di ogni dispositivo client smart light per ottenere lo stato cromatico iniziale.

   • Imposta il colore di ogni dispositivo client smart light su un colore casuale ogni 15 secondi. Il componente aggiorna l'ombra del dispositivo client per cambiarne il colore. Questa operazione invia un evento shadow delta al dispositivo client tramite MQTT.

   • Effettua la sottoscrizione ai messaggi Shadow Update accettati sull'interfaccia di pubblicazione/sottoscrizione locale utilizzando l'operazione IPC. SubscribeToTopic Questo componente riceve questi messaggi per tracciare il colore di ogni dispositivo client smart light. Quando un dispositivo client smart light riceve un aggiornamento ombra, invia un messaggio MQTT per confermare che ha ricevuto l'aggiornamento. Il bridge MQTT inoltra questo messaggio all'interfaccia di pubblicazione/sottoscrizione locale.

4. Usa la Greengrass CLI per distribuire il componente. Quando si distribuisce questo componente, si specifica l'elenco dei dispositivi client di cui gestisce le smartLightDeviceNames ombre. Sostituisci MyClientDevice1 con il nome dell'oggetto del dispositivo client.

   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"
           ]
         }
       }
     }'

Visualizza i log dei componenti per verificare che il componente sia installato ed eseguito correttamente.

Il componente invia richieste per cambiare il colore del dispositivo client smart light. Il gestore delle ombre riceve la richiesta e imposta lo desired stato dell'ombra. Tuttavia, il dispositivo client smart light non è ancora in esecuzione, quindi lo reported stato dell'ombra non cambia. I log del componente includono i seguenti messaggi.

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}

È possibile tenere aperto il feed di registro per vedere quando il componente stampa i messaggi.

Scarica ed esegui un'applicazione di esempio che utilizza Greengrass discovery e sottoscrive gli aggiornamenti shadow del dispositivo. Sul dispositivo client, effettuate le seguenti operazioni:

1. Passa alla cartella samples nella SDK per dispositivi AWS IoT v2 per Python. Questa applicazione di esempio utilizza un modulo di analisi della riga di comando nella cartella samples.

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

2. Usa un editor di testo per creare uno script Python denominato basic_discovery_shadow.py con i seguenti contenuti. Questa applicazione utilizza Greengrass discovery e shadows per mantenere sincronizzata una proprietà tra il dispositivo client e il dispositivo principale.

   Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.

   nano basic_discovery_shadow.py

   Copia il seguente codice Python nel file.

   # 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()
   

   Questa applicazione Python esegue le seguenti operazioni:

   • Utilizza Greengrass discovery per scoprire e connettersi al dispositivo principale.

   • Richiede il documento shadow dal dispositivo principale per ottenere lo stato iniziale della proprietà.

   • Si iscrive agli eventi shadow delta, che il dispositivo principale invia quando il desired valore della proprietà è diverso dal suo reported valore. Quando l'applicazione riceve un evento shadow delta, modifica il valore della proprietà e invia un aggiornamento al dispositivo principale per impostare il nuovo valore come valorereported.

   Questa applicazione combina i campioni Greengrass discovery e shadow della SDK per dispositivi AWS IoT v2.

3. Esegui l'applicazione di esempio. Questa applicazione prevede argomenti che specifichino il nome dell'oggetto del dispositivo client, la proprietà shadow da utilizzare e i certificati che autenticano e proteggono la connessione.

   • Sostituisci MyClientDevice1 con il nome dell'oggetto del dispositivo client.

   • Sostituisci ~/certs/ AmazonRoot CA1.pem con il percorso del certificato CA root Amazon sul dispositivo client.

   • Sostituisci ~/certs/device.pem.crt con il percorso del certificato del dispositivo sul dispositivo client.

   • Sostituisci ~/certs/private.pem.key con il percorso del file della chiave privata sul dispositivo client.

   • Sostituisci us-east-1 con la regione in cui operano il dispositivo client e il dispositivo principale. AWS

   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

   L'applicazione di esempio sottoscrive gli argomenti shadow e attende di ricevere gli eventi shadow delta dal dispositivo principale. Se l'output indica che l'applicazione riceve e risponde agli eventi shadow delta, il dispositivo client può interagire correttamente con la relativa ombra sul dispositivo principale.

   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.

   Se invece l'applicazione genera un errore, consulta Risoluzione dei problemi di rilevamento di Greengrass.

   Puoi anche visualizzare i log di Greengrass sul dispositivo principale per verificare se il dispositivo client si connette e invia messaggi correttamente. Per ulteriori informazioni, consulta Monitora AWS IoT Greengrass i registri.

Visualizza nuovamente i registri dei componenti per verificare che il componente riceva conferme di aggiornamento ombra dal dispositivo client smart light.

Il componente registra i messaggi per confermare che il dispositivo client smart light ha cambiato colore.

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}