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: Dimostrare la comunicazione dei messaggi MQTT con il AWS IoT Device Client Questo tutorial dimostra come il AWS IoT Device Client può sottoscrivere e pubblicare messaggi MQTT, che sono comunemente usati nelle soluzioni IoT. **Per iniziare il tutorial:** + Configurare il computer host locale e Raspberry Pi configurati come nella [la sezione precedente](iot-dc-install-dc.md). Se hai salvato l'immagine della scheda microSD dopo aver installato AWS IoT il Device Client, puoi utilizzare una scheda microSD con quell'immagine con il tuo Raspberry Pi. + Se hai già eseguito questa demo, prova [Passo 2: Pulizia delle demo Account AWS dopo la creazione con AWS IoT Device Client](iot-dc-cleanup.md#iot-dc-cleanup-cloud) a eliminare tutte le AWS IoT risorse create nelle esecuzioni precedenti per evitare errori di risorse duplicate. Questo tutorial dura circa 45 minuti. **Al termine di questo argomento:** + Avrai dimostrato diversi modi in cui il tuo dispositivo IoT può iscriversi ai messaggi MQTT AWS IoT e pubblicare messaggi MQTT su. AWS IoT **Equipaggiamento necessario:** + Il tuo ambiente locale di sviluppo e di test dalla [sezione precedente](iot-dc-install-dc.md) + Il Raspberry Pi che hai utilizzato nella [sezione precedente](iot-dc-install-dc.md) + La scheda di memoria microSD del Raspberry Pi utilizzata nella [sezione precedente](iot-dc-install-dc.md) **Topics** + [Prepara il Raspberry Pi per dimostrare la comunicazione tramite messaggi MQTT](iot-dc-testconn-provision.md) + [Dimostra la pubblicazione di messaggi con AWS IoT Device Client](iot-dc-testconn-publish.md) + [Dimostra l'iscrizione ai messaggi con Device Client AWS IoT](iot-dc-testconn-subscribe.md) # Prepara il Raspberry Pi per dimostrare la comunicazione tramite messaggi MQTT Questa procedura crea le risorse in AWS IoT e nel Raspberry Pi per dimostrare la comunicazione dei messaggi MQTT utilizzando il AWS IoT Device Client. **Topics** + [Creare i file di certificato per dimostrare la comunicazione MQTT](#iot-dc-testconn-provision-certs) + [Effettua il provisioning del dispositivo per dimostrare la comunicazione MQTT](#iot-dc-testconn-provision-aws) + [Configura il file di configurazione del AWS IoT Device Client e il client di test MQTT per dimostrare la comunicazione MQTT](#iot-dc-testconn-provision-dc-config) ## Creare i file di certificato per dimostrare la comunicazione MQTT Questa procedura crea i file di certificato del dispositivo per questa demo. **Per creare e scaricare i file di certificato del dispositivo per il tuo Raspberry Pi** 1. Nella finestra terminale del computer host locale, immettere questi comandi per creare i file di certificato del dispositivo per il dispositivo. ``` mkdir ~/certs/pubsub aws iot create-keys-and-certificate \ --set-as-active \ --certificate-pem-outfile "~/certs/pubsub/device.pem.crt" \ --public-key-outfile "~/certs/pubsub/public.pem.key" \ --private-key-outfile "~/certs/pubsub/private.pem.key" ``` Questo comando restituisce una risposta simile alla seguente. Salva il `certificateArn` per utilizzarlo in un secondo momento. ``` { "certificateArn": "arn:aws:iot:us-west-2:57EXAMPLE833:cert/76e7e4edb3e52f52334be2f387a06145b2aa4c7fcd810f3aea2d92abc227d269", "certificateId": "76e7e4edb3e52f5233EXAMPLE7a06145b2aa4c7fcd810f3aea2d92abc227d269", "certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCCAkGgAwIBAgI_SHORTENED_FOR_EXAMPLE_Lgn4jfgtS\n-----END CERTIFICATE-----\n", "keyPair": { "PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BA_SHORTENED_FOR_EXAMPLE_ImwIDAQAB\n-----END PUBLIC KEY-----\n", "PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQE_SHORTENED_FOR_EXAMPLE_T9RoDiukY\n-----END RSA PRIVATE KEY-----\n" } } ``` 1. Inserisci i seguenti comandi per impostare le autorizzazioni sulla directory dei certificati e sui relativi file. ``` chmod 700 ~/certs/pubsub chmod 644 ~/certs/pubsub/* chmod 600 ~/certs/pubsub/private.pem.key ``` 1. Esegui questo comando per rivedere le autorizzazioni sulle directory e sui file dei certificati. ``` ls -l ~/certs/pubsub ``` L'output del comando dovrebbe essere lo stesso di quello che vedi qui, tranne per le date e gli orari del file. ``` -rw-r--r-- 1 pi pi 1220 Oct 28 13:02 device.pem.crt -rw------- 1 pi pi 1675 Oct 28 13:02 private.pem.key -rw-r--r-- 1 pi pi 451 Oct 28 13:02 public.pem.key ``` 1. Inserisci questi comandi per creare le directory per i file di log. ``` mkdir ~/.aws-iot-device-client mkdir ~/.aws-iot-device-client/log chmod 745 ~/.aws-iot-device-client/log echo " " > ~/.aws-iot-device-client/log/aws-iot-device-client.log echo " " > ~/.aws-iot-device-client/log/pubsub_rx_msgs.log chmod 600 ~/.aws-iot-device-client/log/* ``` ## Effettua il provisioning del dispositivo per dimostrare la comunicazione MQTT Questa sezione crea le AWS IoT risorse che forniscono il tuo Raspberry Pi. AWS IoT **Per effettuare il provisioning del dispositivo in AWS IoT:** 1. Nella finestra terminale del computer host locale, immettere il seguente comando per ottenere l'indirizzo dell'endpoint dati del dispositivo per l' Account AWS. ``` aws iot describe-endpoint --endpoint-type IoT:Data-ATS ``` Il valore dell'endpoint non è cambiato dal momento in cui hai eseguito questo comando per il tutorial precedente. Il comando viene eseguito nuovamente per trovare e incollare facilmente il valore dell'endpoint dei dati nel file di configurazione utilizzato in questo tutorial. Questo comando restituisce una risposta simile alla seguente. Registra il valore `endpointAddress` per utilizzarlo in seguito. ``` { "endpointAddress": "a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com" } ``` 1. Inserisci questo comando per creare una nuova AWS IoT risorsa per il tuo Raspberry Pi. ``` aws iot create-thing --thing-name "PubSubTestThing" ``` Poiché una risorsa AWS IoT oggetto è una rappresentazione *virtuale* del tuo dispositivo nel cloud, possiamo creare più risorse di oggetti AWS IoT da utilizzare per scopi diversi. Possono essere utilizzati tutti dallo stesso dispositivo IoT fisico per rappresentare diversi aspetti del dispositivo. Questi tutorial utilizzeranno solo una risorsa alla volta per rappresentare il Raspberry Pi. In questo modo, in questi tutorial, rappresentano le diverse demo in modo che, dopo aver creato le AWS IoT risorse per una demo, sia possibile tornare indietro e ripetere la demo utilizzando le risorse create appositamente per ciascuna di esse. Se la risorsa AWS IoT oggetto è stata creata, il comando restituisce una risposta come questa. ``` { "thingName": "PubSubTestThing", "thingArn": "arn:aws:iot:us-west-2:57EXAMPLE833:thing/PubSubTestThing", "thingId": "8ea78707-32c3-4f8a-9232-14bEXAMPLEfd" } ``` 1. Nella finestra terminale: 1. Apri un editor di testo, ad esempio `nano`. 1. Copia questo documento JSON e incollalo nell'editor di testo aperto. **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iot:Connect" ], "Resource": [ "arn:aws:iot:us-west-2:123456789012:client/PubSubTestThing" ] }, { "Effect": "Allow", "Action": [ "iot:Publish" ], "Resource": [ "arn:aws:iot:us-west-2:123456789012:topic/test/dc/pubtopic" ] }, { "Effect": "Allow", "Action": [ "iot:Subscribe" ], "Resource": [ "arn:aws:iot:us-west-2:123456789012:topicfilter/test/dc/subtopic" ] }, { "Effect": "Allow", "Action": [ "iot:Receive" ], "Resource": [ "arn:aws:iot:us-west-2:123456789012:topic/test/dc/subtopic" ] } ] } ``` 1. Nell'editor, in ogni `Resource` sezione del documento di policy, sostituisci *us-west-2:57EXAMPLE833* con i tuoi Regione AWS, un carattere con i due punti (:) e il tuo numero di 12 cifre Account AWS . 1. Salva il file nell'editor di testo come **\$1/policies/pubsub\$1test\$1thing\$1policy.json**. 1. Esegui questo comando per utilizzare il documento di policy dei passaggi precedenti per creare una AWS IoT politica. ``` aws iot create-policy \ --policy-name "PubSubTestThingPolicy" \ --policy-document "file://~/policies/pubsub_test_thing_policy.json" ``` Se la policy viene creata, verrà visualizzata una risposta simile alla seguente. ``` { "policyName": "PubSubTestThingPolicy", "policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/PubSubTestThingPolicy", "policyDocument": "{\n\"Version\": \"2012-10-17\", \n\"Statement\": [\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Connect\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Publish\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Subscribe\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Receive\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n]\n}\n]\n}\n", "policyVersionId": "1" } ``` 1. Eseguire questo comando per attribuire la policy al certificato del dispositivo. Sostituisci `certificateArn` con il valore `certificateArn` salvato in precedenza in questa sezione. ``` aws iot attach-policy \ --policy-name "PubSubTestThingPolicy" \ --target "certificateArn" ``` In caso di successo, questo comando non restituisce alcun risultato. 1. Esegui questo comando per attribuire il certificato del dispositivo alle risorse dell'oggetto AWS IoT . Sostituisci `certificateArn` con il valore `certificateArn` salvato in precedenza in questa sezione. ``` aws iot attach-thing-principal \ --thing-name "PubSubTestThing" \ --principal "certificateArn" ``` In caso di successo, questo comando non restituisce alcun risultato. Dopo aver effettuato correttamente il provisioning del dispositivo AWS IoT, sei pronto per continuare[Configura il file di configurazione del AWS IoT Device Client e il client di test MQTT per dimostrare la comunicazione MQTT](#iot-dc-testconn-provision-dc-config). ## Configura il file di configurazione del AWS IoT Device Client e il client di test MQTT per dimostrare la comunicazione MQTT Questa procedura crea un file di configurazione per testare il Device Client. AWS IoT **Per creare il file di configurazione per testare il AWS IoT Device Client** 1. Nella finestra terminale del computer host locale connesso al Raspberry Pi: 1. Apri un editor di testo, ad esempio `nano`. 1. Copia questo documento JSON e incollalo nell'editor di testo aperto. ``` { "endpoint": "a3qEXAMPLEaffp-ats.iot.us-west-2.amazonaws.com", "cert": "~/certs/pubsub/device.pem.crt", "key": "~/certs/pubsub/private.pem.key", "root-ca": "~/certs/AmazonRootCA1.pem", "thing-name": "PubSubTestThing", "logging": { "enable-sdk-logging": true, "level": "DEBUG", "type": "STDOUT", "file": "" }, "jobs": { "enabled": false, "handler-directory": "" }, "tunneling": { "enabled": false }, "device-defender": { "enabled": false, "interval": 300 }, "fleet-provisioning": { "enabled": false, "template-name": "", "template-parameters": "", "csr-file": "", "device-key": "" }, "samples": { "pub-sub": { "enabled": true, "publish-topic": "test/dc/pubtopic", "publish-file": "", "subscribe-topic": "test/dc/subtopic", "subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log" } }, "config-shadow": { "enabled": false }, "sample-shadow": { "enabled": false, "shadow-name": "", "shadow-input-file": "", "shadow-output-file": "" } } ``` 1. Sostituisci il *endpoint* valore con Device Data Endpoint per il tuo dispositivo Account AWS che hai trovato in. [Effettua il provisioning del dispositivo in AWS IoT Core](iot-dc-install-provision.md#iot-dc-install-dc-provision) 1. Salva il file nell'editor di testo come **\$1/dc-configs/dc-pubsub-config.json**. 1. Esegui questo comando per impostare le autorizzazioni sul nuovo file di configurazione. ``` chmod 644 ~/dc-configs/dc-pubsub-config.json ``` 1. Per preparare il **Client MQTT di test** a sottoscrivere tutti i messaggi MQTT: 1. Sul computer host locale, nella [console AWS IoT](https://console.aws.amazon.com//iot/home#/test), seleziona **Client MQTT di test**. 1. Nella tabella **Subscribe to a topic (Sottoscrivi un argomento)**, in **Topic filter (Filtro argomenti)**, inserisci **\$1** (un solo segno di cancelletto) e scegli **Subscribe (Sottoscrivi)**. 1. Sotto l'etichetta **Subscriptions (Sottoscrizioni)**, conferma di vedere **\$1** (un solo segno di cancelletto). Lascia la finestra con il **Client MQTT di test** aperta mentre continui questo tutorial. Dopo aver salvato il file e configurato il **client MQTT di test**, sei pronto a proseguire con [Dimostra la pubblicazione di messaggi con AWS IoT Device Client](iot-dc-testconn-publish.md). # Dimostra la pubblicazione di messaggi con AWS IoT Device Client Le procedure in questa sezione mostrano come il AWS IoT Device Client può inviare messaggi MQTT predefiniti e personalizzati. Queste istruzioni di policy nella policy creata nella fase precedente per questi esercizi consentono al Raspberry Pi di eseguire queste azioni: + **`iot:Connect`** Consente la connessione al client denominato`PubSubTestThing`, il Raspberry Pi su cui è in esecuzione il AWS IoT Device Client. ``` { "Effect": "Allow", "Action": [ "iot:Connect" ], "Resource": [ "arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing" ] } ``` + **`iot:Publish`** Fornire al Raspberry Pi l'autorizzazione a pubblicare messaggi con un argomento MQTT di `test/dc/pubtopic`. ``` { "Effect": "Allow", "Action": [ "iot:Publish" ], "Resource": [ "arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic" ] } ``` L'azione `iot:Publish` consente di pubblicare agli argomenti MQTT elencati nell'array di Risorsa. Il *contenuto* di tali messaggi non è controllato dall'istruzione di policy. ## Pubblica il messaggio predefinito utilizzando il AWS IoT Device Client Questa procedura esegue il AWS IoT Device Client in modo da pubblicare un singolo messaggio MQTT predefinito che il **client di test MQTT riceve** e visualizza. **Per inviare il messaggio MQTT predefinito dal Device Client AWS IoT** 1. Assicurati che sia la finestra terminale collegata al computer host locale sia connessa al tuo Raspberry Pi e che la finestra con il **client MQTT di test** sia visibile durante l'esecuzione di questa procedura. 1. Nella finestra del terminale, inserisci questi comandi per eseguire il AWS IoT Device Client utilizzando il file di configurazione creato in. [Creare il file di configurazione](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1) ``` cd ~/aws-iot-device-client/build ./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-config.json ``` Nella finestra del terminale, il AWS IoT Device Client visualizza i messaggi informativi e gli eventuali errori che si verificano durante l'esecuzione. Se nella finestra del terminale non vengono visualizzati errori, esamina il **client MQTT di test**. 1. In **MQTT test client** (Client MQTT di test), nella finestra **Subscriptions** (Sottoscrizioni) viene visualizzato il messaggio *Hello World\$1* inviato all'argomento del messaggio `test/dc/pubtopic`. 1. Se il AWS IoT Device Client non mostra errori e viene visualizzato *Hello World\$1* inviato al `test/dc/pubtopic` messaggio nel **client di test MQTT**, hai dimostrato che la connessione è riuscita. 1. Nella finestra del terminale, digitate **^C** (Ctrl-C) per fermare il AWS IoT Device Client. Dopo aver dimostrato che AWS IoT Device Client ha pubblicato il messaggio MQTT predefinito, puoi continuare con. [Pubblica un messaggio personalizzato utilizzando AWS IoT Device Client](#iot-dc-testconn-publish-custom) ## Pubblica un messaggio personalizzato utilizzando AWS IoT Device Client Le procedure di questa sezione creano un messaggio MQTT personalizzato e quindi eseguono AWS IoT Device Client in modo che pubblichi il messaggio MQTT personalizzato una volta per essere ricevuto e visualizzato dal **client MQTT di test**. ### Crea un messaggio MQTT personalizzato per il Device Client AWS IoT Esegui questi passaggi nella finestra terminale del computer host locale connesso al Raspberry Pi. **Per creare un messaggio personalizzato da pubblicare sul AWS IoT Device Client** 1. Nella finestra terminale, apri un editor di testo, ad esempio `nano`. 1. Nell'editor di testo, copia e incolla il documento JSON riportato di seguito. Questo sarà il payload del messaggio MQTT pubblicato da AWS IoT Device Client. ``` { "temperature": 28, "humidity": 80, "barometer": 1013, "wind": { "velocity": 22, "bearing": 255 } } ``` 1. Salva il contenuto dell'editor di testo come **\$1/messages/sample-ws-message.json**. 1. Inserisci il comando seguente per impostare le autorizzazioni del file di messaggio appena creato. ``` chmod 600 ~/messages/* ``` **Per creare un file di configurazione per il AWS IoT Device Client da utilizzare per inviare il messaggio personalizzato** 1. Nella finestra del terminale, in un editor di testo come`nano`, apri il file di configurazione esistente di AWS IoT Device Client:. **\$1/dc-configs/dc-pubsub-config.json** 1. Modifica l'oggetto `samples` in questo modo. Nessun'altra parte di questo file deve essere modificata. ``` "samples": { "pub-sub": { "enabled": true, "publish-topic": "test/dc/pubtopic", "publish-file": "~/messages/sample-ws-message.json", "subscribe-topic": "test/dc/subtopic", "subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log" ``` 1. Salva il contenuto dell'editor di testo come **\$1/dc-configs/dc-pubsub-custom-config.json**. 1. Esegui questo comando per impostare le autorizzazioni sul nuovo file di configurazione. ``` chmod 644 ~/dc-configs/dc-pubsub-custom-config.json ``` ### Pubblica il messaggio MQTT personalizzato utilizzando Device Client AWS IoT Questa modifica influisce solo sui *contenuti* del payload del messaggio MQTT, quindi la policy attuale continuerà a funzionare. Tuttavia, se l'*argomento MQTT* (come definito dal valore `publish-topic` in `~/dc-configs/dc-pubsub-custom-config.json`) è stato cambiato, anche l'istruzione di policy `iot::Publish` dovrebbe essere modificata per consentire a Raspberry Pi di pubblicare sul nuovo argomento MQTT. **Per inviare il messaggio MQTT dal Device Client AWS IoT** 1. Assicurati che sia la finestra terminale che la finestra con il **client MQTT di test** siano visibili durante l'esecuzione di questa procedura. Inoltre, assicurati che il tuo **client MQTT di test** abbia una sottoscrizione ancora attiva per il filtro di argomenti **\$1**. Se non lo è, effettua nuovamente la sottoscrizione al filtro argomento**\$1**. 1. Nella finestra terminale, immettere questi comandi per eseguire AWS IoT Device Client utilizzando il file di configurazione creato in [Creare il file di configurazione](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1). ``` cd ~/aws-iot-device-client/build ./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json ``` Nella finestra del terminale, il AWS IoT Device Client visualizza i messaggi informativi e gli eventuali errori che si verificano durante l'esecuzione. Se nella finestra del terminale non vengono visualizzati errori, esaminare il client di test MQTT. 1. Nel **client MQTT di test**, nella finestra **Subscriptions (Sottoscrizioni)**, viene visualizzato il payload del messaggio personalizzato inviato all'argomento del messaggio `test/dc/pubtopic`. 1. Se il AWS IoT Device Client non mostra errori e vedi il payload di messaggi personalizzati che hai pubblicato nel `test/dc/pubtopic` messaggio nel **client di test MQTT**, hai pubblicato un messaggio personalizzato con successo. 1. Nella finestra del terminale, digitate **^C** (Ctrl-C) per arrestare il Device Client. AWS IoT Dopo aver dimostrato che AWS IoT Device Client ha pubblicato un payload di messaggi personalizzato, puoi continuare a farlo. [Dimostra l'iscrizione ai messaggi con Device Client AWS IoT](iot-dc-testconn-subscribe.md) # Dimostra l'iscrizione ai messaggi con Device Client AWS IoT In questa sezione verranno illustrati due tipi di sottoscrizione ai messaggi: + Sottoscrizione ad argomento singolo + Sottoscrizione ad argomento con caratteri jolly Queste istruzioni di policy nella policy creata per questi esercizi consentono a Raspberry Pi di eseguire queste azioni: + **`iot:Receive`** Fornisce al AWS IoT Device Client l'autorizzazione a ricevere argomenti MQTT che corrispondono a quelli nominati nell'`Resource`oggetto. ``` { "Effect": "Allow", "Action": [ "iot:Receive" ], "Resource": [ "arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/subtopic" ] } ``` + **`iot:Subscribe`** Fornisce al AWS IoT Device Client l'autorizzazione a sottoscrivere i filtri degli argomenti MQTT che corrispondono a quelli nominati nell'`Resource`oggetto. ``` { "Effect": "Allow", "Action": [ "iot:Subscribe" ], "Resource": [ "arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic" ] } ``` ## Iscriviti a un singolo argomento del messaggio MQTT Questa procedura dimostra come AWS IoT Device Client può sottoscrivere e registrare i messaggi MQTT. Nella finestra del terminale del computer host locale connesso al Raspberry Pi, elenca il contenuto di **\$1/dc-configs/dc-pubsub-custom-config.json** oppure aprire il file in un editor di testo per esaminarne il contenuto. Individua l'oggetto `samples`, che dovrebbe essere simile a questo. ``` "samples": { "pub-sub": { "enabled": true, "publish-topic": "test/dc/pubtopic", "publish-file": "~/messages/sample-ws-message.json", "subscribe-topic": "test/dc/subtopic", "subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log" ``` Nota che il valore `subscribe-topic` è l'argomento MQTT che AWS IoT Device Client sottoscriverà quando viene eseguito. Il AWS IoT Device Client scrive i payload dei messaggi che riceve da questo abbonamento nel file indicato nel valore. `subscribe-file` **Per sottoscrivere un argomento relativo a un messaggio MQTT dal Device Client AWS IoT** 1. Assicurati che sia la finestra terminale che la finestra con il client MQTT di test siano visibili durante l'esecuzione di questa procedura. Inoltre, assicurati che il tuo **client MQTT di test** abbia una sottoscrizione ancora attiva per il filtro di argomenti **\$1**. Se non lo è, effettua nuovamente la sottoscrizione al filtro argomento**\$1**. 1. Nella finestra del terminale, inserisci questi comandi per eseguire il AWS IoT Device Client utilizzando il file di configurazione creato in. [Creare il file di configurazione](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1) ``` cd ~/aws-iot-device-client/build ./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json ``` Nella finestra del terminale, il AWS IoT Device Client visualizza i messaggi informativi e gli eventuali errori che si verificano durante l'esecuzione. Se nella finestra del terminale non vengono visualizzati errori, continuare nella console AWS IoT . 1. Nella AWS IoT console, nel **client di test MQTT**, scegliete la scheda **Pubblica su un argomento**. 1. Alla voce **Topic name (Nome argomento)**, inserisci **test/dc/subtopic** 1. Alla voce **Message Payload (Payload del messaggio)**, esamina i contenuti del messaggio. 1. Per pubblicare il messaggio MQTT, scegli **Publish (Pubblica)**. 1. Nella finestra del terminale, controllate la voce relativa al *messaggio ricevuto* dal AWS IoT Device Client che assomiglia a questa. ``` 2021-11-10T16:02:20.890Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 45 bytes ``` 1. Dopo aver visualizzato la voce relativa al *messaggio ricevuto* che indica che il messaggio è stato ricevuto, digita **^C** (Ctrl-C) per interrompere il AWS IoT Device Client. 1. Inserisci questo comando per visualizzare la fine del file di log dei messaggi e visualizzare il messaggio pubblicato dal **client MQTT di test**. ``` tail ~/.aws-iot-device-client/log/pubsub_rx_msgs.log ``` Visualizzando il messaggio nel file di log, è stato dimostrato che AWS IoT Device Client ha ricevuto il messaggio pubblicato dal client di test MQTT. ## Sottoscrivi a più argomenti del messaggio MQTT utilizzando caratteri jolly Queste procedure dimostrano come il AWS IoT Device Client può sottoscrivere e registrare i messaggi MQTT utilizzando caratteri jolly. Per fare ciò, dovrai: 1. Aggiornate il filtro degli argomenti utilizzato da AWS IoT Device Client per sottoscrivere gli argomenti MQTT. 1. Aggiornare la policy utilizzata dal dispositivo per consentire le nuove sottoscrizioni. 1. Esegui il AWS IoT Device Client e pubblica messaggi dalla console di test MQTT. **Per creare un file di configurazione per la sottoscrizione a più argomenti di messaggio MQTT utilizzando un filtro argomento MQTT con caratteri jolly** 1. Nella finestra del terminale del computer host locale connesso al Raspberry Pi, apri **\$1/dc-configs/dc-pubsub-custom-config.json** per modificare e localizzare l'oggetto `samples`. 1. Nell'editor di testo, individua l'oggetto `samples` e aggiorna il valore `subscribe-topic` in modo che somigli a questo. ``` "samples": { "pub-sub": { "enabled": true, "publish-topic": "test/dc/pubtopic", "publish-file": "~/messages/sample-ws-message.json", "subscribe-topic": "test/dc/#", "subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log" ``` Il nuovo valore `subscribe-topic` è un [filtro di argomento MQTT](topics.md#topicfilters) con un carattere jolly MQTT alla fine. Descrive una sottoscrizione a tutti gli argomenti MQTT che iniziano con `test/dc/`. Il AWS IoT Device Client scrive i payload dei messaggi che riceve da questo abbonamento nel file indicato in. `subscribe-file` 1. Salva il file di configurazione modificato come **\$1/dc-configs/dc-pubsub-wild-config.json** ed esci dall'editor. **Per modificare la policy utilizzata da Raspberry Pi per consentire la sottoscrizione e la ricezione di più argomenti di messaggio MQTT** 1. Nella finestra del terminale del computer host locale connesso al tuo Raspberry Pi, nel tuo editor di testo preferito, apri **\$1/policies/pubsub\$1test\$1thing\$1policy.json** per la modifica e quindi individua le istruzioni di policy `iot::Subscribe` e `iot::Receive` nel file. 1. Nell'istruzione di policy `iot::Subscribe`, aggiorna la stringa nell'oggetto Risorsa per sostituire `subtopic` con `*`, in modo tale che l'indirizzo sia simile al seguente. ``` { "Effect": "Allow", "Action": [ "iot:Subscribe" ], "Resource": [ "arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/*" ] } ``` **Nota** I [caratteri jolly del filtro di argomento MQTT](topics.md#topicfilters) sono il `+` (segno più) e il `#` (segno cancelletto). Una richiesta di sottoscrizione con un `#` alla fine sottoscrive tutti gli argomenti che iniziano con la stringa che precede il carattere `#` (ad esempio, `test/dc/` in questo caso). Tuttavia, il valore della risorsa nell'istruzione di policy che autorizza questa sottoscrizione deve utilizzare un `*` (un asterisco) al posto di `#` (segno del cancelletto) nel filtro argomento ARN. Questo perché il processore di policy utilizza un carattere jolly diverso da quello utilizzato da MQTT. Per ulteriori informazioni sull'utilizzo di caratteri jolly per argomenti e filtri di argomento nelle policy, consulta [Utilizzo di caratteri jolly in MQTT e nelle policy AWS IoT Core](pub-sub-policy.md#pub-sub-policy-cert). 1. Nell'istruzione di policy `iot::Receive`, aggiorna la stringa nell'oggetto Risorsa per sostituire `subtopic` con `*`, in modo tale che l'indirizzo sia simile al seguente. ``` { "Effect": "Allow", "Action": [ "iot:Receive" ], "Resource": [ "arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*" ] } ``` 1. Salva il documento della policy aggiornato con nome **\$1/policies/pubsub\$1wild\$1test\$1thing\$1policy.json** ed esci dall'editor. 1. Inserisci questo comando per aggiornare la policy di questo tutorial per utilizzare le nuove definizioni delle risorse. ``` aws iot create-policy-version \ --set-as-default \ --policy-name "PubSubTestThingPolicy" \ --policy-document "file://~/policies/pubsub_wild_test_thing_policy.json" ``` Se il comando viene eseguito correttamente, verrà visualizzata una risposta simile alla seguente. Nota che `policyVersionId` ora è `2`, indicando che questa è la seconda versione di questa policy. Se hai aggiornato correttamente la policy, puoi passare alla procedura successiva. ``` { "policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/PubSubTestThingPolicy", "policyDocument": "{\n \"Version\": \"2012-10-17\", \n \"Statement\": [\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Connect\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Publish\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Subscribe\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/*\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Receive\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n ]\n }\n ]\n}\n", "policyVersionId": "2", "isDefaultVersion": true } ``` Se si verifica un errore che contiene troppe versioni di policy per salvarne una nuova, inserisci questo comando per elencare le versioni attuali della policy. Esamina l'elenco restituito da questo comando per trovare una versione della policy che è possibile eliminare. ``` aws iot list-policy-versions --policy-name "PubSubTestThingPolicy" ``` Inserisci questo comando per eliminare una versione che non serve più. Attenzione: non puoi eliminare la versione di default della policy. La versione della policy di default è quella con un valore `isDefaultVersion` di `true`. ``` aws iot delete-policy-version \ --policy-name "PubSubTestThingPolicy" \ --policy-version-id policyId ``` Dopo aver eliminato una versione della policy, riprova questo passaggio. Con il file di configurazione e la policy aggiornati, sei pronto a dimostrare gli abbonamenti wild card con Device Client. AWS IoT **Per dimostrare come AWS IoT Device Client sottoscrive e riceve più argomenti relativi ai messaggi MQTT** 1. Nel **client MQTT di test**, controlla le sottoscrizioni. Se il **client MQTT di test** è sottoscritto al filtro dell'argomento **\$1**, passare alla fase successiva. In caso contrario, in **MQTT test client** (Client MQTT di test), nella scheda **Subscribe to a topic** (Sottoscrivi un argomento), in **Topic filter** (Filtro argomenti) inserisci **\$1** (un cancelletto), quindi scegli **Subscribe** (Sottoscrivi) per sottoscriverlo. 1. Nella finestra del terminale del computer host locale connesso a Raspberry Pi, inserisci questi comandi per avviare AWS IoT Device Client. ``` cd ~/aws-iot-device-client/build ./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-wild-config.json ``` 1. Mentre guardate l'output del AWS IoT Device Client nella finestra del terminale sul computer host locale, tornate al client di test **MQTT**. Nella scheda **Publish to a topic (Pubblica in un argomento)**, in **Topic name (Nome argomento)**, inserisci **test/dc/subtopic** e quindi scegli **Publish (Pubblica)**. 1. Nella finestra del terminale, conferma che il messaggio è stato ricevuto cercando un messaggio come: ``` 2021-11-10T16:34:20.101Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 76 bytes ``` 1. Mentre guardate l'output del AWS IoT Device Client nella finestra del terminale del computer host locale, tornate al client di **test MQTT**. Nella scheda **Publish to a topic (Pubblica in un argomento)**, in **Topic name (Nome argomento)**, inserisci **test/dc/subtopic2** e quindi scegli **Publish (Pubblica)**. 1. Nella finestra del terminale, conferma che il messaggio è stato ricevuto cercando un messaggio come: ``` 2021-11-10T16:34:32.078Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 77 bytes ``` 1. Dopo aver visualizzato i messaggi che confermano la ricezione di entrambi i messaggi, digitate **^C** (Ctrl-C) per fermare il AWS IoT Device Client. 1. Inserisci questo comando per visualizzare la fine del file di log dei messaggi e visualizzare il messaggio pubblicato dal **client MQTT di test**. ``` tail -n 20 ~/.aws-iot-device-client/log/pubsub_rx_msgs.log ``` **Nota** Il file di log contiene solo payload del messaggio. Gli argomenti del messaggio non vengono registrati nel file di registro dei messaggi ricevuti. Potresti anche vedere il messaggio pubblicato dal AWS IoT Device Client nel registro ricevuto. Questo perché il filtro degli argomenti jolly include l'argomento del messaggio e, a volte, la richiesta di sottoscrizione può essere elaborata dal broker messaggi prima che il messaggio pubblicato venga inviato agli iscritti. Le voci nel file di registro dimostrano che i messaggi sono stati ricevuti. È possibile ripetere questa procedura utilizzando altri nomi di argomenti. Tutti i messaggi con un nome argomento che iniziano per `test/dc/` devono essere ricevuti e registrati. I messaggi con nomi di argomenti che iniziano con qualsiasi altro testo vengono ignorati. Dopo aver dimostrato come AWS IoT Device Client può pubblicare e sottoscrivere messaggi MQTT, continua con. [Tutorial: Dimostra le azioni (lavori) remote con il AWS IoT Device Client](iot-dc-runjobs.md)