Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Tutorial: Interagisci con i dispositivi IoT locali tramite MQTT
Puoi completare questo tutorial per configurare un dispositivo principale per interagire con i dispositivi IoT locali, chiamati *dispositivi client*, che si connettono al dispositivo principale tramite MQTT. In questo tutorial, configurerai AWS IoT le cose per utilizzare il *cloud discovery* per connetterti al dispositivo principale come dispositivi client. Quando configuri il cloud discovery, un dispositivo client può inviare una richiesta al servizio AWS IoT Greengrass cloud per scoprire i dispositivi principali. La risposta di AWS IoT Greengrass include informazioni sulla connettività e certificati per i dispositivi principali che configuri il dispositivo client per il rilevamento. Quindi, il dispositivo client può utilizzare queste informazioni per connettersi a un dispositivo principale disponibile in cui comunicare tramite MQTT.
In questo tutorial, esegui quanto indicato di seguito:
1. Rivedi e aggiorna le autorizzazioni del dispositivo principale, se necessario.
1. Associa i dispositivi client al dispositivo principale, in modo che possano scoprire il dispositivo principale utilizzando il cloud discovery.
1. Implementa i componenti Greengrass sul dispositivo principale per abilitare il supporto dei dispositivi client.
1. Connect i dispositivi client al dispositivo principale e testa la comunicazione con il servizio AWS IoT Core cloud.
1. Sviluppa un componente Greengrass personalizzato che comunichi con i dispositivi client.
1. [Sviluppa un componente personalizzato che interagisca con le ombre dei dispositivi AWS IoT client.](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html)
Questo tutorial utilizza un singolo dispositivo core e un singolo dispositivo client. Puoi anche seguire il tutorial per connettere e testare più dispositivi client.
Puoi aspettarti di dedicare 30-60 minuti a questo tutorial.
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Un. Account AWS Se non lo hai, consultare [Configura un Account AWS](setting-up.md#set-up-aws-account).
+ Un utente AWS Identity and Access Management (IAM) con autorizzazioni di amministratore.
+ Un dispositivo principale Greengrass. Per ulteriori informazioni su come configurare un dispositivo principale, vedere[Configurazione dei dispositivi AWS IoT Greengrass principali](setting-up.md).
+ Il dispositivo principale deve eseguire Greengrass nucleus v2.6.0 o versione successiva. Questa versione include il supporto per i caratteri jolly nelle publish/subscribe comunicazioni locali e il supporto per le ombre dei dispositivi client.
**Nota**
Il supporto per i dispositivi client richiede Greengrass nucleus v2.2.0 o versione successiva. Tuttavia, questo tutorial esplora le funzionalità più recenti, come il supporto per le wildcard MQTT in locale e il supporto per le ombre dei dispositivi client. publish/subscribe Queste funzionalità richiedono Greengrass nucleus v2.6.0 o versione successiva.
+ Il dispositivo principale deve trovarsi sulla stessa rete dei dispositivi client per connettersi.
+ (Facoltativo) Per completare i moduli in cui si sviluppano componenti Greengrass personalizzati, il dispositivo principale deve eseguire la Greengrass CLI. Per ulteriori informazioni, consulta [Installazione della CLI di Greengrass](install-gg-cli.md).
+ Qualsiasi AWS IoT cosa da connettere come dispositivo client in questo tutorial. Per ulteriori informazioni, consulta [AWS IoT Create resources](https://docs.aws.amazon.com/iot/latest/developerguide/create-iot-resources.html) nella *AWS IoT Core Developer Guide*.
+ La AWS IoT politica del dispositivo client deve consentire l'`greengrass:Discover`autorizzazione. Per ulteriori informazioni, consulta [AWS IoT Politica minima per i dispositivi client](device-auth.md#client-device-minimal-iot-policy).
+ Il dispositivo client deve trovarsi sulla stessa rete del dispositivo principale.
+ Il dispositivo client deve eseguire [Python 3](https://www.python.org/).
+ Il dispositivo client deve eseguire [Git](https://git-scm.com/).
## Passaggio 1: rivedi e aggiorna la AWS IoT politica di base del dispositivo
Per supportare i dispositivi client, la AWS IoT politica di base del dispositivo deve consentire le seguenti autorizzazioni:
+ `greengrass:PutCertificateAuthorities`
+ `greengrass:VerifyClientDeviceIdentity`
+ `greengrass:VerifyClientDeviceIoTCertificateAssociation`
+ `greengrass:GetConnectivityInfo`
+ `greengrass:UpdateConnectivityInfo`— (Facoltativo) Questa autorizzazione è necessaria per utilizzare il [componente del rilevatore IP](ip-detector-component.md), che riporta le informazioni sulla connettività di rete del dispositivo principale al AWS IoT Greengrass servizio cloud.
Per ulteriori informazioni su queste autorizzazioni e AWS IoT politiche per i dispositivi principali, consulta [AWS IoT politiche per le operazioni sul piano dati](device-auth.md#iot-policies) e. [AWS IoT Politica minima per il supporto dei dispositivi client](device-auth.md#client-device-support-minimal-iot-policy)
In questa sezione, esamini le AWS IoT politiche per il tuo dispositivo principale e aggiungi le autorizzazioni necessarie mancanti. Se hai utilizzato il programma di [installazione del software AWS IoT Greengrass Core per il provisioning delle risorse](quick-installation.md), il tuo dispositivo principale dispone di una AWS IoT politica che consente l'accesso a tutte le AWS IoT Greengrass azioni ()`greengrass:*`. In questo caso, è necessario aggiornare la AWS IoT policy solo se si prevede di configurare il componente shadow manager con cui sincronizzare le ombre del dispositivo. AWS IoT Core Altrimenti, puoi saltare questa sezione.
**Per rivedere e aggiornare la politica di un dispositivo principale AWS IoT**
1. Nel menu di navigazione della [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass), scegli **Dispositivi principali**.
1. Nella pagina **Dispositivi principali**, scegli il dispositivo principale da aggiornare.
1. 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.
1. Nella pagina dei dettagli dell'oggetto, scegli **Certificati**.
1. Nella scheda **Certificati**, scegli il certificato attivo dell'oggetto.
1. Nella pagina dei dettagli del certificato, scegli **Politiche**.
1. 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.
**Nota**
Se hai utilizzato il programma di [installazione del software AWS IoT Greengrass Core per il provisioning delle risorse](quick-installation.md), hai due AWS IoT politiche. Ti consigliamo di scegliere la politica denominata **GreengrassV2IoTThingPolicy**, se esiste. I dispositivi principali creati con il programma di installazione rapida utilizzano questo nome di policy per impostazione predefinita. Se aggiungi autorizzazioni a questa politica, le concedi anche ad altri dispositivi principali che utilizzano questa politica.
1. Nella panoramica della politica, scegli **Modifica** versione attiva.
1. Rivedi la politica per le autorizzazioni richieste e aggiungi le autorizzazioni richieste mancanti.
1. 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.
1. Scegli **Salva come nuova versione**.
## Passaggio 2: abilitare il supporto per i dispositivi client
Affinché un dispositivo client utilizzi cloud discovery per connettersi a un dispositivo principale, è necessario associare i dispositivi. Quando associ un dispositivo client a un dispositivo principale, consenti a tale dispositivo client di recuperare gli indirizzi IP e i certificati del dispositivo principale da utilizzare per la connessione.
Per consentire ai dispositivi client di connettersi in modo sicuro a un dispositivo principale e comunicare con i componenti AWS IoT Core Greengrass, distribuisci i seguenti componenti Greengrass sul dispositivo principale:
+ [Autenticazione del dispositivo client](client-device-auth-component.md) (`aws.greengrass.clientdevices.Auth`)
Implementate il componente di autenticazione dei dispositivi client per autenticare i dispositivi client e autorizzare le azioni dei dispositivi client. Questo componente consente ai tuoi dispositivi di AWS IoT connettersi a un dispositivo principale.
Questo componente richiede alcune configurazioni per utilizzarlo. È necessario specificare i gruppi di dispositivi client e le operazioni che ciascun gruppo è autorizzato a eseguire, ad esempio connettersi e comunicare tramite MQTT. Per ulteriori informazioni, consultate Configurazione dei [componenti di autenticazione dei dispositivi client](client-device-auth-component.md#client-device-auth-component-configuration).
+ [Broker MQTT 3.1.1 (Moquette)](mqtt-broker-moquette-component.md) (`aws.greengrass.clientdevices.mqtt.Moquette`)
Implementate il componente del broker MQTT Moquette per eseguire un broker MQTT leggero. Il broker Moquette MQTT è conforme a MQTT 3.1.1 e include il supporto locale per QoS 0, QoS 1, QoS 2, messaggi conservati, messaggi di ultima volontà e abbonamenti permanenti.
Non è necessario configurare questo componente per utilizzarlo. Tuttavia, è possibile configurare la porta su cui questo componente gestisce il broker MQTT. Per impostazione predefinita, utilizza la porta 8883.
+ [Ponte MQTT](mqtt-bridge-component.md) (`aws.greengrass.clientdevices.mqtt.Bridge`)
(Facoltativo) Implementate il componente bridge MQTT per inoltrare messaggi tra dispositivi client (MQTT locale), pubblicazione e sottoscrizione locali e MQTT. AWS IoT Core Configura questo componente per sincronizzare i dispositivi client AWS IoT Core e interagire con i dispositivi client dai componenti Greengrass.
Questo componente richiede una configurazione per essere utilizzato. È necessario specificare le mappature degli argomenti in cui questo componente inoltra i messaggi. Per ulteriori informazioni, vedere Configurazione dei componenti del bridge [MQTT](mqtt-bridge-component.md#mqtt-bridge-component-configuration).
+ [Rilevatore IP](ip-detector-component.md) (`aws.greengrass.clientdevices.IPDetector`)
(Facoltativo) Implementate il componente del rilevatore IP per segnalare automaticamente gli endpoint del broker MQTT del dispositivo principale al servizio cloud. AWS IoT Greengrass Non è possibile utilizzare questo componente se si dispone di una configurazione di rete complessa, ad esempio una in cui un router inoltra la porta del broker MQTT al dispositivo principale.
Non è necessario configurare questo componente per utilizzarlo.
In questa sezione, si utilizza la AWS IoT Greengrass console per associare i dispositivi client e distribuire i componenti dei dispositivi client su un dispositivo principale.
**Per abilitare il supporto dei dispositivi client**
1. Passare alla [console AWS IoT Greengrass](https://console.aws.amazon.com/greengrass).
1. Nel menu di navigazione a sinistra, scegli **Dispositivi principali**.
1. Nella pagina **Dispositivi principali**, scegli il dispositivo principale su cui desideri abilitare il supporto per i dispositivi client.
1. Nella pagina dei dettagli del dispositivo principale, scegli la scheda **Dispositivi client**.
1. 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**.
**Nota**
È inoltre possibile utilizzare questa pagina per configurare l'individuazione dei dispositivi principali per un gruppo di oggetti. Se si sceglie questa opzione, è possibile distribuire i componenti dei dispositivi client su tutti i dispositivi principali di un gruppo di oggetti. Tuttavia, se si sceglie questa opzione, è necessario associare manualmente i dispositivi client a ciascun dispositivo principale in un secondo momento dopo aver creato la distribuzione. In questo tutorial, configurerai un dispositivo single core.
1. Nel **passaggio 2: Associa i dispositivi client**, associa l' AWS IoT elemento 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.**
1. Nella modalità **Associa i dispositivi client al dispositivo principale**, inserisci il nome dell' AWS IoT oggetto da associare.
1. Scegliere **Aggiungi**.
1. Selezionare **Associate (Associa)**.
1. 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](greengrass-nucleus-component.md) 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.Nucleus**componente.
1. Per il **aws.greengrass.Nucleus**componente, scegli **Modifica configurazione**.
1. Per la **versione del componente**, scegli la versione 2.6.0 o successiva.
1. Scegli **Conferma**.
**Nota**
Se si aggiorna il nucleo Greengrass da una versione secondaria precedente e il dispositivo principale esegue [componenti AWS forniti](public-components.md) 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)](update-greengrass-core-v2.md).
1. Per il **aws.greengrass.clientdevices.Auth**componente, scegli **Modifica configurazione**.
1. 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\$1* con il nome dell' AWS IoT oggetto da connettere come dispositivo client. Puoi anche specificare un nome con il 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, sostituiscilo *MyOtherClientDevice\$1* 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](client-device-auth-component.md#client-device-auth-component-configuration).
1. Scegli **Conferma**.
1. Per il **aws.greengrass.clientdevices.mqtt.Bridge**componente, scegli **Modifica configurazione**.
1. 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](mqtt-bridge-component.md#mqtt-bridge-component-configuration).
1. Scegli **Conferma**.
1. Scegliete **Review and deploy** per esaminare la distribuzione creata da questa pagina per voi.
1. Se non hai precedentemente impostato il [ruolo di servizio Greengrass](greengrass-service-role.md) 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**.
1. Nella pagina di **revisione**, scegli **Distribuisci** per avviare la distribuzione sul dispositivo principale.
1. 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:
+ [Verifica lo stato della distribuzione](check-deployment-status.md)
+ [Monitora AWS IoT Greengrass i registri](monitor-logs.md)
## Fase 3: Connect i dispositivi client
I dispositivi client possono utilizzare il SDK per dispositivi AWS IoT per rilevare, connettersi e comunicare con un dispositivo principale. Il dispositivo client deve essere una AWS IoT cosa. Per ulteriori informazioni, consulta [Create a thing object](https://docs.aws.amazon.com/iot/latest/developerguide/create-iot-resources.html#create-aws-thing) nella *AWS IoT Core Developer Guide*.
In questa sezione, installate la [SDK per dispositivi AWS IoT versione 2 per Python](https://github.com/aws/aws-iot-device-sdk-python-v2) ed eseguite l'applicazione di esempio Greengrass discovery da. SDK per dispositivi AWS IoT
**Nota**
SDK per dispositivi AWS IoT È disponibile anche in altri linguaggi di programmazione. Questo tutorial utilizza la SDK per dispositivi AWS IoT v2 per Python, ma puoi esplorare l' SDKs altra per il tuo caso d'uso. Per ulteriori informazioni, consulta [AWS IoT Device SDKs nella *AWS IoT Core Developer*](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sdks.html) Guide.
**Per connettere un dispositivo client a un dispositivo principale**
1. Scarica e installa la [SDK per dispositivi AWS IoT versione 2 per Python](https://github.com/aws/aws-iot-device-sdk-python-v2) 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
```
1. Installa la SDK per dispositivi AWS IoT v2 per Python.
```
python3 -m pip install --user ./aws-iot-device-sdk-python-v2
```
1. Passa alla cartella samples nella SDK per dispositivi AWS IoT v2 per Python.
```
cd aws-iot-device-sdk-python-v2/samples/greengrass
```
1. 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`
**Nota**
Questo argomento corrisponde all'argomento in cui è stato configurato il bridge MQTT per inoltrare i messaggi in AWS IoT Core precedenza.
+ Sostituisci *MyClientDevice1* con il nome dell'oggetto del dispositivo client.
+ Sostituisci *\$1/certs/AmazonRootCA1.pem* con il percorso del certificato Amazon root CA sul dispositivo client.
+ Sostituisci *\$1/certs/device.pem.crt* con il percorso del certificato del dispositivo sul dispositivo client.
+ Sostituisci *\$1/certs/private.pem.key* con il percorso del file della chiave privata sul dispositivo client.
+ Sostituiscilo *us-east-1* con la AWS regione in cui operano il dispositivo client e il 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
```
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](troubleshooting-client-devices.md#greengrass-discovery-issues).
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](monitor-logs.md).
1. 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](https://console.aws.amazon.com/iot).
1. Nel menu di navigazione a sinistra, sotto **Test**, scegli **MQTT** test client.
1. Nella scheda **Sottoscrivi a un argomento****, per Filtro argomento**, inserisci `clients/+/hello/world` per iscriverti ai messaggi del dispositivo client dal dispositivo principale.
1. Scegli **Abbonati**.
1. Esegui nuovamente l' publish/subscribe applicazione sul dispositivo client.
Il client di test MQTT visualizza i messaggi inviati dal dispositivo client su argomenti che corrispondono a questo filtro per argomenti.
## Fase 4: Sviluppare un componente che comunichi con i dispositivi client
È possibile sviluppare componenti Greengrass che comunicano con i dispositivi client. I componenti utilizzano la [comunicazione tra processi (IPC)](interprocess-communication.md) e l'[ publish/subscribe interfaccia locale](ipc-publish-subscribe.md) per comunicare su un dispositivo principale. Per interagire con i dispositivi client, configurate il componente bridge MQTT per inoltrare i messaggi tra i dispositivi client e l'interfaccia locale. publish/subscribe
In questa sezione, si aggiorna il componente bridge MQTT per inoltrare i messaggi dai dispositivi client all'interfaccia locale. publish/subscribe Quindi, sviluppate un componente che sottoscrive questi messaggi e stampa i messaggi quando li riceve.
**Sviluppare un componente che comunichi con i dispositivi client**
1. 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](https://console.aws.amazon.com/greengrass).
1. **Nel menu di navigazione a sinistra, scegli Dispositivi principali.**
1. Nella pagina **Dispositivi principali**, scegli il dispositivo principale che stai utilizzando per questo tutorial.
1. Nella pagina dei dettagli del dispositivo principale, scegli la scheda **Dispositivi client**.
1. 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.
1. Nel **passaggio 3**, per il **aws.greengrass.clientdevices.mqtt.Bridge**componente, scegli **Modifica configurazione**.
1. Nella modalità **Modifica configurazione** per il componente bridge MQTT, configurate una mappatura degli argomenti che inoltri i messaggi MQTT dai dispositivi client all'interfaccia locale. publish/subscribe Esegui questa operazione:
1. In **Configurazione**, nel blocco **Configurazione per unire** 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 Greengrass locale. publish/subscribe
```
{
"mqttTopicMapping": {
"HelloWorldIotCoreMapping": {
"topic": "clients/+/hello/world",
"source": "LocalMqtt",
"target": "IotCore"
},
"HelloWorldPubsubMapping": {
"topic": "clients/+/hello/world",
"source": "LocalMqtt",
"target": "Pubsub"
}
}
}
```
Per ulteriori informazioni, vedete Configurazione dei componenti del bridge [MQTT](mqtt-bridge-component.md#mqtt-bridge-component-configuration).
1. Scegli **Conferma**.
1. Scegliete **Review and deploy** per esaminare la distribuzione creata da questa pagina per voi.
1. Nella pagina **Revisione**, scegli **Distribuisci** per avviare la distribuzione sul dispositivo principale.
1. 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:
+ [Verifica lo stato della distribuzione](check-deployment-status.md)
+ [Monitora AWS IoT Greengrass i registri](monitor-logs.md)
1. 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/
```
1. 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"
}
}
]
}
```
1. 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 publish/subscribe IPC per sottoscrivere l'`clients/+/hello/world`argomento e stampare i messaggi che riceve.
Ad esempio, su un sistema basato su Linux, è possibile eseguire il seguente comando 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 IoT v2 for Python per](https://github.com/aws/aws-iot-device-sdk-python-v2) 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.
1. 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"
```
------
1. Visualizza i log dei componenti per verificare che il componente sia stato installato correttamente e che sottoscriva l'argomento.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log -Tail 10 -Wait
```
------
È possibile mantenere aperto il feed di registro per verificare che il dispositivo principale riceva messaggi.
1. 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
```
1. Visualizzate nuovamente i registri dei componenti per verificare che il componente riceva e stampi i messaggi dal dispositivo client.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log -Tail 10 -Wait
```
------
## Fase 5: Sviluppa un componente che interagisca con le ombre del dispositivo client
È possibile sviluppare componenti Greengrass che interagiscono con le ombre del [AWS IoT dispositivo](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html) client. Un'*ombra* è un documento JSON che memorizza le informazioni sullo stato corrente o desiderato per qualsiasi AWS IoT cosa, ad esempio un dispositivo client. I componenti personalizzati possono accedere alle ombre dei dispositivi client per gestirne lo stato, anche quando il dispositivo client non è connesso. AWS IoT Ogni AWS IoT oggetto ha un'ombra senza nome e puoi anche creare più ombre con nome per ogni cosa.
In questa sezione, si distribuisce il [componente Shadow Manager](shadow-manager-component.md) per gestire le ombre sul dispositivo principale. È inoltre necessario aggiornare il componente bridge MQTT per inoltrare messaggi shadow tra i dispositivi client e il componente shadow manager. Quindi, sviluppate un componente che aggiorna le ombre dei dispositivi client ed eseguite un'applicazione di esempio sui dispositivi client che risponde agli aggiornamenti shadow del componente. Questo componente rappresenta un'applicazione intelligente per la gestione della luce, in cui il dispositivo principale gestisce lo stato cromatico delle luci intelligenti che si collegano ad esso come dispositivi client.
**Sviluppare un componente che interagisca con le ombre dei dispositivi client**
1. 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](https://console.aws.amazon.com/greengrass).
1. **Nel menu di navigazione a sinistra, scegli Dispositivi principali.**
1. Nella pagina **Dispositivi principali**, scegli il dispositivo principale che stai utilizzando per questo tutorial.
1. Nella pagina dei dettagli del dispositivo principale, scegli la scheda **Dispositivi client**.
1. 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.
1. Nel **passaggio 3**, per il **aws.greengrass.clientdevices.mqtt.Bridge**componente, scegli **Modifica configurazione**.
1. Nella modalità **Modifica configurazione** per il componente bridge MQTT, configurate una mappatura degli argomenti che inoltri i messaggi MQTT sugli [argomenti shadow del dispositivo](https://docs.aws.amazon.com/iot/latest/developerguide/reserved-topics.html#reserved-topics-shadow) 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.
1. 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](mqtt-bridge-component.md#mqtt-bridge-component-configuration).
1. Scegli **Conferma**.
1. Nel **passaggio 3**, selezionate il **aws.greengrass.ShadowManager**componente per distribuirlo.
1. Scegliete **Review and deploy** per esaminare la distribuzione creata da questa pagina per voi.
1. Nella pagina **Revisione**, scegli **Distribuisci** per avviare la distribuzione sul dispositivo principale.
1. 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:
+ [Verifica lo stato della distribuzione](check-deployment-status.md)
+ [Monitora AWS IoT Greengrass i registri](monitor-logs.md)
1. 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/
```
1. 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"
}
}
]
}
```
1. 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 shadow IPC per ottenere e aggiornare le ombre dei dispositivi client e il servizio publish/subscribe IPC 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-component-configuration.md#ipc-operation-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](ipc-publish-subscribe.md#ipc-operation-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 locale. publish/subscribe
1. 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"
]
}
}
}'
```
------
1. Visualizza i log dei componenti per verificare che il componente sia installato ed eseguito correttamente.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MySmartLightManager.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2/logs/com.example.clientdevices.MySmartLightManager.log -Tail 10 -Wait
```
------
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.
1. 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. 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
# --------------------------------- ARGUMENT PARSING -----------------------------------------
import argparse
def parse_sample_input():
parser = argparse.ArgumentParser(
description="AWS IoT Greengrass Discovery Shadow",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
# Connection / TLS
parser.add_argument("--cert", required=True, dest="input_cert",
help="Path to the certificate file to use during mTLS connection establishment")
parser.add_argument("--key", required=True, dest="input_key",
help="Path to the private key file to use during mTLS connection establishment")
parser.add_argument("--ca_file", dest="input_ca", help="Path to optional CA bundle (PEM)")
# Shadow
parser.add_argument("--thing_name", required=True, dest="input_thing_name", help="The name assigned to your IoT Thing.")
parser.add_argument("--shadow_property", dest="input_shadow_property", default="color",
help="The name of the shadow property you want to change (optional, default='color'")
parser.add_argument("--region", dest="input_region", help="The region to connect through.", required=True)
parser.add_argument("--print_discover_resp_only", dest="input_print_discover_resp_only", default=False)
return parser.parse_args()
args = parse_sample_input()
# --------------------------------- ARGUMENT PARSING END -----------------------------------------
# Using globals to simplify sample code
is_sample_done = threading.Event()
mqtt_connection = None
shadow_thing_name = args.input_thing_name
shadow_property = args.input_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=args.input_cert,
pri_key_filepath=args.input_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=args.input_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(args.input_cert,args.input_key)
if args.input_ca:
tls_options.override_default_trust_store_from_path(None, args.input_ca)
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, args.input_region)
resp_future = discovery_client.discover(args.input_thing_name)
discover_response = resp_future.result()
print(discover_response)
if args.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 valore`reported`.
Questa applicazione combina i campioni Greengrass discovery e shadow della SDK per dispositivi AWS IoT v2.
1. 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.
+ Sostituire *MyClientDevice1* con il nome dell'oggetto del dispositivo client.
+ Sostituisci *\$1/certs/AmazonRootCA1.pem* con il percorso del certificato Amazon root CA sul dispositivo client.
+ Sostituisci *\$1/certs/device.pem.crt* con il percorso del certificato del dispositivo sul dispositivo client.
+ Sostituisci *\$1/certs/private.pem.key* con il percorso del file della chiave privata sul dispositivo client.
+ Sostituiscilo *us-east-1* con la AWS regione in cui operano il dispositivo client e il dispositivo principale.
```
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](troubleshooting-client-devices.md#greengrass-discovery-issues).
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](monitor-logs.md).
1. Visualizza nuovamente i registri dei componenti per verificare che il componente riceva conferme di aggiornamento ombra dal dispositivo client smart light.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MySmartLightManager.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2/logs/com.example.clientdevices.MySmartLightManager.log -Tail 10 -Wait
```
------
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}
```
**Nota**
L'ombra del dispositivo client è sincronizzata tra il dispositivo principale e il dispositivo client. Tuttavia, il dispositivo principale non sincronizza l'ombra del dispositivo client con AWS IoT Core. Ad esempio, potresti sincronizzare un'ombra con AWS IoT Core per visualizzare o modificare lo stato di tutti i dispositivi del tuo parco dispositivi. Per ulteriori informazioni su come configurare il componente Shadow Manager con cui sincronizzare le ombre AWS IoT Core, consulta[Sincronizza le ombre del dispositivo locale con AWS IoT Core](sync-shadows-with-iot-core.md).
Hai completato questo tutorial. Il dispositivo client si connette al dispositivo principale, invia messaggi MQTT ai componenti Greengrass AWS IoT Core e riceve aggiornamenti shadow dal dispositivo principale. Per ulteriori informazioni sugli argomenti trattati in questo tutorial, consulta quanto segue:
+ [Associa i dispositivi client](associate-client-devices.md)
+ [Gestisci gli endpoint principali dei dispositivi](manage-core-device-endpoints.md)
+ [Verifica le comunicazioni con i dispositivi client](test-client-device-communications.md)
+ [API Greengrass Discovery RESTful](greengrass-discover-api.md)
+ [Inoltra messaggi MQTT tra dispositivi client e AWS IoT Core](relay-client-device-messages.md)
+ [Interagisci con i dispositivi client nei componenti](interact-with-client-devices-in-components.md)
+ [Interagisci con le ombre dei dispositivi](interact-with-shadows.md)
+ [Interazione e sincronizzazione delle ombre dei dispositivi client](work-with-client-device-shadows.md)