Avviso di fine del supporto: il 7 ottobre 2026, AWS il supporto per. AWS IoT Greengrass Version 1 Dopo il 7 ottobre 2026, non potrai più accedere alle risorse. AWS IoT Greengrass V1 Per ulteriori informazioni, visita [Migrate](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html) from. AWS IoT Greengrass Version 1
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à.
# Integrazione con servizi e protocolli tramite i connettori Greengrass
Questa funzionalità è disponibile per AWS IoT Greengrass Core v1.7 e versioni successive.
I connettori AWS IoT Greengrass sono moduli predefiniti che rendono più efficiente l'interazione con l'infrastruttura locale, i protocolli dei dispositivi e altri servizi cloud. AWS Utilizzando i connettori, puoi dedicare meno tempo all'apprendimento di nuovi protocolli APIs e dedicare più tempo alla logica che conta per la tua azienda.
Il diagramma seguente mostra dove i connettori possono inserirsi nel AWS IoT Greengrass panorama.
![\[I connettori si connettono a dispositivi, servizi e risorse locali.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/connectors/connectors-arch.png)
Molti connettori utilizzano messaggi MQTT per comunicare con i dispositivi client e le funzioni Greengrass Lambda del gruppo AWS IoT o con il servizio shadow locale. Nell'esempio seguente, il connettore Twilio Notifications riceve messaggi MQTT da una funzione Lambda definita dall'utente, utilizza un riferimento locale di un segreto Gestione dei segreti AWS da e chiama l'API Twilio.
![\[Un connettore che riceve un messaggio MQTT da una funzione Lambda e chiama un servizio.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/connectors/twilio-solution.png)
Per i tutorial sulla creazione di questa soluzione, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md) e [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md).
I connettori Greengrass possono aiutarti a estendere le funzionalità dei dispositivi o a creare dispositivi monouso. Utilizzando i connettori, è possibile:
+ L'implementazione di una logica di business riutilizzabile.
+ Interagisci con servizi cloud e locali, inclusi AWS servizi di terze parti.
+ L'integrazione e l'elaborazione dei dati del dispositivo.
+ Abilita device-to-device le chiamate utilizzando gli abbonamenti agli argomenti MQTT e le funzioni Lambda definite dall'utente.
AWS fornisce una serie di connettori Greengrass che semplificano le interazioni con servizi e fonti di dati comuni. Questi moduli precostituiti attivano gli scenari di logging e diagnostica, rifornimento, elaborazione dei dati industriali, allarmi e messaggistica. Per ulteriori informazioni, consulta [AWS-connettori Greengrass forniti](connectors-list.md).
## Requisiti
Per utilizzare i connettori, tieni presente questi punti:
+ Ogni connettore che utilizzi ha dei requisiti che devi soddisfare. Questi requisiti possono includere la versione minima del software AWS IoT Greengrass Core, i prerequisiti del dispositivo, le autorizzazioni e i limiti richiesti. Per ulteriori informazioni, consulta [AWS-connettori Greengrass forniti](connectors-list.md).
+ Un gruppo Greengrass può contenere solo un'istanza configurata di un determinato connettore. Tuttavia, è possibile utilizzare l'istanza in più abbonamenti. Per ulteriori informazioni, consulta [Parametri di configurazione](#connectors-parameters).
+ Quando la [containerizzazione predefinita](lambda-group-config.md#lambda-containerization-groupsettings) per il gruppo Greengrass è impostata su **Nessun container**, i connettori del gruppo devono essere eseguiti senza containerizzazione. Per trovare i connettori che supportano la modalità **Nessun container** consulta [AWS-connettori Greengrass forniti](connectors-list.md).
## Utilizzo dei connettori Greengrass
Un connettore è un tipo di componente di gruppo. Come altri componenti del gruppo, come i dispositivi client e le funzioni Lambda definite dall'utente, puoi aggiungere connettori ai gruppi, configurarne le impostazioni e distribuirli nel core. AWS IoT Greengrass I connettori vengono eseguiti nell'ambiente core.
È possibile distribuire alcuni connettori come semplici applicazioni autonome. Ad esempio, il connettore Device Defender legge le metriche di sistema dal dispositivo principale e le invia per l'analisi. AWS IoT Device Defender
È possibile aggiungere altri connettori come elementi costitutivi in soluzioni più grandi. La seguente soluzione di esempio utilizza il connettore Modbus-RTU Protocol Adapter per elaborare i messaggi provenienti dai sensori e il connettore Twilio Notifications per avviare i messaggi Twilio.
![\[Flusso di dati dalla funzione Lambda al connettore Modbus-RTU Protocol Adapter alla funzione Lambda al connettore Twilio Notifications a Twilio.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/connectors/modbus-twilio-solution.png)
Le soluzioni spesso includono funzioni Lambda definite dall'utente che si trovano accanto ai connettori ed elaborano i dati che il connettore invia o riceve. In questo esempio, la TempMonitor funzione riceve dati dall'adattatore di protocollo Modbus-RTU, esegue alcune logiche aziendali e quindi invia i dati a Twilio Notifications.
Di seguito è riportata la procedura generica per creare e distribuire una soluzione:
1. Definire il flusso di dati di alto livello. Identificare le origini dati, i canali dei dati, i servizi, i protocolli e le risorse di cui hai bisogno. In questa soluzione di esempi, sono inclusi dati sul protocollo RTU Modbus, la porta seriale Modbus fisica e Twilio.
1. Individuare i connettori da includere nella soluzione e aggiungerli al gruppo. La soluzione di esempio utilizza l'adattatore di protocollo Modbus-RTU e le notifiche Twilio. Per aiutarti a trovare i connettori adeguati al tuo scenario e per ulteriori informazioni sui singoli requisiti, consulta [AWS-connettori Greengrass forniti](connectors-list.md).
1. Identifica se sono necessarie funzioni Lambda, dispositivi client o risorse definite dall'utente, quindi creali e aggiungili al gruppo. Questo passaggio potrebbe includere funzioni che contengono logica di business o l'elaborazione di dati in un formato richiesto da un'altra entità della soluzione. La soluzione di esempio utilizza funzioni per inviare richieste Modbus RTU e avviare notifiche Twilio. Include anche una risorsa dispositivo locale per la porta seriale RTU Modbus e una risorsa segreta per il token di autenticazione Twilio.
**Nota**
Le risorse segrete fanno riferimento a password, token e altri segreti di Gestione dei segreti AWS. I segreti possono essere utilizzati dai connettori e dalle funzioni Lambda per l'autenticazione con servizi e applicazioni. Per impostazione predefinita, AWS IoT Greengrass può accedere ai segreti con nomi che iniziano con "*greengrass-*». Per ulteriori informazioni, consulta [Implementa i segreti fino al nucleo AWS IoT Greengrass](secrets.md).
1. Creazione di sottoscrizioni che consentono alle entità della soluzione di scambiarsi messaggi MQTT. Se un connettore viene utilizzato in una sottoscrizione, il connettore e il messaggio di origine o di destinazione devono utilizzare la sintassi dell'argomento predefinita supportata dal connettore. Per ulteriori informazioni, consulta [Input e output](#connectors-inputs-outputs).
1. Distribuzione del gruppo nel core Greengrass
Per informazioni sulla creazione e la distribuzione di un connettore, consulta i seguenti tutorial:
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
## Parametri di configurazione
Molti connettori forniscono parametri che consentono di personalizzarne il funzionamento o l'output. Questi parametri vengono utilizzati durante l'inizializzazione, in fase di runtime o in altri momenti del ciclo di vita del connettore.
I tipi di parametri e il relativo utilizzo possono variare in base al connettore. Ad esempio, il connettore SNS ha un parametro che configura l'argomento SNS predefinito e Device Defender ha un parametro che configura la frequenza di campionamento dei dati.
Una versione di gruppo può contenere vari connettori, ma una sola istanza alla volta di un determinato connettore. Questo significa che ciascun connettore nel gruppo può avere solo una configurazione attiva. Tuttavia, l'istanza del connettore può essere utilizzata in più sottoscrizioni nel gruppo. Ad esempio, è possibile creare abbonamenti che consentono a molti dispositivi di inviare dati al connettore Kinesis Firehose.
### Parametri utilizzati per l'accesso alle risorse di gruppo
I connettori Greengrass utilizzano le risorse di gruppo per accedere al file system, alle porte, alle periferiche e ad altre risorse locali sul dispositivo core. Se un connettore richiede l'accesso a una risorsa di gruppo, fornirà i relativi parametri di configurazione.
Le risorse di gruppo includono:
+ [Risorse locali](access-local-resources.md). Directory, file, porte, pin e periferiche presenti sul dispositivo core Greengrass.
+ [Risorse di Machine Learning](ml-inference.md). Modelli Machine Learning che ricevono formazione nel cloud e vengono distribuiti al core per un'inferenza locale.
+ [Risorse segrete](secrets.md). Copie locali crittografate di password, chiavi, token o testo arbitrario da. Gestione dei segreti AWS I connettori possono accedere in modo sicuro a questi segreti locali e utilizzarli per autenticare i servizi o l'infrastruttura locale.
Ad esempio, i parametri per Device Defender consentono l'accesso alle metriche di sistema nella `/proc` directory host e i parametri per le notifiche Twilio consentono l'accesso a un token di autenticazione Twilio memorizzato localmente.
### Aggiornamento dei parametri del connettore
I parametri sono configurati quando il connettore viene aggiunto a un gruppo Greengrass. È possibile modificare i valori dei parametri dopo l'aggiunta del connettore.
+ Nella console: dalla pagina di configurazione del gruppo, apri **Connettori** e dal menu contestuale del connettore scegli **Modifica**.
**Nota**
Se il connettore utilizza una risorsa segreta che successivamente verrà modificata per fare riferimento a un altro segreto, è necessario modificare i parametri del connettore e confermare la modifica.
+ Nell'API: crea un'altra versione del connettore che definisca la nuova configurazione.
L' AWS IoT Greengrass API utilizza versioni per gestire i gruppi. Le versioni sono immutabili, quindi per aggiungere o modificare i componenti del gruppo, ad esempio i dispositivi client, le funzioni e le risorse del gruppo, è necessario creare versioni di componenti nuovi o aggiornati. Quindi, si crea e si distribuisce una versione di gruppo che contiene la versione di destinazione di ciascun componente.
Dopo aver modificato la configurazione del connettore, è necessario distribuire il gruppo per propagare le modifiche apportate al core.
## Input e output
Molti connettori Greengrass possono comunicare con altre entità inviando e ricevendo messaggi MQTT. La comunicazione MQTT è controllata da abbonamenti che consentono a un connettore di scambiare dati con funzioni Lambda, dispositivi client e altri connettori del gruppo Greengrass o con AWS IoT e il servizio shadow locale. Per consentire questa comunicazione, devi creare sottoscrizioni nel gruppo a cui appartiene il connettore. Per ulteriori informazioni, consulta [Sottoscrizioni gestite nel flusso di lavoro di messaggistica MQTT](gg-sec.md#gg-msg-workflow).
I connettori possono essere autori di messaggi, abbonati ai messaggi o entrambi. Ogni connettore definisce gli argomenti MQTT che pubblica o a cui è abbonato. Questi argomenti predefiniti devono essere utilizzati nelle sottoscrizioni in cui il connettore è l'origine o la destinazione di un messaggio. Per i tutorial che includono le fasi di configurazione delle sottoscrizioni a un connettore, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md) e [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md).
**Nota**
Molti connettori dispongono anche di modalità di comunicazione integrate per interagire con il cloud o i servizi locali. Queste variano in base al connettore e potrebbero richiedere la configurazione di parametri o l'aggiunta di autorizzazioni al [ruolo del gruppo](group-role.md). Per informazioni sui requisiti del connettore, consultare [AWS-connettori Greengrass forniti](connectors-list.md).
### Argomenti di input
La maggior dei connettori ricevono dati su argomenti MQTT. Alcuni connettori effettuano la sottoscrizione a più argomenti per i dati di input. Ad esempio, il connettore Serial Stream supporta due argomenti:
+ `serial/+/read/#`
+ `serial/+/write/#`
Per questo connettore, le richieste di lettura e scrittura vengono inviate all'argomento corrispondente. Quando crei gli abbonamenti, assicurati di utilizzare l'argomento in linea con l'implementazione.
I caratteri `+` e `#` negli esempi precedenti sono caratteri jolly. Questi caratteri jolly consentono agli abbonati di ricevere messaggi su più argomenti e agli autori di personalizzare gli argomenti di destinazione.
+ Il carattere jolly `+` appare ovunque nella gerarchia degli argomenti. Può essere sostituito da una voce della gerarchia.
Ad esempio, per l'argomento `sensor/+/input`, i messaggi possono essere pubblicati negli argomenti `sensor/id-123/input`, ma non in `sensor/group-a/id-123/input`.
+ Il carattere jolly `#` può comparire solo alla fine della gerarchia dell'argomento. Può essere sostituito da zero o più elementi della gerarchia.
Ad esempio, per l'argomento `sensor/#`, i messaggi possono essere pubblicati in `sensor/`, `sensor/id-123` e `sensor/group-a/id-123`, ma non in `sensor`.
I caratteri jolly sono validi solo per l'abbonamento agli argomenti. Non è possibile pubblicare messaggi in argomenti contenenti caratteri jolly. Consulta la documentazione del connettore per ulteriori informazioni sui requisiti degli argomenti di input o output. Per ulteriori informazioni, consulta [AWS-connettori Greengrass forniti](connectors-list.md).
## Supporto per la containerizzazione
Per impostazione predefinita, la maggior parte dei connettori viene eseguita sul core di Greengrass in un ambiente di runtime isolato gestito da AWS IoT Greengrass. Questi ambienti di runtime, denominati *container*, forniscono l'isolamento tra i connettori e il sistema host, offrendo maggiore sicurezza per l'host e il connettore.
Tuttavia, questa containerizzazione Greengrass non è supportata in alcuni ambienti, ad esempio quando si esegue AWS IoT Greengrass in un contenitore Docker o su vecchi kernel Linux senza cgroup. In questi ambienti, i connettori devono essere eseguiti in modalità **No container (Nessun container)** . Per trovare i connettori che supportano la modalità **Nessun container** consulta [AWS-connettori Greengrass forniti](connectors-list.md). Alcuni connettori vengono eseguiti in questa modalità in modo nativo e alcuni connettori consentono di impostare la modalità di isolamento.
Puoi inoltre impostare la modalità di isolamento su **No container (Nessun container)** in ambienti che supportano la containerizzazione di Greengrass, ma consigliamo di utilizzare la modalità **Greengrass container (Container Greengrass)** quando possibile.
**Nota**
L'impostazione predefinita della containerizzazione per il gruppo Greengrass non si applica ai [connettori](lambda-group-config.md#lambda-containerization-groupsettings).
## Aggiornamento delle versioni dei connettori
I provider di connettori potrebbero rilasciare nuove versioni di un connettore che aggiungono funzionalità, risolvono problemi o migliorano le prestazioni. Per informazioni sulle versioni disponibili e sulle modifiche correlate, consulta la [documentazione relativa a ciascun connettore](connectors-list.md).
Nella AWS IoT console, puoi verificare la presenza di nuove versioni per i connettori del tuo gruppo Greengrass.
1. Nel riquadro di navigazione della AWS IoT console, in **Gestione**, espandi **i dispositivi Greengrass**, quindi scegli **Gruppi (V1**).
1. In **Gruppi Greengrass**, scegli il tuo gruppo.
1. Scegli **Connectors (Connettori)** per visualizzare i connettori nel gruppo.
Se il connettore ha una nuova versione, viene visualizzato un pulsante **Disponibile** nella colonna **Aggiorna**.
1. Per aggiornare la versione del connettore:
1. Nella pagina **Connettori**, nella colonna **Aggiornamento**, scegli **Disponibile**. Viene visualizzata la pagina **Upgrade connector (Aggiorna connettore)** in cui vengono visualizzate le impostazioni dei parametri correnti, se applicabili.
Scegli la nuova versione del connettore, definisci i parametri in base alle esigenze, quindi scegli **Upgrade (Aggiorna)**.
1. Nella pagina **Subscriptions (Sottoscrizioni)** aggiungi nuove sottoscrizioni nel gruppo per sostituire quelle che utilizzano il connettore come origine o destinazione. Quindi, rimuovi le vecchie sottoscrizioni.
Le sottoscrizioni fanno riferimento ai connettori in base alla versione, in modo che diventino non validi se si modifica la versione del connettore nel gruppo.
1. Dal menu **Azioni**, scegli **Distribuisci** per distribuire le modifiche al core.
Per aggiornare un connettore dall' AWS IoT Greengrass API, crea e distribuisci una versione di gruppo che includa il connettore e gli abbonamenti aggiornati. Utilizza lo stesso processo seguito per aggiungere un connettore a un gruppo. Per i passaggi dettagliati che mostrano come utilizzare il connettore di notifica Twilio di esempio AWS CLI per configurare e distribuire un esempio di connettore di notifica Twilio, consulta. [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
## Registrazione per connettori
I connettori Greengrass contengono funzioni Lambda che scrivono eventi ed errori nei log Greengrass. A seconda delle impostazioni del gruppo, i log vengono scritti in CloudWatch Logs, nel file system locale o in entrambi. I log dei connettori includono gli ARN della funzione corrispondente. L'esempio ARN seguente proviene dal connettore Kinesis Firehose:
```
arn:aws:lambda:aws-region:account-id:function:KinesisFirehoseClient:1
```
La configurazione di logging predefinita scrive log a livello di informazioni nel file system con la seguente struttura di directory:
```
greengrass-root/ggc/var/log/user/region/aws/function-name.log
```
Per ulteriori informazioni sulla registrazione di Greengrass, vedere. [Monitoraggio con AWS IoT Greengrass registri](greengrass-logs-overview.md)
# AWS-connettori Greengrass forniti
AWS fornisce i seguenti connettori che supportano AWS IoT Greengrass scenari comuni. Per ulteriori informazioni sul funzionamento dei connettori, consulta la documentazione seguente:
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori (console)](connectors-console.md) o [Nozioni di base sui connettori (CLI)](connectors-cli.md)
| Connector | Descrizione | Runtime Lambda supportati | Supporta la modalità **Nessun container** |
| --- | --- | --- | --- |
| [CloudWatch Metriche](cloudwatch-metrics-connector.md) | Pubblica metriche personalizzate su Amazon. CloudWatch | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | Sì |
| [Dispositivo Defender](device-defender-connector.md) | Invia le metriche di sistema a. AWS IoT Device Defender | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | No |
| [Distribuzione delle applicazioni Docker](docker-app-connector.md) | Esegue un file di Docker Compose per avviare un'applicazione Docker sul dispositivo core. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | Sì |
| [IoT Analytics](iot-analytics-connector.md) | Invia dati da dispositivi e sensori a AWS IoT Analytics. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | Sì |
| [Adattatore di protocollo IP Ethernet IoT](ethernet-ip-connector.md) | Raccoglie dati dai dispositivi EtherNet/IP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | Sì |
| [IoT SiteWise](iot-sitewise-connector.md) | Invia i dati provenienti da dispositivi e sensori a proprietà degli asset in AWS IoT SiteWise. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | Sì |
| [Kinesis Firehose](kinesis-firehose-connector.md) | Invia dati ai flussi di distribuzione di Amazon Data Firehose. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | Sì |
| [Feedback ML](ml-feedback-connector.md) | Pubblica l'input del modello di machine learning nel cloud e l'output in un argomento MQTT. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | No |
| [Classificazione delle immagini ML](image-classification-connector.md) | Esegue un servizio locale di inferenza di classificazione delle immagini. Questo connettore fornisce le versioni per diverse piattaforme. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | No |
| [Rilevamento di oggetti ML](obj-detection-connector.md) | Esegue un servizio di inferenza di rilevamento oggetti locale. Questo connettore fornisce le versioni per diverse piattaforme. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | No |
| [Adattatore di protocollo Modbus-RTU](modbus-protocol-adapter-connector.md) | Invia le richieste ai dispositivi RTU Modbus. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | No |
| [Adattatore di protocollo Modbus-TCP](modbus-tcp-connector.md) | Raccoglie dati dai dispositivi ModbusTCP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | Sì |
| [Raspberry Pi GPIO](raspberrypi-gpio-connector.md) | Controlla i pin GPIO in un dispositivo core Raspberry Pi. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | No |
| [Flusso seriale](serial-stream-connector.md) | Effettua operazioni di lettura e scrittura in una porta seriale del dispositivo core. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | No |
| [ServiceNow MetricBase Integration](servicenow-connector.md) | Pubblica le metriche delle serie temporali su. ServiceNow MetricBase | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | Sì |
| [SNS](sns-connector.md) | Invia messaggi a un argomento di Amazon SNS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | Sì |
| [Integrazione con Splunk](splunk-connector.md) | Pubblica dati su Splunk HEC. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | Sì |
| [Notifiche Twilio](twilio-notifications-connector.md) | Avvia un messaggio di testo o vocale Twilio. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-list.html) | Sì |
\$1 Per utilizzare i runtime di Python 3.8, è necessario creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati. Per ulteriori informazioni, consulta i requisiti specifici del connettore.
**Nota**
Si consiglia di [aggiornare le versioni dei connettori](connectors.md#upgrade-connector-versions) da Python 2.7 a Python 3.7. Il supporto continuo per i connettori Python 2.7 dipende dal supporto in AWS Lambda fase di esecuzione. Per ulteriori informazioni, consulta la [politica di supporto di Runtime](https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html) nella *AWS Lambda Developer Guide*.
# CloudWatch Connettore Metrics
Il [connettore CloudWatch ](connectors.md) Metrics pubblica metriche personalizzate dai dispositivi Greengrass su Amazon. CloudWatch Il connettore fornisce un'infrastruttura centralizzata per la pubblicazione delle CloudWatch metriche, che puoi utilizzare per monitorare e analizzare l'ambiente principale di Greengrass e agire sugli eventi locali. Per ulteriori informazioni, consulta [Using Amazon CloudWatch metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) nella *Amazon CloudWatch User Guide*.
Questo connettore riceve i dati dei parametri come messaggi MQTT. Il connettore raggruppa i parametri che si trovano nello stesso namespace e li pubblica a intervalli regolari. CloudWatch
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 5 | `arn:aws:greengrass:region::/connectors/CloudWatchMetrics/versions/5` |
| 4 | `arn:aws:greengrass:region::/connectors/CloudWatchMetrics/versions/4` |
| 3 | `arn:aws:greengrass:region::/connectors/CloudWatchMetrics/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/CloudWatchMetrics/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/CloudWatchMetrics/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#cloudwatch-metrics-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 3 - 5 ]
+ AWS IoT Greengrass Software principale v1.9.3 o versione successiva.
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ Il [ruolo del gruppo Greengrass](group-role.md) è configurato per consentire l'`cloudwatch:PutMetricData`azione, come illustrato nel seguente esempio di policy AWS Identity and Access Management (IAM).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Stmt1528133056761",
"Action": [
"cloudwatch:PutMetricData"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
Per ulteriori informazioni sulle CloudWatch autorizzazioni, consulta [Amazon CloudWatch permissions reference](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/permissions-reference-cw.html) nella *IAM User* Guide.
------
#### [ Versions 1 - 2 ]
+ AWS IoT Greengrass Software di base v1.7 o successivo.
+ [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH.
+ Il [ruolo del gruppo Greengrass](group-role.md) è configurato per consentire l'`cloudwatch:PutMetricData`azione, come illustrato nel seguente esempio di policy AWS Identity and Access Management (IAM).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Stmt1528133056761",
"Action": [
"cloudwatch:PutMetricData"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
Per ulteriori informazioni sulle CloudWatch autorizzazioni, consulta [Amazon CloudWatch permissions reference](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/permissions-reference-cw.html) nella *IAM User* Guide.
------
## Parametri del connettore
Questo connettore fornisce i seguenti parametri:
------
#### [ Versions 4 - 5 ]
`PublishInterval`
Il numero massimo di secondi di attesa prima di pubblicare i parametri raggruppati per un dato spazio dei nomi. Il valore massimo è 900. Per configurare il connettore in modo da pubblicare i parametri man mano che vengono ricevuti (senza raggruppamento), specificare 0.
Il connettore pubblica su CloudWatch dopo aver ricevuto 20 metriche nello stesso namespace o dopo l'intervallo specificato.
Il connettore non garantisce l'ordine degli eventi di pubblicazione.
**Nome visualizzato nella console: Intervallo di pubblicazione AWS IoT **
Obbligatorio: `true`
Tipo: `string`
Valori validi: `0 - 900`
Schema valido: `[0-9]|[1-9]\d|[1-9]\d\d|900`
`PublishRegion`
Il file Regione AWS su cui pubblicare le CloudWatch metriche. Questo valore sostituisce la regione predefinita dei parametri Greengrass. È obbligatorio solo durante la pubblicazione di parametri tra regioni.
Nome visualizzato nella AWS IoT console: regione di **pubblicazione**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^$|([a-z]{2}-[a-z]+-\d{1})`
`MemorySize`
La memoria (in KB) da allocare al connettore.
Nome visualizzato nella AWS IoT console: **dimensione della memoria**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[0-9]+$`
`MaxMetricsToRetain`
Il numero massimo di parametri in tutti gli spazi dei nomi da salvare in memoria prima che vengano sostituiti da nuovi parametri. Il valore minimo è 2000.
Questo limite è valido quando non è presente una connessione a Internet e il connettore inizia il buffering dei parametri da pubblicare successivamente. Quando il buffer è pieno, i parametri meno recenti vengono sostituiti da quelli nuovi. I parametri in un determinato spazio dei nomi vengono sostituiti solo da quelli dello stesso spazio dei nomi.
I parametri non vengono salvati se si interrompe il processo host del connettore. Ad esempio, questa interruzione potrebbe verificarsi durante la distribuzione dei gruppi o al riavvio del dispositivo.
Nome visualizzato nella AWS IoT console: **numero massimo di metriche da conservare**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `^([2-9]\d{3}|[1-9]\d{4,})$`
`IsolationMode`
Modalità di [containerizzazione](connectors.md#connector-containerization) per questo connettore. L'impostazione predefinita è`GreengrassContainer`, il che significa che il connettore viene eseguito in un ambiente di runtime isolato all'interno del AWS IoT Greengrass contenitore.
L'impostazione predefinita della containerizzazione per il gruppo non si applica ai connettori.
Nome visualizzato nella AWS IoT console: **modalità di isolamento del contenitore**
Obbligatorio: `false`
Tipo: `string`
Valori validi: `GreengrassContainer` o `NoContainer`
Modello valido: `^NoContainer$|^GreengrassContainer$`
------
#### [ Versions 1 - 3 ]
`PublishInterval`
Il numero massimo di secondi di attesa prima di pubblicare i parametri raggruppati per un dato spazio dei nomi. Il valore massimo è 900. Per configurare il connettore in modo da pubblicare i parametri man mano che vengono ricevuti (senza raggruppamento), specificare 0.
Il connettore pubblica su CloudWatch dopo aver ricevuto 20 metriche nello stesso namespace o dopo l'intervallo specificato.
Il connettore non garantisce l'ordine degli eventi di pubblicazione.
**Nome visualizzato nella console: Intervallo di pubblicazione AWS IoT **
Obbligatorio: `true`
Tipo: `string`
Valori validi: `0 - 900`
Schema valido: `[0-9]|[1-9]\d|[1-9]\d\d|900`
`PublishRegion`
Il file Regione AWS su cui pubblicare le CloudWatch metriche. Questo valore sostituisce la regione predefinita dei parametri Greengrass. È obbligatorio solo durante la pubblicazione di parametri tra regioni.
Nome visualizzato nella AWS IoT console: regione di **pubblicazione**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^$|([a-z]{2}-[a-z]+-\d{1})`
`MemorySize`
La memoria (in KB) da allocare al connettore.
Nome visualizzato nella AWS IoT console: **dimensione della memoria**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[0-9]+$`
`MaxMetricsToRetain`
Il numero massimo di parametri in tutti gli spazi dei nomi da salvare in memoria prima che vengano sostituiti da nuovi parametri. Il valore minimo è 2000.
Questo limite è valido quando non è presente una connessione a Internet e il connettore inizia il buffering dei parametri da pubblicare successivamente. Quando il buffer è pieno, i parametri meno recenti vengono sostituiti da quelli nuovi. I parametri in un determinato spazio dei nomi vengono sostituiti solo da quelli dello stesso spazio dei nomi.
I parametri non vengono salvati se si interrompe il processo host del connettore. Ad esempio, questa interruzione potrebbe verificarsi durante la distribuzione dei gruppi o al riavvio del dispositivo.
Nome visualizzato nella AWS IoT console: **numero massimo di metriche da conservare**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `^([2-9]\d{3}|[1-9]\d{4,})$`
------
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea un `ConnectorDefinition` con una versione iniziale che contiene il connettore CloudWatch Metrics.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyCloudWatchMetricsConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/CloudWatchMetrics/versions/4",
"Parameters": {
"PublishInterval" : "600",
"PublishRegion" : "us-west-2",
"MemorySize" : "16",
"MaxMetricsToRetain" : "2500",
"IsolationMode" : "GreengrassContainer"
}
}
]
}'
```
Nella AWS IoT Greengrass console, puoi aggiungere un connettore dalla pagina **Connettori** del gruppo. Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md).
## Dati di input
Questo connettore accetta metriche su un argomento MQTT e le pubblica su. CloudWatch I messaggi di input devono essere in formato JSON.
**Filtro argomento in sottoscrizione**
`cloudwatch/metric/put`
**Proprietà dei messaggi**
`request`
Informazioni sui parametri di questo messaggio.
L'oggetto della richiesta contiene i dati dei parametri da pubblicare in CloudWatch. I valori delle metriche devono soddisfare le specifiche dell'[https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html)API. Sono obbligatorie solo le proprietà `namespace`, `metricData.metricName` e `metricData.value`.
Obbligatorio: `true`
Tipo: `object` che include le seguenti proprietà:
`namespace`
Lo spazio dei nomi definito dall'utente per i dati metrici in questa richiesta. CloudWatch utilizza i namespace come contenitori per i punti dati metrici.
Non è possibile specificare uno spazio dei nomi che inizi con la stringa riservata. `AWS/`
Obbligatorio: `true`
Tipo: `string`
Modello valido: `[^:].*`
`metricData`
I dati del parametro.
Obbligatorio: `true`
Tipo: `object` che include le seguenti proprietà:
`metricName`
Nome del parametro.
Obbligatorio: `true`
Tipo: `string`
`dimensions`
Le dimensioni associate al parametro. Le dimensioni forniscono ulteriori informazioni sul parametro e sui relativi dati. Un parametro è in grado di definire fino a 10 dimensioni.
Questo connettore include automaticamente una dimensione denominata`coreName`, dove il valore è il nome del core.
Obbligatorio: `false`
Tipo: `array` di oggetti dimensionali che includono le seguenti proprietà:
`name`
Il nome della dimensione.
Obbligatorio: `false`
Tipo: `string`
`value`
Il valore della dimensione.
Obbligatorio: `false`
Tipo: `string`
`timestamp`
L'ora in cui i dati della metrica sono stati ricevuti, espressa come numero di secondi trascorsi da allora`Jan 1, 1970 00:00:00 UTC`. Se questo valore viene omesso, il connettore utilizza l'ora di ricezione del messaggio.
Obbligatorio: `false`
Tipo: `timestamp`
Se utilizzi tra le versioni 1 e 4 di questo connettore, ti consigliamo di recuperare il timestamp separatamente per ogni metrica quando invii più metriche da un'unica fonte. Non utilizzare una variabile per memorizzare il timestamp.
`value`
Il valore del parametro.
CloudWatch rifiuta valori troppo piccoli o troppo grandi. I valori devono essere compresi nell'intervallo da `8.515920e-109` a `1.174271e+108` (Base 10) o da `2e-360` a `2e360` (Base 2). I valori speciali (ad esempio, `NaN`, `+Infinity`, `-Infinity`) non sono supportati.
Obbligatorio: `true`
Tipo: `double`
`unit`
Unità del parametro.
Obbligatorio: `false`
Tipo: `string`
Valori validi: `Seconds, Microseconds, Milliseconds, Bytes, Kilobytes, Megabytes, Gigabytes, Terabytes, Bits, Kilobits, Megabits, Gigabits, Terabits, Percent, Count, Bytes/Second, Kilobytes/Second, Megabytes/Second, Gigabytes/Second, Terabytes/Second, Bits/Second, Kilobits/Second, Megabits/Second, Gigabits/Second, Terabits/Second, Count/Second, None`
Limits
Tutti i limiti imposti dall' CloudWatch [https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html)API si applicano alle metriche quando si utilizza questo connettore. Di seguito sono riportati i limiti particolarmente importanti:
+ Limite di 40 KB sul payload dell'API
+ 20 parametri per ciascuna richiesta API
+ 150 transazioni al secondo (TPS) per l'API `PutMetricData`
Per ulteriori informazioni, consulta [CloudWatch i limiti](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_limits.html) nella *Amazon CloudWatch User Guide*.
**Input di esempio**
```
{
"request": {
"namespace": "Greengrass",
"metricData":
{
"metricName": "latency",
"dimensions": [
{
"name": "hostname",
"value": "test_hostname"
}
],
"timestamp": 1539027324,
"value": 123.0,
"unit": "Seconds"
}
}
}
```
## Dati di output
Questo connettore pubblica le informazioni di stato come dati di output su un argomento MQTT.
**Filtro argomento in sottoscrizione**
`cloudwatch/metric/put/status`
**Output di esempio: Operazione riuscita**
La risposta include lo spazio dei nomi dei dati metrici e il `RequestId` campo della risposta. CloudWatch
```
{
"response": {
"cloudwatch_rid":"70573243-d723-11e8-b095-75ff2EXAMPLE",
"namespace": "Greengrass",
"status":"success"
}
}
```
**Esempio di output: Errore**
```
{
"response" : {
"namespace": "Greengrass",
"error": "InvalidInputException",
"error_message":"cw metric is invalid",
"status":"fail"
}
}
```
Se il connettore rileva un errore ripetibile (ad esempio errori di connessione), riprova la pubblicazione nel batch successivo.
## Esempio di utilizzo
Usa i seguenti passaggi di alto livello per configurare una funzione Lambda di esempio di Python 3.7 che puoi usare per provare il connettore.
**Nota**
Se usi altri runtime Python, puoi creare un collegamento simbolico da Python3.x a Python 3.7.
Gli argomenti [Nozioni di base sui connettori (console)](connectors-console.md) e [Nozioni di base sui connettori (CLI)](connectors-cli.md) contengono passaggi dettagliati che illustrano come configurare e distribuire un connettore Twilio Notifications di esempio.
1. Assicurarsi di soddisfare i [requisiti](#cloudwatch-metrics-connector-req) per il connettore.
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
1. Crea e pubblica una funzione Lambda che invia dati di input al connettore.
Salvare il [codice di esempio](#cloudwatch-metrics-connector-usage-example) come file PY. Scarica e decomprimi il [AWS IoT Greengrass Core SDK per Python](lambda-functions.md#lambda-sdks-core). Quindi, crea un pacchetto zip che contiene il file PY e la cartella `greengrasssdk` a livello root. Questo pacchetto zip è il pacchetto di distribuzione in cui carichi. AWS Lambda
Dopo aver creato la funzione Python 3.7 Lambda, pubblica una versione della funzione e crea un alias.
1. Configurare il gruppo Greengrass.
1. Aggiungi la funzione Lambda tramite il relativo alias (consigliato). Configura il ciclo di vita Lambda come longevo (o nella `"Pinned": true` CLI).
1. Aggiungere il connettore e configurarne i relativi [parametri](#cloudwatch-metrics-connector-param).
1. Aggiungere sottoscrizioni che consentono al connettore di ricevere [i dati di input](#cloudwatch-metrics-connector-data-input) e inviare [i dati di output](#cloudwatch-metrics-connector-data-output) nei filtri degli argomenti supportati.
+ Imposta la funzione Lambda come origine, il connettore come destinazione e utilizza un filtro per argomenti di input supportato.
+ Imposta il connettore come origine, AWS IoT Core come destinazione e utilizza un filtro per l’argomento di output supportato. Utilizzi questo abbonamento per visualizzare i messaggi di stato nella AWS IoT console.
1. Distribuisci il gruppo.
1. Nella AWS IoT console, nella pagina **Test**, sottoscrivi l'argomento relativo ai dati di output per visualizzare i messaggi di stato dal connettore. La funzione Lambda di esempio è di lunga durata e inizia a inviare messaggi subito dopo l'implementazione del gruppo.
Al termine del test, puoi impostare il ciclo di vita Lambda su richiesta (o nella CLI) e `"Pinned": false` distribuire il gruppo. Ciò impedisce alla funzione di inviare messaggi.
### Esempio
L'esempio seguente della funzione Lambda invia un messaggio di input al connettore.
```
import greengrasssdk
import time
import json
iot_client = greengrasssdk.client('iot-data')
send_topic = 'cloudwatch/metric/put'
def create_request_with_all_fields():
return {
"request": {
"namespace": "Greengrass_CW_Connector",
"metricData": {
"metricName": "Count1",
"dimensions": [
{
"name": "test",
"value": "test"
}
],
"value": 1,
"unit": "Seconds",
"timestamp": time.time()
}
}
}
def publish_basic_message():
messageToPublish = create_request_with_all_fields()
print("Message To Publish: ", messageToPublish)
iot_client.publish(topic=send_topic,
payload=json.dumps(messageToPublish))
publish_basic_message()
def lambda_handler(event, context):
return
```
## Licenze
Il connettore CloudWatch Metrics include i seguenti software/licenze di terze parti:
+ [AWS SDK per Python (Boto3)](https://pypi.org/project/boto3/)/Apache License 2.0
+ [botocore](https://pypi.org/project/botocore/)/Apache License 2.0
+ [dateutil](https://pypi.org/project/python-dateutil/1.4/)/PSF License
+ [docutils](https://pypi.org/project/docutils/)/BSD License, GNU General Public License (GPL), Python Software Foundation License, Public Domain
+ [jmespath](https://pypi.org/project/jmespath/)/MIT License
+ [s3transfer](https://pypi.org/project/s3transfer/)/Apache License 2.0
+ [urllib3](https://pypi.org/project/urllib3/)/MIT License
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche |
| --- | --- |
| 5 | Correzione dell'aggiunta del supporto per timestamp duplicati nei dati di input. |
| 4 | Aggiunto il parametro `IsolationMode` per configurare la modalità di containerizzazione per il connettore. |
| 3 | È stato aggiornato il runtime Lambda a Python 3.7, che modifica i requisiti di runtime. |
| 2 | Correggere per ridurre l'eccessiva registrazione di log. |
| 1 | Versione iniziale. |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
+ [Utilizzo dei CloudWatch parametri di Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) nella *Amazon CloudWatch User Guide*
+ [ PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html)nell'*Amazon CloudWatch API Reference*
# Connettore Device Defender
Il [connettore](connectors.md) Device Defender notifica agli amministratori le modifiche allo stato di un dispositivo core Greengrass. Ciò consente di identificare un comportamento anomalo che potrebbe indicare la compromissione del dispositivo.
Questo connettore legge le metriche di sistema dalla `/proc` directory sul dispositivo principale, quindi le pubblica su. AWS IoT Device Defender*Per i dettagli sui rapporti sulle metriche, consulta le specifiche del [documento sulle metriche del dispositivo](https://docs.aws.amazon.com/iot/latest/developerguide/device-defender-detect.html#DetectMetricsMessagesSpec) nella Guida per gli sviluppatori.AWS IoT *
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 3 | `arn:aws:greengrass:region::/connectors/DeviceDefender/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/DeviceDefender/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/DeviceDefender/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#device-defender-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 3 ]
+ AWS IoT Greengrass Software principale v1.9.3 o successivo.
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ AWS IoT Device Defender configurato per utilizzare la funzione Detect per tenere traccia delle violazioni. Per ulteriori informazioni, consulta [Detect](https://docs.aws.amazon.com/iot/latest/developerguide/device-defender-detect.html) nella *AWS IoT Developer Guide*.
+ Una [risorsa di volume locale](access-local-resources.md) nel gruppo Greengrass che punta alla `/proc` directory. La risorsa deve utilizzare le seguenti proprietà:
+ Percorso di origine: `/proc`
+ Percorso di destinazione: `/host_proc` (o un valore che corrisponda al [modello valido](#param-ProcDestinationPath))
+ AutoAddGroupOwner: `true`
+ La libreria [psutil](https://pypi.org/project/psutil/) installata sul core Greengrass. La versione 5.7.0 è la versione più recente verificata per funzionare con il connettore.
+ La libreria [cbor](https://pypi.org/project/cbor/) installata sul core Greengrass. La versione 1.0.0 è l'ultima versione verificata per il funzionamento con il connettore.
------
#### [ Versions 1 - 2 ]
+ AWS IoT Greengrass Software principale v1.7 o successivo.
+ [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH.
+ AWS IoT Device Defender configurato per utilizzare la funzione Detect per tenere traccia delle violazioni. Per ulteriori informazioni, consulta [Detect](https://docs.aws.amazon.com/iot/latest/developerguide/device-defender-detect.html) nella *AWS IoT Developer Guide*.
+ Una [risorsa di volume locale](access-local-resources.md) nel gruppo Greengrass che punta alla `/proc` directory. La risorsa deve utilizzare le seguenti proprietà:
+ Percorso di origine: `/proc`
+ Percorso di destinazione: `/host_proc` (o un valore che corrisponda al [modello valido](#param-ProcDestinationPath))
+ AutoAddGroupOwner: `true`
+ La libreria [psutil](https://pypi.org/project/psutil/) installata sul core Greengrass.
+ La libreria [cbor](https://pypi.org/project/cbor/) installata sul core Greengrass.
------
## Parametri del connettore
Questo connettore fornisce i seguenti parametri:
`SampleIntervalSeconds`
Il numero di secondi tra ciascun ciclo di raccolta e produzione del rapporto dei parametri. Il valore minimo è di 300 secondi (5 minuti).
Nome visualizzato nella AWS IoT console: Intervallo di **segnalazione delle metriche**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[0-9]*(?:3[0-9][0-9]|[4-9][0-9]{2}|[1-9][0-9]{3,})$`
`ProcDestinationPath-ResourceId`
L'ID della risorsa del volume `/proc`.
Al connettore è concesso l'accesso in sola lettura alla risorsa.
Nome visualizzato nella AWS IoT console: **Resource for /proc directory**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `[a-zA-Z0-9_-]+`
`ProcDestinationPath`
Il percorso di destinazione della risorsa del volume `/proc`.
Nome visualizzato nella AWS IoT console: **percorso di destinazione della risorsa /proc**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `\/[a-zA-Z0-9_-]+`
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea un `ConnectorDefinition` con una versione iniziale che contiene il connettore Device Defender.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyDeviceDefenderConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/DeviceDefender/versions/3",
"Parameters": {
"SampleIntervalSeconds": "600",
"ProcDestinationPath": "/host_proc",
"ProcDestinationPath-ResourceId": "my-proc-resource"
}
}
]
}'
```
**Nota**
La funzione Lambda in questo connettore ha un ciclo di vita di [lunga durata](lambda-functions.md#lambda-lifecycle).
**Nella AWS IoT Greengrass console, puoi aggiungere un connettore dalla pagina Connettori del gruppo.** Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md).
## Dati di input
Questo connettore non accetta messaggi MQTT come dati di input.
## Dati di output
Questo connettore pubblica le metriche di sicurezza AWS IoT Device Defender come dati di output.
**Filtro argomento in sottoscrizione**
`$aws/things/+/defender/metrics/json`
Questa è la sintassi dell'argomento prevista. AWS IoT Device Defender Il connettore sostituisce il carattere jolly `+` con il nome del dispositivo (ad esempio, `$aws/things/thing-name/defender/metrics/json`).
**Output di esempio**
*Per i dettagli relativi ai rapporti sulle metriche, consulta le [specifiche del documento sulle metriche dei dispositivi](https://docs.aws.amazon.com/iot/latest/developerguide/device-defender-detect.html#DetectMetricsMessagesSpec) nella Guida per gli sviluppatori.AWS IoT *
```
{
"header": {
"report_id": 1529963534,
"version": "1.0"
},
"metrics": {
"listening_tcp_ports": {
"ports": [
{
"interface": "eth0",
"port": 24800
},
{
"interface": "eth0",
"port": 22
},
{
"interface": "eth0",
"port": 53
}
],
"total": 3
},
"listening_udp_ports": {
"ports": [
{
"interface": "eth0",
"port": 5353
},
{
"interface": "eth0",
"port": 67
}
],
"total": 2
},
"network_stats": {
"bytes_in": 1157864729406,
"bytes_out": 1170821865,
"packets_in": 693092175031,
"packets_out": 738917180
},
"tcp_connections": {
"established_connections":{
"connections": [
{
"local_interface": "eth0",
"local_port": 80,
"remote_addr": "192.168.0.1:8000"
},
{
"local_interface": "eth0",
"local_port": 80,
"remote_addr": "192.168.0.1:8000"
}
],
"total": 2
}
}
}
}
```
## Licenze
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche |
| --- | --- |
| 3 | È stato aggiornato il runtime Lambda a Python 3.7, che modifica i requisiti di runtime. |
| 2 | Correggere per ridurre l'eccessiva registrazione di log. |
| 1 | Versione iniziale. |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
+ [Device Defender](https://docs.aws.amazon.com/iot/latest/developerguide/device-defender.html) *nella Guida per gli sviluppatori AWS IoT *
# Connettore di distribuzione dell'applicazione Docker
Il connettore di distribuzione delle applicazioni Greengrass Docker semplifica l'esecuzione delle immagini Docker su un core. AWS IoT Greengrass Il connettore utilizza Docker Compose per avviare un'applicazione Docker multi-container da un file `docker-compose.yml`. In particolare, il connettore esegue i comandi `docker-compose` per gestire container Docker su un singolo dispositivo core. Per ulteriori informazioni, consulta [Overview of Docker Compose](https://docs.docker.com/compose/) nella documentazione di Docker. Il connettore può accedere alle immagini Docker archiviate nei registri di container Docker, come Amazon Elastic Container Registry (Amazon ECR), Docker Hub e registri affidabili Docker privati.
Dopo aver distribuito il gruppo Greengrass, il connettore recupera le immagini più recenti e avvia i contenitori Docker. Esegue il comando and. `docker-compose pull` `docker-compose up` Quindi, il connettore pubblica lo stato del comando in un argomento [MQTT di output](#docker-app-connector-data-output). Inoltre, registra le informazioni di stato relative all'esecuzione dei container Docker. In questo modo è possibile monitorare i log delle applicazioni in Amazon CloudWatch. Per ulteriori informazioni, consulta [Monitoraggio con AWS IoT Greengrass registri](greengrass-logs-overview.md). Il connettore avvia inoltre container Docker ad ogni riavvio del daemon Greengrass. Il numero di container Docker che possono essere eseguiti sul core dipende dall'hardware in uso.
I container Docker vengono eseguiti all'esterno del dominio Greengrass sul dispositivo core, pertanto non possano accedere alla comunicazione tra processi (IPC) del core. Tuttavia, è possibile configurare alcuni canali di comunicazione con componenti Greengrass, come le funzioni Lambda locali. Per ulteriori informazioni, consulta [Comunicazione con i container Docker](#docker-app-connector-communicating).
Puoi utilizzare il connettore per scenari come l'hosting di un server Web o di un server MySQL sul dispositivo core. I servizi locali nelle applicazioni Docker possono comunicare tra loro, con altri processi nell'ambiente locale e con i servizi cloud. Ad esempio, puoi eseguire un server Web sul core che invia le richieste dalle funzioni Lambda a un servizio Web nel cloud.
Questo connettore viene eseguito in modalità di isolamento [Nessun container](lambda-group-config.md#no-container-mode), quindi è possibile distribuirlo in un gruppo Greengrass che viene eseguito senza la containerizzazione di Greengrass.
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 7 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/7` |
| 6 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/6` |
| 5 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/5` |
| 4 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/4` |
| 3 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#docker-app-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
+ AWS IoT Greengrass Software principale v1.10 o successivo.
**Nota**
Questo connettore non è supportato nelle distribuzioni. OpenWrt
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ Un minimo di 36 MB di RAM sul core Greengrass per consentire al connettore per monitorare i container Docker in esecuzione. Il requisito di memoria totale dipende dal numero di container Docker in esecuzione sul core.
+ [Docker Engine](https://docs.docker.com/install/) v1.1.9.1 o versione successiva installato sul core Greengrass. La versione 19.0.3 è l'ultima versione verificata per il funzionamento con il connettore.
L'eseguibile `docker` deve trovarsi nella directory `/usr/bin` o `/usr/local/bin`.
**Importante**
Ti consigliamo di installare un archivio delle credenziali per proteggere le copie locali delle credenziali Docker. Per ulteriori informazioni, consulta [Note sulla sicurezza](#docker-app-connector-security).
Per informazioni sull'installazione di Docker su distribuzioni Amazon Linux, consulta [Docker basics for Amazon ECS nella Amazon](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/docker-basics.html) *Elastic Container Service Developer* Guide.
+ [Docker Compose](https://docs.docker.com/compose/install/) installato sul core Greengrass. L'eseguibile `docker-compose` deve trovarsi nella directory `/usr/bin` o `/usr/local/bin`.
Le seguenti versioni di Docker Compose sono state verificate per il funzionamento con il connettore.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/docker-app-connector.html)
+ Un singolo file Docker Compose (ad esempio,`docker-compose.yml`), archiviato in Amazon Simple Storage Service (Amazon S3). Il formato deve essere compatibile con la versione di Docker Compose installata sul core. È opportuno testare il file prima di utilizzarlo sul core. Se modifichi il file dopo la distribuzione del gruppo Greengrass, devi ridistribuire il gruppo per aggiornare la copia locale sul core.
+ Un utente Linux che dispone dell'autorizzazione per chiamare il daemon Docker locale e scrivere nella directory che archivia la copia locale del file Compose. Per ulteriori informazioni, consulta [Configurazione dell'utente Docker sul core](#docker-app-connector-linux-user).
+ Il [ruolo del gruppo Greengrass](group-role.md) configurato per consentire l'operazione `s3:GetObject` sul bucket S3 che contiene il file Compose. Questa autorizzazione è mostrata nel seguente esempio di politica IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAccessToComposeFileS3Bucket",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::bucket-name/*"
}
]
}
```
------
**Nota**
Se il tuo bucket S3 è abilitato al controllo delle versioni, allora il ruolo deve essere configurato anche per consentire l'azione. `s3:GetObjectVersion` Per ulteriori informazioni, consulta [Using versioning](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) nella *Amazon Simple Storage Service User Guide*.
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
+ Se il file Docker Compose fa riferimento a un'immagine Docker archiviata in Amazon ECR, il [ruolo del gruppo Greengrass](group-role.md) è configurato per consentire quanto segue:
+ `ecr:GetDownloadUrlForLayer`e `ecr:BatchGetImage` azioni sui tuoi repository Amazon ECR che contengono le immagini Docker.
+ Operazione `ecr:GetAuthorizationToken` sulle risorse.
I repository devono trovarsi nello stesso Account AWS e Regione AWS nel connettore.
**Importante**
Le autorizzazioni nel ruolo di gruppo possono essere assunte da tutte le funzioni e i connettori Lambda del gruppo Greengrass. Per ulteriori informazioni, consulta [Note sulla sicurezza](#docker-app-connector-security).
Queste autorizzazioni vengono mostrate nella policy di esempio riportata di seguito.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowGetEcrRepositories",
"Effect": "Allow",
"Action": [
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage"
],
"Resource": [
"arn:aws:ecr:us-east-1:123456789012:repository/repository-name"
]
},
{
"Sid": "AllowGetEcrAuthToken",
"Effect": "Allow",
"Action": "ecr:GetAuthorizationToken",
"Resource": "*"
}
]
}
```
------
Per ulteriori informazioni, consulta gli [esempi di policy relative ai repository di Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/RepositoryPolicyExamples.html) nella *Amazon ECR* User Guide.
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
+ Se il file di Docker Compose fa riferimento a un'immagine Docker di [Marketplace AWS](https://aws.amazon.com/marketplace), anche il connettore dispone dei seguenti requisiti:
+ Devi essere abbonato ai prodotti container. Marketplace AWS Per ulteriori informazioni, consulta la sezione relativa all'[individuazione e alla sottoscrizione ai prodotti container](https://docs.aws.amazon.com/marketplace/latest/buyerguide/buyer-finding-and-subscribing-to-container-products.html) nella *Marketplace AWS Subscribers Guide*.
+ AWS IoT Greengrass deve essere configurato per supportare i segreti locali, come descritto in [Secrets Requirements](secrets.md#secrets-reqs). Il connettore utilizza questa funzionalità solo per recuperare i segreti da Gestione dei segreti AWS, non per archiviarli.
+ È necessario creare un segreto in Secrets Manager per ogni Marketplace AWS registro che memorizza un'immagine Docker a cui si fa riferimento nel file Compose. Per ulteriori informazioni, consulta [Accesso alle immagini Docker da repository privati](#access-private-repositories).
+ Se il tuo file Docker Compose fa riferimento a un'immagine Docker da archivi privati in registri diversi da Amazon ECR, come Docker Hub, il connettore ha anche i seguenti requisiti:
+ AWS IoT Greengrass [deve essere configurato per supportare i segreti locali, come descritto in Secrets Requirements.](secrets.md#secrets-reqs) Il connettore utilizza questa funzionalità solo per recuperare i segreti da Gestione dei segreti AWS, non per archiviarli.
+ È necessario creare un segreto in Secrets Manager per ogni repository privato che memorizza un'immagine Docker a cui si fa riferimento nel file Compose. Per ulteriori informazioni, consulta [Accesso alle immagini Docker da repository privati](#access-private-repositories).
+ Il daemon Docker deve essere in esecuzione quando si distribuisce un gruppo Greengrass contenente questo connettore.
### Accesso alle immagini Docker da repository privati
Se utilizzi le credenziali per accedere alle immagini Docker, il connettore deve poter accedere ad esse. La modalità utilizzata dipende dalla posizione dell'immagine Docker.
Per le immagini Docker archiviate in Amazon ECR, concedi l'autorizzazione a ottenere il token di autorizzazione nel ruolo del gruppo Greengrass. Per ulteriori informazioni, consulta [Requisiti](#docker-app-connector-req).
Per le immagini Docker archiviate in altri archivi o registri privati, è necessario creare un account segreto per archiviare le informazioni di accesso. Gestione dei segreti AWS Sono incluse le immagini Docker a cui ti sei abbonato. Marketplace AWS Crea un segreto per ogni repository. Se aggiorni i tuoi segreti in Secrets Manager, le modifiche si propagano al core la prossima volta che distribuisci il gruppo.
**Nota**
Secrets Manager è un servizio che puoi utilizzare per archiviare e gestire in modo sicuro credenziali, chiavi e altri segreti in. Cloud AWS Per ulteriori informazioni, consulta [Cos'è? Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) nella *Guida Gestione dei segreti AWS per l'utente*.
Ogni segreto deve contenere le seguenti chiavi:
| Chiave | Valore |
| --- | --- |
| `username` | Il nome utente utilizzato per accedere al repository o al registro. |
| `password` | La password utilizzata per accedere al repository o al registro. |
| `registryUrl` | L'endpoint del registro. Questo deve corrispondere all'URL del registro corrispondente nel file Compose. |
**Nota**
Per consentire l'accesso AWS IoT Greengrass a un segreto per impostazione predefinita, il nome del segreto deve iniziare con *greengrass-*. In caso contrario, il ruolo del servizio Greengrass deve concedere l'accesso. Per ulteriori informazioni, consulta [AWS IoT Greengrass Consenti di ottenere valori segreti](secrets.md#secrets-config-service-role).
**Per ottenere le informazioni di accesso per le immagini Docker da Marketplace AWS**
1. Ottieni la password per le immagini Docker Marketplace AWS da usando il `aws ecr get-login-password` comando. Per ulteriori informazioni, consulta [get-login-password](https://docs.aws.amazon.com/cli/latest/reference/ecr/get-login.html) nella *documentazione di riferimento dei comandi della AWS CLI *.
```
aws ecr get-login-password
```
1. Recupera l'URL del registro per l'immagine Docker. Apri il Marketplace AWS sito Web e apri la pagina di lancio del prodotto container. In **Immagini del contenitore**, scegli **Visualizza i dettagli dell'immagine del contenitore** per individuare il nome utente e l'URL del registro.
Usa il nome utente, la password e l'URL del registro recuperati per creare un segreto per ogni Marketplace AWS registro che memorizza le immagini Docker a cui si fa riferimento nel file Compose.
**Per creare segreti (console)**
Nella Gestione dei segreti AWS console, scegli **Altro tipo** di segreti. In **Specify the key-value pairs to be stored for this secret (Specifica le coppie chiave-valore da archiviare per questo segreto)**, aggiungi righe per `username`, `password` e `registryUrl`. Per ulteriori informazioni, consulta [Creazione di un segreto di base](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) nella *Guida Gestione dei segreti AWS per l'utente*.
![\[Creazione di un segreto con nome utente, password e chiavi registryUrl.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/connectors/secret-docker-trusted-registry.png)
**Per creare segreti (CLI)**
In AWS CLI, utilizzare il `create-secret` comando Secrets Manager, come illustrato nell'esempio seguente. Per ulteriori informazioni, vedere [create-secret](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/create-secret.html) nel *AWS CLI Command* Reference.
```
aws secretsmanager create-secret --name greengrass-MySecret --secret-string [{"username":"Mary_Major"},{"password":"abc123xyz456"},{"registryUrl":"https://docker.io"}]
```
**Importante**
È responsabilità dell'utente proteggere la directory `DockerComposeFileDestinationPath` che archivia il file di Docker Compose e le credenziali per le immagini Docker di repository privati. Per ulteriori informazioni, consulta [Note sulla sicurezza](#docker-app-connector-security).
## Parameters
Questo connettore fornisce i seguenti parametri:
------
#### [ Version 7 ]
`DockerComposeFileS3Bucket`
Il nome del bucket S3 che contiene il file di Docker Compose. Quando crei il bucket, assicurati di seguire [le regole per i nomi dei bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritte nella *Amazon Simple Storage Service User* Guide.
Nome visualizzato nella AWS IoT console: file **Docker Compose** in S3
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `true`
Tipo: `string`
Modello valido `[a-zA-Z0-9\\-\\.]{3,63}`
`DockerComposeFileS3Key`
La chiave oggetto per il tuo file Docker Compose in Amazon S3. Per ulteriori informazioni, incluse le linee guida per la denominazione delle chiavi degli oggetti, consulta [Chiave oggetto e metadati](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) nella Guida per *l'utente di Amazon Simple Storage Service*.
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `true`
Tipo: `string`
Schema valido `.+`
`DockerComposeFileS3Version`
La versione dell'oggetto per il tuo file Docker Compose in Amazon S3. Per ulteriori informazioni, incluse le linee guida per la denominazione delle chiavi degli oggetti, consulta [Using versioning](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) nella *Amazon Simple Storage Service User* Guide.
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `false`
Tipo: `string`
Schema valido `.+`
`DockerComposeFileDestinationPath`
Il percorso assoluto della directory locale utilizzata per archiviare una copia del file di Docker Compose. Deve essere una directory esistente. L'utente specificato per `DockerUserId` deve disporre dell'autorizzazione per creare un file in questa directory. Per ulteriori informazioni, consulta [Configurazione dell'utente Docker sul core AWS IoT Greengrass](#docker-app-connector-linux-user).
Questa directory archivia il file di Docker Compose e le credenziali per le immagini Docker di repository privati. È responsabilità dell'utente proteggere questa directory. Per ulteriori informazioni, consulta [Note sulla sicurezza](#docker-app-connector-security).
Nome visualizzato nella AWS IoT console: **percorso della directory per il file Compose locale**
Obbligatorio: `true`
Tipo: `string`
Modello valido `\/.*\/?`
Ad esempio: `/home/username/myCompose`
`DockerUserId`
L'UID dell'utente Linux con cui viene eseguito il connettore. Questo utente deve appartenere al gruppo Linux `docker` sul dispositivo core e disporre delle autorizzazioni in scrittura per la directory `DockerComposeFileDestinationPath`. Per ulteriori informazioni, consulta [Configurazione dell'utente Docker sul core](#docker-app-connector-linux-user).
L'esecuzione come root deve essere utilizzata solo quando strettamente necessario. Se specifichi l'utente root, devi consentire alle funzioni Lambda di essere eseguite come root sul AWS IoT Greengrass core. Per ulteriori informazioni, consulta [Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
Nome visualizzato nella AWS IoT console: ID utente **Docker**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^[0-9]{1,5}$`
`AWSSecretsArnList`
I nomi delle risorse Amazon (ARNs) dei segreti Gestione dei segreti AWS che contengono le informazioni di accesso utilizzate per accedere alle immagini Docker in repository privati. Per ulteriori informazioni, consulta [Accesso alle immagini Docker da repository privati](#access-private-repositories).
Nome visualizzato nella AWS IoT console: **Credentials** for private repository
Obbligatorio: `false`. Questo parametro è obbligatorio per accedere alle immagini Docker archiviate nei repository privati.
Tipo: di `array` `string`
Schema valido: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]`
`DockerContainerStatusLogFrequency`
La frequenza (in secondi) di registrazione delle informazioni sullo stato relative ai container Docker in esecuzione sul core. Il valore predefinito è 300 secondi (5 minuti).
Nome visualizzato nella AWS IoT console: frequenza **di registrazione**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^[1-9]{1}[0-9]{0,3}$`
`ForceDeploy`
Indica se forzare la distribuzione di Docker se fallisce a causa della pulizia impropria dell'ultima distribuzione. Il valore predefinito è `False`.
**Nome visualizzato nella AWS IoT console: Force deployment**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^(true|false)$`
`DockerPullBeforeUp`
Indica se il deployer deve essere eseguito `docker-compose pull` prima di eseguire un `docker-compose up` determinato pull-down-up comportamento. Il valore predefinito è `True`.
Nome visualizzato nella AWS IoT console: **Docker Pull** Before Up
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^(true|false)$`
`StopContainersOnNewDeployment`
Indica se il connettore deve interrompere i contenitori docker gestiti da Docker Deployer quando GGC viene interrotto (GGC si interrompe quando viene distribuito un nuovo gruppo o il kernel viene spento). Il valore predefinito è `True`.
**Nome visualizzato nella console: Docker stop in caso di nuova distribuzione AWS IoT **
Consigliamo di mantenere questo parametro impostato sul `True` valore predefinito. Il parametro che `False` fa sì che il contenitore Docker continui a funzionare anche dopo l'interruzione del AWS IoT Greengrass core o l'avvio di una nuova distribuzione. Se imposti questo parametro su`False`, devi assicurarti che i contenitori Docker vengano mantenuti come necessario in caso di modifica o aggiunta del nome del `docker-compose` servizio.
Per ulteriori informazioni, consulta la documentazione del file di `docker-compose` composizione.
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^(true|false)$`
`DockerOfflineMode`
Indica se utilizzare il file Docker Compose esistente all' AWS IoT Greengrass avvio offline. Il valore predefinito è `False`.
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^(true|false)$`
------
#### [ Version 6 ]
`DockerComposeFileS3Bucket`
Il nome del bucket S3 che contiene il file di Docker Compose. Quando crei il bucket, assicurati di seguire [le regole per i nomi dei bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritte nella *Amazon Simple Storage Service User* Guide.
Nome visualizzato nella AWS IoT console: file **Docker Compose** in S3
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `true`
Tipo: `string`
Modello valido `[a-zA-Z0-9\\-\\.]{3,63}`
`DockerComposeFileS3Key`
La chiave oggetto per il tuo file Docker Compose in Amazon S3. Per ulteriori informazioni, incluse le linee guida per la denominazione delle chiavi degli oggetti, consulta [Chiave oggetto e metadati](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) nella Guida per *l'utente di Amazon Simple Storage Service*.
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `true`
Tipo: `string`
Schema valido `.+`
`DockerComposeFileS3Version`
La versione dell'oggetto per il tuo file Docker Compose in Amazon S3. Per ulteriori informazioni, incluse le linee guida per la denominazione delle chiavi degli oggetti, consulta [Using versioning](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) nella *Amazon Simple Storage Service User* Guide.
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `false`
Tipo: `string`
Schema valido `.+`
`DockerComposeFileDestinationPath`
Il percorso assoluto della directory locale utilizzata per archiviare una copia del file di Docker Compose. Deve essere una directory esistente. L'utente specificato per `DockerUserId` deve disporre dell'autorizzazione per creare un file in questa directory. Per ulteriori informazioni, consulta [Configurazione dell'utente Docker sul core AWS IoT Greengrass](#docker-app-connector-linux-user).
Questa directory archivia il file di Docker Compose e le credenziali per le immagini Docker di repository privati. È responsabilità dell'utente proteggere questa directory. Per ulteriori informazioni, consulta [Note sulla sicurezza](#docker-app-connector-security).
Nome visualizzato nella AWS IoT console: **percorso della directory per il file Compose locale**
Obbligatorio: `true`
Tipo: `string`
Modello valido `\/.*\/?`
Ad esempio: `/home/username/myCompose`
`DockerUserId`
L'UID dell'utente Linux con cui viene eseguito il connettore. Questo utente deve appartenere al gruppo Linux `docker` sul dispositivo core e disporre delle autorizzazioni in scrittura per la directory `DockerComposeFileDestinationPath`. Per ulteriori informazioni, consulta [Configurazione dell'utente Docker sul core](#docker-app-connector-linux-user).
L'esecuzione come root deve essere utilizzata solo quando strettamente necessario. Se specifichi l'utente root, devi consentire alle funzioni Lambda di essere eseguite come root sul AWS IoT Greengrass core. Per ulteriori informazioni, consulta [Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
Nome visualizzato nella AWS IoT console: ID utente **Docker**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^[0-9]{1,5}$`
`AWSSecretsArnList`
I nomi delle risorse Amazon (ARNs) dei segreti Gestione dei segreti AWS che contengono le informazioni di accesso utilizzate per accedere alle immagini Docker in repository privati. Per ulteriori informazioni, consulta [Accesso alle immagini Docker da repository privati](#access-private-repositories).
Nome visualizzato nella AWS IoT console: **Credentials** for private repository
Obbligatorio: `false`. Questo parametro è obbligatorio per accedere alle immagini Docker archiviate nei repository privati.
Tipo: di `array` `string`
Schema valido: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]`
`DockerContainerStatusLogFrequency`
La frequenza (in secondi) di registrazione delle informazioni sullo stato relative ai container Docker in esecuzione sul core. Il valore predefinito è 300 secondi (5 minuti).
Nome visualizzato nella AWS IoT console: frequenza **di registrazione**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^[1-9]{1}[0-9]{0,3}$`
`ForceDeploy`
Indica se forzare la distribuzione di Docker se fallisce a causa della pulizia impropria dell'ultima distribuzione. Il valore predefinito è `False`.
**Nome visualizzato nella AWS IoT console: Force deployment**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^(true|false)$`
`DockerPullBeforeUp`
Indica se il deployer deve essere eseguito `docker-compose pull` prima di eseguire un `docker-compose up` determinato pull-down-up comportamento. Il valore predefinito è `True`.
Nome visualizzato nella AWS IoT console: **Docker Pull** Before Up
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^(true|false)$`
`StopContainersOnNewDeployment`
Indica se il connettore deve interrompere i contenitori docker gestiti da Docker Deployer quando GGC viene interrotto (quando viene effettuata una nuova distribuzione di gruppo o il kernel viene chiuso). Il valore predefinito è `True`.
**Nome visualizzato nella console: Docker stop in caso di nuova distribuzione AWS IoT **
Consigliamo di mantenere questo parametro impostato sul `True` valore predefinito. Il parametro che `False` fa sì che il contenitore Docker continui a funzionare anche dopo l'interruzione del AWS IoT Greengrass core o l'avvio di una nuova distribuzione. Se imposti questo parametro su`False`, devi assicurarti che i contenitori Docker vengano mantenuti come necessario in caso di modifica o aggiunta del nome del `docker-compose` servizio.
Per ulteriori informazioni, consulta la documentazione del file di `docker-compose` composizione.
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^(true|false)$`
------
#### [ Version 5 ]
`DockerComposeFileS3Bucket`
Il nome del bucket S3 che contiene il file di Docker Compose. Quando crei il bucket, assicurati di seguire [le regole per i nomi dei bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritte nella *Amazon Simple Storage Service User* Guide.
Nome visualizzato nella AWS IoT console: file **Docker Compose** in S3
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `true`
Tipo: `string`
Modello valido `[a-zA-Z0-9\\-\\.]{3,63}`
`DockerComposeFileS3Key`
La chiave oggetto per il tuo file Docker Compose in Amazon S3. Per ulteriori informazioni, incluse le linee guida per la denominazione delle chiavi degli oggetti, consulta [Chiave oggetto e metadati](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) nella Guida per *l'utente di Amazon Simple Storage Service*.
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `true`
Tipo: `string`
Schema valido `.+`
`DockerComposeFileS3Version`
La versione dell'oggetto per il tuo file Docker Compose in Amazon S3. Per ulteriori informazioni, incluse le linee guida per la denominazione delle chiavi degli oggetti, consulta [Using versioning](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) nella *Amazon Simple Storage Service User* Guide.
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `false`
Tipo: `string`
Schema valido `.+`
`DockerComposeFileDestinationPath`
Il percorso assoluto della directory locale utilizzata per archiviare una copia del file di Docker Compose. Deve essere una directory esistente. L'utente specificato per `DockerUserId` deve disporre dell'autorizzazione per creare un file in questa directory. Per ulteriori informazioni, consulta [Configurazione dell'utente Docker sul core AWS IoT Greengrass](#docker-app-connector-linux-user).
Questa directory archivia il file di Docker Compose e le credenziali per le immagini Docker di repository privati. È responsabilità dell'utente proteggere questa directory. Per ulteriori informazioni, consulta [Note sulla sicurezza](#docker-app-connector-security).
Nome visualizzato nella AWS IoT console: **percorso della directory per il file Compose locale**
Obbligatorio: `true`
Tipo: `string`
Modello valido `\/.*\/?`
Ad esempio: `/home/username/myCompose`
`DockerUserId`
L'UID dell'utente Linux con cui viene eseguito il connettore. Questo utente deve appartenere al gruppo Linux `docker` sul dispositivo core e disporre delle autorizzazioni in scrittura per la directory `DockerComposeFileDestinationPath`. Per ulteriori informazioni, consulta [Configurazione dell'utente Docker sul core](#docker-app-connector-linux-user).
L'esecuzione come root deve essere utilizzata solo quando strettamente necessario. Se specifichi l'utente root, devi consentire alle funzioni Lambda di essere eseguite come root sul AWS IoT Greengrass core. Per ulteriori informazioni, consulta [Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
Nome visualizzato nella AWS IoT console: ID utente **Docker**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^[0-9]{1,5}$`
`AWSSecretsArnList`
I nomi delle risorse Amazon (ARNs) dei segreti Gestione dei segreti AWS che contengono le informazioni di accesso utilizzate per accedere alle immagini Docker in repository privati. Per ulteriori informazioni, consulta [Accesso alle immagini Docker da repository privati](#access-private-repositories).
Nome visualizzato nella AWS IoT console: **Credentials** for private repository
Obbligatorio: `false`. Questo parametro è obbligatorio per accedere alle immagini Docker archiviate nei repository privati.
Tipo: di `array` `string`
Schema valido: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]`
`DockerContainerStatusLogFrequency`
La frequenza (in secondi) di registrazione delle informazioni sullo stato relative ai container Docker in esecuzione sul core. Il valore predefinito è 300 secondi (5 minuti).
Nome visualizzato nella AWS IoT console: frequenza **di registrazione**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^[1-9]{1}[0-9]{0,3}$`
`ForceDeploy`
Indica se forzare la distribuzione di Docker se fallisce a causa della pulizia impropria dell'ultima distribuzione. Il valore predefinito è `False`.
**Nome visualizzato nella AWS IoT console: Force deployment**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^(true|false)$`
`DockerPullBeforeUp`
Indica se il deployer deve essere eseguito `docker-compose pull` prima di eseguire un `docker-compose up` determinato pull-down-up comportamento. Il valore predefinito è `True`.
Nome visualizzato nella AWS IoT console: **Docker Pull** Before Up
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^(true|false)$`
------
#### [ Versions 2 - 4 ]
`DockerComposeFileS3Bucket`
Il nome del bucket S3 che contiene il file di Docker Compose. Quando crei il bucket, assicurati di seguire [le regole per i nomi dei bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritte nella *Amazon Simple Storage Service User* Guide.
Nome visualizzato nella AWS IoT console: file **Docker Compose** in S3
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `true`
Tipo: `string`
Modello valido `[a-zA-Z0-9\\-\\.]{3,63}`
`DockerComposeFileS3Key`
La chiave oggetto per il tuo file Docker Compose in Amazon S3. Per ulteriori informazioni, incluse le linee guida per la denominazione delle chiavi degli oggetti, consulta [Chiave oggetto e metadati](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) nella Guida per *l'utente di Amazon Simple Storage Service*.
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `true`
Tipo: `string`
Schema valido `.+`
`DockerComposeFileS3Version`
La versione dell'oggetto per il tuo file Docker Compose in Amazon S3. Per ulteriori informazioni, incluse le linee guida per la denominazione delle chiavi degli oggetti, consulta [Using versioning](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) nella *Amazon Simple Storage Service User* Guide.
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `false`
Tipo: `string`
Schema valido `.+`
`DockerComposeFileDestinationPath`
Il percorso assoluto della directory locale utilizzata per archiviare una copia del file di Docker Compose. Deve essere una directory esistente. L'utente specificato per `DockerUserId` deve disporre dell'autorizzazione per creare un file in questa directory. Per ulteriori informazioni, consulta [Configurazione dell'utente Docker sul core AWS IoT Greengrass](#docker-app-connector-linux-user).
Questa directory archivia il file di Docker Compose e le credenziali per le immagini Docker di repository privati. È responsabilità dell'utente proteggere questa directory. Per ulteriori informazioni, consulta [Note sulla sicurezza](#docker-app-connector-security).
Nome visualizzato nella AWS IoT console: **percorso della directory per il file Compose locale**
Obbligatorio: `true`
Tipo: `string`
Modello valido `\/.*\/?`
Ad esempio: `/home/username/myCompose`
`DockerUserId`
L'UID dell'utente Linux con cui viene eseguito il connettore. Questo utente deve appartenere al gruppo Linux `docker` sul dispositivo core e disporre delle autorizzazioni in scrittura per la directory `DockerComposeFileDestinationPath`. Per ulteriori informazioni, consulta [Configurazione dell'utente Docker sul core](#docker-app-connector-linux-user).
L'esecuzione come root deve essere utilizzata solo quando strettamente necessario. Se specifichi l'utente root, devi consentire alle funzioni Lambda di essere eseguite come root sul AWS IoT Greengrass core. Per ulteriori informazioni, consulta [Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
Nome visualizzato nella AWS IoT console: ID utente **Docker**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^[0-9]{1,5}$`
`AWSSecretsArnList`
I nomi delle risorse Amazon (ARNs) dei segreti Gestione dei segreti AWS che contengono le informazioni di accesso utilizzate per accedere alle immagini Docker in repository privati. Per ulteriori informazioni, consulta [Accesso alle immagini Docker da repository privati](#access-private-repositories).
Nome visualizzato nella AWS IoT console: **Credentials** for private repository
Obbligatorio: `false`. Questo parametro è obbligatorio per accedere alle immagini Docker archiviate nei repository privati.
Tipo: di `array` `string`
Schema valido: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]`
`DockerContainerStatusLogFrequency`
La frequenza (in secondi) di registrazione delle informazioni sullo stato relative ai container Docker in esecuzione sul core. Il valore predefinito è 300 secondi (5 minuti).
Nome visualizzato nella AWS IoT console: frequenza **di registrazione**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^[1-9]{1}[0-9]{0,3}$`
`ForceDeploy`
Indica se forzare la distribuzione di Docker se fallisce a causa della pulizia impropria dell'ultima distribuzione. Il valore predefinito è `False`.
**Nome visualizzato nella AWS IoT console: Force deployment**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^(true|false)$`
------
#### [ Version 1 ]
`DockerComposeFileS3Bucket`
Il nome del bucket S3 che contiene il file di Docker Compose. Quando crei il bucket, assicurati di seguire [le regole per i nomi dei bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritte nella *Amazon Simple Storage Service User* Guide.
Nome visualizzato nella AWS IoT console: file **Docker Compose** in S3
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `true`
Tipo: `string`
Modello valido `[a-zA-Z0-9\\-\\.]{3,63}`
`DockerComposeFileS3Key`
La chiave oggetto per il tuo file Docker Compose in Amazon S3. Per ulteriori informazioni, incluse le linee guida per la denominazione delle chiavi degli oggetti, consulta [Chiave oggetto e metadati](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) nella Guida per *l'utente di Amazon Simple Storage Service*.
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `true`
Tipo: `string`
Schema valido `.+`
`DockerComposeFileS3Version`
La versione dell'oggetto per il tuo file Docker Compose in Amazon S3. Per ulteriori informazioni, incluse le linee guida per la denominazione delle chiavi degli oggetti, consulta [Using versioning](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) nella *Amazon Simple Storage Service User* Guide.
Nella console, la proprietà **Docker Compose file in S3 (File di Docker Compose in S3)** combina i parametri `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`.
Obbligatorio: `false`
Tipo: `string`
Schema valido `.+`
`DockerComposeFileDestinationPath`
Il percorso assoluto della directory locale utilizzata per archiviare una copia del file di Docker Compose. Deve essere una directory esistente. L'utente specificato per `DockerUserId` deve disporre dell'autorizzazione per creare un file in questa directory. Per ulteriori informazioni, consulta [Configurazione dell'utente Docker sul core AWS IoT Greengrass](#docker-app-connector-linux-user).
Questa directory archivia il file di Docker Compose e le credenziali per le immagini Docker di repository privati. È responsabilità dell'utente proteggere questa directory. Per ulteriori informazioni, consulta [Note sulla sicurezza](#docker-app-connector-security).
Nome visualizzato nella AWS IoT console: **percorso della directory per il file Compose locale**
Obbligatorio: `true`
Tipo: `string`
Modello valido `\/.*\/?`
Ad esempio: `/home/username/myCompose`
`DockerUserId`
L'UID dell'utente Linux con cui viene eseguito il connettore. Questo utente deve appartenere al gruppo Linux `docker` sul dispositivo core e disporre delle autorizzazioni in scrittura per la directory `DockerComposeFileDestinationPath`. Per ulteriori informazioni, consulta [Configurazione dell'utente Docker sul core](#docker-app-connector-linux-user).
L'esecuzione come root deve essere utilizzata solo quando strettamente necessario. Se specifichi l'utente root, devi consentire alle funzioni Lambda di essere eseguite come root sul AWS IoT Greengrass core. Per ulteriori informazioni, consulta [Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
Nome visualizzato nella AWS IoT console: ID utente **Docker**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^[0-9]{1,5}$`
`AWSSecretsArnList`
I nomi delle risorse Amazon (ARNs) dei segreti Gestione dei segreti AWS che contengono le informazioni di accesso utilizzate per accedere alle immagini Docker in repository privati. Per ulteriori informazioni, consulta [Accesso alle immagini Docker da repository privati](#access-private-repositories).
Nome visualizzato nella AWS IoT console: **Credentials** for private repository
Obbligatorio: `false`. Questo parametro è obbligatorio per accedere alle immagini Docker archiviate nei repository privati.
Tipo: di `array` `string`
Schema valido: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]`
`DockerContainerStatusLogFrequency`
La frequenza (in secondi) di registrazione delle informazioni sullo stato relative ai container Docker in esecuzione sul core. Il valore predefinito è 300 secondi (5 minuti).
Nome visualizzato nella AWS IoT console: frequenza **di registrazione**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^[1-9]{1}[0-9]{0,3}$`
------
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea una `ConnectorDefinition` versione iniziale che contiene il connettore di distribuzione dell'applicazione Greengrass Docker.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyDockerAppplicationDeploymentConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/5",
"Parameters": {
"DockerComposeFileS3Bucket": "amzn-s3-demo-bucket",
"DockerComposeFileS3Key": "production-docker-compose.yml",
"DockerComposeFileS3Version": "123",
"DockerComposeFileDestinationPath": "/home/username/myCompose",
"DockerUserId": "1000",
"AWSSecretsArnList": "[\"arn:aws:secretsmanager:region:account-id:secret:greengrass-secret1-hash\",\"arn:aws:secretsmanager:region:account-id:secret:greengrass-secret2-hash\"]",
"DockerContainerStatusLogFrequency": "30",
"ForceDeploy": "True",
"DockerPullBeforeUp": "True"
}
}
]
}'
```
**Nota**
La funzione Lambda in questo connettore ha un ciclo di vita di [lunga durata](lambda-functions.md#lambda-lifecycle).
## Dati di input
Questo connettore non richiede né accetta dati di input.
## Dati di output
Questo connettore pubblica lo stato del comando `docker-compose up` come dati di output.
**Filtro argomento in sottoscrizione**
`dockerapplicationdeploymentconnector/message/status`
**Output di esempio: Operazione riuscita**
```
{
"status":"success",
"GreengrassDockerApplicationDeploymentStatus":"Successfully triggered docker-compose up",
"S3Bucket":"amzn-s3-demo-bucket",
"ComposeFileName":"production-docker-compose.yml",
"ComposeFileVersion":"123"
}
```
**Esempio di output: Errore**
```
{
"status":"fail",
"error_message":"description of error",
"error":"InvalidParameter"
}
```
Il tipo di errore può essere `InvalidParameter` o `InternalError`.
## Configurazione dell'utente Docker sul core AWS IoT Greengrass
Il connettore di distribuzione dell'applicazione Greengrass Docker viene eseguito come utente specificato per il parametro. `DockerUserId` Se non specifichi un valore, il connettore viene eseguito come `ggc_user`, che è l'identità di accesso Greengrass predefinita.
Per consentire al connettore di interagire con il daemon Docker, l'utente Docker deve appartenere al gruppo Linux `docker` sul core. L'utente Docker deve inoltre disporre delle autorizzazioni in scrittura per la directory `DockerComposeFileDestinationPath`. Questa è la posizione in cui il connettore archivia il file `docker-compose.yml` locale e le credenziali Docker.
**Nota**
Ti consigliamo di creare un utente Linux anziché utilizzare l'impostazione predefinita `ggc_user`. Altrimenti, qualsiasi funzione Lambda nel gruppo Greengrass può accedere al file Compose e alle credenziali Docker.
L'esecuzione come root deve essere utilizzata solo quando strettamente necessario. Se specifichi l'utente root, devi consentire alle funzioni Lambda di essere eseguite come root sul AWS IoT Greengrass core. Per ulteriori informazioni, consulta [Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
1. Creare l’utente. È possibile eseguire il comando `useradd` e includere l'opzione `-u` facoltativa per assegnare un UID. Esempio:
```
sudo useradd -u 1234 user-name
```
1. Aggiungere l'utente al gruppo `docker` sul core. Esempio:
```
sudo usermod -aG docker user-name
```
Per ulteriori informazioni, inclusa la modalità di creazione del gruppo `docker`, consulta [Manage Docker as a non-root user](https://docs.docker.com/install/linux/linux-postinstall/#manage-docker-as-a-non-root-user) nella documentazione di Docker.
1. Concedere le autorizzazioni utente per scrivere nella directory specificata per il parametro `DockerComposeFileDestinationPath`. Esempio:
1. Per impostare l'utente come il proprietario della directory. Questo esempio utilizza l'UID della fase 1.
```
chown 1234 docker-compose-file-destination-path
```
1. Per fornire le autorizzazioni in lettura e scrittura al proprietario.
```
chmod 700 docker-compose-file-destination-path
```
Per ulteriori informazioni, consulta [How To Manage File And Folder Permissions In Linux](https://www.linux.com/tutorials/how-manage-file-and-folder-permissions-linux/) nella documentazione di Linux Foundation.
1. Se non è stato assegnato un UID al momento della creazione dell'utente o se è stato utilizzato un utente esistente, eseguire il comando `id` per cercare l'UID.
```
id -u user-name
```
Utilizzare l'UID per configurare il parametro `DockerUserId` per il connettore.
## Informazioni sull'utilizzo
Quando si utilizza il connettore di distribuzione delle applicazioni Greengrass Docker, è necessario conoscere le seguenti informazioni sull'utilizzo specifiche dell'implementazione.
+ **Prefisso per i nomi dei progetti.** Il connettore antepone il prefisso `greengrassdockerapplicationdeployment` ai nomi dei container Docker che avvia. Il connettore utilizza questo prefisso come il nome del progetto nei comandi `docker-compose` che esegue.
+ **Comportamento di registrazione.** Il connettore scrive informazioni sullo stato e informazioni sulla risoluzione dei problemi in un file di log. È possibile configurare AWS IoT Greengrass l'invio dei log a CloudWatch Logs e la scrittura dei log localmente. Per ulteriori informazioni, consulta [Registrazione per connettori](connectors.md#connectors-logging). Questo è il percorso al log locale per il connettore:
```
/greengrass-root/ggc/var/log/user/region/aws/DockerApplicationDeployment.log
```
Devi disporre delle autorizzazioni root per accedere ai log locali.
+ **Aggiornamento delle immagini Docker.** Docker memorizza le immagini nella cache sul dispositivo core. Se aggiorni un'immagine Docker e desideri propagare la modifica al dispositivo core, assicurati di modificare il tag per l'immagine nel file Compose. Le modifiche diventano effettive dopo la distribuzione del gruppo Greengrass.
+ **Timeout di 10 minuti per le operazioni di pulizia.** Quando il demone Greengrass si ferma durante un riavvio, il `docker-compose down` comando viene avviato. Tutti i contenitori Docker dispongono di un massimo di 10 minuti dopo l'avvio per eseguire qualsiasi `docker-compose down` operazione di pulizia. Se la pulizia non viene completata entro 10 minuti, devi pulire manualmente i contenitori rimanenti. Per ulteriori informazioni, consulta [docker rm](https://docs.docker.com/engine/reference/commandline/rm/) nella documentazione dell'interfaccia a riga di comandi di Docker.
+ **Esecuzione di comandi Docker.** Per risolvere i problemi, puoi eseguire i comandi Docker in una finestra del terminale sul dispositivo core. Ad esempio, esegui il comando seguente per visualizzare i container Docker avviati dal connettore:
```
docker ps --filter name="greengrassdockerapplicationdeployment"
```
+ **ID di risorsa riservato.** Il connettore utilizza l'ID `DOCKER_DEPLOYER_SECRET_RESOURCE_RESERVED_ID_index` per le risorse Greengrass create nel gruppo Greengrass. La risorsa IDs deve essere univoca nel gruppo, quindi non assegnate un ID di risorsa che potrebbe essere in conflitto con questo ID di risorsa riservato.
+ **Modalità offline.** Quando si imposta il parametro di `DockerOfflineMode` configurazione su`True`, il connettore Docker è in grado di funzionare in *modalità offline*. Ciò può accadere quando una distribuzione di gruppo Greengrass si riavvia mentre il dispositivo principale è offline e il connettore non riesce a stabilire una connessione ad Amazon S3 o Amazon ECR per recuperare il file Docker Compose.
Con la modalità offline abilitata, il connettore tenta di scaricare il file Compose ed eseguire i `docker login` comandi come farebbe per un normale riavvio. Se questi tentativi falliscono, il connettore cerca un file Compose archiviato localmente nella cartella specificata utilizzando il `DockerComposeFileDestinationPath` parametro. Se esiste un file Compose locale, il connettore segue la normale sequenza di `docker-compose` comandi ed estrae immagini locali. Se il file Compose o le immagini locali non sono presenti, il connettore si guasta. Il comportamento dei `StopContainersOnNewDeployment` parametri `ForceDeploy` and rimane lo stesso in modalità offline.
## Comunicazione con i container Docker
AWS IoT Greengrass supporta i seguenti canali di comunicazione tra i componenti Greengrass e i contenitori Docker:
+ Le funzioni Greengrass Lambda possono utilizzare REST APIs per comunicare con i processi nei contenitori Docker. È possibile configurare un server in un contenitore Docker che apre una porta. Le funzioni Lambda possono comunicare con il contenitore su questa porta.
+ I processi nei container Docker possono scambiare messaggi MQTT tramite il broker messaggi Greengrass locale. È possibile configurare il contenitore Docker come dispositivo client nel gruppo Greengrass e quindi creare abbonamenti per consentire al contenitore di comunicare con le funzioni Greengrass Lambda, i dispositivi client e altri connettori del gruppo o con e il servizio shadow locale. AWS IoT Per ulteriori informazioni, consulta [Configurazione della comunicazione MQTT con i container Docker](#docker-app-connector-mqtt-communication).
+ Le funzioni Greengrass Lambda possono aggiornare un file condiviso per passare informazioni ai contenitori Docker. Puoi utilizzare il file Compose per eseguire il montaggio vincolato del percorso file condiviso per un container Docker.
### Configurazione della comunicazione MQTT con i container Docker
Puoi configurare un contenitore Docker come dispositivo client e aggiungerlo a un gruppo Greengrass. Quindi, puoi creare sottoscrizioni che consentono la comunicazione MQTT tra il container Docker e i componenti Greengrass o AWS IoT. Nella procedura seguente, viene creata una sottoscrizione che consente al dispositivo del container Docker di ricevere messaggi di aggiornamento shadow dal servizio shadow locale. Puoi seguire questo modello per creare altre sottoscrizioni.
**Nota**
Questa procedura presuppone che abbiate già creato un gruppo Greengrass e un core Greengrass (v1.10 o successivo). Per informazioni sulla creazione di un gruppo e di un core Greengrass, vedere. [Iniziare con AWS IoT Greengrass](gg-gs.md)
**Per configurare un contenitore Docker come dispositivo client e aggiungerlo a un gruppo Greengrass**
1. Crea una cartella sul dispositivo principale per archiviare i certificati e le chiavi utilizzati per autenticare il dispositivo Greengrass.
Il percorso del file deve essere montato sul container Docker che si desidera avviare. Il frammento di codice seguente mostra come montare un percorso del file nel file Compose. In questo esempio, *path-to-device-certs* rappresenta la cartella creata in questo passaggio.
```
version: '3.3'
services:
myService:
image: user-name/repo:image-tag
volumes:
- /path-to-device-certs/:/path-accessible-in-container
```
1. Nel riquadro di navigazione della AWS IoT console, in **Gestione**, espandi **i dispositivi Greengrass**, quindi scegli **Gruppi (V1**).
1. Scegliere il gruppo target.
1. **Nella pagina di configurazione del gruppo, scegli **Dispositivi client**, quindi scegli Associa.**
1. Nella finestra Modale **Associa un dispositivo client a questo gruppo**, scegli **Crea nuovo AWS IoT elemento**.
La pagina **Crea oggetti** si apre in una nuova scheda.
1. Nella pagina **Crea elementi**, scegli **Crea elemento singolo**, quindi scegli **Avanti**.
1. Nella pagina **Specificare le proprietà** dell'oggetto, inserisci un nome per il dispositivo, quindi scegli **Avanti**.
1. Nella pagina **Configura il certificato del dispositivo**, scegli **Avanti**.
1. Nella pagina **Allega le politiche al certificato**, esegui una delle seguenti operazioni:
+ Seleziona una politica esistente che conceda le autorizzazioni richieste dai dispositivi client, quindi scegli **Crea** oggetto.
Si apre una finestra modale in cui è possibile scaricare i certificati e le chiavi utilizzati dal dispositivo per connettersi al core Cloud AWS .
+ Crea e allega una nuova policy che conceda le autorizzazioni per i dispositivi client. Esegui questa operazione:
1. Scegli **Crea policy**.
La pagina **Create policy (Crea policy)** viene aperta in una nuova scheda.
1. Nella pagina **Create policy (Crea policy)**, eseguire le operazioni seguenti:
1. Per **Nome della politica**, inserisci un nome che descriva la politica, ad esempio. **GreengrassV1ClientDevicePolicy**
1. Nella scheda **Dichiarazioni politiche**, in **Documento di politica**, scegli **JSON**.
1. Inserisci il seguente documento di policy. Questa politica consente al dispositivo client di scoprire i core Greengrass e comunicare su tutti gli argomenti MQTT. Per informazioni su come limitare l'accesso a questa politica, vedere. [Autenticazione e autorizzazione del dispositivo per AWS IoT Greengrass](device-auth.md)
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Connect",
"iot:Receive"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"greengrass:*"
],
"Resource": [
"*"
]
}
]
}
```
------
1. Scegliere **Crea** per creare la policy.
1. Torna alla scheda del browser con la pagina **Allega politiche al certificato** aperta. Esegui questa operazione:
1. Nell'elenco **Politiche**, seleziona la politica che hai creato, ad esempio **GreengrassV1ClientDevicePolicy**.
Se non vedi la politica, scegli il pulsante di aggiornamento.
1. Scegli **Create thing (Crea oggetto)**.
Si apre una finestra modale in cui puoi scaricare i certificati e le chiavi che il dispositivo utilizza per connettersi al Cloud AWS core.
1. Nella modalità **Scarica certificati e chiavi**, scarica i certificati del dispositivo.
**Importante**
Prima di scegliere **Fine**, scarica le risorse di sicurezza.
Esegui questa operazione:
1. Per **Certificato del dispositivo**, scegli **Scarica** per scaricare il certificato del dispositivo.
1. Per il **file della chiave pubblica**, scegli **Scarica** per scaricare la chiave pubblica per il certificato.
1. Per **File di chiave privata**, scegli **Scarica** per scaricare il file di chiave privata per il certificato.
1. Consulta [l'autenticazione del server](https://docs.aws.amazon.com/iot/latest/developerguide/server-authentication.html) nella *Guida per gli AWS IoT sviluppatori* e scegli il certificato CA principale appropriato. Ti consigliamo di utilizzare gli endpoint Amazon Trust Services (ATS) e i certificati CA root ATS. In **Certificati CA root**, scegli **Scarica** per un certificato CA root.
1. Seleziona **Fatto**.
Prendi nota dell'ID del certificato che è comune nei nomi dei file per il certificato e le chiavi del dispositivo. perché sarà necessaria in seguito.
1. Copia i certificati e le chiavi nella cartella creata nel passaggio 1.
Quindi, creare una sottoscrizione nel gruppo. Per questo esempio, creare una sottoscrizione che consente al dispositivo container Docker di ricevere messaggi MQTT dal servizio shadow locale.
**Nota**
La dimensione massima di un documento shadow è di 8 KB. Per ulteriori informazioni, consulta [Quote di AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/limits-iot.html) nella *Guida per gli sviluppatori di AWS IoT *.
**Per creare una sottoscrizione che consente al dispositivo container Docker di ricevere messaggi MQTT dal servizio shadow locale**
1. Nella pagina di configurazione del gruppo, scegli la scheda **Abbonamenti**, quindi scegli **Aggiungi abbonamento**.
1. Nella pagina **Select your source and target (Seleziona origine e destinazione)**, configura l'origine e la destinazione come indicato di seguito:
1. Per **Select a source (Seleziona un'origine)**, scegli **Services (Servizi)**, quindi scegli **Local Shadow Service (Servizio shadow locale)**.
1. In **Select a target (Seleziona una destinazione)**, scegliere **Devices (Dispositivi)**, quindi selezionare il dispositivo.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Filtra i dati con un argomento**, per **Filtro argomento** scegli**\$1aws/things/*MyDockerDevice*/shadow/update/accepted**, quindi scegli **Avanti**. Sostituiscilo *MyDockerDevice* con il nome del dispositivo che hai creato in precedenza.
1. Scegli **Fine**.
Includi il frammento di codice seguente nell'immagine Docker cui fai riferimento nel file Compose. Questo è il codice del dispositivo Greengrass. Inoltre, aggiungi il codice nel container Docker che avvia il dispositivo Greengrass all'interno del container. Può essere eseguito come un processo separato nell'immagine o in un thread separato.
```
import os
import sys
import time
import uuid
from AWSIoTPythonSDK.core.greengrass.discovery.providers import DiscoveryInfoProvider
from AWSIoTPythonSDK.exception.AWSIoTExceptions import DiscoveryInvalidRequestException
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
# Replace thingName with the name you registered for the Docker device.
thingName = "MyDockerDevice"
clientId = thingName
# Replace host with the IoT endpoint for your &AWS-account;.
host = "myPrefix.iot.region.amazonaws.com"
# Replace topic with the topic where the Docker container subscribes.
topic = "$aws/things/MyDockerDevice/shadow/update/accepted"
# Replace these paths based on the download location of the certificates for the Docker container.
rootCAPath = "/path-accessible-in-container/AmazonRootCA1.pem"
certificatePath = "/path-accessible-in-container/certId-certificate.pem.crt"
privateKeyPath = "/path-accessible-in-container/certId-private.pem.key"
# Discover Greengrass cores.
discoveryInfoProvider = DiscoveryInfoProvider()
discoveryInfoProvider.configureEndpoint(host)
discoveryInfoProvider.configureCredentials(rootCAPath, certificatePath, privateKeyPath)
discoveryInfoProvider.configureTimeout(10) # 10 seconds.
GROUP_CA_PATH = "./groupCA/"
MQTT_QOS = 1
discovered = False
groupCA = None
coreInfo = None
try:
# Get discovery info from AWS IoT.
discoveryInfo = discoveryInfoProvider.discover(thingName)
caList = discoveryInfo.getAllCas()
coreList = discoveryInfo.getAllCores()
# Use first discovery result.
groupId, ca = caList[0]
coreInfo = coreList[0]
# Save the group CA to a local file.
groupCA = GROUP_CA_PATH + groupId + "_CA_" + str(uuid.uuid4()) + ".crt"
if not os.path.exists(GROUP_CA_PATH):
os.makedirs(GROUP_CA_PATH)
groupCAFile = open(groupCA, "w")
groupCAFile.write(ca)
groupCAFile.close()
discovered = True
except DiscoveryInvalidRequestException as e:
print("Invalid discovery request detected!")
print("Type: %s" % str(type(e)))
print("Error message: %s" % str(e))
print("Stopping...")
except BaseException as e:
print("Error in discovery!")
print("Type: %s" % str(type(e)))
print("Error message: %s" % str(e))
print("Stopping...")
myAWSIoTMQTTClient = AWSIoTMQTTClient(clientId)
myAWSIoTMQTTClient.configureCredentials(groupCA, privateKeyPath, certificatePath)
# Try to connect to the Greengrass core.
connected = False
for connectivityInfo in coreInfo.connectivityInfoList:
currentHost = connectivityInfo.host
currentPort = connectivityInfo.port
myAWSIoTMQTTClient.configureEndpoint(currentHost, currentPort)
try:
myAWSIoTMQTTClient.connect()
connected = True
except BaseException as e:
print("Error in connect!")
print("Type: %s" % str(type(e)))
print("Error message: %s" % str(e))
if connected:
break
if not connected:
print("Cannot connect to core %s. Exiting..." % coreInfo.coreThingArn)
sys.exit(-2)
# Handle the MQTT message received from GGShadowService.
def customCallback(client, userdata, message):
print("Received an MQTT message")
print(message)
# Subscribe to the MQTT topic.
myAWSIoTMQTTClient.subscribe(topic, MQTT_QOS, customCallback)
# Keep the process alive to listen for messages.
while True:
time.sleep(1)
```
## Note sulla sicurezza
Quando utilizzi il connettore di distribuzione delle applicazioni Greengrass Docker, tieni presente le seguenti considerazioni sulla sicurezza.
**Storage locale del file di Docker Compose**
Il connettore archivia una copia del file Compose nella directory specificata per il parametro `DockerComposeFileDestinationPath`.
È responsabilità dell'utente proteggere questa directory. Utilizzare le autorizzazioni del file system per limitare l'accesso alla directory.
**Storage locale delle credenziali Docker**
Se le immagini Docker vengono archiviate in repository privati, il connettore archivia le credenziali Docker nella directory specificata per il parametro `DockerComposeFileDestinationPath`.
È responsabilità dell'utente proteggere queste credenziali. Ad esempio, utilizzare [credential-helper](https://docs.docker.com/engine/reference/commandline/login/#credentials-store) sul dispositivo core quando si installa Docker Engine.
**Istallazione di Docker Engine da un'origine attendibile**
È responsabilità dell'utente installare Docker Engine da un'origine attendibile. Questo connettore utilizza il daemon Docker sul dispositivo core per accedere agli asset Docker e gestire i container Docker.
**Ambito delle autorizzazioni del ruolo del gruppo Greengrass**
Le autorizzazioni aggiunte al ruolo di gruppo Greengrass possono essere assunte da tutte le funzioni e i connettori Lambda del gruppo Greengrass. Questo connettore richiede l'accesso al file di Docker Compose archiviato in un bucket S3. Richiede inoltre l'accesso al token di autorizzazione Amazon ECR se le immagini Docker sono archiviate in un repository privato in Amazon ECR.
## Licenze
Il connettore di distribuzione delle applicazioni Greengrass Docker include i seguenti software/licenze di terze parti:
+ [AWS SDK per Python (Boto3)](https://pypi.org/project/boto3/)/Apache License 2.0
+ [botocore](https://pypi.org/project/botocore/)/Apache License 2.0
+ [dateutil](https://pypi.org/project/python-dateutil/1.4/)/PSF License
+ [docutils](https://pypi.org/project/docutils/)/BSD License, GNU General Public License (GPL), Python Software Foundation License, Public Domain
+ [jmespath](https://pypi.org/project/jmespath/)/MIT License
+ [s3transfer](https://pypi.org/project/s3transfer/)/Apache License 2.0
+ [urllib3](https://pypi.org/project/urllib3/)/MIT License
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche |
| --- | --- |
| 7 | `DockerOfflineMode`Aggiunto per utilizzare un file Docker Compose esistente all' AWS IoT Greengrass avvio offline. Sono stati implementati nuovi tentativi per il comando. `docker login` Support per 32 bit UIDs. |
| 6 | Aggiunto `StopContainersOnNewDeployment` per ignorare la pulizia del contenitore quando viene effettuata una nuova implementazione o GGC si interrompe. Meccanismi di spegnimento e avvio più sicuri. Correzione di bug di convalida YAML. |
| 5 | Le immagini vengono estratte prima dell'esecuzione. `docker-compose down` |
| 4 | Aggiunto pull-before-up un comportamento per aggiornare le immagini Docker. |
| 3 | Risolto un problema con la ricerca di variabili d'ambiente. |
| 2 | Aggiunto il parametro `ForceDeploy`. |
| 1 | Versione iniziale. |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
# Connettore IoT Analytics
**avvertimento**
Questo connettore è entrato nella *fase di vita prolungata* e AWS IoT Greengrass non rilascerà aggiornamenti che forniscano funzionalità, miglioramenti alle funzionalità esistenti, patch di sicurezza o correzioni di bug. Per ulteriori informazioni, consulta [AWS IoT Greengrass Version 1 politica di manutenzione](maintenance-policy.md).
Il connettore IoT Analytics invia i dati del dispositivo locale a AWS IoT Analytics. È possibile utilizzare questo connettore come hub centrale per raccogliere dati dai sensori sul dispositivo principale Greengrass e dai dispositivi [client collegati](what-is-gg.md#greengrass-devices). Il connettore invia i dati ai AWS IoT Analytics canali della regione corrente Account AWS e della regione. Può inviare i dati a un canale di destinazione predefinito e ai canali specificati in modo dinamico.
**Nota**
AWS IoT Analytics è un servizio completamente gestito che consente di raccogliere, archiviare, elaborare e interrogare dati IoT. Nel AWS IoT Analytics, i dati possono essere ulteriormente analizzati ed elaborati. Ad esempio, possono essere utilizzati per dare forma ai modelli ML per il monitoraggio della salute macchina o per testare nuove strategie di modellazione. Per ulteriori informazioni, consulta [Cos'è AWS IoT Analytics?](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) nella *Guida AWS IoT Analytics per l'utente*.
Il connettore accetta i dati formattati e non formattati negli [argomenti MQTT di input](#iot-analytics-connector-data-input). Supporta due argomenti predefiniti in cui il canale di destinazione viene specificato in linea. Può anche ricevere i messaggi su argomenti definiti dal cliente che vengono [configurati nelle sottoscrizioni](connectors.md#connectors-inputs-outputs). Questo può essere usato per indirizzare messaggi da dispositivi client che pubblicano su argomenti fissi o per gestire dati non strutturati o dipendenti dallo stack provenienti da dispositivi con risorse limitate.
Questo connettore utilizza l'[https://docs.aws.amazon.com/iotanalytics/latest/userguide/api.html#cli-iotanalytics-batchputmessage](https://docs.aws.amazon.com/iotanalytics/latest/userguide/api.html#cli-iotanalytics-batchputmessage)API per inviare dati (come stringa con codifica JSON o base64) al canale di destinazione. Il connettore è in grado di eseguire i dati non elaborati in un formato che soddisfa i requisiti delle API. Il connettore memorizza nel buffer i messaggi nelle code per canale ed elabora in modo asincrono i batch. Offre i parametri che consentono di controllare l'accodamento e la creazione di comportamenti in batch, nonché di limitare il consumo della memoria. Ad esempio, è possibile configurare dimensioni massime della coda, intervallo in batch, dimensioni della memoria e numero di canali attivo.
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 4 | `arn:aws:greengrass:region::/connectors/IoTAnalytics/versions/4` |
| 3 | `arn:aws:greengrass:region::/connectors/IoTAnalytics/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/IoTAnalytics/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/IoTAnalytics/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#iot-analytics-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 3 - 4 ]
+ AWS IoT Greengrass Software principale v1.9.3 o successivo.
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ Questo connettore può essere utilizzato solo nelle regioni di Amazon Web Services in cui entrambi [AWS IoT Greengrass[AWS IoT Analytics](https://docs.aws.amazon.com/general/latest/gr/iot-analytics.html)](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)sono supportati.
+ Tutte le AWS IoT Analytics entità e i flussi di lavoro correlati vengono creati e configurati. Le entità includono canali, pipeline, datastore e set di dati. Per ulteriori informazioni, consulta le procedure [AWS CLI](https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html) o [console](https://docs.aws.amazon.com/iotanalytics/latest/userguide/quickstart.html) nella *Guida per l'utente AWS IoT Analytics *.
**Nota**
AWS IoT Analytics I canali di destinazione devono utilizzare lo stesso account e trovarsi nello Regione AWS stesso connettore.
+ Il [ruolo del gruppo Greengrass](group-role.md) è configurato per consentire l'`iotanalytics:BatchPutMessage`azione sui canali di destinazione, come mostrato nel seguente esempio di politica IAM. I canali devono trovarsi nell'area corrente Account AWS e nella regione.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Stmt1528133056761",
"Action": [
"iotanalytics:BatchPutMessage"
],
"Effect": "Allow",
"Resource": [
"arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_1_name",
"arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_2_name"
]
}
]
}
```
------
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
------
#### [ Versions 1 - 2 ]
+ AWS IoT Greengrass Software principale v1.7 o successivo.
+ [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH.
+ Questo connettore può essere utilizzato solo nelle regioni di Amazon Web Services in cui entrambi [AWS IoT Greengrass[AWS IoT Analytics](https://docs.aws.amazon.com/general/latest/gr/iot-analytics.html)](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)sono supportati.
+ Tutte le AWS IoT Analytics entità e i flussi di lavoro correlati vengono creati e configurati. Le entità includono canali, pipeline, datastore e set di dati. Per ulteriori informazioni, consulta le procedure [AWS CLI](https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html) o [console](https://docs.aws.amazon.com/iotanalytics/latest/userguide/quickstart.html) nella *Guida per l'utente AWS IoT Analytics *.
**Nota**
AWS IoT Analytics I canali di destinazione devono utilizzare lo stesso account e trovarsi nello Regione AWS stesso connettore.
+ Il [ruolo del gruppo Greengrass](group-role.md) è configurato per consentire l'`iotanalytics:BatchPutMessage`azione sui canali di destinazione, come mostrato nel seguente esempio di politica IAM. I canali devono trovarsi nell'area corrente Account AWS e nella regione.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Stmt1528133056761",
"Action": [
"iotanalytics:BatchPutMessage"
],
"Effect": "Allow",
"Resource": [
"arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_1_name",
"arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_2_name"
]
}
]
}
```
------
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
------
## Parameters
`MemorySize`
La quantità di memoria (in KB) da allocare al connettore.
Nome visualizzato nella AWS IoT console: **dimensione della memoria**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `^[0-9]+$`
`PublishRegion`
Il Regione AWS modo in cui vengono creati i tuoi AWS IoT Analytics canali. Utilizza la stessa regione del connettore.
Questo deve inoltre corrispondere alla regione per i canali specificati nel [ruolo gruppo](#iot-analytics-connector-req).
Nome visualizzato nella AWS IoT console: **regione di pubblicazione**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^$|([a-z]{2}-[a-z]+-\\d{1})`
`PublishInterval`
L'intervallo (in secondi) in cui pubblicare un batch di dati ricevuti. AWS IoT Analytics
Nome visualizzato nella AWS IoT console: Intervallo di **pubblicazione**
Obbligatorio: `false`
Tipo: `string`
Valore predefinito: `1`
Schema valido: `$|^[0-9]+$`
`IotAnalyticsMaxActiveChannels`
Il numero massimo di AWS IoT Analytics canali che il connettore monitora attivamente. Questo deve essere maggiore di 0 e almeno pari al numero di canali su cui prevedi che il connettore pubblicherà in un determinato momento.
Puoi utilizzare questo parametro per limitare il consumo della memoria limitando il numero totale di code che il connettore è in grado di gestire in un determinato momento. Una coda viene eliminato quando tutti i messaggi in coda vengono inviati.
Nome visualizzato nella AWS IoT console: **numero massimo di canali attivi**
Obbligatorio: `false`
Tipo: `string`
Valore predefinito: `50`
Schema valido: `^$|^[1-9][0-9]*$`
`IotAnalyticsQueueDropBehavior`
Il comportamento per l'eliminazione di messaggi da una coda del canale quando la coda è piena.
Nome visualizzato nella AWS IoT console: comportamento di **caduta dalla coda**
Obbligatorio: `false`
Tipo: `string`
Valori validi: `DROP_NEWEST` o `DROP_OLDEST`
Valore predefinito: `DROP_NEWEST`
Modello valido: `^DROP_NEWEST$|^DROP_OLDEST$`
`IotAnalyticsQueueSizePerChannel`
Il numero massimo di messaggi da conservare in memoria (per canale) prima che vengano inviati o eliminati. Questo numero deve essere maggiore di 0.
Nome visualizzato nella AWS IoT console: **dimensione massima della coda per canale**
Obbligatorio: `false`
Tipo: `string`
Valore predefinito: `2048`
Modello valido: `^$|^[1-9][0-9]*$`
`IotAnalyticsBatchSizePerChannel`
Il numero massimo di messaggi da inviare a un AWS IoT Analytics canale in una richiesta batch. Questo numero deve essere maggiore di 0.
Nome visualizzato nella AWS IoT console: **numero massimo di messaggi da raggruppare in batch per canale**
Obbligatorio: `false`
Tipo: `string`
Valore predefinito: `5`
Modello valido: `^$|^[1-9][0-9]*$`
`IotAnalyticsDefaultChannelName`
Il nome del AWS IoT Analytics canale utilizzato da questo connettore per i messaggi inviati a un argomento di input definito dal cliente.
Nome visualizzato nella AWS IoT console: nome del canale **predefinito**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^[a-zA-Z0-9_]$`
`IsolationMode`
Modalità di [containerizzazione](connectors.md#connector-containerization) per questo connettore. L'impostazione predefinita è`GreengrassContainer`, il che significa che il connettore viene eseguito in un ambiente di runtime isolato all'interno del AWS IoT Greengrass contenitore.
L'impostazione predefinita della containerizzazione per il gruppo non si applica ai connettori.
Nome visualizzato nella AWS IoT console: **modalità di isolamento del contenitore**
Obbligatorio: `false`
Tipo: `string`
Valori validi: `GreengrassContainer` o `NoContainer`
Modello valido: `^NoContainer$|^GreengrassContainer$`
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea una `ConnectorDefinition` versione iniziale che contiene il connettore IoT Analytics.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyIoTAnalyticsApplication",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/IoTAnalytics/versions/3",
"Parameters": {
"MemorySize": "65535",
"PublishRegion": "us-west-1",
"PublishInterval": "2",
"IotAnalyticsMaxActiveChannels": "25",
"IotAnalyticsQueueDropBehavior": "DROP_OLDEST",
"IotAnalyticsQueueSizePerChannel": "1028",
"IotAnalyticsBatchSizePerChannel": "5",
"IotAnalyticsDefaultChannelName": "my_channel"
}
}
]
}'
```
**Nota**
La funzione Lambda in questo connettore ha un ciclo di vita di [lunga durata](lambda-functions.md#lambda-lifecycle).
**Nella AWS IoT Greengrass console, puoi aggiungere un connettore dalla pagina Connettori del gruppo.** Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md).
## Dati di input
Questo connettore accetta i dati su argomenti MQTT predefiniti e definiti dal cliente. Gli editori possono essere dispositivi client, funzioni Lambda o altri connettori.
Argomenti predefiniti
Il connettore supporta i due seguenti argomenti MQTT strutturati che consentono ai publisher di specificare il nome del canale in linea.
+ Un [messaggio formattato](#iot-analytics-connector-data-input-json) sull'argomento `iotanalytics/channels/+/messages/put`. I dati IoT in questi messaggi di input devono essere in formato JSON o una stringa con codifica base64.
+ Un messaggio non formattato sull'argomento `iotanalytics/channels/+/messages/binary/put`. I messaggi di input ricevuti su questo argomento vengono trattati come dati binari e possono contenere qualsiasi tipo di dati.
Per pubblicare gli argomenti predefiniti, sostituire il carattere jolly `+` con il nome del canale. Esempio:
```
iotanalytics/channels/my_channel/messages/put
```
Argomenti definiti dal cliente
Il connettore supporta la sintassi dell'argomento `#`, che consente di accettare messaggi di input su qualsiasi argomento MQTT che configuri in una sottoscrizione. Ti consigliamo di specificare il percorso di un argomento invece di utilizzare solo il carattere `#` jolly nelle tue sottoscrizioni. Questi messaggi vengono inviati al canale predefinito specificato per il connettore.
I messaggi di input sugli argomenti definiti dal cliente vengono trattati come dati binari. Essi possono usare qualsiasi formato del messaggio e contenere qualsiasi tipo di dati. Puoi utilizzare gli argomenti definiti dal cliente per instradare i messaggi provenienti da dispositivi che pubblicano su argomenti fissi. È inoltre possibile utilizzarli per accettare dati di input da dispositivi client che non sono in grado di elaborare i dati in un messaggio formattato da inviare al connettore.
Per ulteriori informazioni sulle sottoscrizioni e sugli argomenti MQTT, consulta [Input e output](connectors.md#connectors-inputs-outputs).
Il ruolo del gruppo consente l'operazione `iotanalytics:BatchPutMessage` su tutti i canali di destinazione. Per ulteriori informazioni, consulta [Requisiti](#iot-analytics-connector-req).
**Filtro di argomenti:** `iotanalytics/channels/+/messages/put`
Utilizzare questo argomento per inviare messaggi formattati al connettore e specificare in modo dinamico un canale di destinazione. Questo argomento consente inoltre di specificare un ID restituito nell'output della risposta. Il connettore verifica che sia IDs univoco per ogni messaggio della `BatchPutMessage` richiesta in uscita a cui viene inviato. AWS IoT Analytics Viene eliminato un messaggio con un ID duplicato.
I dati di input inviati a questo argomento devono utilizzare il seguente formato del messaggio.
**Proprietà dei messaggi**
`request`
I dati da inviare al canale specificato.
Obbligatorio: `true`
Tipo: `object` che include le seguenti proprietà:
`message`
Il dispositivo o i dati di sensori come JSON o stringa con codifica base64.
Obbligatorio: `true`
Tipo: `string`
`id`
Un ID arbitrario della richiesta. Questa proprietà viene utilizzata per associare una richiesta di input a una risposta di output. Quando specificato, la proprietà `id` nell'oggetto della risposta è impostata su questo valore. Se si omette questa proprietà, il connettore genera un ID.
Obbligatorio: `false`
Tipo: `string`
Modello valido: `.*`
**Input di esempio**
```
{
"request": {
"message" : "{\"temp\":23.33}"
},
"id" : "req123"
}
```
**Filtro di argomenti:** `iotanalytics/channels/+/messages/binary/put`
Utilizzare questo argomento per inviare messaggi non formattati al connettore e specificare in modo dinamico un canale di destinazione.
I dati del connettore non analizzano i messaggi di input ricevuti su questo argomento. Vengono trattati come dati binari. Prima di inviare i messaggi a AWS IoT Analytics, il connettore li codifica e li formatta per renderli conformi ai requisiti `BatchPutMessage` dell'API:
+ Il connettore codifica su base64 i dati grezzi e include il payload codificato in una richiesta `BatchPutMessage` in uscita.
+ Il connettore genera e assegna un ID per ogni messaggio di input.
**Nota**
L'output della risposta del connettore non include una correlazione di ID per questi messaggi di input.
**Proprietà dei messaggi**
Nessuna.
**Filtro di argomenti:** `#`
Utilizzare questo argomento per inviare qualsiasi formato del messaggio al canale predefinito. Ciò è particolarmente utile quando i dispositivi client pubblicano su argomenti fissi o quando si desidera inviare dati al canale predefinito da dispositivi client che non sono in grado di elaborare i dati nel formato di [messaggio supportato](#iot-analytics-connector-data-input-json) dal connettore.
La sintassi dell'argomento viene definita nell'abbonamento creato per connettere questo connettore all'origine dati. Ti consigliamo di specificare il percorso di un argomento invece di utilizzare solo il carattere `#` jolly nelle tue sottoscrizioni.
I dati del connettore non analizzano i messaggi pubblicati su questo argomento di input. Tutti i messaggi di input vengono trattati come dati binari. Prima di inviare i messaggi a AWS IoT Analytics, il connettore li codifica e li formatta per renderli conformi ai requisiti dell'API: `BatchPutMessage`
+ Il connettore codifica su base64 i dati grezzi e include il payload codificato in una richiesta `BatchPutMessage` in uscita.
+ Il connettore genera e assegna un ID per ogni messaggio di input.
**Nota**
L'output della risposta del connettore non include una correlazione di ID per questi messaggi di input.
**Proprietà dei messaggi**
Nessuna.
## Dati di output
Questo connettore pubblica le informazioni di stato come dati di output su un argomento MQTT. Queste informazioni contengono la risposta restituita da AWS IoT Analytics per ogni messaggio di input ricevuto e inviato. AWS IoT Analytics
**Filtro argomento in sottoscrizione**
`iotanalytics/messages/put/status`
**Output di esempio: Operazione riuscita**
```
{
"response" : {
"status" : "success"
},
"id" : "req123"
}
```
**Esempio di output: Errore**
```
{
"response" : {
"status" : "fail",
"error" : "ResourceNotFoundException",
"error_message" : "A resource with the specified name could not be found."
},
"id" : "req123"
}
```
Se il connettore rileva un errore ripetibile (ad esempio errori di connessione), riprova la pubblicazione nel batch successivo. Il backoff esponenziale viene gestito dall'SDK. AWS Le richieste con errori non irreversibili vengono aggiunte alla coda del canale per ulteriore pubblicazione in base al parametro `IotAnalyticsQueueDropBehavior`.
## Esempio di utilizzo
Usa i seguenti passaggi di alto livello per configurare una funzione Lambda di esempio di Python 3.7 che puoi usare per provare il connettore.
**Nota**
Se usi altri runtime Python, puoi creare un collegamento simbolico da Python3.x a Python 3.7.
Gli argomenti [Nozioni di base sui connettori (console)](connectors-console.md) e [Nozioni di base sui connettori (CLI)](connectors-cli.md) contengono passaggi dettagliati che illustrano come configurare e distribuire un connettore Twilio Notifications di esempio.
1. Assicurarsi di soddisfare i [requisiti](#iot-analytics-connector-req) per il connettore.
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
1. Crea e pubblica una funzione Lambda che invia dati di input al connettore.
Salvare il [codice di esempio](#iot-analytics-connector-usage-example) come file PY. Scarica e decomprimi il [AWS IoT Greengrass Core SDK per Python](lambda-functions.md#lambda-sdks-core). Quindi, crea un pacchetto zip che contiene il file PY e la cartella `greengrasssdk` a livello root. Questo pacchetto zip è il pacchetto di distribuzione in cui carichi. AWS Lambda
Dopo aver creato la funzione Python 3.7 Lambda, pubblica una versione della funzione e crea un alias.
1. Configurare il gruppo Greengrass.
1. Aggiungi la funzione Lambda tramite il relativo alias (consigliato). Configura il ciclo di vita Lambda come longevo (o nella `"Pinned": true` CLI).
1. Aggiungere il connettore e configurarne i relativi [parametri](#iot-analytics-connector-param).
1. Aggiungere sottoscrizioni che consentono al connettore di ricevere [i dati di input](#iot-analytics-connector-data-input) e inviare [i dati di output](#iot-analytics-connector-data-output) nei filtri degli argomenti supportati.
+ Imposta la funzione Lambda come origine, il connettore come destinazione e utilizza un filtro per argomenti di input supportato.
+ Imposta il connettore come origine, AWS IoT Core come destinazione e utilizza un filtro per l’argomento di output supportato. Utilizzi questo abbonamento per visualizzare i messaggi di stato nella AWS IoT console.
1. Distribuisci il gruppo.
1. Nella AWS IoT console, nella pagina **Test**, sottoscrivi l'argomento relativo ai dati di output per visualizzare i messaggi di stato dal connettore. La funzione Lambda di esempio è di lunga durata e inizia a inviare messaggi subito dopo l'implementazione del gruppo.
Al termine del test, puoi impostare il ciclo di vita Lambda su richiesta (o nella CLI) e `"Pinned": false` distribuire il gruppo. Ciò impedisce alla funzione di inviare messaggi.
### Esempio
L'esempio seguente della funzione Lambda invia un messaggio di input al connettore.
```
import greengrasssdk
import time
import json
iot_client = greengrasssdk.client('iot-data')
send_topic = 'iotanalytics/channels/my_channel/messages/put'
def create_request_with_all_fields():
return {
"request": {
"message" : "{\"temp\":23.33}"
},
"id" : "req_123"
}
def publish_basic_message():
messageToPublish = create_request_with_all_fields()
print("Message To Publish: ", messageToPublish)
iot_client.publish(topic=send_topic,
payload=json.dumps(messageToPublish))
publish_basic_message()
def lambda_handler(event, context):
return
```
## Limits
Questo connettore è soggetto ai limiti descritti di seguito.
+ Tutti i limiti AWS SDK per Python (Boto3) imposti dall' AWS IoT Analytics [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/iotanalytics.html#IoTAnalytics.Client.batch_put_message](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/iotanalytics.html#IoTAnalytics.Client.batch_put_message)azione.
+ Tutte le quote imposte dall' AWS IoT Analytics [ BatchPutMessage](https://docs.aws.amazon.com/iotanalytics/latest/userguide/api.html#cli-iotanalytics-batchputmessage)API. Per ulteriori informazioni, vedere [Service Quotas](https://docs.aws.amazon.com/general/latest/gr/iot-analytics.html#limits_iot_analytics) for AWS IoT Analytics in. *Riferimenti generali di AWS*
+ 100.000 messaggi al secondo per canale.
+ 100 messaggi per batch.
+ 128 KB per messaggio.
Questa API utilizza i nomi dei canali (non i canali ARNs), pertanto l'invio di dati a canali interregionali o tra account non è supportato.
+ Tutte le quote imposte dal Core. AWS IoT Greengrass Per ulteriori informazioni, vedere [Service Quotas](https://docs.aws.amazon.com/general/latest/gr/greengrass.html#limits_greengrass) for the AWS IoT Greengrass core in. *Riferimenti generali di AWS*
In particolare potrebbero essere applicate le seguenti quote:
+ La dimensione massima dei messaggi inviati da un dispositivo è 128 KB.
+ La dimensione massima della coda di messaggi nel router core di Greengrass è 2,5 MB.
+ La lunghezza massima di una stringa argomento è 256 byte di caratteri con codifica UTF-8.
## Licenze
Il connettore IoT Analytics include i seguenti software/licenze di terze parti:
+ [AWS SDK per Python (Boto3)](https://pypi.org/project/boto3/)/Apache License 2.0
+ [botocore](https://pypi.org/project/botocore/)/Apache License 2.0
+ [dateutil](https://pypi.org/project/python-dateutil/1.4/)/PSF License
+ [docutils](https://pypi.org/project/docutils/)/BSD License, GNU General Public License (GPL), Python Software Foundation License, Public Domain
+ [jmespath](https://pypi.org/project/jmespath/)/MIT License
+ [s3transfer](https://pypi.org/project/s3transfer/)/Apache License 2.0
+ [urllib3](https://pypi.org/project/urllib3/)/MIT License
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche |
| --- | --- |
| 4 | Aggiunge il `IsolationMode` parametro per configurare la modalità di containerizzazione per il connettore. |
| 3 | È stato aggiornato il runtime Lambda a Python 3.7, che modifica i requisiti di runtime. |
| 2 | Correggere per ridurre l'eccessiva registrazione di log. |
| 1 | Versione iniziale. |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
+ [Che cos'è? AWS IoT Analytics](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) nella *Guida per l'AWS IoT Analytics utente*
# Connettore adattatore per protocollo IP Ethernet IoT
Il [connettore](connectors.md) IoT Ethernet IP Protocol Adapter raccoglie i dati dai dispositivi locali utilizzando il protocollo EtherNet/IP. È possibile utilizzare questo connettore per raccogliere dati da più dispositivi e pubblicarli in un flusso di messaggi. `StreamManager`
Puoi utilizzare questo connettore anche con il SiteWise connettore IoT e il tuo SiteWise gateway IoT. Il gateway deve fornire la configurazione per il connettore. Per ulteriori informazioni, consulta [Configurare una sorgente EtherNet/IP (EIP) nella](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/configure-eip-source.html) guida per l'utente IoT. SiteWise
**Nota**
Questo connettore funziona in modalità [Nessun contenitore](lambda-group-config.md#no-container-mode) isolato, quindi puoi distribuirlo a un AWS IoT Greengrass gruppo in esecuzione in un contenitore Docker.
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 2 (consigliato) | `arn:aws:greengrass:region::/connectors/IoTEIPProtocolAdaptor/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/IoTEIPProtocolAdaptor/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#ethernet-ip-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 1 and 2 ]
+ AWS IoT Greengrass Software di base v1.10.2 o successivo.
+ Stream manager abilitato sul gruppo. AWS IoT Greengrass
+ Java 8 installato sul dispositivo principale e aggiunto alla variabile di `PATH` ambiente.
+ Un minimo di 256 MB di RAM aggiuntiva. Questo requisito si aggiunge ai requisiti di memoria AWS IoT Greengrass Core.
**Nota**
Questo connettore è disponibile solo nelle seguenti regioni:
cn-north-1
ap-southeast-1
ap-southeast-2
eu-central-1
eu-west-1
us-east-1
us-west-2
------
## Parametri del connettore
Questo connettore supporta i seguenti parametri:
`LocalStoragePath`
La directory sull' AWS IoT Greengrass host su cui il SiteWise connettore IoT può scrivere dati persistenti. La directory predefinita è `/var/sitewise`.
Nome visualizzato nella AWS IoT console: **Percorso di archiviazione locale**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^\s*$|\/.`
`ProtocolAdapterConfiguration`
L'insieme di configurazioni del collettore EtherNet/IP da cui il connettore raccoglie i dati o a cui si connette. Può trattarsi di un elenco vuoto.
Nome visualizzato nella AWS IoT console: **Protocol Adapter Configuration**
Richiesto: `true`
Tipo: una stringa JSON ben formata che definisce l'insieme di configurazioni di feedback supportate.
Di seguito è riportato un esempio di: `ProtocolAdapterConfiguration`
```
{
"sources": [
{
"type": "EIPSource",
"name": "TestSource",
"endpoint": {
"ipAddress": "52.89.2.42",
"port": 44818
},
"destination": {
"type": "StreamManager",
"streamName": "MyOutput_Stream",
"streamBufferSize": 10
},
"destinationPathPrefix": "EIPSource_Prefix",
"propertyGroups": [
{
"name": "DriveTemperatures",
"scanMode": {
"type": "POLL",
"rate": 10000
},
"tagPathDefinitions": [
{
"type": "EIPTagPath",
"path": "arrayREAL[0]",
"dstDataType": "double"
}
]
}
]
}
]
}
```
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea una `ConnectorDefinition` versione iniziale che contiene il connettore IoT Ethernet IP Protocol Adapter.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version
'{
"Connectors": [
{
"Id": "MyIoTEIPProtocolConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/IoTEIPProtocolAdaptor/versions/2",
"Parameters": {
"ProtocolAdaptorConfiguration": "{ \"sources\": [{ \"type\": \"EIPSource\", \"name\": \"Source1\", \"endpoint\": { \"ipAddress\": \"54.245.77.218\", \"port\": 44818 }, \"destinationPathPrefix\": \"EIPConnector_Prefix\", \"propertyGroups\": [{ \"name\": \"Values\", \"scanMode\": { \"type\": \"POLL\", \"rate\": 2000 }, \"tagPathDefinitions\": [{ \"type\": \"EIPTagPath\", \"path\": \"arrayREAL[0]\", \"dstDataType\": \"double\" }]}]}]}",
"LocalStoragePath": "/var/MyIoTEIPProtocolConnectorState"
}
}
]
}'
```
**Nota**
La funzione Lambda in questo connettore ha un ciclo di vita di [lunga durata](lambda-functions.md#lambda-lifecycle).
## Dati di input
Questo connettore non accetta messaggi MQTT come dati di input.
## Dati di output
Questo connettore pubblica dati su. `StreamManager` È necessario configurare il flusso di messaggi di destinazione. I messaggi di output hanno la seguente struttura:
```
{
"alias": "string",
"messages": [
{
"name": "string",
"value": boolean|double|integer|string,
"timestamp": number,
"quality": "string"
}
]
}
```
## Licenze
Il connettore IoT Ethernet IP Protocol Adapter include i seguenti software/licenze di terze parti:
+ [Client EtherNet/IP](https://github.com/digitalpetri/ethernet-ip/blob/master/LICENSE)
+ [Mappa DB](https://github.com/jankotek/mapdb/blob/master/LICENSE.txt)
+ [Elsa](https://github.com/jankotek/elsa/blob/master/LICENSE.txt)
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche | Data |
| --- | --- | --- |
| 2 | Questa versione contiene correzioni di bug. | 23 dicembre 2021 |
| 1 | Versione iniziale. | 15 dicembre 2020 |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
# SiteWise Connettore IoT
Il SiteWise connettore IoT invia i dati locali di dispositivi e apparecchiature alle proprietà degli asset in AWS IoT SiteWise. È possibile utilizzare questo connettore per raccogliere dati da più server OPC-UA e pubblicarli su IoT. SiteWise Il connettore invia i dati alle proprietà degli asset nell'area corrente Account AWS e nella regione.
**Nota**
SiteWise L'IoT è un servizio completamente gestito che raccoglie, elabora e visualizza i dati provenienti da dispositivi e apparecchiature industriali. Puoi configurare le proprietà degli asset che elaborano i dati grezzi inviati da questo connettore alle proprietà di misurazione degli asset. Ad esempio, puoi definire una proprietà di trasformazione che converte i punti dati di temperatura Celsius di un dispositivo in Faherenheit oppure puoi definire una proprietà del parametro che calcola la temperatura oraria media. Per ulteriori informazioni, consulta [Che cos’è AWS IoT SiteWise?](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/) nella *Guida per l’utente di AWS IoT SiteWise *.
Il connettore invia dati all'IoT SiteWise con i percorsi del flusso di dati OPC-UA inviati dai server OPC-UA. Ad esempio, il percorso del flusso di dati `/company/windfarm/3/turbine/7/temperature` potrebbe rappresentare il sensore di temperatura della turbina \$17 nel parco eolico \$13. Se il AWS IoT Greengrass core perde la connessione a Internet, il connettore memorizza i dati nella cache finché non riesce a connettersi correttamente a. Cloud AWS Puoi configurare la dimensione massima del buffer del disco utilizzato per il caching dei dati. Se la dimensione della cache supera la dimensione massima del buffer del disco, il connettore elimina i dati meno recenti dalla coda.
[Dopo aver configurato e distribuito il SiteWise connettore IoT, puoi aggiungere un gateway e sorgenti OPC-UA nella console IoT. SiteWise ](https://console.aws.amazon.com/iotsitewise/) Quando configuri una sorgente nella console, puoi filtrare o aggiungere un prefisso ai percorsi del flusso di dati OPC-UA inviati dal connettore IoT. SiteWise Per istruzioni su come completare la configurazione del gateway e delle origini, consulta [Aggiunta del gateway](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/configure-gateway.html#add-gateway) nel *Manuale dell'utente di AWS IoT SiteWise *.
L'IoT SiteWise riceve dati solo dai flussi di dati mappati alle proprietà di misurazione degli asset SiteWise IoT. Per mappare i flussi di dati alle proprietà degli asset, puoi impostare l'alias di una proprietà in modo che sia equivalente a un percorso del flusso di dati OPC-UA. Per informazioni sulla definizione dei modelli di asset e la creazione di asset, consulta la sezione relativa alla [modellazione degli asset industriali](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/industrial-asset-models) nella *Guida per l'utente di AWS IoT SiteWise *.
**Note**
Puoi utilizzare stream manager per caricare dati su IoT SiteWise da fonti diverse dai server OPC-UA. Stream manager fornisce anche un supporto personalizzabile per la persistenza e la gestione della larghezza di banda. Per ulteriori informazioni, consulta [Gestisci i flussi di dati sul core AWS IoT Greengrass](stream-manager.md).
Questo connettore funziona in modalità [No container](lambda-group-config.md#no-container-mode) isolation, quindi puoi distribuirlo a un gruppo Greengrass in esecuzione in un contenitore Docker.
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 12 (consigliato) | `arn:aws:greengrass:region::/connectors/IoTSiteWise/versions/12` |
| 11 | `arn:aws:greengrass:region::/connectors/IoTSiteWise/versions/11` |
| 10 | `arn:aws:greengrass:region::/connectors/IoTSiteWise/versions/10` |
| 9 | `arn:aws:greengrass:region::/connectors/IoTSiteWise/versions/9` |
| 8 | `arn:aws:greengrass:region::/connectors/IoTSiteWise/versions/8` |
| 7 | `arn:aws:greengrass:region::/connectors/IoTSiteWise/versions/7` |
| 6 | `arn:aws:greengrass:region::/connectors/IoTSiteWise/versions/6` |
| 5 | `arn:aws:greengrass:region::/connectors/IoTSiteWise/versions/5` |
| 4 | `arn:aws:greengrass:region::/connectors/IoTSiteWise/versions/4` |
| 3 | `arn:aws:greengrass:region::/connectors/IoTSiteWise/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/IoTSiteWise/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/IoTSiteWise/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#iot-sitewise-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 9, 10, 11, and 12 ]
**Importante**
[Questa versione introduce nuovi requisiti: software di AWS IoT Greengrass base v1.10.2 e stream manager.](stream-manager.md)
+ AWS IoT Greengrass Software di base v1.10.2.
+ [Gestore di flusso](stream-manager.md) attivato nel gruppo Greengrass.
+ Java 8 installato sul dispositivo core e aggiunto alla variabile di ambiente PATH.
+ Questo connettore può essere utilizzato solo nelle regioni di Amazon Web Services in cui SiteWise sono supportati [AWS IoT Greengrass](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)sia l'[IoT](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html).
+ Una policy IAM aggiunta al ruolo del gruppo Greengrass. Questo ruolo consente al AWS IoT Greengrass gruppo di accedere all'`iotsitewise:BatchPutAssetPropertyValue`azione sull'asset root di destinazione e sui relativi figli, come illustrato nell'esempio seguente. Puoi rimuoverlo `Condition` dalla policy per consentire al connettore di accedere a tutte le tue SiteWise risorse IoT.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotsitewise:BatchPutAssetPropertyValue",
"Resource": "*",
"Condition": {
"StringLike": {
"iotsitewise:assetHierarchyPath": [
"/root node asset ID",
"/root node asset ID/*"
]
}
}
}
]
}
```
------
Per ulteriori informazioni, consulta [Aggiungere e rimuovere le policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) nella *IAM User Guide*.
------
#### [ Versions 6, 7, and 8 ]
**Importante**
[Questa versione introduce nuovi requisiti: software di AWS IoT Greengrass base v1.10.0 e stream manager.](stream-manager.md)
+ AWS IoT Greengrass Software di base v1.10.0.
+ [Gestore di flusso](stream-manager.md) attivato nel gruppo Greengrass.
+ Java 8 installato sul dispositivo core e aggiunto alla variabile di ambiente PATH.
+ Questo connettore può essere utilizzato solo nelle regioni di Amazon Web Services in cui SiteWise sono supportati [AWS IoT Greengrass](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)sia l'[IoT](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html).
+ Una policy IAM aggiunta al ruolo del gruppo Greengrass. Questo ruolo consente al AWS IoT Greengrass gruppo di accedere all'`iotsitewise:BatchPutAssetPropertyValue`azione sull'asset root di destinazione e sui relativi figli, come illustrato nell'esempio seguente. Puoi rimuoverlo `Condition` dalla policy per consentire al connettore di accedere a tutte le tue SiteWise risorse IoT.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotsitewise:BatchPutAssetPropertyValue",
"Resource": "*",
"Condition": {
"StringLike": {
"iotsitewise:assetHierarchyPath": [
"/root node asset ID",
"/root node asset ID/*"
]
}
}
}
]
}
```
------
Per ulteriori informazioni, consulta [Aggiungere e rimuovere le policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) nella *IAM User Guide*.
------
#### [ Version 5 ]
+ AWS IoT Greengrass Software di base v1.9.4.
+ Java 8 installato sul dispositivo core e aggiunto alla variabile di ambiente PATH.
+ Questo connettore può essere utilizzato solo nelle regioni di Amazon Web Services in cui SiteWise sono supportati [AWS IoT Greengrass](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)sia l'[IoT](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html).
+ Una policy IAM aggiunta al ruolo del gruppo Greengrass. Questo ruolo consente al AWS IoT Greengrass gruppo di accedere all'`iotsitewise:BatchPutAssetPropertyValue`azione sull'asset root di destinazione e sui relativi figli, come illustrato nell'esempio seguente. Puoi rimuoverlo `Condition` dalla policy per consentire al connettore di accedere a tutte le tue SiteWise risorse IoT.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotsitewise:BatchPutAssetPropertyValue",
"Resource": "*",
"Condition": {
"StringLike": {
"iotsitewise:assetHierarchyPath": [
"/root node asset ID",
"/root node asset ID/*"
]
}
}
}
]
}
```
------
Per ulteriori informazioni, consulta [Aggiungere e rimuovere le policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) nella *IAM User Guide*.
------
#### [ Version 4 ]
+ AWS IoT Greengrass Software di base v1.10.0.
+ Java 8 installato sul dispositivo core e aggiunto alla variabile di ambiente PATH.
+ Questo connettore può essere utilizzato solo nelle regioni di Amazon Web Services in cui SiteWise sono supportati [AWS IoT Greengrass](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)sia l'[IoT](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html).
+ Una policy IAM aggiunta al ruolo del gruppo Greengrass. Questo ruolo consente al AWS IoT Greengrass gruppo di accedere all'`iotsitewise:BatchPutAssetPropertyValue`azione sull'asset root di destinazione e sui relativi figli, come illustrato nell'esempio seguente. Puoi rimuoverlo `Condition` dalla policy per consentire al connettore di accedere a tutte le tue SiteWise risorse IoT.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotsitewise:BatchPutAssetPropertyValue",
"Resource": "*",
"Condition": {
"StringLike": {
"iotsitewise:assetHierarchyPath": [
"/root node asset ID",
"/root node asset ID/*"
]
}
}
}
]
}
```
------
Per ulteriori informazioni, consulta [Aggiungere e rimuovere le policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) nella *IAM User Guide*.
------
#### [ Version 3 ]
+ AWS IoT Greengrass Software di base v1.9.4.
+ Java 8 installato sul dispositivo core e aggiunto alla variabile di ambiente PATH.
+ Questo connettore può essere utilizzato solo nelle regioni di Amazon Web Services in cui SiteWise sono supportati [AWS IoT Greengrass](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)sia l'[IoT](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html).
+ Una policy IAM aggiunta al ruolo del gruppo Greengrass. Questo ruolo consente al AWS IoT Greengrass gruppo di accedere all'`iotsitewise:BatchPutAssetPropertyValue`azione sull'asset root di destinazione e sui relativi figli, come illustrato nell'esempio seguente. Puoi rimuoverlo `Condition` dalla policy per consentire al connettore di accedere a tutte le tue SiteWise risorse IoT.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotsitewise:BatchPutAssetPropertyValue",
"Resource": "*",
"Condition": {
"StringLike": {
"iotsitewise:assetHierarchyPath": [
"/root node asset ID",
"/root node asset ID/*"
]
}
}
}
]
}
```
------
Per ulteriori informazioni, consulta [Aggiungere e rimuovere le policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) nella *IAM User Guide*.
------
#### [ Versions 1 and 2 ]
+ AWS IoT Greengrass Software di base v1.9.4.
+ Java 8 installato sul dispositivo core e aggiunto alla variabile di ambiente PATH.
+ Questo connettore può essere utilizzato solo nelle regioni di Amazon Web Services in cui SiteWise sono supportati [AWS IoT Greengrass](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)sia l'[IoT](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html).
+ Una policy IAM aggiunta al ruolo del gruppo Greengrass che consente l'accesso AWS IoT Core e l'`iotsitewise:BatchPutAssetPropertyValue`azione sull'asset root di destinazione e sui relativi figli, come illustrato nell'esempio seguente. Puoi rimuoverlo `Condition` dalla policy per consentire al connettore di accedere a tutte le tue SiteWise risorse IoT.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotsitewise:BatchPutAssetPropertyValue",
"Resource": "*",
"Condition": {
"StringLike": {
"iotsitewise:assetHierarchyPath": [
"/root node asset ID",
"/root node asset ID/*"
]
}
}
},
{
"Effect": "Allow",
"Action": [
"iot:Connect",
"iot:DescribeEndpoint",
"iot:Publish",
"iot:Receive",
"iot:Subscribe"
],
"Resource": "*"
}
]
}
```
------
Per ulteriori informazioni, consulta [Aggiunta e rimozione di autorizzazioni per identità IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) nella *Guida per l’utente di IAM *.
------
## Parameters
------
#### [ Versions 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, and 12 ]
`SiteWiseLocalStoragePath`
La directory sull' AWS IoT Greengrass host su cui il SiteWise connettore IoT può scrivere dati persistenti. L’impostazione predefinita è `/var/sitewise`.
Nome visualizzato nella AWS IoT console: **Percorso di archiviazione locale**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^\s*$|\/.`
`AWSSecretsArnList`
Un elenco di segreti, ciascuno dei quali contiene una coppia chiave-valore di nome utente e password OPC-UA. Gestione dei segreti AWS Ciascun segreto deve essere di tipo coppia chiave-valore.
Nome visualizzato nella AWS IoT console: **elenco** dei segreti OPC-UA ARNs username/password
Obbligatorio: `false`
Tipo: `JsonArrayOfStrings`
Modello valido: `\[( ?,? ?\"(arn:(aws(-[a-z]+)*):secretsmanager:[a-z0-9\\-]+:[0-9]{12}:secret:([a-zA-Z0-9\\\\]+\/)*[a-zA-Z0-9\/_+=,.@\\-]+-[a-zA-Z0-9]+)*\")*\]`
`MaximumBufferSize`
La dimensione massima in GB per l'utilizzo SiteWise del disco IoT. Il valore predefinito è 10 GB.
Nome visualizzato nella AWS IoT console: dimensione **massima del buffer del disco**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^\s*$|[0-9]+`
------
#### [ Version 1 ]
`SiteWiseLocalStoragePath`
La directory sull' AWS IoT Greengrass host su cui il SiteWise connettore IoT può scrivere dati persistenti. L’impostazione predefinita è `/var/sitewise`.
Nome visualizzato nella AWS IoT console: **Percorso di archiviazione locale**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^\s*$|\/.`
`SiteWiseOpcuaUserIdentityTokenSecretArn`
Il segreto contiene Gestione dei segreti AWS la coppia chiave-valore del nome utente e della password OPC-UA. Questo segreto deve essere di tipo coppia chiave-valore.
Nome visualizzato nella AWS IoT console: **ARN** del segreto OPC-UA username/password
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^$|arn:(aws(-[a-z]+)*):secretsmanager:[a-z0-9\\-]+:[0-9]{12}:secret:([a-zA-Z0-9\\\\]+/)*[a-zA-Z0-9/_+=,.@\\-]+-[a-zA-Z0-9]+`
`SiteWiseOpcuaUserIdentityTokenSecretArn-ResourceId`
La risorsa segreta del AWS IoT Greengrass gruppo che fa riferimento a un nome utente e una password OPC-UA segreti.
Nome visualizzato nella AWS IoT console: risorsa segreta ** username/password OPC-UA**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^$|.+`
`MaximumBufferSize`
La dimensione massima in GB per l'utilizzo SiteWise del disco IoT. Il valore predefinito è 10 GB.
Nome visualizzato nella AWS IoT console: dimensione **massima del buffer del disco**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^\s*$|[0-9]+`
------
### Esempio di creazione di un connettore (AWS CLI)
Il AWS CLI comando seguente crea un file `ConnectorDefinition` con una versione iniziale che contiene il SiteWise connettore IoT.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyIoTSiteWiseConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/IoTSiteWise/versions/11"
}
]
}'
```
**Nota**
Le funzioni Lambda di questo connettore hanno un ciclo di vita di [lunga durata](lambda-functions.md#lambda-lifecycle).
**Nella AWS IoT Greengrass console, puoi aggiungere un connettore dalla pagina Connettori del gruppo.** Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md).
## Dati di input
Questo connettore non accetta messaggi MQTT come dati di input.
## Dati di output
Questo connettore non pubblica messaggi MQTT come dati di output.
## Limits
Questo connettore è soggetto ai seguenti limiti imposti dall'IoT SiteWise, inclusi i seguenti. Per ulteriori informazioni, consulta [AWS IoT SiteWise endpoint e quote](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html) in. *Riferimenti generali di AWS*
+ Numero massimo di gateway per. Account AWS
+ Numero massimo di origini OPC-UA per gateway.
+ Velocità massima di punti dati timestamp-quality-value (TQV) archiviati per. Account AWS
+ Tasso massimo di punti dati TQV archiviati per proprietà asset.
## Licenze
------
#### [ Version 9, 10, 11, and 12 ]
Il SiteWise connettore IoT include i seguenti software/licenze di terze parti:
+ [MapDB](https://github.com/jankotek/mapdb/blob/master/LICENSE.txt)
+ [Elsa](https://github.com/jankotek/elsa/blob/master/LICENSE.txt)
+ [Eclissi Milo](https://github.com/eclipse/milo/blob/maintenance/0.2/LICENSE)
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
------
#### [ Versions 6, 7, and 8 ]
Il SiteWise connettore IoT include i seguenti software/licenze di terze parti:
+ [Milo](https://github.com/eclipse/milo/) / EDL 1.0
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
------
#### [ Versions 1, 2, 3, 4, and 5 ]
Il SiteWise connettore IoT include i seguenti software/licenze di terze parti:
+ [Milo](https://github.com/eclipse/milo/) / EDL 1.0
+ [Chronicle-Queue](https://github.com/OpenHFT/Chronicle-Queue) /Licenza Apache 2.0
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
------
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche | Data |
| --- | --- | --- |
| 12 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/iot-sitewise-connector.html) | 22 dicembre 2021 |
| 11 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/iot-sitewise-connector.html) | 24 marzo 2021 |
| 10 | Configurato `StreamManager` per migliorare la gestione in caso di interruzione e ripristino della connessione di origine. Questa versione accetta anche valori OPC-UA con un `ServerTimestamp` quando no è `SourceTimestamp` disponibile. | 22 gennaio 2021 |
| 9 | Supporto lanciato per destinazioni di `StreamManager` streaming Greengrass personalizzate, deadbanding OPC-UA, modalità di scansione personalizzata e velocità di scansione personalizzata. Include anche prestazioni migliorate durante gli aggiornamenti della configurazione effettuati dal SiteWise gateway IoT. | 15 dicembre 2020 |
| 8 | Maggiore stabilità quando il connettore presenta una connettività di rete intermittente. | 19 novembre 2020 |
| 7 | È stato risolto un problema con le metriche del gateway. | 14 agosto 2020 |
| 6 | È stato aggiunto il supporto per le CloudWatch metriche e l'individuazione automatica di nuovi tag OPC-UA. Questa versione richiede [lo stream manager](stream-manager.md) e il software AWS IoT Greengrass Core v1.10.0 o superiore. | 29 aprile 2020 |
| 5 | È stato risolto un problema di compatibilità con il software AWS IoT Greengrass Core v1.9.4. | 12 febbraio 2020 |
| 4 | Risolto un problema con la riconnessione del server OPC-UA. | 7 febbraio 2020 |
| 3 | Rimozione del requisito delle autorizzazioni `iot:*`. | 17 dicembre 2019 |
| 2 | Aggiunto il supporto per più risorse segrete OPC-UA. | 10 dicembre 2019 |
| 1 | Versione iniziale. | 2 dicembre 2019 |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
+ Consulta i seguenti argomenti nella *Guida per l'utente di AWS IoT SiteWise *:
+ [Che cos'è? AWS IoT SiteWise](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/)
+ [Utilizzo di un gateway](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/gateway-connector.html)
+ [Metriche del CloudWatch gateway](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/monitor-cloudwatch-metrics.html#gateway-metrics)
+ [Risoluzione dei problemi di un SiteWise gateway IoT](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/troubleshooting.html#troubleshooting-gateway)
# Kinesis Firehose
Il [connettore](connectors.md) Kinesis Firehose pubblica i dati tramite un flusso di distribuzione Amazon Data Firehose verso destinazioni come Amazon S3, Amazon Redshift o Amazon Service. OpenSearch
Questo connettore è un produttore di dati per un flusso di distribuzione Kinesis. Riceve i dati di input in un argomento MQTT e invia i dati al flusso di distribuzione specificato. Il flusso di distribuzione invia il record dei dati alla destinazione configurata (per esempio, un bucket S3).
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 5 | `arn:aws:greengrass:region::/connectors/KinesisFirehose/versions/5` |
| 4 | `arn:aws:greengrass:region::/connectors/KinesisFirehose/versions/4` |
| 3 | `arn:aws:greengrass:region::/connectors/KinesisFirehose/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/KinesisFirehose/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/KinesisFirehose/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#kinesis-firehose-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 4 - 5 ]
+ AWS IoT Greengrass Software principale v1.9.3 o versione successiva.
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ Un flusso di distribuzione Kinesis configurato. Per ulteriori informazioni, consulta [Creazione di un flusso di distribuzione di Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) nella *Amazon Kinesis Firehose Developer Guide*.
+ Il [ruolo del gruppo Greengrass](group-role.md) è configurato per consentire le `firehose:PutRecordBatch` azioni `firehose:PutRecord` e sul flusso di consegna di destinazione, come mostrato nel seguente esempio di politica IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"Stmt1528133056761",
"Action":[
"firehose:PutRecord",
"firehose:PutRecordBatch"
],
"Effect":"Allow",
"Resource":[
"arn:aws:firehose:us-east-1:123456789012:deliverystream/stream-name"
]
}
]
}
```
------
Questo connettore consente di sostituire dinamicamente il flusso di distribuzione predefinito nel payload del messaggio di input. Se l'implementazione utilizza questa funzionalità, la policy IAM dovrebbe includere tutti i flussi di destinazione come risorse. Puoi concedere alle risorse un accesso granulare o condizionale (ad esempio, utilizzando uno schema di denominazione con il carattere jolly \$1).
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
------
#### [ Versions 2 - 3 ]
+ AWS IoT Greengrass Software di base v1.7 o successivo.
+ [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH.
+ Un flusso di distribuzione Kinesis configurato. Per ulteriori informazioni, consulta [Creazione di un flusso di distribuzione di Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) nella *Amazon Kinesis Firehose Developer Guide*.
+ Il [ruolo del gruppo Greengrass](group-role.md) è configurato per consentire le `firehose:PutRecordBatch` azioni `firehose:PutRecord` e sul flusso di consegna di destinazione, come mostrato nel seguente esempio di politica IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"Stmt1528133056761",
"Action":[
"firehose:PutRecord",
"firehose:PutRecordBatch"
],
"Effect":"Allow",
"Resource":[
"arn:aws:firehose:us-east-1:123456789012:deliverystream/stream-name"
]
}
]
}
```
------
Questo connettore consente di sostituire dinamicamente il flusso di distribuzione predefinito nel payload del messaggio di input. Se l'implementazione utilizza questa funzionalità, la policy IAM dovrebbe includere tutti i flussi di destinazione come risorse. Puoi concedere alle risorse un accesso granulare o condizionale (ad esempio, utilizzando uno schema di denominazione con il carattere jolly \$1).
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
------
#### [ Version 1 ]
+ AWS IoT Greengrass Software di base v1.7 o successivo.
+ [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH.
+ Un flusso di distribuzione Kinesis configurato. Per ulteriori informazioni, consulta [Creazione di un flusso di distribuzione di Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) nella *Amazon Kinesis Firehose Developer Guide*.
+ Il [ruolo del gruppo Greengrass](group-role.md) è configurato per consentire l'`firehose:PutRecord`azione sul flusso di consegna di destinazione, come mostrato nel seguente esempio di politica IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"Stmt1528133056761",
"Action":[
"firehose:PutRecord"
],
"Effect":"Allow",
"Resource":[
"arn:aws:firehose:us-east-1:123456789012:deliverystream/stream-name"
]
}
]
}
```
------
Questo connettore consente di sostituire dinamicamente il flusso di distribuzione predefinito nel payload del messaggio di input. Se l'implementazione utilizza questa funzionalità, la policy IAM dovrebbe includere tutti i flussi di destinazione come risorse. Puoi concedere alle risorse un accesso granulare o condizionale (ad esempio, utilizzando uno schema di denominazione con il carattere jolly \$1).
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
------
## Parametri del connettore
Questo connettore fornisce i seguenti parametri:
------
#### [ Versions 5 ]
`DefaultDeliveryStreamArn`
L'ARN del flusso di distribuzione Firehose predefinito a cui inviare i dati. Il flusso di destinazione può essere ignorato con la proprietà `delivery_stream_arn` del payload del messaggio di input.
Il ruolo del gruppo deve consentire le operazioni appropriate su tutti i flussi di distribuzione di destinazione. Per ulteriori informazioni, consulta [Requisiti](#kinesis-firehose-connector-req).
Nome visualizzato nella AWS IoT console: **flusso di distribuzione predefinito ARN**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `arn:aws:firehose:([a-z]{2}-[a-z]+-\d{1}):(\d{12}):deliverystream/([a-zA-Z0-9_\-.]+)$`
`DeliveryStreamQueueSize`
Il numero massimo di record da conservare in memoria prima che vengano rifiutati nuovi record per lo stesso flusso di distribuzione. Il valore minimo è 2000.
Nome visualizzato nella AWS IoT console: **numero massimo di record da memorizzare nel buffer (per stream**)
Obbligatorio: `true`
Tipo: `string`
Modello valido: `^([2-9]\\d{3}|[1-9]\\d{4,})$`
`MemorySize`
La quantità di memoria (in KB) da allocare al connettore.
Nome visualizzato nella AWS IoT console: **dimensione della memoria**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[0-9]+$`
`PublishInterval`
L'intervallo (in secondi) per la pubblicazione dei record su Firehose. Per disabilitare il batch, impostare questo valore su 0.
**Nome visualizzato nella AWS IoT console: Intervallo di pubblicazione**
Obbligatorio: `true`
Tipo: `string`
Valori validi: `0 - 900`
Schema valido: `[0-9]|[1-9]\\d|[1-9]\\d\\d|900`
`IsolationMode`
Modalità di [containerizzazione](connectors.md#connector-containerization) per questo connettore. L'impostazione predefinita è`GreengrassContainer`, il che significa che il connettore viene eseguito in un ambiente di runtime isolato all'interno del AWS IoT Greengrass contenitore.
L'impostazione predefinita della containerizzazione per il gruppo non si applica ai connettori.
Nome visualizzato nella AWS IoT console: **modalità di isolamento del contenitore**
Obbligatorio: `false`
Tipo: `string`
Valori validi: `GreengrassContainer` o `NoContainer`
Modello valido: `^NoContainer$|^GreengrassContainer$`
------
#### [ Versions 2 - 4 ]
`DefaultDeliveryStreamArn`
L'ARN del flusso di distribuzione Firehose predefinito a cui inviare i dati. Il flusso di destinazione può essere ignorato con la proprietà `delivery_stream_arn` del payload del messaggio di input.
Il ruolo del gruppo deve consentire le operazioni appropriate su tutti i flussi di distribuzione di destinazione. Per ulteriori informazioni, consulta [Requisiti](#kinesis-firehose-connector-req).
Nome visualizzato nella AWS IoT console: **flusso di distribuzione predefinito ARN**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `arn:aws:firehose:([a-z]{2}-[a-z]+-\d{1}):(\d{12}):deliverystream/([a-zA-Z0-9_\-.]+)$`
`DeliveryStreamQueueSize`
Il numero massimo di record da conservare in memoria prima che vengano rifiutati nuovi record per lo stesso flusso di distribuzione. Il valore minimo è 2000.
Nome visualizzato nella AWS IoT console: **numero massimo di record da memorizzare nel buffer (per stream**)
Obbligatorio: `true`
Tipo: `string`
Modello valido: `^([2-9]\\d{3}|[1-9]\\d{4,})$`
`MemorySize`
La quantità di memoria (in KB) da allocare al connettore.
Nome visualizzato nella AWS IoT console: **dimensione della memoria**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[0-9]+$`
`PublishInterval`
L'intervallo (in secondi) per la pubblicazione dei record su Firehose. Per disabilitare il batch, impostare questo valore su 0.
**Nome visualizzato nella AWS IoT console: Intervallo di pubblicazione**
Obbligatorio: `true`
Tipo: `string`
Valori validi: `0 - 900`
Schema valido: `[0-9]|[1-9]\\d|[1-9]\\d\\d|900`
------
#### [ Version 1 ]
`DefaultDeliveryStreamArn`
L'ARN del flusso di distribuzione Firehose predefinito a cui inviare i dati. Il flusso di destinazione può essere ignorato con la proprietà `delivery_stream_arn` del payload del messaggio di input.
Il ruolo del gruppo deve consentire le operazioni appropriate su tutti i flussi di distribuzione di destinazione. Per ulteriori informazioni, consulta [Requisiti](#kinesis-firehose-connector-req).
Nome visualizzato nella AWS IoT console: **flusso di distribuzione predefinito ARN**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `arn:aws:firehose:([a-z]{2}-[a-z]+-\d{1}):(\d{12}):deliverystream/([a-zA-Z0-9_\-.]+)$`
------
**Example**
**Esempio di creazione di connettore (AWS CLI)**
Il seguente comando CLI crea un `ConnectorDefinition` con una versione iniziale che contiene il connettore.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyKinesisFirehoseConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/KinesisFirehose/versions/5",
"Parameters": {
"DefaultDeliveryStreamArn": "arn:aws:firehose:region:account-id:deliverystream/stream-name",
"DeliveryStreamQueueSize": "5000",
"MemorySize": "65535",
"PublishInterval": "10",
"IsolationMode" : "GreengrassContainer"
}
}
]
}'
```
Nella AWS IoT Greengrass console, è possibile aggiungere un connettore dalla pagina **Connettori** del gruppo. Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md).
## Dati di input
Questo connettore accetta i contenuti in streaming negli argomenti MQTT e quindi invia i contenuti nel flusso di distribuzione di destinazione. Accetta due tipi di dati di input:
+ Dati JSON nell'argomento `kinesisfirehose/message`.
+ Dati binari nell'argomento `kinesisfirehose/message/binary/#`.
------
#### [ Versions 2 - 5 ]
**Filtro di argomenti:** `kinesisfirehose/message`
Utilizzare questo argomento per inviare un messaggio contenente dati JSON.
**Proprietà dei messaggi**
`request`
I dati da inviare al flusso di distribuzione e al flusso di distribuzione di destinazione, se diverso da quello predefinito.
Obbligatorio: `true`
Tipo: `object` che include le seguenti proprietà:
`data`
I dati da inviare al flusso di distribuzione.
Obbligatorio: `true`
Tipo: `string`
`delivery_stream_arn`
L'ARN del flusso di distribuzione Kinesis di destinazione. Includi questa proprietà per sovrascrivere il flusso di distribuzione predefinito.
Obbligatorio: `false`
Tipo: `string`
Modello valido: `arn:aws:firehose:([a-z]{2}-[a-z]+-\d{1}):(\d{12}):deliverystream/([a-zA-Z0-9_\-.]+)$`
`id`
Un ID arbitrario della richiesta. Questa proprietà viene utilizzata per associare una richiesta di input a una risposta di output. Quando specificato, la proprietà `id` nell'oggetto della risposta è impostata su questo valore. Se non utilizzi questa funzione, puoi omettere la proprietà oppure specificare una stringa vuota.
Obbligatorio: `false`
Tipo: `string`
Schema valido: `.*`
**Input di esempio**
```
{
"request": {
"delivery_stream_arn": "arn:aws:firehose:region:account-id:deliverystream/stream2-name",
"data": "Data to send to the delivery stream."
},
"id": "request123"
}
```
**Filtro di argomenti:** `kinesisfirehose/message/binary/#`
Utilizzare questo argomento per inviare un messaggio contenente dati binari. Il connettore non analizza i dati binari. I dati sono trasferiti in streaming così come sono.
Per associare la richiesta di input a una risposta di output, sostituisci il carattere jolly `#` nell'argomento del messaggio con un ID richiesta arbitrario. Ad esempio, se pubblichi un messaggio in `kinesisfirehose/message/binary/request123`, la proprietà `id` nell'oggetto di risposta viene impostata su `request123`.
Se non desideri associare una richiesta a una risposta, puoi pubblicare i messaggi in `kinesisfirehose/message/binary/`. Assicurarsi di includere la barra finale.
------
#### [ Version 1 ]
**Filtro di argomenti:** `kinesisfirehose/message`
Utilizzare questo argomento per inviare un messaggio contenente dati JSON.
**Proprietà dei messaggi**
`request`
I dati da inviare al flusso di distribuzione e al flusso di distribuzione di destinazione, se diverso da quello predefinito.
Obbligatorio: `true`
Tipo: `object` che include le seguenti proprietà:
`data`
I dati da inviare al flusso di distribuzione.
Obbligatorio: `true`
Tipo: `string`
`delivery_stream_arn`
L'ARN del flusso di distribuzione Kinesis di destinazione. Includi questa proprietà per sovrascrivere il flusso di distribuzione predefinito.
Obbligatorio: `false`
Tipo: `string`
Modello valido: `arn:aws:firehose:([a-z]{2}-[a-z]+-\d{1}):(\d{12}):deliverystream/([a-zA-Z0-9_\-.]+)$`
`id`
Un ID arbitrario della richiesta. Questa proprietà viene utilizzata per associare una richiesta di input a una risposta di output. Quando specificato, la proprietà `id` nell'oggetto della risposta è impostata su questo valore. Se non utilizzi questa funzione, puoi omettere la proprietà oppure specificare una stringa vuota.
Obbligatorio: `false`
Tipo: `string`
Schema valido: `.*`
**Input di esempio**
```
{
"request": {
"delivery_stream_arn": "arn:aws:firehose:region:account-id:deliverystream/stream2-name",
"data": "Data to send to the delivery stream."
},
"id": "request123"
}
```
**Filtro di argomenti:** `kinesisfirehose/message/binary/#`
Utilizzare questo argomento per inviare un messaggio contenente dati binari. Il connettore non analizza i dati binari. I dati sono trasferiti in streaming così come sono.
Per associare la richiesta di input a una risposta di output, sostituisci il carattere jolly `#` nell'argomento del messaggio con un ID richiesta arbitrario. Ad esempio, se pubblichi un messaggio in `kinesisfirehose/message/binary/request123`, la proprietà `id` nell'oggetto di risposta viene impostata su `request123`.
Se non desideri associare una richiesta a una risposta, puoi pubblicare i messaggi in `kinesisfirehose/message/binary/`. Assicurarsi di includere la barra finale.
------
## Dati di output
Questo connettore pubblica le informazioni di stato come dati di output su un argomento MQTT.
------
#### [ Versions 2 - 5 ]
**Filtro argomento in sottoscrizione**
`kinesisfirehose/message/status`
**Output di esempio**
La risposta contiene lo stato di ogni record di dati inviati nel batch.
```
{
"response": [
{
"ErrorCode": "error",
"ErrorMessage": "test error",
"id": "request123",
"status": "fail"
},
{
"firehose_record_id": "xyz2",
"id": "request456",
"status": "success"
},
{
"firehose_record_id": "xyz3",
"id": "request890",
"status": "success"
}
]
}
```
Se il connettore rileva un errore riutilizzabile (ad esempio errori di connessione), riprova la pubblicazione nel batch successivo. Il backoff esponenziale viene gestito dall'SDK. AWS Le richieste respinte con errori riproducibili vengono aggiunti alla fine della coda per ulteriore pubblicazione.
------
#### [ Version 1 ]
**Filtro argomento in sottoscrizione**
`kinesisfirehose/message/status`
**Output di esempio: Operazione riuscita**
```
{
"response": {
"firehose_record_id": "1lxfuuuFomkpJYzt/34ZU/r8JYPf8Wyf7AXqlXm",
"status": "success"
},
"id": "request123"
}
```
**Esempio di output: Errore**
```
{
"response" : {
"error": "ResourceNotFoundException",
"error_message": "An error occurred (ResourceNotFoundException) when calling the PutRecord operation: Firehose test1 not found under account 123456789012.",
"status": "fail"
},
"id": "request123"
}
```
------
## Esempio di utilizzo
Usa i seguenti passaggi di alto livello per configurare una funzione Lambda di esempio di Python 3.7 che puoi usare per provare il connettore.
**Nota**
Se usi altri runtime Python, puoi creare un collegamento simbolico da Python3.x a Python 3.7.
Gli argomenti [Nozioni di base sui connettori (console)](connectors-console.md) e [Nozioni di base sui connettori (CLI)](connectors-cli.md) contengono passaggi dettagliati che illustrano come configurare e distribuire un connettore Twilio Notifications di esempio.
1. Assicurarsi di soddisfare i [requisiti](#kinesis-firehose-connector-req) per il connettore.
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
1. Crea e pubblica una funzione Lambda che invia dati di input al connettore.
Salvare il [codice di esempio](#kinesis-firehose-connector-usage-example) come file PY. Scarica e decomprimi il [AWS IoT Greengrass Core SDK per Python](lambda-functions.md#lambda-sdks-core). Quindi, crea un pacchetto zip che contiene il file PY e la cartella `greengrasssdk` a livello root. Questo pacchetto zip è il pacchetto di distribuzione in cui carichi. AWS Lambda
Dopo aver creato la funzione Python 3.7 Lambda, pubblica una versione della funzione e crea un alias.
1. Configurare il gruppo Greengrass.
1. Aggiungi la funzione Lambda tramite il relativo alias (consigliato). Configura il ciclo di vita Lambda come longevo (o nella `"Pinned": true` CLI).
1. Aggiungere il connettore e configurarne i relativi [parametri](#kinesis-firehose-connector-param).
1. Aggiungere sottoscrizioni che consentono al connettore di ricevere [i dati di input JSON](#kinesis-firehose-connector-data-input) e inviare [i dati di output](#kinesis-firehose-connector-data-output) nei filtri degli argomenti supportati.
+ Imposta la funzione Lambda come origine, il connettore come destinazione e utilizza un filtro per argomenti di input supportato.
+ Imposta il connettore come origine, AWS IoT Core come destinazione e utilizza un filtro per l’argomento di output supportato. Utilizzi questo abbonamento per visualizzare i messaggi di stato nella AWS IoT console.
1. Distribuisci il gruppo.
1. Nella AWS IoT console, nella pagina **Test**, sottoscrivi l'argomento relativo ai dati di output per visualizzare i messaggi di stato dal connettore. La funzione Lambda di esempio è di lunga durata e inizia a inviare messaggi subito dopo l'implementazione del gruppo.
Al termine del test, puoi impostare il ciclo di vita Lambda su richiesta (o nella CLI) e `"Pinned": false` distribuire il gruppo. Ciò impedisce alla funzione di inviare messaggi.
### Esempio
L'esempio seguente della funzione Lambda invia un messaggio di input al connettore. Questo messaggio contiene dati JSON.
```
import greengrasssdk
import time
import json
iot_client = greengrasssdk.client('iot-data')
send_topic = 'kinesisfirehose/message'
def create_request_with_all_fields():
return {
"request": {
"data": "Message from Firehose Connector Test"
},
"id" : "req_123"
}
def publish_basic_message():
messageToPublish = create_request_with_all_fields()
print("Message To Publish: ", messageToPublish)
iot_client.publish(topic=send_topic,
payload=json.dumps(messageToPublish))
publish_basic_message()
def lambda_handler(event, context):
return
```
## Licenze
Il connettore Kinesis Firehose include i seguenti software/licenze di terze parti:
+ [AWS SDK per Python (Boto3)](https://pypi.org/project/boto3/)/Apache License 2.0
+ [botocore](https://pypi.org/project/botocore/)/Apache License 2.0
+ [dateutil](https://pypi.org/project/python-dateutil/1.4/)/PSF License
+ [docutils](https://pypi.org/project/docutils/)/BSD License, GNU General Public License (GPL), Python Software Foundation License, Public Domain
+ [jmespath](https://pypi.org/project/jmespath/)/MIT License
+ [s3transfer](https://pypi.org/project/s3transfer/)/Apache License 2.0
+ [urllib3](https://pypi.org/project/urllib3/)/MIT License
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche |
| --- | --- |
| 5 | Aggiunto il parametro `IsolationMode` per configurare la modalità di containerizzazione per il connettore. |
| 4 | È stato aggiornato il runtime Lambda a Python 3.7, che modifica i requisiti di runtime. |
| 3 | Correzione per ridurre la registrazione eccessiva e altre correzioni di bug minori. |
| 2 | È stato aggiunto il supporto per l'invio di record di dati in batch a Firehose a intervalli specificati. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/kinesis-firehose-connector.html) |
| 1 | Versione iniziale. |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
+ [Cos'è Amazon Kinesis Data Firehose?](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html) nella *Amazon Kinesis* Developer Guide
# Connettore ML Feedback
**avvertimento**
Questo connettore è entrato nella *fase di vita prolungata* e AWS IoT Greengrass non rilascerà aggiornamenti che forniscano funzionalità, miglioramenti alle funzionalità esistenti, patch di sicurezza o correzioni di bug. Per ulteriori informazioni, consulta [AWS IoT Greengrass Version 1 politica di manutenzione](maintenance-policy.md).
Il connettore ML Feedback semplifica l'accesso ai dati del modello di machine learning (ML) per la riqualificazione e l'analisi dei modelli. Il connettore:
+ Carica i dati di input (esempi) utilizzati dal tuo modello ML su Amazon S3. L'input del modello può essere in qualsiasi formato, ad esempio immagini, JSON o audio. Dopo che gli esempi sono stati caricati nel cloud, puoi utilizzarli per eseguire un nuovo training del modello per migliorare l'accuratezza e la precisione delle sue previsioni. Ad esempio, puoi utilizzare [SageMaker AI Ground Truth](https://docs.aws.amazon.com/sagemaker/latest/dg/sms.html) per etichettare i tuoi campioni e l'[SageMaker intelligenza artificiale](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html) per riqualificare il modello.
+ Pubblica i risultati delle previsioni ricevuti dal modello come messaggi MQTT. In questo modo puoi monitorare e analizzare la qualità dell'inferenza del modello in tempo reale. Puoi anche archiviare i risultati delle previsioni e utilizzarli per analizzare le tendenze nel corso del tempo.
+ Pubblica metriche sui caricamenti e sui dati di esempio su Amazon. CloudWatch
Per configurare questo connettore, descrivi le *configurazioni di feedback* supportate in formato JSON. [Una configurazione di feedback definisce proprietà come il bucket Amazon S3 di destinazione, il tipo di contenuto e la strategia di campionamento.](#ml-feedback-connector-sampling-strategies) (Una strategia di campionamento viene utilizzata per determinare quali esempi caricare.)
Puoi utilizzare il connettore ML Feedback nei seguenti scenari:
+ Con funzioni Lambda definite dall'utente. Le funzioni Lambda di inferenza locale utilizzano il Machine AWS IoT Greengrass Learning SDK per richiamare questo connettore e trasmettere la configurazione del feedback di destinazione, l'input e l'output del modello (risultati di previsione). Per vedere un esempio, consulta [Esempio di utilizzo](#ml-feedback-connector-usage).
+ Con il connettore [ML Image Classification](image-classification-connector.md) (v2). Per utilizzare questo connettore con il connettore ML Image Classification, configura il `MLFeedbackConnectorConfigId` parametro per il connettore ML Image Classification.
+ Con il [connettore ML Object Detection](obj-detection-connector.md). Per utilizzare questo connettore con il connettore ML Object Detection, configura il `MLFeedbackConnectorConfigId` parametro per il connettore ML Object Detection.
**ARN:** `arn:aws:greengrass:region::/connectors/MLFeedback/versions/1`
## Requisiti
Questo connettore presenta i seguenti requisiti:
+ AWS IoT Greengrass Core Software v1.9.3 o versione successiva.
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ Uno o più bucket Amazon S3. Il numero di bucket utilizzati dipende dalla strategia di campionamento.
+ Il [ruolo del gruppo Greengrass](group-role.md) è configurato per consentire l'`s3:PutObject`azione sugli oggetti nel bucket Amazon S3 di destinazione, come illustrato nel seguente esempio di policy IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:PutObject",
"Resource": [
"arn:aws:s3:::bucket-name/*"
]
}
]
}
```
------
La policy deve includere tutti i bucket di destinazione come risorse. Puoi concedere alle risorse un accesso granulare o condizionale (ad esempio, utilizzando uno schema di denominazione con il carattere jolly \$1).
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
+ Il [connettore CloudWatch Metrics](cloudwatch-metrics-connector.md) è stato aggiunto al gruppo Greengrass e configurato. Questo è obbligatorio solo se desideri utilizzare la funzionalità di creazione di report dei parametri.
+ AWS IoT Greengrass Per interagire con questo connettore è necessario [Machine Learning SDK](lambda-functions.md#lambda-sdks-ml) v1.1.0.
## Parameters
`FeedbackConfigurationMap`
Un set di una o più configurazioni di feedback che il connettore può utilizzare per caricare campioni su Amazon S3. Una configurazione di feedback definisce proprietà quali il bucket di destinazione, il tipo di contenuti e la [strategia di campionamento](#ml-feedback-connector-sampling-strategies). Quando questo connettore viene richiamato, la funzione o il connettore Lambda chiamante specifica una configurazione di feedback di destinazione.
**Nome visualizzato nella AWS IoT console: mappa di configurazione del feedback**
Obbligatorio: `true`
Tipo: una stringa JSON ben formata che definisce l'insieme di configurazioni di feedback supportate. Per vedere un esempio, consulta [FeedbackConfigurationMap esempio](#ml-feedback-connector-feedbackconfigmap).
L'ID di un oggetto di configurazione di feedback dispone dei seguenti requisiti.
L'ID:
+ Deve essere univoco tra gli oggetti di configurazione.
+ Deve iniziare con una lettera o un numero. Può contenere lettere minuscole e maiuscole, numeri e trattini.
+ Deve avere una lunghezza compresa tra 2 e 63 caratteri.
Obbligatorio: `true`
Tipo: `string`
Modello valido: `^[a-zA-Z0-9][a-zA-Z0-9-]{1,62}$`
Esempi: `MyConfig0`, `config-a`, `12id`
Il corpo di un oggetto di configurazione di feedback contiene le seguenti proprietà.
`s3-bucket-name`
Il nome del bucket Amazon S3 di destinazione.
Il ruolo del gruppo deve consentire l'operazione `s3:PutObject` su tutti i bucket di destinazione. Per ulteriori informazioni, consulta [Requisiti](#ml-feedback-connector-req).
Obbligatorio: `true`
Tipo: `string`
Modello valido: `^[a-z0-9\.\-]{3,63}$`
`content-type`
Il tipo di contenuto dei campioni da caricare. Tutti i contenuti di una singola configurazione di feedback devono essere dello stesso tipo.
Obbligatorio: `true`
Tipo: `string`
Esempi: `image/jpeg`, `application/json`, `audio/ogg`
`s3-prefix`
Il prefisso della chiave da utilizzare per i campioni caricati. Un prefisso è simile al nome di una directory. Consente di archiviare dati simili nella stessa directory in un bucket. Per ulteriori informazioni, consulta la [chiave dell'oggetto e i metadati](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
Obbligatorio: `false`
Tipo: `string`
`file-ext`
L'estensione da utilizzare per i campioni caricati. Deve essere un'estensione file valida per il tipo di contenuti.
Obbligatorio: `false`
Tipo: `string`
Esempi: `jpg`, `json`, `ogg`
`sampling-strategy`
La [strategia di campionamento](#ml-feedback-connector-sampling-strategies) da utilizzare per filtrare i campioni da caricare. Se omessa, il connettore tenta di caricare tutti i campioni che riceve.
Obbligatorio: `false`
Tipo: una stringa JSON ben formata che contiene le seguenti proprietà.
`strategy-name`
Il nome della strategia di campionamento.
Obbligatorio: `true`
Tipo: `string`
Valori validi: `RANDOM_SAMPLING`, `LEAST_CONFIDENCE`, `MARGIN` o `ENTROPY`
`rate`
La velocità della strategia di campionamento [causale](#ml-feedback-connector-sampling-strategies-random).
Obbligatorio: `true` se lo è`strategy-name`. `RANDOM_SAMPLING`
Tipo: `number`
Valori validi: `0.0 - 1.0`
`threshold`
La soglia per la strategia di campionamento [Fiducia minima](#ml-feedback-connector-sampling-strategies-least-confidence), [Margine](#ml-feedback-connector-sampling-strategies-margin) o [Entropia](#ml-feedback-connector-sampling-strategies-entropy).
Obbligatorio: `true` se `strategy-name` è `LEAST_CONFIDENCE``MARGIN`, o`ENTROPY`.
Tipo: `number`
Valori validi:
+ `0.0 - 1.0` per la strategia `LEAST_CONFIDENCE` o `MARGIN`.
+ `0.0 - no limit` per la strategia `ENTROPY`.
`RequestLimit`
Il numero massimo di richieste che il connettore può elaborare alla volta.
Puoi utilizzare questo parametro per limitare il consumo di memoria limitando il numero di richieste che il connettore elabora nello stesso momento. Le richieste che superano questo limite vengono ignorate.
Nome visualizzato nella AWS IoT console: **Request limit**
Obbligatorio: `false`
Tipo: `string`
Valori validi: `0 - 999`
Schema valido: `^$|^[0-9]{1,3}$`
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea un file `ConnectorDefinition` con una versione iniziale che contiene il connettore ML Feedback.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyMLFeedbackConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/MLFeedback/versions/1",
"Parameters": {
"FeedbackConfigurationMap": "{ \"RandomSamplingConfiguration\": { \"s3-bucket-name\": \"my-aws-bucket-random-sampling\", \"content-type\": \"image/png\", \"file-ext\": \"png\", \"sampling-strategy\": { \"strategy-name\": \"RANDOM_SAMPLING\", \"rate\": 0.5 } }, \"LeastConfidenceConfiguration\": { \"s3-bucket-name\": \"my-aws-bucket-least-confidence-sampling\", \"content-type\": \"image/png\", \"file-ext\": \"png\", \"sampling-strategy\": { \"strategy-name\": \"LEAST_CONFIDENCE\", \"threshold\": 0.4 } } }",
"RequestLimit": "10"
}
}
]
}'
```
### FeedbackConfigurationMap esempio
Di seguito è riportato un valore di esempio espanso per il parametro `FeedbackConfigurationMap`. Questo esempio include diverse configurazioni di feedback che utilizzano varie strategie di campionamento.
```
{
"ConfigID1": {
"s3-bucket-name": "my-aws-bucket-random-sampling",
"content-type": "image/png",
"file-ext": "png",
"sampling-strategy": {
"strategy-name": "RANDOM_SAMPLING",
"rate": 0.5
}
},
"ConfigID2": {
"s3-bucket-name": "my-aws-bucket-margin-sampling",
"content-type": "image/png",
"file-ext": "png",
"sampling-strategy": {
"strategy-name": "MARGIN",
"threshold": 0.4
}
},
"ConfigID3": {
"s3-bucket-name": "my-aws-bucket-least-confidence-sampling",
"content-type": "image/png",
"file-ext": "png",
"sampling-strategy": {
"strategy-name": "LEAST_CONFIDENCE",
"threshold": 0.4
}
},
"ConfigID4": {
"s3-bucket-name": "my-aws-bucket-entropy-sampling",
"content-type": "image/png",
"file-ext": "png",
"sampling-strategy": {
"strategy-name": "ENTROPY",
"threshold": 2
}
},
"ConfigID5": {
"s3-bucket-name": "my-aws-bucket-no-sampling",
"s3-prefix": "DeviceA",
"content-type": "application/json"
}
}
```
### Strategie di campionamento
Il connettore supporta quattro strategie di campionamento che determinano se caricare i campioni che vengono passati al connettore. Gli esempi sono istanze discrete di dati utilizzati da un modello per una previsione. Puoi utilizzare strategie di campionamento per filtrare i campioni che è più probabile migliorino l'accuratezza del modello.
`RANDOM_SAMPLING`
Carica in modo casuale campioni in base alla velocità fornita. Carica un campione se un valore generato casualmente è inferiore alla velocità. Più alta è la velocità, maggiore è il numero di campioni caricati.
Questa strategia ignora qualsiasi previsione del modello fornita.
`LEAST_CONFIDENCE`
Carica esempi la cui probabilità di affidabilità massima scende al di sotto della soglia fornita.
Scenario di esempio:
Soglia: `.6`
Previsione del modello: `[.2, .2, .4, .2]`
Probabilità di affidabilità massima: `.4`
Risultato:
Utilizza il campione perché la probabilità di affidabilità massima (`.4`) <= soglia (`.6`).
`MARGIN`
Carica esempi se il margine tra le prime due probabilità di affidabilità principali rientra nella soglia fornita. Il margine è la differenza tra le prime due probabilità principali.
Scenario di esempio:
Soglia: `.02`
Previsione del modello: `[.3, .35, .34, .01]`
Le due probabilità di affidabilità principali: `[.35, .34]`
Margine: `.01` (`.35 - .34`)
Risultato:
Utilizza il campione perché margine (`.01`) <= soglia (`.02`).
`ENTROPY`
Carica campioni la cui entropia è maggiore della soglia specificata. Utilizza l'entropia normalizzata della previsione del modello.
Scenario di esempio:
Soglia: `0.75`
Previsione del modello: `[.5, .25, .25]`
Entropia per la previsione: `1.03972`
Risultato:
Utilizza campione perché entropia (`1.03972`) > soglia (`0.75`).
## Dati di input
Le funzioni Lambda definite dall'utente utilizzano `publish` la funzione del client `feedback` nel Machine AWS IoT Greengrass Learning SDK per richiamare il connettore. Per vedere un esempio, consulta [Esempio di utilizzo](#ml-feedback-connector-usage).
**Nota**
Questo connettore non accetta messaggi MQTT come dati di input.
La funzione `publish` accetta i seguenti argomenti:
ConfigId
L'ID della configurazione di feedback di destinazione. Questo deve corrispondere all'ID di una configurazione di feedback definita nel [FeedbackConfigurationMap](#ml-feedback-connector-param)parametro per il connettore ML Feedback.
Obbligatorio: true
Tipo: stringa
ModelInput
I dati di input che sono stati passati a un modello per l'inferenza. Questi dati di input vengono caricati utilizzando la configurazione di destinazione, a meno che non vengano filtrati in base alla strategia di campionamento.
Obbligatorio: true
Tipo: byte
ModelPrediction
I risultati delle previsioni dal modello. Il tipo di risultato può essere un dizionario o un elenco. Ad esempio, i risultati della previsione del connettore ML Image Classification sono un elenco di probabilità (ad esempio). `[0.25, 0.60, 0.15]` Questi dati vengono pubblicati nell'argomento `/feedback/message/prediction`.
Obbligatorio: true
Tipo: dizionario o elenco di `float` valori
Metadati
Metadati specifici dell'applicazione definiti dal cliente collegati al campione caricato e pubblicati nell'argomento `/feedback/message/prediction`. Il connettore inserisce inoltre una chiave `publish-ts` con un valore di timestamp nei metadati.
Obbligatorio: false
Tipo: dizionario
Ad esempio: `{"some-key": "some value"}`
## Dati di output
Questo connettore pubblica i dati in tre argomenti MQTT:
+ Le informazioni sullo stato del connettore nell'argomento `feedback/message/status`.
+ Risultati delle previsioni nell'argomento `feedback/message/prediction`.
+ Metriche destinate all' CloudWatch `cloudwatch/metric/put`argomento.
È necessario configurare le sottoscrizioni per consentire al connettore di comunicare su argomenti MQTT. Per ulteriori informazioni, consulta [Input e output](connectors.md#connectors-inputs-outputs).
**Filtro di argomenti:** `feedback/message/status`
Utilizza questo argomento per monitorare lo stato dei caricamenti di campioni e dei campioni rimossi. Il connettore pubblica in questo argomento ogni volta che riceve una richiesta.
**Output di esempio: caricamento campione riuscito**
```
{
"response": {
"status": "success",
"s3_response": {
"ResponseMetadata": {
"HostId": "IOWQ4fDEXAMPLEQM+ey7N9WgVhSnQ6JEXAMPLEZb7hSQDASK+Jd1vEXAMPLEa3Km",
"RetryAttempts": 1,
"HTTPStatusCode": 200,
"RequestId": "79104EXAMPLEB723",
"HTTPHeaders": {
"content-length": "0",
"x-amz-id-2": "lbbqaDVFOhMlyU3gRvAX1ZIdg8P0WkGkCSSFsYFvSwLZk3j7QZhG5EXAMPLEdd4/pEXAMPLEUqU=",
"server": "AmazonS3",
"x-amz-expiration": "expiry-date=\"Wed, 17 Jul 2019 00:00:00 GMT\", rule-id=\"OGZjYWY3OTgtYWI2Zi00ZDllLWE4YmQtNzMyYzEXAMPLEoUw\"",
"x-amz-request-id": "79104EXAMPLEB723",
"etag": "\"b9c4f172e64458a5fd674EXAMPLE5628\"",
"date": "Thu, 11 Jul 2019 00:12:50 GMT",
"x-amz-server-side-encryption": "AES256"
}
},
"bucket": "greengrass-feedback-connector-data-us-west-2",
"ETag": "\"b9c4f172e64458a5fd674EXAMPLE5628\"",
"Expiration": "expiry-date=\"Wed, 17 Jul 2019 00:00:00 GMT\", rule-id=\"OGZjYWY3OTgtYWI2Zi00ZDllLWE4YmQtNzMyYzEXAMPLEoUw\"",
"key": "s3-key-prefix/UUID.file_ext",
"ServerSideEncryption": "AES256"
}
},
"id": "5aaa913f-97a3-48ac-5907-18cd96b89eeb"
}
```
Il connettore aggiunge i `key` campi `bucket` e alla risposta di Amazon S3. Per ulteriori informazioni sulla risposta di Amazon S3, consulta l'[oggetto PUT](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html#RESTObjectPUT-responses) nel riferimento all'*API di Amazon Simple Storage Service*.
**Output di esempio: campione rimosso a causa della strategia di campionamento**
```
{
"response": {
"status": "sample_dropped_by_strategy"
},
"id": "4bf5aeb0-d1e4-4362-5bb4-87c05de78ba3"
}
```
**Output di esempio: caricamento campione non riuscito**
Uno stato di errore include il messaggio di errore come il valore `error_message` e la classe di eccezione come il valore `error`.
```
{
"response": {
"status": "fail",
"error_message": "[RequestId: 4bf5aeb0-d1e4-4362-5bb4-87c05de78ba3] Failed to upload model input data due to exception. Model prediction will not be published. Exception type: NoSuchBucket, error: An error occurred (NoSuchBucket) when calling the PutObject operation: The specified bucket does not exist",
"error": "NoSuchBucket"
},
"id": "4bf5aeb0-d1e4-4362-5bb4-87c05de78ba3"
}
```
**Output di esempio: richiesta con throttling a causa del limite di richieste**
```
{
"response": {
"status": "fail",
"error_message": "Request limit has been reached (max request: 10 ). Dropping request.",
"error": "Queue.Full"
},
"id": "4bf5aeb0-d1e4-4362-5bb4-87c05de78ba3"
}
```
**Filtro di argomenti:** `feedback/message/prediction`
Utilizza questo argomento per ascoltare le previsioni in base ai dati campione caricati. Questo consente di analizzare le prestazioni del modello in tempo reale. Le previsioni dei modelli vengono pubblicate su questo argomento solo se i dati vengono caricati correttamente su Amazon S3. I messaggi pubblicati in questo argomento sono in formato JSON. Contengono il collegamento all'oggetto dati caricato, la previsione del modello e i metadati inclusi nella richiesta.
Puoi anche archiviare i risultati delle previsioni e utilizzarli per segnalare e analizzare le tendenze nel tempo. Le tendenze possono fornire informazioni preziose. Ad esempio, una tendenza *precisione decrescente nel tempo* consente di decidere se occorre eseguire un nuovo training del modello.
**Output di esempio**
```
{
"source-ref": "s3://greengrass-feedback-connector-data-us-west-2/s3-key-prefix/UUID.file_ext",
"model-prediction": [
0.5,
0.2,
0.2,
0.1
],
"config-id": "ConfigID2",
"metadata": {
"publish-ts": "2019-07-11 00:12:48.816752"
}
}
```
Puoi configurare il [connettore IoT Analytics](iot-analytics-connector.md) per iscriverti a questo argomento e inviare le informazioni a AWS IoT Analytics per ulteriori analisi o analisi cronologiche.
**Filtro di argomenti:** `cloudwatch/metric/put`
Questo è l'argomento di output utilizzato per pubblicare i parametri in CloudWatch. Questa funzionalità richiede l'installazione e la configurazione del [connettore CloudWatch Metrics](cloudwatch-metrics-connector.md).
I parametri includono:
+ Il numero di campioni caricati.
+ Le dimensioni dei campioni caricati.
+ Il numero di errori causati dai caricamenti su Amazon S3.
+ Il numero di campioni rimossi in base alla strategia di campionamento.
+ Il numero di richieste sottoposte a throttling.
**Output di esempio: dimensioni del campione di dati (pubblicato prima del caricamento effettivo)**
```
{
"request": {
"namespace": "GreengrassFeedbackConnector",
"metricData": {
"value": 47592,
"unit": "Bytes",
"metricName": "SampleSize"
}
}
}
```
**Output di esempio: caricamento campione riuscito**
```
{
"request": {
"namespace": "GreengrassFeedbackConnector",
"metricData": {
"value": 1,
"unit": "Count",
"metricName": "SampleUploadSuccess"
}
}
}
```
**Output di esempio: caricamento campione riuscito e risultato delle previsioni pubblicato**
```
{
"request": {
"namespace": "GreengrassFeedbackConnector",
"metricData": {
"value": 1,
"unit": "Count",
"metricName": "SampleAndPredictionPublished"
}
}
}
```
**Output di esempio: caricamento campione non riuscito**
```
{
"request": {
"namespace": "GreengrassFeedbackConnector",
"metricData": {
"value": 1,
"unit": "Count",
"metricName": "SampleUploadFailure"
}
}
}
```
**Output di esempio: campione rimosso a causa della strategia di campionamento**
```
{
"request": {
"namespace": "GreengrassFeedbackConnector",
"metricData": {
"value": 1,
"unit": "Count",
"metricName": "SampleNotUsed"
}
}
}
```
**Output di esempio: richiesta con throttling a causa del limite di richieste**
```
{
"request": {
"namespace": "GreengrassFeedbackConnector",
"metricData": {
"value": 1,
"unit": "Count",
"metricName": "ErrorRequestThrottled"
}
}
}
```
## Esempio di utilizzo
L'esempio seguente è una funzione Lambda definita dall'utente che utilizza [Machine AWS IoT Greengrass Learning](lambda-functions.md#lambda-sdks-ml) SDK per inviare dati al connettore ML Feedback.
**Nota**
Puoi scaricare il AWS IoT Greengrass Machine Learning SDK dalla [pagina dei AWS IoT Greengrass download](what-is-gg.md#gg-ml-sdk-download).
```
import json
import logging
import os
import sys
import greengrass_machine_learning_sdk as ml
client = ml.client('feedback')
try:
feedback_config_id = os.environ["FEEDBACK_CONFIG_ID"]
model_input_data_dir = os.environ["MODEL_INPUT_DIR"]
model_prediction_str = os.environ["MODEL_PREDICTIONS"]
model_prediction = json.loads(model_prediction_str)
except Exception as e:
logging.info("Failed to open environment variables. Failed with exception:{}".format(e))
sys.exit(1)
try:
with open(os.path.join(model_input_data_dir, os.listdir(model_input_data_dir)[0]), 'rb') as f:
content = f.read()
except Exception as e:
logging.info("Failed to open model input directory. Failed with exception:{}".format(e))
sys.exit(1)
def invoke_feedback_connector():
logging.info("Invoking feedback connector.")
try:
client.publish(
ConfigId=feedback_config_id,
ModelInput=content,
ModelPrediction=model_prediction
)
except Exception as e:
logging.info("Exception raised when invoking feedback connector:{}".format(e))
sys.exit(1)
invoke_feedback_connector()
def function_handler(event, context):
return
```
## Licenze
Il connettore ML Feedback include i seguenti software/licenze di terze parti:
+ [AWS SDK per Python (Boto3)](https://pypi.org/project/boto3/)/Apache License 2.0
+ [botocore](https://pypi.org/project/botocore/)/Apache License 2.0
+ [dateutil](https://pypi.org/project/python-dateutil/1.4/)/PSF License
+ [docutils](https://pypi.org/project/docutils/)/BSD License, GNU General Public License (GPL), Python Software Foundation License, Public Domain
+ [jmespath](https://pypi.org/project/jmespath/)/MIT License
+ [s3transfer](https://pypi.org/project/s3transfer/)/Apache License 2.0
+ [urllib3](https://pypi.org/project/urllib3/)/MIT License
+ [six](https://github.com/benjaminp/six)/MIT
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
# Connettore ML Image Classification
**avvertimento**
Questo connettore è entrato nella *fase di vita prolungata* e AWS IoT Greengrass non rilascerà aggiornamenti che forniscano funzionalità, miglioramenti alle funzionalità esistenti, patch di sicurezza o correzioni di bug. Per ulteriori informazioni, consulta [AWS IoT Greengrass Version 1 politica di manutenzione](maintenance-policy.md).
I [connettori](connectors.md) ML Image Classification forniscono un servizio di inferenza di machine learning (ML) che viene eseguito sul core. AWS IoT Greengrass Questo servizio di inferenza locale esegue la classificazione delle immagini utilizzando un modello addestrato dall'algoritmo di classificazione delle immagini SageMaker AI.
Le funzioni Lambda definite dall'utente utilizzano il Machine AWS IoT Greengrass Learning SDK per inviare richieste di inferenza al servizio di inferenza locale. Il servizio esegue l'inferenza in locale e restituisce le probabilità che l'immagine di input appartenga a categorie specifiche.
AWS IoT Greengrass fornisce le seguenti versioni di questo connettore, disponibile per più piattaforme.
------
#### [ Version 2 ]
| Connector | Descrizione e ARN |
| --- | --- |
| Classificazione delle immagini ML Aarch64 JTX2 | Servizio di inferenza per la classificazione delle immagini per NVIDIA Jetson. TX2 Supporta l'accelerazione GPU. **ARN:** `arn:aws:greengrass:region::/connectors/ImageClassificationAarch64JTX2/versions/2` |
| Classificazione delle immagini ML x86\$164 | Servizio di inferenza di classificazione delle immagini per le piattaforme x86\$164. **ARN:** `arn:aws:greengrass:region::/connectors/ImageClassificationx86-64/versions/2` |
| Classificazione delle immagini ML ARMv7 | Servizio di inferenza per la classificazione delle immagini per ARMv7 piattaforme. **ARN:** `arn:aws:greengrass:region::/connectors/ImageClassificationARMv7/versions/2` |
------
#### [ Version 1 ]
| Connector | Descrizione e ARN |
| --- | --- |
| Classificazione delle immagini ML Aarch64 JTX2 | Servizio di inferenza per la classificazione delle immagini per NVIDIA Jetson. TX2 Supporta l'accelerazione GPU. **ARN:** `arn:aws:greengrass:region::/connectors/ImageClassificationAarch64JTX2/versions/1` |
| Classificazione delle immagini ML x86\$164 | Servizio di inferenza di classificazione delle immagini per le piattaforme x86\$164. **ARN:** `arn:aws:greengrass:region::/connectors/ImageClassificationx86-64/versions/1` |
| Classificazione delle immagini ML Armv7 | Servizio di inferenza di classificazione delle immagini per le piattaforme Armv7. **ARN:** `arn:aws:greengrass:region::/connectors/ImageClassificationARMv7/versions/1` |
------
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#image-classification-connector-changelog).
## Requisiti
Questi connettori presentano i seguenti requisiti:
------
#### [ Version 2 ]
+ AWS IoT Greengrass Core Software v1.9.3 o versione successiva.
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ Dipendenze per il framework Apache installato sul dispositivo principale. MXNet Per ulteriori informazioni, consulta [Installazione MXNet delle dipendenze sul core AWS IoT Greengrass](#image-classification-connector-config).
+ Una [risorsa ML](ml-inference.md#ml-resources) del gruppo Greengrass che fa riferimento a una fonte di modelli di SageMaker intelligenza artificiale. Questo modello deve essere addestrato dall'algoritmo di classificazione delle immagini SageMaker AI. Per ulteriori informazioni, consulta [Algoritmo di classificazione delle immagini](https://docs.aws.amazon.com/sagemaker/latest/dg/image-classification.html) nella *Amazon SageMaker AI Developer Guide*.
+ Il [connettore ML Feedback](ml-feedback-connector.md) aggiunto al gruppo Greengrass e configurato. Questo è obbligatorio solo se desideri utilizzare il connettore per caricare i dati di input del modello e pubblicare le previsioni in un argomento MQTT.
+ Il [ruolo del gruppo Greengrass](group-role.md) è configurato per consentire l'`sagemaker:DescribeTrainingJob`azione sul lavoro di formazione target, come mostrato nel seguente esempio di politica IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:DescribeTrainingJob"
],
"Resource": "arn:aws:sagemaker:us-east-1:123456789012:training-job/training-job-name"
}
]
}
```
------
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
Puoi concedere alle risorse un accesso granulare o condizionale (ad esempio, utilizzando uno schema di denominazione con il carattere jolly \$1). Se in futuro cambierai il tipo di formazione desiderato, assicurati di aggiornare il ruolo del gruppo.
+ AWS IoT Greengrass Per interagire con questo connettore è necessario [Machine Learning SDK](lambda-functions.md#lambda-sdks-ml) v1.1.0.
------
#### [ Version 1 ]
+ AWS IoT Greengrass Core Software v1.7 o versione successiva.
+ [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH.
+ Dipendenze per il MXNet framework Apache installato sul dispositivo principale. Per ulteriori informazioni, consulta [Installazione MXNet delle dipendenze sul core AWS IoT Greengrass](#image-classification-connector-config).
+ Una [risorsa ML](ml-inference.md#ml-resources) del gruppo Greengrass che fa riferimento a una fonte di modelli di SageMaker intelligenza artificiale. Questo modello deve essere addestrato dall'algoritmo di classificazione delle immagini SageMaker AI. Per ulteriori informazioni, consulta [Algoritmo di classificazione delle immagini](https://docs.aws.amazon.com/sagemaker/latest/dg/image-classification.html) nella *Amazon SageMaker AI Developer Guide*.
+ Il [ruolo del gruppo Greengrass](group-role.md) è configurato per consentire l'`sagemaker:DescribeTrainingJob`azione sul lavoro di formazione target, come mostrato nel seguente esempio di politica IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:DescribeTrainingJob"
],
"Resource": "arn:aws:sagemaker:us-east-1:123456789012:training-job/training-job-name"
}
]
}
```
------
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
Puoi concedere alle risorse un accesso granulare o condizionale (ad esempio, utilizzando uno schema di denominazione con il carattere jolly \$1). Se in futuro cambierai il tipo di formazione desiderato, assicurati di aggiornare il ruolo del gruppo.
+ AWS IoT Greengrass Per interagire con questo connettore è necessario [Machine Learning SDK](lambda-functions.md#lambda-sdks-ml) v1.0.0 o versione successiva.
------
## Parametri del connettore
Questi connettori forniscono i seguenti parametri.
------
#### [ Version 2 ]
`MLModelDestinationPath`
Il percorso locale assoluto della risorsa ML all'interno dell'ambiente Lambda. Si tratta del percorso di destinazione specificato per la risorsa ML.
Se hai creato la risorsa ML nella console, si tratta del percorso locale.
Nome visualizzato nella AWS IoT console: percorso di **destinazione del modello**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `.+`
`MLModelResourceId`
L'ID della risorsa ML che fa riferimento al modello di origine.
Nome visualizzato nella AWS IoT console: risorsa **SageMaker ARN del lavoro**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `[a-zA-Z0-9:_-]+`
`MLModelSageMakerJobArn`
L'ARN del job di formazione sull' SageMaker intelligenza artificiale che rappresenta la fonte del modello SageMaker AI. Il modello deve essere addestrato dall'algoritmo di classificazione delle immagini SageMaker AI.
Nome visualizzato nella AWS IoT console: **SageMaker job ARN**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `^arn:aws:sagemaker:[a-zA-Z0-9-]+:[0-9]+:training-job/[a-zA-Z0-9][a-zA-Z0-9-]+$`
`LocalInferenceServiceName`
Il nome del servizio di inferenza locale. Le funzioni Lambda definite dall'utente richiamano il servizio passando il nome alla funzione `invoke_inference_service` del Machine AWS IoT Greengrass Learning SDK. Per vedere un esempio, consulta [Esempio di utilizzo](#image-classification-connector-usage).
**Nome visualizzato nella AWS IoT console: nome del servizio di inferenza locale**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `[a-zA-Z0-9][a-zA-Z0-9-]{1,62}`
`LocalInferenceServiceTimeoutSeconds`
L'intervallo di tempo (in secondi) prima che la richiesta di inferenza venga terminata. Il valore minimo è 1.
Nome visualizzato nella AWS IoT console: **Timeout (secondo)**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `[1-9][0-9]*`
`LocalInferenceServiceMemoryLimitKB`
La quantità di memoria (in KB) a cui ha accesso il servizio. Il valore minimo è 1.
Nome visualizzato nella AWS IoT console: **limite di memoria (KB)**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `[1-9][0-9]*`
`GPUAcceleration`
Il contesto di calcolo della CPU o GPU (accelerata). Questa proprietà si applica solo al JTX2 connettore ML Image Classification Aarch64.
**Nome visualizzato nella AWS IoT console: accelerazione GPU**
Obbligatorio: `true`
Tipo: `string`
Valori validi: `CPU` o `GPU`
`MLFeedbackConnectorConfigId`
L'ID della configurazione di feedback da utilizzare per caricare i dati di input del modello. Deve corrispondere all'ID di una configurazione di feedback definita per il [connettore ML Feedback](ml-feedback-connector.md).
Questo parametro è obbligatorio solo se desideri utilizzare il connettore ML Feedback per caricare i dati di input del modello e pubblicare le previsioni in un argomento MQTT.
Nome visualizzato nella AWS IoT console: ID di configurazione del **connettore ML Feedback**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^$|^[a-zA-Z0-9][a-zA-Z0-9-]{1,62}$`
------
#### [ Version 1 ]
`MLModelDestinationPath`
Il percorso locale assoluto della risorsa ML all'interno dell'ambiente Lambda. Si tratta del percorso di destinazione specificato per la risorsa ML.
Se hai creato la risorsa ML nella console, si tratta del percorso locale.
Nome visualizzato nella AWS IoT console: percorso di **destinazione del modello**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `.+`
`MLModelResourceId`
L'ID della risorsa ML che fa riferimento al modello di origine.
Nome visualizzato nella AWS IoT console: risorsa **SageMaker ARN del lavoro**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `[a-zA-Z0-9:_-]+`
`MLModelSageMakerJobArn`
L'ARN del job di formazione sull' SageMaker intelligenza artificiale che rappresenta la fonte del modello SageMaker AI. Il modello deve essere addestrato dall'algoritmo di classificazione delle immagini SageMaker AI.
Nome visualizzato nella AWS IoT console: **SageMaker job ARN**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `^arn:aws:sagemaker:[a-zA-Z0-9-]+:[0-9]+:training-job/[a-zA-Z0-9][a-zA-Z0-9-]+$`
`LocalInferenceServiceName`
Il nome del servizio di inferenza locale. Le funzioni Lambda definite dall'utente richiamano il servizio passando il nome alla funzione `invoke_inference_service` del Machine AWS IoT Greengrass Learning SDK. Per vedere un esempio, consulta [Esempio di utilizzo](#image-classification-connector-usage).
**Nome visualizzato nella AWS IoT console: nome del servizio di inferenza locale**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `[a-zA-Z0-9][a-zA-Z0-9-]{1,62}`
`LocalInferenceServiceTimeoutSeconds`
L'intervallo di tempo (in secondi) prima che la richiesta di inferenza venga terminata. Il valore minimo è 1.
Nome visualizzato nella AWS IoT console: **Timeout (secondo)**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `[1-9][0-9]*`
`LocalInferenceServiceMemoryLimitKB`
La quantità di memoria (in KB) a cui ha accesso il servizio. Il valore minimo è 1.
Nome visualizzato nella AWS IoT console: **limite di memoria (KB)**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `[1-9][0-9]*`
`GPUAcceleration`
Il contesto di calcolo della CPU o GPU (accelerata). Questa proprietà si applica solo al JTX2 connettore ML Image Classification Aarch64.
**Nome visualizzato nella AWS IoT console: accelerazione GPU**
Obbligatorio: `true`
Tipo: `string`
Valori validi: `CPU` o `GPU`
------
### Esempio di creazione di un connettore (AWS CLI)
I seguenti comandi CLI creano una `ConnectorDefinition` versione iniziale che contiene un connettore ML Image Classification.
**Esempio: istanza CPU**
Questo esempio crea un'istanza del connettore ML Image Classification ARMv7l.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyImageClassificationConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/ImageClassificationARMv7/versions/2",
"Parameters": {
"MLModelDestinationPath": "/path-to-model",
"MLModelResourceId": "my-ml-resource",
"MLModelSageMakerJobArn": "arn:aws:sagemaker:us-west-2:123456789012:training-job:MyImageClassifier",
"LocalInferenceServiceName": "imageClassification",
"LocalInferenceServiceTimeoutSeconds": "10",
"LocalInferenceServiceMemoryLimitKB": "500000",
"MLFeedbackConnectorConfigId": "MyConfig0"
}
}
]
}'
```
**Esempio: istanza GPU**
Questo esempio crea un'istanza del JTX2 connettore ML Image Classification Aarch64, che supporta l'accelerazione GPU su una scheda NVIDIA Jetson. TX2
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyImageClassificationConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/ImageClassificationAarch64JTX2/versions/2",
"Parameters": {
"MLModelDestinationPath": "/path-to-model",
"MLModelResourceId": "my-ml-resource",
"MLModelSageMakerJobArn": "arn:aws:sagemaker:us-west-2:123456789012:training-job:MyImageClassifier",
"LocalInferenceServiceName": "imageClassification",
"LocalInferenceServiceTimeoutSeconds": "10",
"LocalInferenceServiceMemoryLimitKB": "500000",
"GPUAcceleration": "GPU",
"MLFeedbackConnectorConfigId": "MyConfig0"
}
}
]
}'
```
**Nota**
La funzione Lambda di questi connettori ha un ciclo di vita di [lunga durata](lambda-functions.md#lambda-lifecycle).
**Nella AWS IoT Greengrass console, puoi aggiungere un connettore dalla pagina Connettori del gruppo.** Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md).
## Dati di input
Questi connettori accettano un file di immagine come input. I file di immagine di input devono essere in formato `png` o `jpeg`. Per ulteriori informazioni, consulta [Esempio di utilizzo](#image-classification-connector-usage).
Questi connettori non accettano messaggi MQTT come dati di input.
## Dati di output
Questi connettori restituiscono una previsione formattata per l'oggetto identificato nell'immagine di input:
```
[0.3,0.1,0.04,...]
```
La previsione contiene un elenco di valori che corrispondono alle categorie utilizzate nel set di dati di training durante il training del modello. Ogni valore rappresenta la probabilità che l'immagine rientri nella categoria corrispondente. La categoria con la probabilità più alta è la previsione dominante.
Questi connettori non pubblicano messaggi MQTT come dati di output.
## Esempio di utilizzo
L'esempio seguente della funzione Lambda utilizza il [AWS IoT Greengrass Machine Learning SDK](lambda-functions.md#lambda-sdks-ml) per interagire con un connettore ML Image Classification.
**Nota**
Puoi scaricare l'SDK dalla pagina dei download di [AWS IoT Greengrass Machine Learning SDK](what-is-gg.md#gg-ml-sdk-download).
In questo esempio viene inizializzato un client SDK e viene chiamata in modo sincrono la funzione `invoke_inference_service` di SDK per richiamare il servizio di inferenza locale. Trasferisce il tipo di algoritmo, il nome del servizio, il tipo di immagine e il contenuto dell'immagine. Quindi, l'esempio analizza la risposta del servizio per ottenere i risultati di probabilità (previsioni).
------
#### [ Python 3.7 ]
```
import logging
from threading import Timer
import numpy as np
import greengrass_machine_learning_sdk as ml
# We assume the inference input image is provided as a local file
# to this inference client Lambda function.
with open('/test_img/test.jpg', 'rb') as f:
content = bytearray(f.read())
client = ml.client('inference')
def infer():
logging.info('invoking Greengrass ML Inference service')
try:
resp = client.invoke_inference_service(
AlgoType='image-classification',
ServiceName='imageClassification',
ContentType='image/jpeg',
Body=content
)
except ml.GreengrassInferenceException as e:
logging.info('inference exception {}("{}")'.format(e.__class__.__name__, e))
return
except ml.GreengrassDependencyException as e:
logging.info('dependency exception {}("{}")'.format(e.__class__.__name__, e))
return
logging.info('resp: {}'.format(resp))
predictions = resp['Body'].read().decode("utf-8")
logging.info('predictions: {}'.format(predictions))
# The connector output is in the format: [0.3,0.1,0.04,...]
# Remove the '[' and ']' at the beginning and end.
predictions = predictions[1:-1]
count = len(predictions.split(','))
predictions_arr = np.fromstring(predictions, count=count, sep=',')
# Perform business logic that relies on the predictions_arr, which is an array
# of probabilities.
# Schedule the infer() function to run again in one second.
Timer(1, infer).start()
return
infer()
def function_handler(event, context):
return
```
------
#### [ Python 2.7 ]
```
import logging
from threading import Timer
import numpy
import greengrass_machine_learning_sdk as gg_ml
# The inference input image.
with open("/test_img/test.jpg", "rb") as f:
content = f.read()
client = gg_ml.client("inference")
def infer():
logging.info("Invoking Greengrass ML Inference service")
try:
resp = client.invoke_inference_service(
AlgoType="image-classification",
ServiceName="imageClassification",
ContentType="image/jpeg",
Body=content,
)
except gg_ml.GreengrassInferenceException as e:
logging.info('Inference exception %s("%s")', e.__class__.__name__, e)
return
except gg_ml.GreengrassDependencyException as e:
logging.info('Dependency exception %s("%s")', e.__class__.__name__, e)
return
logging.info("Response: %s", resp)
predictions = resp["Body"].read()
logging.info("Predictions: %s", predictions)
# The connector output is in the format: [0.3,0.1,0.04,...]
# Remove the '[' and ']' at the beginning and end.
predictions = predictions[1:-1]
predictions_arr = numpy.fromstring(predictions, sep=",")
logging.info("Split into %s predictions.", len(predictions_arr))
# Perform business logic that relies on predictions_arr, which is an array
# of probabilities.
# Schedule the infer() function to run again in one second.
Timer(1, infer).start()
infer()
# In this example, the required AWS Lambda handler is never called.
def function_handler(event, context):
return
```
------
La `invoke_inference_service` funzione nel AWS IoT Greengrass Machine Learning SDK accetta i seguenti argomenti.
| Argomento | Description |
| --- | --- |
| `AlgoType` | Il nome del tipo di algoritmo da utilizzare per l'inferenza. Attualmente è supportato solo `image-classification`. Obbligatorio: `true` Tipo: `string` Valori validi: `image-classification` |
| `ServiceName` | Il nome del servizio di inferenza locale. Utilizza il nome specificato per il parametro `LocalInferenceServiceName` al momento della configurazione del connettore. Obbligatorio: `true` Tipo: `string` |
| `ContentType` | Il tipo mime dell'immagine di input. Obbligatorio: `true` Tipo: `string` Valori validi: `image/jpeg, image/png` |
| `Body` | Il contenuto del file immagine di input. Obbligatorio: `true` Tipo: `binary` |
## Installazione MXNet delle dipendenze sul core AWS IoT Greengrass
Per utilizzare un connettore ML Image Classification, è necessario installare le dipendenze per il MXNet framework Apache sul dispositivo principale. I connettori utilizzano il framework per servire il modello ML.
**Nota**
Questi connettori sono forniti in bundle con una MXNet libreria precompilata, quindi non è necessario installare il MXNet framework sul dispositivo principale.
AWS IoT Greengrass fornisce script per installare le dipendenze per le seguenti piattaforme e dispositivi comuni (o da utilizzare come riferimento per l'installazione). Se utilizzi una piattaforma o un dispositivo diverso, consulta la [MXNet documentazione](https://mxnet.apache.org/) per la configurazione.
Prima di installare le MXNet dipendenze, assicurati che le [librerie di sistema](#image-classification-connector-logging) richieste (con le versioni minime specificate) siano presenti sul dispositivo.
------
#### [ NVIDIA Jetson TX2 ]
1. Installa CUDA Toolkit 9.0 e cuDNN 7.0. Puoi seguire le istruzioni di [Configurazione di altri dispositivi](setup-filter.other.md) nel tutorial Nozioni di base.
1. Abilita i repository universali in modo che il connettore sia in grado di installare l'open software gestito dalla community. Per ulteriori informazioni, consulta [Repository/Ubuntu](https://help.ubuntu.com/community/Repositories/Ubuntu) nella documentazione Ubuntu.
1. Apri il file `/etc/apt/sources.list`.
1. Assicurati che le seguenti righe non presentino commenti.
```
deb http://ports.ubuntu.com/ubuntu-ports/ xenial universe
deb-src http://ports.ubuntu.com/ubuntu-ports/ xenial universe
deb http://ports.ubuntu.com/ubuntu-ports/ xenial-updates universe
deb-src http://ports.ubuntu.com/ubuntu-ports/ xenial-updates universe
```
1. Salva una copia del seguente script di installazione nel file `nvidiajtx2.sh` del dispositivo core.
------
#### [ Python 3.7 ]
```
#!/bin/bash
set -e
echo "Installing dependencies on the system..."
echo 'Assuming that universe repos are enabled and checking dependencies...'
apt-get -y update
apt-get -y dist-upgrade
apt-get install -y liblapack3 libopenblas-dev liblapack-dev libatlas-base-dev
apt-get install -y python3.7 python3.7-dev
python3.7 -m pip install --upgrade pip
python3.7 -m pip install numpy==1.15.0
python3.7 -m pip install opencv-python || echo 'Error: Unable to install OpenCV with pip on this platform. Try building the latest OpenCV from source (https://github.com/opencv/opencv).'
echo 'Dependency installation/upgrade complete.'
```
**Nota**
Se [OpenCV](https://github.com/opencv/opencv) non viene installato correttamente utilizzando questo script, puoi provare a compilare dall'origine. Per ulteriori informazioni, consulta [ Installazione in Linux](https://docs.opencv.org/4.1.0/d7/d9f/tutorial_linux_install.html) nella documentazione di OpenCV o fai riferimento ad altre risorse online per la tua piattaforma.
------
#### [ Python 2.7 ]
```
#!/bin/bash
set -e
echo "Installing dependencies on the system..."
echo 'Assuming that universe repos are enabled and checking dependencies...'
apt-get -y update
apt-get -y dist-upgrade
apt-get install -y liblapack3 libopenblas-dev liblapack-dev libatlas-base-dev python-dev
echo 'Install latest pip...'
wget https://bootstrap.pypa.io/get-pip.py
python get-pip.py
rm get-pip.py
pip install numpy==1.15.0 scipy
echo 'Dependency installation/upgrade complete.'
```
------
1. Dalla directory in cui hai salvato il file, esegui il seguente comando:
```
sudo nvidiajtx2.sh
```
------
#### [ x86\$164 (Ubuntu or Amazon Linux) ]
1. Salva una copia del seguente script di installazione nel file `x86_64.sh` del dispositivo core.
------
#### [ Python 3.7 ]
```
#!/bin/bash
set -e
echo "Installing dependencies on the system..."
release=$(awk -F= '/^NAME/{print $2}' /etc/os-release)
if [ "$release" == '"Ubuntu"' ]; then
# Ubuntu. Supports EC2 and DeepLens. DeepLens has all the dependencies installed, so
# this is mostly to prepare dependencies on Ubuntu EC2 instance.
apt-get -y update
apt-get -y dist-upgrade
apt-get install -y libgfortran3 libsm6 libxext6 libxrender1
apt-get install -y python3.7 python3.7-dev
elif [ "$release" == '"Amazon Linux"' ]; then
# Amazon Linux. Expect python to be installed already
yum -y update
yum -y upgrade
yum install -y compat-gcc-48-libgfortran libSM libXrender libXext
else
echo "OS Release not supported: $release"
exit 1
fi
python3.7 -m pip install --upgrade pip
python3.7 -m pip install numpy==1.15.0
python3.7 -m pip install opencv-python || echo 'Error: Unable to install OpenCV with pip on this platform. Try building the latest OpenCV from source (https://github.com/opencv/opencv).'
echo 'Dependency installation/upgrade complete.'
```
**Nota**
Se [OpenCV](https://github.com/opencv/opencv) non viene installato correttamente utilizzando questo script, puoi provare a compilare dall'origine. Per ulteriori informazioni, consulta [ Installazione in Linux](https://docs.opencv.org/4.1.0/d7/d9f/tutorial_linux_install.html) nella documentazione di OpenCV o fai riferimento ad altre risorse online per la tua piattaforma.
------
#### [ Python 2.7 ]
```
#!/bin/bash
set -e
echo "Installing dependencies on the system..."
release=$(awk -F= '/^NAME/{print $2}' /etc/os-release)
if [ "$release" == '"Ubuntu"' ]; then
# Ubuntu. Supports EC2 and DeepLens. DeepLens has all the dependencies installed, so
# this is mostly to prepare dependencies on Ubuntu EC2 instance.
apt-get -y update
apt-get -y dist-upgrade
apt-get install -y libgfortran3 libsm6 libxext6 libxrender1 python-dev python-pip
elif [ "$release" == '"Amazon Linux"' ]; then
# Amazon Linux. Expect python to be installed already
yum -y update
yum -y upgrade
yum install -y compat-gcc-48-libgfortran libSM libXrender libXext python-pip
else
echo "OS Release not supported: $release"
exit 1
fi
pip install numpy==1.15.0 scipy opencv-python
echo 'Dependency installation/upgrade complete.'
```
------
1. Dalla directory in cui hai salvato il file, esegui il comando seguente:
```
sudo x86_64.sh
```
------
#### [ Armv7 (Raspberry Pi) ]
1. Salva una copia del seguente script di installazione nel file `armv7l.sh` del dispositivo core.
------
#### [ Python 3.7 ]
```
#!/bin/bash
set -e
echo "Installing dependencies on the system..."
apt-get update
apt-get -y upgrade
apt-get install -y liblapack3 libopenblas-dev liblapack-dev
apt-get install -y python3.7 python3.7-dev
python3.7 -m pip install --upgrade pip
python3.7 -m pip install numpy==1.15.0
python3.7 -m pip install opencv-python || echo 'Error: Unable to install OpenCV with pip on this platform. Try building the latest OpenCV from source (https://github.com/opencv/opencv).'
echo 'Dependency installation/upgrade complete.'
```
**Nota**
Se [OpenCV](https://github.com/opencv/opencv) non viene installato correttamente utilizzando questo script, puoi provare a compilare dall'origine. Per ulteriori informazioni, consulta [ Installazione in Linux](https://docs.opencv.org/4.1.0/d7/d9f/tutorial_linux_install.html) nella documentazione di OpenCV o fai riferimento ad altre risorse online per la tua piattaforma.
------
#### [ Python 2.7 ]
```
#!/bin/bash
set -e
echo "Installing dependencies on the system..."
apt-get update
apt-get -y upgrade
apt-get install -y liblapack3 libopenblas-dev liblapack-dev python-dev
# python-opencv depends on python-numpy. The latest version in the APT repository is python-numpy-1.8.2
# This script installs python-numpy first so that python-opencv can be installed, and then install the latest
# numpy-1.15.x with pip
apt-get install -y python-numpy python-opencv
dpkg --remove --force-depends python-numpy
echo 'Install latest pip...'
wget https://bootstrap.pypa.io/get-pip.py
python get-pip.py
rm get-pip.py
pip install --upgrade numpy==1.15.0 picamera scipy
echo 'Dependency installation/upgrade complete.'
```
------
1. Dalla directory in cui hai salvato il file, esegui il comando seguente:
```
sudo bash armv7l.sh
```
**Nota**
Su un Raspberry Pi, l'utilizzo di `pip` per installare dipendenze di machine learning è un'operazione con elevati requisiti di memoria che può esaurire la memoria del dispositivo e causarne il blocco. Per risolvere il problema, è possibile aumentare temporaneamente la dimensione di swap:
In `/etc/dphys-swapfile`, aumenta il valore della variabile `CONF_SWAPSIZE` e quindi esegui il comando seguente per riavviare `dphys-swapfile`.
```
/etc/init.d/dphys-swapfile restart
```
------
## Registrazione e risoluzione dei problemi
A seconda delle impostazioni del gruppo, i registri degli eventi e degli errori vengono scritti in CloudWatch Logs, nel file system locale o in entrambi. I log di questo connettore utilizzano il prefisso `LocalInferenceServiceName`. Se il connettore si comporta inaspettatamente, controlla i log del connettore. Questi di solito contengono utili informazioni di debug, ad esempio una dipendenza della libreria ML mancante o la causa di un errore di avvio del connettore.
Se il AWS IoT Greengrass gruppo è configurato per scrivere registri locali, il connettore scrive i file di registro su. `greengrass-root/ggc/var/log/user/region/aws/` Per ulteriori informazioni sulla registrazione di Greengrass, vedere. [Monitoraggio con AWS IoT Greengrass registri](greengrass-logs-overview.md)
Utilizzate le seguenti informazioni per risolvere i problemi relativi ai connettori ML Image Classification.
**Librerie di sistema richieste**
Le schede seguenti elencano le librerie di sistema richieste per ogni connettore ML Image Classification.
------
#### [ ML Image Classification Aarch64 JTX2 ]
| Libreria | Versione minima |
| --- | --- |
| ld-linux-aarch64.so.1 | GLIBC\$12.17 |
| libc.so.6 | GLIBC\$12.17 |
| libcublas.so.9.0 | non applicabile |
| libcudart.so.9.0 | non applicabile |
| libcudnn.so.7 | non applicabile |
| libcufft.so.9.0 | non applicabile |
| libcurand.so.9.0 | non applicabile |
| libcusolver.so.9.0 | non applicabile |
| libgcc\$1s.so.1 | GCC\$14.2.0 |
| libgomp.so.1 | GOMP\$14.0, OMP\$11.0 |
| libm.so.6 | GLIBC\$12.23 |
| libpthread.so.0 | GLIBC\$12.17 |
| librt.so.1 | GLIBC\$12.17 |
| libstdc\$1\$1.so.6 | GLIBCXX\$13.4.21, CXXABI\$11.3.8 |
------
#### [ ML Image Classification x86\$164 ]
| Libreria | Versione minima |
| --- | --- |
| ld-linux-x86-64.so.2 | GCC\$14.0.0 |
| libc.so.6 | GLIBC\$12.4 |
| libgfortran.so.3 | GFORTRAN\$11.0 |
| libm.so.6 | GLIBC\$12.23 |
| libpthread.so.0 | GLIBC\$12.2.5 |
| librt.so.1 | GLIBC\$12.2.5 |
| libstdc\$1\$1.so.6 | CXXABI\$11.3.8, GLIBCXX\$13.4.21 |
------
#### [ ML Image Classification Armv7 ]
| Libreria | Versione minima |
| --- | --- |
| ld-linux-armhf.so.3 | GLIBC\$12.4 |
| libc.so.6 | GLIBC\$12.7 |
| libgcc\$1s.so.1 | GCC\$14.0.0 |
| libgfortran.so.3 | GFORTRAN\$11.0 |
| libm.so.6 | GLIBC\$12.4 |
| libpthread.so.0 | GLIBC\$12.4 |
| librt.so.1 | GLIBC\$12.4 |
| libstdc\$1\$1.so.6 | CXXABI\$11.3.8, CXXABI\$1ARM\$11.3.3, GLIBCXX\$13.4.20 |
------
**Problemi**
| Caratteristiche | Soluzione |
| --- | --- |
| In un Raspberry Pi, il seguente messaggio di errore viene registrato e non si sta utilizzando la fotocamera: `Failed to initialize libdc1394` | Per disabilitare il driver, esegui il seguente comando: sudo ln /dev/null /dev/raw1394
Questa operazione è effimera e il collegamento simbolico scompare dopo il riavvio. Consulta il manuale di distribuzione del sistema operativo per ulteriori informazioni su come creare automaticamente il link al riavvio. |
## Licenze
I connettori ML Image Classification includono i seguenti software/licenze di terze parti:
+ [AWS SDK per Python (Boto3)](https://pypi.org/project/boto3/)/Apache License 2.0
+ [botocore](https://pypi.org/project/botocore/)/Apache License 2.0
+ [dateutil](https://pypi.org/project/python-dateutil/1.4/)/PSF License
+ [docutils](https://pypi.org/project/docutils/)/BSD License, GNU General Public License (GPL), Python Software Foundation License, Public Domain
+ [jmespath](https://pypi.org/project/jmespath/)/MIT License
+ [s3transfer](https://pypi.org/project/s3transfer/)/Apache License 2.0
+ [urllib3](https://pypi.org/project/urllib3/)/MIT License
+ [Deep Neural Network Library (DNNL)](https://github.com/intel/mkl-dnn)/Apache License 2.0
+ [OpenMP\$1 Runtime Library](https://software.intel.com/content/www/us/en/develop/documentation/cpp-compiler-developer-guide-and-reference/top/optimization-and-programming-guide/openmp-support/openmp-library-support/openmp-run-time-library-routines.html)/Consulta [Libreria di licenze di Intel OpenMP Runtime](#openmp-license).
+ [mxnet](https://pypi.org/project/mxnet/)/Apache License 2.0
+ [six](https://github.com/benjaminp/six)/MIT
**Libreria di licenze di Intel OpenMP Runtime**. Il runtime Intel® OpenMP\$1 è dotato di doppia licenza, con una licenza commerciale (COM) come parte dei prodotti Intel® Parallel Studio XE Suite e una licenza open source BSD (OSS).
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche |
| --- | --- |
| 2 | È stato aggiunto il `MLFeedbackConnectorConfigId` parametro per supportare l'uso del [connettore ML Feedback](ml-feedback-connector.md) per caricare i dati di input del modello, pubblicare previsioni su un argomento MQTT e pubblicare metriche su Amazon. CloudWatch |
| 1 | Versione iniziale. |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
+ [Esecuzione dell'inferenza di Machine Learning](ml-inference.md)
+ [Algoritmo di classificazione delle immagini](https://docs.aws.amazon.com/sagemaker/latest/dg/image-classification.html) nella *Amazon SageMaker AI Developer Guide*
# Connettore ML Object Detection
**avvertimento**
Questo connettore è entrato nella *fase di vita prolungata* e AWS IoT Greengrass non rilascerà aggiornamenti che forniscano funzionalità, miglioramenti alle funzionalità esistenti, patch di sicurezza o correzioni di bug. Per ulteriori informazioni, consulta [AWS IoT Greengrass Version 1 politica di manutenzione](maintenance-policy.md).
I [connettori](connectors.md) ML Object Detection forniscono un servizio di inferenza di machine learning (ML) che viene eseguito sul core. AWS IoT Greengrass Questo servizio di inferenza locale esegue il rilevamento degli oggetti utilizzando un modello di rilevamento degli oggetti compilato dal compilatore di deep learning SageMaker AI Neo. Sono supportati due tipi di modelli di rilevamento dell'oggetto: Single Shot Multibox Detector (SSD) e You Only Look Once (YOLO) v3. Per ulteriori informazioni, consulta la sezione relativa ai [requisiti del modello di rilevamento dell'oggetto](#obj-detection-connector-req-model).
Le funzioni Lambda definite dall'utente utilizzano il Machine AWS IoT Greengrass Learning SDK per inviare richieste di inferenza al servizio di inferenza locale. Il servizio esegue l'inferenza locale su un'immagine di input e restituisce un elenco di previsioni per ogni oggetto rilevato nell'immagine. Ogni previsione contiene una categoria dell'oggetto, un punteggio di affidabilità della previsione e le coordinate dei pixel che specificano un riquadro di delimitazione intorno all'oggetto previsto.
AWS IoT Greengrass fornisce connettori ML Object Detection per più piattaforme:
| Connector | Descrizione e ARN |
| --- | --- |
| ML Object Detection Aarch64 JTX2 | Servizio di inferenza per il rilevamento di oggetti per NVIDIA Jetson. TX2 Supporta l'accelerazione GPU. **ARN:** `arn:aws:greengrass:region::/connectors/ObjectDetectionAarch64JTX2/versions/1` |
| Rilevamento di oggetti ML x86\$164 | Servizio di inferenza di rilevamento oggetti per piattaforme x86\$164. **ARN:** `arn:aws:greengrass:region::/connectors/ObjectDetectionx86-64/versions/1` |
| Rilevamento di oggetti ML ARMv7 | Servizio di inferenza per il rilevamento di oggetti per ARMv7 piattaforme. **ARN:** `arn:aws:greengrass:region::/connectors/ObjectDetectionARMv7/versions/1` |
## Requisiti
Questi connettori presentano i seguenti requisiti:
+ AWS IoT Greengrass Core Software v1.9.3 o versione successiva.
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ Dipendenze per il runtime di deep learning SageMaker AI Neo installato sul dispositivo principale. Per ulteriori informazioni, consulta [Installazione delle dipendenze del runtime di Neo Deep Learning sul core AWS IoT Greengrass](#obj-detection-connector-config).
+ Una [risorsa ML](ml-inference.md#ml-resources) nel gruppo Greengrass. La risorsa ML deve fare riferimento a un bucket Amazon S3 che contiene un modello di rilevamento degli oggetti. Per ulteriori informazioni, consulta i sorgenti dei [modelli Amazon S3](ml-inference.md#s3-ml-resources).
**Nota**
Il modello deve essere un tipo di modello di rilevamento dell'oggetto Single Shot Multibox Detector o You Only Look Once v3. Deve essere compilato utilizzando il compilatore di deep learning SageMaker AI Neo. Per ulteriori informazioni, consulta la sezione relativa ai [requisiti del modello di rilevamento dell'oggetto](#obj-detection-connector-req-model).
+ Il [connettore ML Feedback](ml-feedback-connector.md) aggiunto al gruppo Greengrass e configurato. Questo è obbligatorio solo se desideri utilizzare il connettore per caricare i dati di input del modello e pubblicare le previsioni in un argomento MQTT.
+ AWS IoT Greengrass Per interagire con questo connettore è necessario [Machine Learning SDK](lambda-functions.md#lambda-sdks-ml) v1.1.0.
### Requisiti del modello di rilevamento dell'oggetto
I connettori ML Object Detection supportano i modelli di rilevamento di oggetti Single Shot multibox Detector (SSD) e You Only Look Once (YOLO) v3. Puoi utilizzare i componenti di rilevamento dell'oggetto forniti da [GluonCV](https://gluon-cv.mxnet.io) per eseguire il training del modello con il tuo set di dati. In alternativa, puoi utilizzare modelli pre-formati da GluonCV Model Zoo:
+ [Modello SSD pre-formato](https://gluon-cv.mxnet.io/build/examples_detection/demo_ssd.html)
+ [Modello YOLO v3 pre-formato](https://gluon-cv.mxnet.io/build/examples_detection/demo_yolo.html)
Il training del modello di rilevamento dell'oggetto deve essere eseguito con immagini di input 512 x 512. I modelli pre-formati da GluonCV Model Zoo soddisfano già questo requisito.
I modelli di rilevamento di oggetti addestrati devono essere compilati con il compilatore di deep learning AI Neo. SageMaker Durante la compilazione, assicurati che l'hardware di destinazione corrisponda all'hardware del dispositivo core Greengrass. Per ulteriori informazioni, consulta [ SageMaker AI Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) nella *Amazon SageMaker AI Developer Guide*.
Il modello compilato deve essere aggiunto come risorsa ML ([origine del modello Amazon S3](ml-inference.md#s3-ml-resources)) allo stesso gruppo Greengrass del connettore.
## Parametri del connettore
Questi connettori forniscono i seguenti parametri.
`MLModelDestinationPath`
Il percorso assoluto verso il bucket Amazon S3 che contiene il modello ML compatibile con NEO. Si tratta del percorso di destinazione specificato per la risorsa del modello ML.
**Nome visualizzato nella AWS IoT console: percorso di destinazione del modello**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `.+`
`MLModelResourceId`
L'ID della risorsa ML che fa riferimento al modello di origine.
Nome visualizzato nella AWS IoT console: risorsa ML del **gruppo Greengrass**
Obbligatorio: `true`
Tipo: `S3MachineLearningModelResource`
Schema valido: `^[a-zA-Z0-9:_-]+$`
`LocalInferenceServiceName`
Il nome del servizio di inferenza locale. Le funzioni Lambda definite dall'utente richiamano il servizio passando il nome alla funzione `invoke_inference_service` del Machine AWS IoT Greengrass Learning SDK. Per vedere un esempio, consulta [Esempio di utilizzo](#obj-detection-connector-usage).
**Nome visualizzato nella AWS IoT console: nome del servizio di inferenza locale**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[a-zA-Z0-9][a-zA-Z0-9-]{1,62}$`
`LocalInferenceServiceTimeoutSeconds`
Il tempo (in secondi) prima che la richiesta di inferenza venga terminata. Il valore minimo è 1. Il valore predefinito è 10.
Nome visualizzato nella AWS IoT console: **Timeout (secondo)**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[1-9][0-9]*$`
`LocalInferenceServiceMemoryLimitKB`
La quantità di memoria (in KB) a cui ha accesso il servizio. Il valore minimo è 1.
Nome visualizzato nella AWS IoT console: **limite di memoria**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[1-9][0-9]*$`
`GPUAcceleration`
Il contesto di calcolo della CPU o GPU (accelerata). Questa proprietà si applica solo al JTX2 connettore ML Image Classification Aarch64.
**Nome visualizzato nella AWS IoT console: accelerazione GPU**
Obbligatorio: `true`
Tipo: `string`
Valori validi: `CPU` o `GPU`
`MLFeedbackConnectorConfigId`
L'ID della configurazione di feedback da utilizzare per caricare i dati di input del modello. Deve corrispondere all'ID di una configurazione di feedback definita per il [connettore ML Feedback](ml-feedback-connector.md).
Questo parametro è obbligatorio solo se desideri utilizzare il connettore ML Feedback per caricare i dati di input del modello e pubblicare le previsioni in un argomento MQTT.
Nome visualizzato nella AWS IoT console: **ID di configurazione del connettore ML Feedback**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^$|^[a-zA-Z0-9][a-zA-Z0-9-]{1,62}$`
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea una `ConnectorDefinition` versione iniziale che contiene un connettore ML Object Detection. Questo esempio crea un'istanza del ARMv7l connettore ML Object Detection.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyObjectDetectionConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/ObjectDetectionARMv7/versions/1",
"Parameters": {
"MLModelDestinationPath": "/path-to-model",
"MLModelResourceId": "my-ml-resource",
"LocalInferenceServiceName": "objectDetection",
"LocalInferenceServiceTimeoutSeconds": "10",
"LocalInferenceServiceMemoryLimitKB": "500000",
"MLFeedbackConnectorConfigId" : "object-detector-random-sampling"
}
}
]
}'
```
**Nota**
La funzione Lambda di questi connettori ha un ciclo di vita di [lunga durata](lambda-functions.md#lambda-lifecycle).
**Nella AWS IoT Greengrass console, puoi aggiungere un connettore dalla pagina Connettori del gruppo.** Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md).
## Dati di input
Questi connettori accettano un file di immagine come input. I file di immagine di input devono essere in formato `png` o `jpeg`. Per ulteriori informazioni, consulta [Esempio di utilizzo](#obj-detection-connector-usage).
Questi connettori non accettano messaggi MQTT come dati di input.
## Dati di output
Questi connettori restituiscono un elenco formattato di risultati delle previsioni per gli oggetti identificati nell'immagine di input:
```
{
"prediction": [
[
14,
0.9384938478469849,
0.37763649225234985,
0.5110225081443787,
0.6697432398796082,
0.8544386029243469
],
[
14,
0.8859519958496094,
0,
0.43536216020584106,
0.3314110040664673,
0.9538808465003967
],
[
12,
0.04128098487854004,
0.5976729989051819,
0.5747185945510864,
0.704264223575592,
0.857937216758728
],
...
]
}
```
Ogni previsione nell'elenco è contenuta tra parentesi quadre e contiene sei valori:
+ Il primo valore rappresenta la categoria di oggetto prevista per l'oggetto identificato. Le categorie di oggetti e i valori corrispondenti vengono determinati durante l'addestramento del modello di apprendimento automatico per il rilevamento di oggetti nel compilatore di deep learning Neo.
+ Il secondo valore è il punteggio di affidabilità per la previsione della categoria dell'oggetto. Questo rappresenta la probabilità che la previsione fosse corretta.
+ Gli ultimi quattro valori corrispondono alle dimensioni in pixel che rappresentano un riquadro di delimitazione intorno all'oggetto previsto nell'immagine.
Questi connettori non pubblicano messaggi MQTT come dati di output.
## Esempio di utilizzo
L'esempio seguente della funzione Lambda utilizza il [AWS IoT Greengrass Machine Learning SDK](lambda-functions.md#lambda-sdks-ml) per interagire con un connettore ML Object Detection.
**Nota**
Puoi scaricare l'SDK dalla pagina dei download di [AWS IoT Greengrass Machine Learning SDK](what-is-gg.md#gg-ml-sdk-download).
In questo esempio viene inizializzato un client SDK e viene chiamata in modo sincrono la funzione `invoke_inference_service` di SDK per richiamare il servizio di inferenza locale. Trasferisce il tipo di algoritmo, il nome del servizio, il tipo di immagine e il contenuto dell'immagine. Quindi, l'esempio analizza la risposta del servizio per ottenere i risultati di probabilità (previsioni).
```
import logging
from threading import Timer
import numpy as np
import greengrass_machine_learning_sdk as ml
# We assume the inference input image is provided as a local file
# to this inference client Lambda function.
with open('/test_img/test.jpg', 'rb') as f:
content = bytearray(f.read())
client = ml.client('inference')
def infer():
logging.info('invoking Greengrass ML Inference service')
try:
resp = client.invoke_inference_service(
AlgoType='object-detection',
ServiceName='objectDetection',
ContentType='image/jpeg',
Body=content
)
except ml.GreengrassInferenceException as e:
logging.info('inference exception {}("{}")'.format(e.__class__.__name__, e))
return
except ml.GreengrassDependencyException as e:
logging.info('dependency exception {}("{}")'.format(e.__class__.__name__, e))
return
logging.info('resp: {}'.format(resp))
predictions = resp['Body'].read().decode("utf-8")
logging.info('predictions: {}'.format(predictions))
predictions = eval(predictions)
# Perform business logic that relies on the predictions.
# Schedule the infer() function to run again in ten second.
Timer(10, infer).start()
return
infer()
def function_handler(event, context):
return
```
La `invoke_inference_service` funzione nel AWS IoT Greengrass Machine Learning SDK accetta i seguenti argomenti.
| Argomento | Descrizione |
| --- | --- |
| `AlgoType` | Il nome del tipo di algoritmo da utilizzare per l'inferenza. Attualmente è supportato solo `object-detection`. Obbligatorio: `true` Tipo: `string` Valori validi: `object-detection` |
| `ServiceName` | Il nome del servizio di inferenza locale. Utilizza il nome specificato per il parametro `LocalInferenceServiceName` al momento della configurazione del connettore. Richiesto: `true` Tipo: `string` |
| `ContentType` | Il tipo mime dell'immagine di input. Richiesto: `true` Tipo: `string` Valori validi: `image/jpeg, image/png` |
| `Body` | Il contenuto del file immagine di input. Richiesto: `true` Tipo: `binary` |
## Installazione delle dipendenze del runtime di Neo Deep Learning sul core AWS IoT Greengrass
I connettori ML Object Detection sono forniti in bundle con il deep learning runtime (DLR) SageMaker AI Neo. I connettori utilizzano il runtime per servire il modello ML. Per utilizzare questi connettori, devi installare le dipendenze per il DLR sul dispositivo core.
Prima di installare le dipendenze DLR, assicurati che le [librerie di sistema](#obj-detection-connector-logging) richieste (nelle versioni minime specificate) siano presenti sul dispositivo.
------
#### [ NVIDIA Jetson TX2 ]
1. Installa CUDA Toolkit 9.0 e cuDNN 7.0. Puoi seguire le istruzioni di [Configurazione di altri dispositivi](setup-filter.other.md) nel tutorial Nozioni di base.
1. Abilita i repository universali in modo che il connettore sia in grado di installare l'open software gestito dalla community. Per ulteriori informazioni, consulta [Repository/Ubuntu](https://help.ubuntu.com/community/Repositories/Ubuntu) nella documentazione Ubuntu.
1. Apri il file `/etc/apt/sources.list`.
1. Assicurati che le seguenti righe non presentino commenti.
```
deb http://ports.ubuntu.com/ubuntu-ports/ xenial universe
deb-src http://ports.ubuntu.com/ubuntu-ports/ xenial universe
deb http://ports.ubuntu.com/ubuntu-ports/ xenial-updates universe
deb-src http://ports.ubuntu.com/ubuntu-ports/ xenial-updates universe
```
1. Salva una copia del seguente script di installazione nel file `nvidiajtx2.sh` del dispositivo core.
```
#!/bin/bash
set -e
echo "Installing dependencies on the system..."
echo 'Assuming that universe repos are enabled and checking dependencies...'
apt-get -y update
apt-get -y dist-upgrade
apt-get install -y liblapack3 libopenblas-dev liblapack-dev libatlas-base-dev
apt-get install -y python3.7 python3.7-dev
python3.7 -m pip install --upgrade pip
python3.7 -m pip install numpy==1.15.0
python3.7 -m pip install opencv-python || echo 'Error: Unable to install OpenCV with pip on this platform. Try building the latest OpenCV from source (https://github.com/opencv/opencv).'
echo 'Dependency installation/upgrade complete.'
```
**Nota**
Se [OpenCV](https://github.com/opencv/opencv) non viene installato correttamente utilizzando questo script, puoi provare a compilare dall'origine. Per ulteriori informazioni, consulta [ Installazione in Linux](https://docs.opencv.org/4.1.0/d7/d9f/tutorial_linux_install.html) nella documentazione di OpenCV o fai riferimento ad altre risorse online per la tua piattaforma.
1. Dalla directory in cui hai salvato il file, esegui il seguente comando:
```
sudo nvidiajtx2.sh
```
------
#### [ x86\$164 (Ubuntu or Amazon Linux) ]
1. Salva una copia del seguente script di installazione nel file `x86_64.sh` del dispositivo core.
```
#!/bin/bash
set -e
echo "Installing dependencies on the system..."
release=$(awk -F= '/^NAME/{print $2}' /etc/os-release)
if [ "$release" == '"Ubuntu"' ]; then
# Ubuntu. Supports EC2 and DeepLens. DeepLens has all the dependencies installed, so
# this is mostly to prepare dependencies on Ubuntu EC2 instance.
apt-get -y update
apt-get -y dist-upgrade
apt-get install -y libgfortran3 libsm6 libxext6 libxrender1
apt-get install -y python3.7 python3.7-dev
elif [ "$release" == '"Amazon Linux"' ]; then
# Amazon Linux. Expect python to be installed already
yum -y update
yum -y upgrade
yum install -y compat-gcc-48-libgfortran libSM libXrender libXext
else
echo "OS Release not supported: $release"
exit 1
fi
python3.7 -m pip install --upgrade pip
python3.7 -m pip install numpy==1.15.0
python3.7 -m pip install opencv-python || echo 'Error: Unable to install OpenCV with pip on this platform. Try building the latest OpenCV from source (https://github.com/opencv/opencv).'
echo 'Dependency installation/upgrade complete.'
```
**Nota**
Se [OpenCV](https://github.com/opencv/opencv) non viene installato correttamente utilizzando questo script, puoi provare a compilare dall'origine. Per ulteriori informazioni, consulta [ Installazione in Linux](https://docs.opencv.org/4.1.0/d7/d9f/tutorial_linux_install.html) nella documentazione di OpenCV o fai riferimento ad altre risorse online per la tua piattaforma.
1. Dalla directory in cui hai salvato il file, esegui il comando seguente:
```
sudo x86_64.sh
```
------
#### [ ARMv7 (Raspberry Pi) ]
1. Salva una copia del seguente script di installazione nel file `armv7l.sh` del dispositivo core.
```
#!/bin/bash
set -e
echo "Installing dependencies on the system..."
apt-get update
apt-get -y upgrade
apt-get install -y liblapack3 libopenblas-dev liblapack-dev
apt-get install -y python3.7 python3.7-dev
python3.7 -m pip install --upgrade pip
python3.7 -m pip install numpy==1.15.0
python3.7 -m pip install opencv-python || echo 'Error: Unable to install OpenCV with pip on this platform. Try building the latest OpenCV from source (https://github.com/opencv/opencv).'
echo 'Dependency installation/upgrade complete.'
```
**Nota**
Se [OpenCV](https://github.com/opencv/opencv) non viene installato correttamente utilizzando questo script, puoi provare a compilare dall'origine. Per ulteriori informazioni, consulta [ Installazione in Linux](https://docs.opencv.org/4.1.0/d7/d9f/tutorial_linux_install.html) nella documentazione di OpenCV o fai riferimento ad altre risorse online per la tua piattaforma.
1. Dalla directory in cui hai salvato il file, esegui il comando seguente:
```
sudo bash armv7l.sh
```
**Nota**
Su un Raspberry Pi, l'utilizzo di `pip` per installare dipendenze di machine learning è un'operazione con elevati requisiti di memoria che può esaurire la memoria del dispositivo e causarne il blocco. Per risolvere il problema, è possibile aumentare temporaneamente la dimensione di swap: In `/etc/dphys-swapfile`, aumenta il valore della variabile `CONF_SWAPSIZE` e quindi esegui il comando seguente per riavviare `dphys-swapfile`.
```
/etc/init.d/dphys-swapfile restart
```
------
## Registrazione e risoluzione dei problemi
A seconda delle impostazioni del gruppo, i registri degli eventi e degli errori vengono scritti CloudWatch nei registri, nel file system locale o in entrambi. I log di questo connettore utilizzano il prefisso `LocalInferenceServiceName`. Se il connettore si comporta inaspettatamente, controlla i log del connettore. Questi di solito contengono utili informazioni di debug, ad esempio una dipendenza della libreria ML mancante o la causa di un errore di avvio del connettore.
Se il AWS IoT Greengrass gruppo è configurato per scrivere registri locali, il connettore scrive i file di registro su. `greengrass-root/ggc/var/log/user/region/aws/` Per ulteriori informazioni sulla registrazione di Greengrass, vedere. [Monitoraggio con AWS IoT Greengrass registri](greengrass-logs-overview.md)
Utilizzate le seguenti informazioni per risolvere i problemi relativi ai connettori ML Object Detection.
**Librerie di sistema richieste**
Le seguenti schede elencano le librerie di sistema necessarie per ogni connettore ML Object Detection.
------
#### [ ML Object Detection Aarch64 JTX2 ]
| Libreria | Versione minima |
| --- | --- |
| ld-linux-aarch64.so.1 | GLIBC\$12.17 |
| libc.so.6 | GLIBC\$12.17 |
| libcublas.so.9.0 | non applicabile |
| libcudart.so.9.0 | non applicabile |
| libcudnn.so.7 | non applicabile |
| libcufft.so.9.0 | non applicabile |
| libcurand.so.9.0 | non applicabile |
| libcusolver.so.9.0 | non applicabile |
| libgcc\$1s.so.1 | GCC\$14.2.0 |
| libgomp.so.1 | GOMP\$14.0, OMP\$11.0 |
| libm.so.6 | GLIBC\$12.23 |
| libnvinfer.so.4 | non applicabile |
| libnvrm\$1gpu.so | non applicabile |
| libnvrm.so | non applicabile |
| libnvidia-fatbinaryloader.so.28.2.1 | non applicabile |
| libnvos.so | non applicabile |
| libpthread.so.0 | GLIBC\$12.17 |
| librt.so.1 | GLIBC\$12.17 |
| libstdc\$1\$1.so.6 | GLIBCXX\$13.4.21, CXXABI\$11.3.8 |
------
#### [ ML Object Detection x86\$164 ]
| Libreria | Versione minima |
| --- | --- |
| ld-linux-x86-64.so.2 | GCC\$14.0.0 |
| libc.so.6 | GLIBC\$12.4 |
| libgfortran.so.3 | GFORTRAN\$11.0 |
| libm.so.6 | GLIBC\$12.23 |
| libpthread.so.0 | GLIBC\$12.2.5 |
| librt.so.1 | GLIBC\$12.2.5 |
| libstdc\$1\$1.so.6 | CXXABI\$11.3.8, GLIBCXX\$13.4.21 |
------
#### [ ML Object Detection ARMv7 ]
| Libreria | Versione minima |
| --- | --- |
| ld-linux-armhf.so.3 | GLIBC\$12.4 |
| libc.so.6 | GLIBC\$12.7 |
| libgcc\$1s.so.1 | GCC\$14.0.0 |
| libgfortran.so.3 | GFORTRAN\$11.0 |
| libm.so.6 | GLIBC\$12.4 |
| libpthread.so.0 | GLIBC\$12.4 |
| librt.so.1 | GLIBC\$12.4 |
| libstdc\$1\$1.so.6 | CXXABI\$11.3.8, CXXABI\$1ARM\$11.3.3, GLIBCXX\$13.4.20 |
------
**Problemi**
| Caratteristiche | Soluzione |
| --- | --- |
| In un Raspberry Pi, il seguente messaggio di errore viene registrato e non si sta utilizzando la fotocamera: `Failed to initialize libdc1394` | Per disabilitare il driver, esegui il seguente comando: sudo ln /dev/null /dev/raw1394
Questa operazione è temporanea. Il collegamento simbolico scompare dopo il riavvio. Consulta il manuale di distribuzione del sistema operativo per ulteriori informazioni su come creare automaticamente il link al riavvio. |
## Licenze
I connettori ML Object Detection includono i seguenti software/licenze di terze parti:
+ [AWS SDK per Python (Boto3)](https://pypi.org/project/boto3/)/Apache License 2.0
+ [botocore](https://pypi.org/project/botocore/)/Apache License 2.0
+ [dateutil](https://pypi.org/project/python-dateutil/1.4/)/PSF License
+ [docutils](https://pypi.org/project/docutils/)/BSD License, GNU General Public License (GPL), Python Software Foundation License, Public Domain
+ [jmespath](https://pypi.org/project/jmespath/)/MIT License
+ [s3transfer](https://pypi.org/project/s3transfer/)/Apache License 2.0
+ [urllib3](https://pypi.org/project/urllib3/)/MIT License
+ [Deep Learning Runtime](https://github.com/neo-ai/neo-ai-dlr)/Apache License 2.0
+ [six](https://github.com/benjaminp/six)/MIT
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
+ [Esecuzione dell'inferenza di Machine Learning](ml-inference.md)
+ [Algoritmo di rilevamento degli oggetti](https://docs.aws.amazon.com/sagemaker/latest/dg/object-detection.html) nell'*Amazon SageMaker AI Developer Guide*
# Connettore adattatore di protocollo Modbus-RTU
Il [connettore](connectors.md) Modbus-RTU Protocol Adapter raccoglie le informazioni dai dispositivi Modbus RTU che fanno parte del gruppo. AWS IoT Greengrass
Questo connettore riceve i parametri per una richiesta Modbus RTU da una funzione Lambda definita dall'utente. Invia la richiesta corrispondente e quindi pubblica la risposta dal dispositivo di destinazione come messaggio MQTT.
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 3 | `arn:aws:greengrass:region::/connectors/ModbusRTUProtocolAdapter/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/ModbusRTUProtocolAdapter/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/ModbusRTUProtocolAdapter/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#modbus-protocol-adapter-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 3 ]
+ AWS IoT Greengrass Software principale v1.9.3 o versione successiva.
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ Una connessione fisica tra il core e i dispositivi Modbus. AWS IoT Greengrass Il core deve essere fisicamente connesso alla rete RTU Modbus attraverso una porta seriale (ad esempio, una porta USB).
+ Una [risorsa di dispositivo locale](access-local-resources.md) del gruppo Greengrass che punta alla porta seriale Modbus fisica.
+ Una funzione Lambda definita dall'utente che invia i parametri di richiesta Modbus RTU a questo connettore. I parametri di richiesta devono essere conformi ai modelli previsti e includere gli indirizzi IDs e gli indirizzi dei dispositivi di destinazione sulla rete Modbus RTU. Per ulteriori informazioni, consulta [Dati di input](#modbus-protocol-adapter-connector-data-input).
------
#### [ Versions 1 - 2 ]
+ AWS IoT Greengrass Software principale v1.7 o successivo.
+ [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH.
+ Una connessione fisica tra il AWS IoT Greengrass core e i dispositivi Modbus. Il core deve essere fisicamente connesso alla rete RTU Modbus attraverso una porta seriale (ad esempio, una porta USB).
+ Una [risorsa di dispositivo locale](access-local-resources.md) del gruppo Greengrass che punta alla porta seriale Modbus fisica.
+ Una funzione Lambda definita dall'utente che invia i parametri di richiesta Modbus RTU a questo connettore. I parametri di richiesta devono essere conformi ai modelli previsti e includere gli indirizzi IDs e gli indirizzi dei dispositivi di destinazione sulla rete Modbus RTU. Per ulteriori informazioni, consulta [Dati di input](#modbus-protocol-adapter-connector-data-input).
------
## Parametri del connettore
Questo connettore supporta i seguenti parametri:
`ModbusSerialPort-ResourceId`
L'ID della risorsa del dispositivo locale fisico che rappresenta la porta seriale Modbus fisica.
Al connettore è concesso l'accesso in lettura e scrittura alla risorsa.
Nome visualizzato nella AWS IoT console: risorsa della **porta seriale Modbus**
Richiesto: `true`
Tipo: `string`
Schema valido: `.+`
`ModbusSerialPort`
Il percorso assoluto della porta seriale Modbus fisica sul dispositivo. Si tratta del percorso di origine specificato per la risorsa del dispositivo locale Modbus.
Nome visualizzato nella AWS IoT console: **percorso di origine della risorsa della porta seriale Modbus**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `.+`
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea un `ConnectorDefinition` con una versione iniziale che contiene il connettore Modbus-RTU Protocol Adapter.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyModbusRTUProtocolAdapterConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/ModbusRTUProtocolAdapter/versions/3",
"Parameters": {
"ModbusSerialPort-ResourceId": "MyLocalModbusSerialPort",
"ModbusSerialPort": "/path-to-port"
}
}
]
}'
```
**Nota**
La funzione Lambda in questo connettore ha un ciclo di vita di [lunga durata](lambda-functions.md#lambda-lifecycle).
**Nella AWS IoT Greengrass console, puoi aggiungere un connettore dalla pagina Connettori del gruppo.** Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md).
**Nota**
Dopo aver distribuito il connettore Modbus-RTU Protocol Adapter, puoi utilizzarlo AWS IoT Things Graph per orchestrare le interazioni tra i dispositivi del gruppo. Per ulteriori informazioni, consulta [Modbus](https://docs.aws.amazon.com/thingsgraph/latest/ug/iot-tg-protocols-modbus.html) nella *AWS IoT Things Graph Guida per l'utente*.
## Dati di input
Questo connettore accetta i parametri di richiesta Modbus RTU da una funzione Lambda definita dall'utente su un argomento MQTT. I messaggi di input devono essere in formato JSON.
**Filtro argomento in sottoscrizione**
`modbus/adapter/request`
**Proprietà dei messaggi**
Il messaggio di richiesta varia in base al tipo di richiesta RTU Modbus che rappresenta. Le seguenti proprietà sono necessarie per tutte le richieste:
+ Nell'oggetto `request`:
+ `operation`. Il nome dell'operazione da eseguire. Ad esempio, specificare `"operation": "ReadCoilsRequest"` per leggere i nastri. Questo valore deve essere una stringa Unicode. Per le operazioni supportate, consulta [Richieste e risposte RTU Modbus](#modbus-protocol-adapter-connector-requests-responses).
+ `device`. Il dispositivo di destinazione della richiesta. Questo valore deve essere compreso tra `0 - 247`.
+ La proprietà `id`. L'ID della richiesta. Tale valore viene utilizzato per la deduplicazione dei dati e viene restituito come è nella proprietà `id` di tutte le risposte, incluse quelle di errore. Questo valore deve essere una stringa Unicode.
Se la richiesta include un campo indirizzo, è necessario specificare il valore come numero intero. Ad esempio `"address": 1`.
Gli altri parametri di includere nella richiesta variano a seconda dell'operazione. Tutti i parametri della richiesta sono necessari tranne il CRC, che viene gestito separatamente. Per alcuni esempi, consulta [Richieste e risposte di esempio](#modbus-protocol-adapter-connector-examples).
**Esempio di input: richiesta lettura nastri**
```
{
"request": {
"operation": "ReadCoilsRequest",
"device": 1,
"address": 1,
"count": 1
},
"id": "TestRequest"
}
```
## Dati di output
Questo connettore pubblica le risposte nelle richieste RTU Modbus in entrata.
**Filtro argomento in sottoscrizione**
`modbus/adapter/response`
**Proprietà dei messaggi**
Il formato del messaggio di risposta varia in base alla richiesta corrispondente e allo stato della risposta. Per alcuni esempi, consulta [Richieste e risposte di esempio](#modbus-protocol-adapter-connector-examples).
Una risposta a un'operazione di scrittura è semplicemente un eco della richiesta. Benché non vengano restituite informazioni rilevanti per le risposte in scrittura, è buona prassi controllare lo stato della risposta.
Ogni risposta include le seguenti proprietà:
+ Nell'oggetto `response`:
+ `status`. Lo stato della richiesta. Lo stato può avere uno dei seguenti valori:
+ `Success`. La richiesta era valida, è stata inviata alla rete Modbus RTU ed è stata restituita una risposta.
+ `Exception`. La richiesta era valida, è stata inviata alla rete Modbus RTU ed è stata restituita una risposta di eccezione. Per ulteriori informazioni, consulta [Stato risposta: eccezione](#modbus-protocol-adapter-connector-response-exception).
+ `No Response`. La richiesta non era valida e il connettore ha rilevato l'errore prima che la richiesta fosse inviata sulla rete Modbus RTU. Per ulteriori informazioni, consulta [Stato risposta: nessuna risposta](#modbus-protocol-adapter-connector-response-noresponse).
+ `device`. Il dispositivo a cui è stata inviata la richiesta.
+ `operation`. Il tipo di richiesta che è stata inviata.
+ `payload`. Il contenuto della risposta che è stato restituito. Se lo `status` è `No Response`, questo oggetto contiene solo una proprietà `error` con la descrizione dell'errore (ad esempio, `"error": "[Input/Output] No Response received from the remote unit"`).
+ La proprietà `id`. L'ID della richiesta, utilizzato per la deduplicazione dei dati.
**Output di esempio: Operazione riuscita**
```
{
"response" : {
"status" : "success",
"device": 1,
"operation": "ReadCoilsRequest",
"payload": {
"function_code": 1,
"bits": [1]
}
},
"id" : "TestRequest"
}
```
**Esempio di output: Errore**
```
{
"response" : {
"status" : "fail",
"error_message": "Internal Error",
"error": "Exception",
"device": 1,
"operation": "ReadCoilsRequest",
"payload": {
"function_code": 129,
"exception_code": 2
}
},
"id" : "TestRequest"
}
```
Per ulteriori esempi, consulta [Richieste e risposte di esempio](#modbus-protocol-adapter-connector-examples).
## Richieste e risposte RTU Modbus
Questo connettore accetta i parametri della richiesta RTU Modbus come [dati di input](#modbus-protocol-adapter-connector-data-input) e pubblica le risposte come [dati di output](#modbus-protocol-adapter-connector-data-output).
Sono supportate le seguenti operazioni comuni.
| Nome dell'operazione nella richiesta | Codice della funzione in risposta |
| --- | --- |
| ReadCoilsRequest | 01 |
| ReadDiscreteInputsRequest | 02 |
| ReadHoldingRegistersRequest | 03 |
| ReadInputRegistersRequest | 04 |
| WriteSingleCoilRequest | 05 |
| WriteSingleRegisterRequest | 06 |
| WriteMultipleCoilsRequest | 15 |
| WriteMultipleRegistersRequest | 16 |
| MaskWriteRegisterRequest | 22 |
| ReadWriteMultipleRegistersRequest | 23 |
### Richieste e risposte di esempio
Di seguito sono riportate alcune richieste e risposte di esempio per le operazioni supportate.
Lettura nastri
**Esempio di richiesta:**
```
{
"request": {
"operation": "ReadCoilsRequest",
"device": 1,
"address": 1,
"count": 1
},
"id": "TestRequest"
}
```
**Esempio di risposta:**
```
{
"response": {
"status": "success",
"device": 1,
"operation": "ReadCoilsRequest",
"payload": {
"function_code": 1,
"bits": [1]
}
},
"id" : "TestRequest"
}
```
Lettura di input discreti
**Esempio di richiesta:**
```
{
"request": {
"operation": "ReadDiscreteInputsRequest",
"device": 1,
"address": 1,
"count": 1
},
"id": "TestRequest"
}
```
**Esempio di risposta:**
```
{
"response": {
"status": "success",
"device": 1,
"operation": "ReadDiscreteInputsRequest",
"payload": {
"function_code": 2,
"bits": [1]
}
},
"id" : "TestRequest"
}
```
Lettura registri di sospensione
**Esempio di richiesta:**
```
{
"request": {
"operation": "ReadHoldingRegistersRequest",
"device": 1,
"address": 1,
"count": 1
},
"id": "TestRequest"
}
```
**Esempio di risposta:**
```
{
"response": {
"status": "success",
"device": 1,
"operation": "ReadHoldingRegistersRequest",
"payload": {
"function_code": 3,
"registers": [20,30]
}
},
"id" : "TestRequest"
}
```
Lettura registri di input
**Esempio di richiesta:**
```
{
"request": {
"operation": "ReadInputRegistersRequest",
"device": 1,
"address": 1,
"value": 1
},
"id": "TestRequest"
}
```
Scrittura nastro singolo
**Esempio di richiesta:**
```
{
"request": {
"operation": "WriteSingleCoilRequest",
"device": 1,
"address": 1,
"value": 1
},
"id": "TestRequest"
}
```
**Esempio di risposta:**
```
{
"response": {
"status": "success",
"device": 1,
"operation": "WriteSingleCoilRequest",
"payload": {
"function_code": 5,
"address": 1,
"value": true
}
},
"id" : "TestRequest"
```
Scrittura registro singolo
**Esempio di richiesta:**
```
{
"request": {
"operation": "WriteSingleRegisterRequest",
"device": 1,
"address": 1,
"value": 1
},
"id": "TestRequest"
}
```
Scrittura di più nastri
**Esempio di richiesta:**
```
{
"request": {
"operation": "WriteMultipleCoilsRequest",
"device": 1,
"address": 1,
"values": [1,0,0,1]
},
"id": "TestRequest"
}
```
**Esempio di risposta:**
```
{
"response": {
"status": "success",
"device": 1,
"operation": "WriteMultipleCoilsRequest",
"payload": {
"function_code": 15,
"address": 1,
"count": 4
}
},
"id" : "TestRequest"
}
```
Scrittura di più registri
**Esempio di richiesta:**
```
{
"request": {
"operation": "WriteMultipleRegistersRequest",
"device": 1,
"address": 1,
"values": [20,30,10]
},
"id": "TestRequest"
}
```
**Esempio di risposta:**
```
{
"response": {
"status": "success",
"device": 1,
"operation": "WriteMultipleRegistersRequest",
"payload": {
"function_code": 23,
"address": 1,
"count": 3
}
},
"id" : "TestRequest"
}
```
Mascheramento dei registri di scrittura
**Esempio di richiesta:**
```
{
"request": {
"operation": "MaskWriteRegisterRequest",
"device": 1,
"address": 1,
"and_mask": 175,
"or_mask": 1
},
"id": "TestRequest"
}
```
**Esempio di risposta:**
```
{
"response": {
"status": "success",
"device": 1,
"operation": "MaskWriteRegisterRequest",
"payload": {
"function_code": 22,
"and_mask": 0,
"or_mask": 8
}
},
"id" : "TestRequest"
}
```
Scrittura/lettura di più registri
**Esempio di richiesta:**
```
{
"request": {
"operation": "ReadWriteMultipleRegistersRequest",
"device": 1,
"read_address": 1,
"read_count": 2,
"write_address": 3,
"write_registers": [20,30,40]
},
"id": "TestRequest"
}
```
**Esempio di risposta:**
```
{
"response": {
"status": "success",
"device": 1,
"operation": "ReadWriteMultipleRegistersRequest",
"payload": {
"function_code": 23,
"registers": [10,20,10,20]
}
},
"id" : "TestRequest"
}
```
I registri restituiti in questa risposta sono quelli che vengono letti.
### Stato risposta: eccezione
Le eccezioni possono verificarsi se il formato della richiesta è valido, ma la richiesta non è stata completata. In questo caso, la risposta contiene le seguenti informazioni:
+ Il `status` è impostato su `Exception`.
+ `function_code` è pari al codice della funzione della richiesta \$1 128.
+ `exception_code` contiene il codice dell'eccezione. Per ulteriori informazioni sull'eccezione , consulta Codici delle eccezioni Modbus.
**Esempio:**
```
{
"response" : {
"status" : "fail",
"error_message": "Internal Error",
"error": "Exception",
"device": 1,
"operation": "ReadCoilsRequest",
"payload": {
"function_code": 129,
"exception_code": 2
}
},
"id" : "TestRequest"
}
```
### Stato risposta: nessuna risposta
Questo connettore esegue controlli di convalida sulla richiesta Modbus. Ad esempio, verifica l'eventuale presenza di formati non validi e campi non compilati. Se la convalida ha esito negativo, il connettore non invia la richiesta. Al contrario, restituirà una risposta contenente le seguenti informazioni:
+ Il `status` è impostato su `No Response`.
+ `error`Contiene il motivo dell'errore.
+ `error_message` contiene il messaggio dell'errore.
**Esempi:**
```
{
"response" : {
"status" : "fail",
"error_message": "Invalid address field. Expected , got ",
"error": "No Response",
"device": 1,
"operation": "ReadCoilsRequest",
"payload": {
"error": "Invalid address field. Expected , got "
}
},
"id" : "TestRequest"
}
```
Se la richiesta è destinata a un dispositivo inesistente o se la rete RTU Modbus non funziona, potrebbe venire restituito `ModbusIOException`, che utilizza il formato Nessuna risposta.
```
{
"response" : {
"status" : "fail",
"error_message": "[Input/Output] No Response received from the remote unit",
"error": "No Response",
"device": 1,
"operation": "ReadCoilsRequest",
"payload": {
"error": "[Input/Output] No Response received from the remote unit"
}
},
"id" : "TestRequest"
}
```
## Esempio di utilizzo
Usa i seguenti passaggi di alto livello per configurare una funzione Lambda di esempio di Python 3.7 che puoi usare per provare il connettore.
**Nota**
Se usi altri runtime Python, puoi creare un collegamento simbolico da Python3.x a Python 3.7.
Gli argomenti [Nozioni di base sui connettori (console)](connectors-console.md) e [Nozioni di base sui connettori (CLI)](connectors-cli.md) contengono passaggi dettagliati che illustrano come configurare e distribuire un connettore Twilio Notifications di esempio.
1. Assicurarsi di soddisfare i [requisiti](#modbus-protocol-adapter-connector-req) per il connettore.
1. Crea e pubblica una funzione Lambda che invia dati di input al connettore.
Salvare il [codice di esempio](#modbus-protocol-adapter-connector-usage-example) come file PY. Scarica e decomprimi il [AWS IoT Greengrass Core SDK per Python](lambda-functions.md#lambda-sdks-core). Quindi, crea un pacchetto zip che contiene il file PY e la cartella `greengrasssdk` a livello root. Questo pacchetto zip è il pacchetto di distribuzione in cui carichi. AWS Lambda
Dopo aver creato la funzione Python 3.7 Lambda, pubblica una versione della funzione e crea un alias.
1. Configurare il gruppo Greengrass.
1. Aggiungi la funzione Lambda tramite il relativo alias (consigliato). Configura il ciclo di vita Lambda come longevo (o nella `"Pinned": true` CLI).
1. Aggiungi la risorsa del dispositivo locale richiesta e concedi l'accesso in lettura/scrittura alla funzione Lambda.
1. Aggiungere il connettore e configurarne i relativi [parametri](#modbus-protocol-adapter-connector-param).
1. Aggiungere sottoscrizioni che consentono al connettore di ricevere [i dati di input](#modbus-protocol-adapter-connector-data-input) e inviare [i dati di output](#modbus-protocol-adapter-connector-data-output) nei filtri degli argomenti supportati.
+ Imposta la funzione Lambda come origine, il connettore come destinazione e utilizza un filtro per argomenti di input supportato.
+ Imposta il connettore come origine, AWS IoT Core come destinazione e utilizza un filtro per l’argomento di output supportato. Utilizzi questo abbonamento per visualizzare i messaggi di stato nella AWS IoT console.
1. Distribuisci il gruppo.
1. Nella AWS IoT console, nella pagina **Test**, sottoscrivi l'argomento relativo ai dati di output per visualizzare i messaggi di stato dal connettore. La funzione Lambda di esempio è di lunga durata e inizia a inviare messaggi subito dopo l'implementazione del gruppo.
Al termine del test, puoi impostare il ciclo di vita Lambda su richiesta (o nella CLI) e `"Pinned": false` distribuire il gruppo. Ciò impedisce alla funzione di inviare messaggi.
### Esempio
L'esempio seguente della funzione Lambda invia un messaggio di input al connettore.
```
import greengrasssdk
import json
TOPIC_REQUEST = 'modbus/adapter/request'
# Creating a greengrass core sdk client
iot_client = greengrasssdk.client('iot-data')
def create_read_coils_request():
request = {
"request": {
"operation": "ReadCoilsRequest",
"device": 1,
"address": 1,
"count": 1
},
"id": "TestRequest"
}
return request
def publish_basic_request():
iot_client.publish(payload=json.dumps(create_read_coils_request()), topic=TOPIC_REQUEST)
publish_basic_request()
def lambda_handler(event, context):
return
```
## Licenze
Il connettore Modbus-RTU Protocol Adapter include i seguenti software/licenze di terze parti:
+ [pymodbus](https://github.com/riptideio/pymodbus/blob/master/README.rst)/BSD
+ [pyserial](https://github.com/pyserial/pyserial)/BSD
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche |
| --- | --- |
| 3 | È stato aggiornato il runtime Lambda a Python 3.7, che modifica i requisiti di runtime. |
| 2 | Arn del connettore aggiornato per Regione AWS il supporto. Registrazione degli errori migliorata. |
| 1 | Versione iniziale. |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
# Connettore adattatore di protocollo Modbus-TCP
Il [connettore](connectors.md) Modbus-TCP Protocol Adapter raccoglie i dati dai dispositivi locali tramite il protocollo Modbus-TCP e li pubblica negli stream selezionati. `StreamManager`
Puoi utilizzare questo connettore anche con il SiteWise connettore IoT e il tuo SiteWise gateway IoT. Il gateway deve fornire la configurazione per il connettore. Per ulteriori informazioni, consulta [Configurare una sorgente Modbus TCP](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/configure-modbus-source.html) nella guida SiteWise utente IoT.
**Nota**
Questo connettore funziona in modalità [Nessun contenitore](lambda-group-config.md#no-container-mode) isolato, quindi puoi distribuirlo a un AWS IoT Greengrass gruppo in esecuzione in un contenitore Docker.
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 3 | `arn:aws:greengrass:region::/connectors/ModbusTCPConnector/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/ModbusTCPConnector/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/ModbusTCPConnector/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#modbus-tcp-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 1 - 3 ]
+ AWS IoT Greengrass Software principale v1.10.2 o successivo.
+ Stream manager abilitato sul gruppo. AWS IoT Greengrass
+ Java 8 installato sul dispositivo principale e aggiunto alla variabile di `PATH` ambiente.
**Nota**
Questo connettore è disponibile solo nelle seguenti regioni:
ap-southeast-1
ap-southeast-2
eu-central-1
eu-west-1
us-east-1
us-west-2
cn-north-1
------
## Parametri del connettore
Questo connettore supporta i seguenti parametri:
`LocalStoragePath`
La directory sull' AWS IoT Greengrass host su cui il SiteWise connettore IoT può scrivere dati persistenti. La directory predefinita è `/var/sitewise`.
Nome visualizzato nella AWS IoT console: **Percorso di archiviazione locale**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^\s*$|\/.`
`MaximumBufferSize`
La dimensione massima in GB per l'utilizzo SiteWise del disco IoT. La dimensione predefinita è 10 GB.
Nome visualizzato nella AWS IoT console: dimensione **massima del buffer del disco**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^\s*$|[0-9]+`
`CapabilityConfiguration`
L'insieme di configurazioni del collettore Modbus TCP da cui il connettore raccoglie i dati e a cui si connette.
Nome visualizzato nella console: AWS IoT **CapabilityConfiguration**
Obbligatorio: `false`
Tipo: una stringa JSON ben formata che definisce l'insieme di configurazioni di feedback supportate.
Di seguito è riportato un esempio di: `CapabilityConfiguration`
```
{
"sources": [
{
"type": "ModBusTCPSource",
"name": "SourceName1",
"measurementDataStreamPrefix": "SourceName1_Prefix",
"destination": {
"type": "StreamManager",
"streamName": "SiteWise_Stream_1",
"streamBufferSize": 8
},
"endpoint": {
"ipAddress": "127.0.0.1",
"port": 8081,
"unitId": 1
},
"propertyGroups": [
{
"name": "GroupName",
"tagPathDefinitions": [
{
"type": "ModBusTCPAddress",
"tag": "TT-001",
"address": "30001",
"size": 2,
"srcDataType": "float",
"transformation": "byteWordSwap",
"dstDataType": "double"
}
],
"scanMode": {
"type": "POLL",
"rate": 100
}
}
]
}
]
}
```
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea una versione iniziale che contiene il connettore Modbus-TCP `ConnectorDefinition` Protocol Adapter.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '
{
"Connectors": [
{
"Id": "MyModbusTCPConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/ModbusTCP/versions/3",
"Parameters": {
"capability_configuration": "{\"version\":1,\"namespace\":\"iotsitewise:modbuscollector:1\",\"configuration\":\"{\"sources\":[{\"type\":\"ModBusTCPSource\",\"name\":\"SourceName1\",\"measurementDataStreamPrefix\":\"\",\"endpoint\":{\"ipAddress\":\"127.0.0.1\",\"port\":8081,\"unitId\":1},\"propertyGroups\":[{\"name\":\"PropertyGroupName\",\"tagPathDefinitions\":[{\"type\":\"ModBusTCPAddress\",\"tag\":\"TT-001\",\"address\":\"30001\",\"size\":2,\"srcDataType\":\"hexdump\",\"transformation\":\"noSwap\",\"dstDataType\":\"string\"}],\"scanMode\":{\"rate\":200,\"type\":\"POLL\"}}],\"destination\":{\"type\":\"StreamManager\",\"streamName\":\"SiteWise_Stream\",\"streamBufferSize\":10},\"minimumInterRequestDuration\":200}]}\"}"
}
}
]
}'
```
**Nota**
La funzione Lambda in questo connettore ha un ciclo di vita di [lunga durata](lambda-functions.md#lambda-lifecycle).
## Dati di input
Questo connettore non accetta messaggi MQTT come dati di input.
## Dati di output
Questo connettore pubblica dati su. `StreamManager` È necessario configurare il flusso di messaggi di destinazione. I messaggi di output hanno la seguente struttura:
```
{
"alias": "string",
"messages": [
{
"name": "string",
"value": boolean|double|integer|string,
"timestamp": number,
"quality": "string"
}
]
}
```
## Licenze
Il connettore Modbus-TCP Protocol Adapter include i seguenti software/licenze di terze parti:
+ [Petri Modbus](https://github.com/digitalpetri/modbus) digitale
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche | Data |
| --- | --- | --- |
| 3 (consigliato) | Questa versione contiene correzioni di bug. | 22 dicembre 2021 |
| 2 | È stato aggiunto il supporto per ASCII e UTF8 stringhe sorgente ISO8859 codificate. | 24 maggio 2021 |
| 1 | Versione iniziale. | 15 dicembre 2020 |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
# Connettore GPIO Raspberry Pi
**avvertimento**
Questo connettore è entrato nella *fase di vita prolungata* e AWS IoT Greengrass non rilascerà aggiornamenti che forniscano funzionalità, miglioramenti alle funzionalità esistenti, patch di sicurezza o correzioni di bug. Per ulteriori informazioni, consulta [AWS IoT Greengrass Version 1 politica di manutenzione](maintenance-policy.md).
Il [connettore](connectors.md) GPIO Raspberry Pi controlla i pin di input/output (GPIO) generici su un dispositivo principale Raspberry Pi.
Questo connettore esegue il polling dei pin di input a un intervallo specificato e pubblica le modifiche allo stato negli argomenti MQTT. Accetta anche richieste di lettura e scrittura come messaggi MQTT da funzioni Lambda definite dall'utente. Le richieste di scrittura vengono utilizzate per impostare il pin sull'alta o bassa tensione.
Il connettore fornisce parametri utilizzabili per indicare i pin di input e output. Questo comportamento viene configurato prima della distribuzione del gruppo. Non può essere modificato in fase di runtime.
+ I pin di input possono essere utilizzati per ricevere i dati da dispositivi periferici.
+ I pin di output possono essere utilizzati per controllare le periferiche o inviare dati alle periferiche.
Puoi utilizzare questo connettore per molti scenari, ad esempio:
+ Controllo delle luci LED verde, gialle e rosse di un semaforo.
+ Controllo di una ventola (collegata a un relè elettrico) in base ai dati forniti da un sensore di umidità.
+ Informare i dipendenti di un negozio sul fatto che i clienti hanno premuto un pulsante.
+ Utilizzo di un interruttore smart per controllare altri dispositivi IoT.
**Nota**
Questo connettore non è idoneo per applicazioni con requisiti in tempo reale. Gli eventi di breve durata potrebbero non venire rilevati.
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 3 | `arn:aws:greengrass:region::/connectors/RaspberryPiGPIO/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/RaspberryPiGPIO/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/RaspberryPiGPIO/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#raspberrypi-gpio-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 3 ]
+ AWS IoT Greengrass Software principale v1.9.3 o successivo.
+ [Python](https://www.python.org/) versione 3.7 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
+ Raspberry Pi 4 modello B o Raspberry Pi 3 modello B/B\$1. È necessario conoscere la sequenza pin del Raspberry Pi. Per ulteriori informazioni, consulta [Sequenza pin GPIO](#raspberrypi-gpio-connector-req-pins).
+ Una [risorsa del dispositivo locale](access-local-resources.md) nel gruppo Greengrass che rimanda al `/dev/gpiomem` Raspberry Pi. Se si crea la risorsa nella console, è necessario selezionare l'opzione **Aggiungi automaticamente le autorizzazioni del gruppo di sistema operativo del gruppo Linux proprietario della** risorsa. Nell'API, imposta la `GroupOwnerSetting.AutoAddGroupOwner` proprietà su`true`.
+ Il [RPimodulo.GPIO](https://sourceforge.net/p/raspberry-gpio-python/wiki/Home/) installato sul Raspberry Pi. In Raspbian, questo modulo è installato per impostazione predefinita. Puoi utilizzare il seguente comando per reinstallarlo:
```
sudo pip install RPi.GPIO
```
------
#### [ Versions 1 - 2 ]
+ AWS IoT Greengrass Software di base v1.7 o successivo.
+ [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH.
+ Raspberry Pi 4 modello B o Raspberry Pi 3 modello B/B\$1. È necessario conoscere la sequenza pin del Raspberry Pi. Per ulteriori informazioni, consulta [Sequenza pin GPIO](#raspberrypi-gpio-connector-req-pins).
+ Una [risorsa del dispositivo locale](access-local-resources.md) nel gruppo Greengrass che rimanda al `/dev/gpiomem` Raspberry Pi. Se si crea la risorsa nella console, è necessario selezionare l'opzione **Aggiungi automaticamente le autorizzazioni del gruppo di sistema operativo del gruppo Linux proprietario della** risorsa. Nell'API, imposta la `GroupOwnerSetting.AutoAddGroupOwner` proprietà su`true`.
+ Il [RPimodulo.GPIO](https://sourceforge.net/p/raspberry-gpio-python/wiki/Home/) installato sul Raspberry Pi. In Raspbian, questo modulo è installato per impostazione predefinita. Puoi utilizzare il seguente comando per reinstallarlo:
```
sudo pip install RPi.GPIO
```
------
### Sequenza pin GPIO
Il connettore GPIO Raspberry Pi fa riferimento ai pin GPIO in base allo schema di numerazione del System on Chip (SoC) sottostante, non in base al layout fisico dei pin GPIO. L'ordine fisico dei pin può variare nelle versioni di Raspberry Pi. Per ulteriori informazioni, consulta [GPIO](https://www.raspberrypi.org/documentation/usage/gpio/) nella documentazione di Raspberry Pi.
Il connettore non è in grado di verificare se i pin di input e output in fase di configurazione sono associati correttamente all'hardware sottostante del Raspberry Pi. Se la configurazione dei pin non è valida, il connettore restituisce un errore di runtime al momento dell'avvio nel dispositivo. Per risolvere il problema, riconfigurare il connettore, quindi ridistribuirlo.
**Nota**
Assicurati che le periferiche dei pin GPIO siano correttamente cablate per evitare danni ai componenti.
## Parametri del connettore
Questo connettore fornisce i seguenti parametri:
`InputGpios`
Un elenco separato da virgole di numeri pin GPIO da configurare come input. Se lo desideri, puoi aggiungere `U` per impostare una resistenza pull-up del pin oppure `D` per impostare la resistenza pull-down. Esempio: `"5,6U,7D"`.
Nome visualizzato nella AWS IoT console: pin **GPIO di input**
Obbligatorio: `false`. Devi specificare i pin di input, quelli di output o entrambi.
Tipo: `string`
Modello valido: `^$|^[0-9]+[UD]?(,[0-9]+[UD]?)*$`
`InputPollPeriod`
L'intervallo (in millisecondi) fra ciascuna operazione di polling, che controlla le modifiche dello stato dei pin GPIO di input. Il valore minimo è 1.
Questo valore dipende dallo scenario e dal tipo di dispositivi in fase di polling. Ad esempio, un valore pari a `50` dovrebbe essere sufficientemente rapido per rilevare la pressione di un pulsante.
Nome visualizzato nella AWS IoT console: periodo di **polling GPIO di input**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^$|^[1-9][0-9]*$`
`OutputGpios`
Un elenco separato da virgole di numeri pin GPIO da configurare come output. Puoi aggiungere `H` per impostare uno stato elevato (1) oppure `L` per impostare uno stato basso (0). Esempio: `"8H,9,27L"`.
Nome visualizzato nella AWS IoT console: pin **GPIO di output**
Obbligatorio: `false`. Devi specificare i pin di input, quelli di output o entrambi.
Tipo: `string`
Modello valido: `^$|^[0-9]+[HL]?(,[0-9]+[HL]?)*$`
`GpioMem-ResourceId`
L'ID della risorsa del dispositivo locale che rappresenta `/dev/gpiomem`.
Al connettore è concesso l'accesso in lettura e scrittura alla risorsa.
Nome visualizzato nella AWS IoT console: **Resource for /dev/gpiomem device**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `.+`
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea un `ConnectorDefinition` con una versione iniziale che contiene il connettore GPIO Raspberry Pi.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyRaspberryPiGPIOConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/RaspberryPiGPIO/versions/3",
"Parameters": {
"GpioMem-ResourceId": "my-gpio-resource",
"InputGpios": "5,6U,7D",
"InputPollPeriod": 50,
"OutputGpios": "8H,9,27L"
}
}
]
}'
```
**Nota**
La funzione Lambda in questo connettore ha un ciclo di vita di [lunga durata](lambda-functions.md#lambda-lifecycle).
**Nella AWS IoT Greengrass console, puoi aggiungere un connettore dalla pagina Connettori del gruppo.** Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md).
## Dati di input
Questo connettore accetta richieste di lettura o scrittura per i pin GPIO in due argomenti MQTT.
+ Richieste di lettura nell'argomento `gpio/+/+/read`.
+ Richieste di scrittura nell'argomento `gpio/+/+/write`.
Per pubblicare in questi argomenti, sostituisci i caratteri jolly `+` rispettivamente con il nome dell'oggetto core e il numero di pin di destinazione. Per esempio:
```
gpio/core-thing-name/gpio-number/read
```
**Nota**
Attualmente, quando si crea un abbonamento che utilizza il connettore GPIO Raspberry Pi, è necessario specificare un valore per almeno una delle \$1 wildcard presenti nell'argomento.
**Filtro di argomenti:** `gpio/+/+/read`
Utilizza questo argomento per indicare al connettore di leggere lo stato del pin GPIO specificato nell'argomento.
Il connettore pubblica la risposta nel corrispondente argomento di output (ad esempio, `gpio/core-thing-name/gpio-number/state`).
**Proprietà dei messaggi**
Nessuna. I messaggi inviati a questo argomento vengono ignorati.
**Filtro di argomenti:** `gpio/+/+/write`
Utilizza questo argomento per inviare richieste di scrittura a un pin GPIO. Indica al connettore di impostare il pin GPIO specificato nell'argomento sulla bassa tensione o sull'alta tensione.
+ `0` imposta il pin sulla bassa tensione.
+ `1` imposta il pin sull'alta tensione.
Il connettore pubblica la risposta nel corrispondente argomento `/state` di output (ad esempio, `gpio/core-thing-name/gpio-number/state`).
**Proprietà dei messaggi**
Il valore `0` o `1`, come intero o stringa.
**Input di esempio**
```
0
```
## Dati di output
Questo connettore pubblica i dati in due argomenti:
+ Le modifiche allo stato alto o basso nell'argomento `gpio/+/+/state`.
+ Gli errori nell'argomento `gpio/+/error`.
**Filtro di argomenti:** `gpio/+/+/state`
Utilizza questo argomento per ascoltare le modifiche dello stato dei pin di input e risposte alle richieste di lettura. Il connettore restituisce la stringa `"0"` se lo stato del pin è basso oppure `"1"` se lo stato è alto.
Durante la pubblicazione in questo argomento, il connettore sostituisce i caratteri jolly `+` rispettivamente con il nome dell'oggetto core e il numero di pin di destinazione. Per esempio:
```
gpio/core-thing-name/gpio-number/state
```
Attualmente, quando si crea un abbonamento che utilizza il connettore GPIO Raspberry Pi, è necessario specificare un valore per almeno uno degli \$1 caratteri jolly presenti nell'argomento.
**Output di esempio**
```
0
```
**Filtro di argomenti:** `gpio/+/error`
Utilizza questo argomento per ascoltare gli errori. Il connettore pubblica in questo argomento in seguito a una richiesta non valida (ad esempio, quando è necessaria una modifica dello stato di un pin di input).
Durante la pubblicazione in questo argomento, il connettore sostituisce il carattere jolly `+` con il nome dell'oggetto core.
**Output di esempio**
```
{
"topic": "gpio/my-core-thing/22/write",
"error": "Invalid GPIO operation",
"long_description": "GPIO 22 is configured as an INPUT GPIO. Write operations are not permitted."
}
```
## Esempio di utilizzo
Usa i seguenti passaggi di alto livello per configurare una funzione Lambda di esempio di Python 3.7 che puoi usare per provare il connettore.
**Nota**
Se usi altri runtime Python, puoi creare un collegamento simbolico da Python3.x a Python 3.7.
Gli argomenti [Nozioni di base sui connettori (console)](connectors-console.md) e [Nozioni di base sui connettori (CLI)](connectors-cli.md) contengono passaggi dettagliati che illustrano come configurare e distribuire un connettore Twilio Notifications di esempio.
1. Assicurarsi di soddisfare i [requisiti](#raspberrypi-gpio-connector-req) per il connettore.
1. Crea e pubblica una funzione Lambda che invia dati di input al connettore.
Salvare il [codice di esempio](#raspberrypi-gpio-connector-usage-example) come file PY. Scarica e decomprimi il [AWS IoT Greengrass Core SDK per Python](lambda-functions.md#lambda-sdks-core). Quindi, crea un pacchetto zip che contiene il file PY e la cartella `greengrasssdk` a livello root. Questo pacchetto zip è il pacchetto di distribuzione in cui carichi. AWS Lambda
Dopo aver creato la funzione Python 3.7 Lambda, pubblica una versione della funzione e crea un alias.
1. Configurare il gruppo Greengrass.
1. Aggiungi la funzione Lambda tramite il relativo alias (consigliato). Configura il ciclo di vita Lambda come longevo (o nella `"Pinned": true` CLI).
1. Aggiungi la risorsa del dispositivo locale richiesta e concedi l'accesso in lettura/scrittura alla funzione Lambda.
1. Aggiungere il connettore e configurarne i relativi [parametri](#raspberrypi-gpio-connector-param).
1. Aggiungere sottoscrizioni che consentono al connettore di ricevere [i dati di input](#raspberrypi-gpio-connector-data-input) e inviare [i dati di output](#raspberrypi-gpio-connector-data-output) nei filtri degli argomenti supportati.
+ Imposta la funzione Lambda come origine, il connettore come destinazione e utilizza un filtro per argomenti di input supportato.
+ Imposta il connettore come origine, AWS IoT Core come destinazione e utilizza un filtro per l’argomento di output supportato. Utilizzi questo abbonamento per visualizzare i messaggi di stato nella AWS IoT console.
1. Distribuisci il gruppo.
1. Nella AWS IoT console, nella pagina **Test**, sottoscrivi l'argomento relativo ai dati di output per visualizzare i messaggi di stato dal connettore. La funzione Lambda di esempio è di lunga durata e inizia a inviare messaggi subito dopo l'implementazione del gruppo.
Al termine del test, puoi impostare il ciclo di vita Lambda su richiesta (o nella CLI) e `"Pinned": false` distribuire il gruppo. Ciò impedisce alla funzione di inviare messaggi.
### Esempio
L'esempio seguente della funzione Lambda invia un messaggio di input al connettore. Questo esempio invia richieste di lettura per un set di pin GPIO di input. Illustra come costruire argomenti utilizzando il nome dell'oggetto core e il numero di pin.
```
import greengrasssdk
import json
import os
iot_client = greengrasssdk.client('iot-data')
INPUT_GPIOS = [6, 17, 22]
thingName = os.environ['AWS_IOT_THING_NAME']
def get_read_topic(gpio_num):
return '/'.join(['gpio', thingName, str(gpio_num), 'read'])
def get_write_topic(gpio_num):
return '/'.join(['gpio', thingName, str(gpio_num), 'write'])
def send_message_to_connector(topic, message=''):
iot_client.publish(topic=topic, payload=str(message))
def set_gpio_state(gpio, state):
send_message_to_connector(get_write_topic(gpio), str(state))
def read_gpio_state(gpio):
send_message_to_connector(get_read_topic(gpio))
def publish_basic_message():
for i in INPUT_GPIOS:
read_gpio_state(i)
publish_basic_message()
def lambda_handler(event, context):
return
```
## Licenze
Il connettore Raspberry Pi GPIO; include i seguenti software/licenze di terze parti:
+ [RPi.GPIO/MIT](https://pypi.org/project/RPi.GPIO/)
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche |
| --- | --- |
| 3 | È stato aggiornato il runtime Lambda a Python 3.7, che modifica i requisiti di runtime. |
| 2 | Arn del connettore aggiornato per Regione AWS il supporto. |
| 1 | Versione iniziale. |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
+ [GPIO](https://www.raspberrypi.org/documentation/usage/gpio/) nella documentazione di Raspberry Pi
# Connettore Serial Stream
**avvertimento**
Questo connettore è entrato nella *fase di vita prolungata* e AWS IoT Greengrass non rilascerà aggiornamenti che forniscano funzionalità, miglioramenti alle funzionalità esistenti, patch di sicurezza o correzioni di bug. Per ulteriori informazioni, consulta [AWS IoT Greengrass Version 1 politica di manutenzione](maintenance-policy.md).
Il [connettore](connectors.md) Serial Stream legge e scrive su una porta seriale di un dispositivo principale. AWS IoT Greengrass
Questo connettore supporta due modalità di funzionamento:
+ **Read-On-Demand**. Riceve richieste di lettura e scrittura su argomenti MQTT e pubblica la risposta dell'operazione di lettura o lo stato dell'operazione di scrittura.
+ **Polling-Read**. Effettua letture dalla porta seriale a intervalli regolari. Questa modalità supporta anche Read-On-Demand le richieste.
**Nota**
Le richieste di lettura possono avere una lunghezza massima di 63994 byte. Le richieste di scrittura possono avere una lunghezza massima dei dati di 128000 byte.
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 3 | `arn:aws:greengrass:region::/connectors/SerialStream/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/SerialStream/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/SerialStream/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#serial-stream-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 3 ]
+ AWS IoT Greengrass Software principale v1.9.3 o successivo.
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ Una [risorsa del dispositivo locale](access-local-resources.md) del gruppo Greengrass che punta alla porta seriale di destinazione.
**Nota**
Prima di distribuire il connettore, ti consigliamo di configurare la porta seriale e di verificare che sia possibile effettuarvi operazioni di lettura e scrittura.
------
#### [ Versions 1 - 2 ]
+ AWS IoT Greengrass Software principale v1.7 o successivo.
+ [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH.
+ Una [risorsa del dispositivo locale](access-local-resources.md) del gruppo Greengrass che punta alla porta seriale di destinazione.
**Nota**
Prima di distribuire il connettore, ti consigliamo di configurare la porta seriale e di verificare che sia possibile effettuarvi operazioni di lettura e scrittura.
------
## Parametri del connettore
Questo connettore fornisce i seguenti parametri:
`BaudRate`
La velocità in baud della connessione seriale.
Nome visualizzato nella AWS IoT console: **baud rate**
Obbligatorio: `true`
Tipo: `string`
Valori validi: `110, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 56000, 57600, 115200, 230400`
Schema valido: `^110$|^300$|^600$|^1200$|^2400$|^4800$|^9600$|^14400$|^19200$|^28800$|^38400$|^56000$|^57600$|^115200$|^230400$`
`Timeout`
Il timeout (in secondi) di un'operazione di lettura.
Nome visualizzato nella AWS IoT console: **Timeout**
Obbligatorio: `true`
Tipo: `string`
Valori validi: `1 - 59`
Schema valido: `^([1-9]|[1-5][0-9])$`
`SerialPort`
Il percorso assoluto della porta seriale fisica sul dispositivo. Si tratta del percorso di origine specificato per la risorsa del dispositivo locale.
Nome visualizzato nella AWS IoT console: **porta seriale**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `[/a-zA-Z0-9_-]+`
`SerialPort-ResourceId`
L'ID della risorsa del dispositivo locale fisico che rappresenta la porta seriale fisica.
Al connettore è concesso l'accesso in lettura e scrittura alla risorsa.
Nome visualizzato nella AWS IoT console: **risorsa della porta seriale**
Richiesto: `true`
Tipo: `string`
Schema valido: `[a-zA-Z0-9_-]+`
`PollingRead`
Imposta la modalità di lettura: Polling-Read o. Read-On-Demand
+ Per la modalità Polling-Read, specificare `true`. In questa modalità, sono obbligatorie le proprietà `PollingInterval`, `PollingReadType` e `PollingReadLength`.
+ Per la Read-On-Demand modalità, specificare. `false` In questa modalità, il tipo e i valori di lunghezza sono specificati nella richiesta di lettura.
Nome visualizzato nella AWS IoT console: **modalità di lettura**
Obbligatorio: `true`
Tipo: `string`
Valori validi: `true, false`
Schema valido: `^([Tt][Rr][Uu][Ee]|[Ff][Aa][Ll][Ss][Ee])$`
`PollingReadLength`
La lunghezza dei dati (in byte) da leggere in ciascuna operazione di lettura di polling. Si applica solo quando si utilizza la modalità Polling-Read.
Nome visualizzato nella AWS IoT console: lunghezza della **lettura del sondaggio**
Obbligatorio: `false`. Questa proprietà è obbligatoria quando `PollingRead` è `true`.
Tipo: `string`
Modello valido: `^(|[1-9][0-9]{0,3}|[1-5][0-9]{4}|6[0-2][0-9]{3}|63[0-8][0-9]{2}|639[0-8][0-9]|6399[0-4])$`
`PollingReadInterval`
L'intervallo di tempo (in secondi) in cui il avviene la lettura di polling. Si applica solo quando si utilizza la modalità Polling-Read.
Nome visualizzato nella AWS IoT console: Intervallo di **lettura dei sondaggi**
Obbligatorio: `false`. Questa proprietà è obbligatoria quando `PollingRead` è `true`.
Tipo: `string`
Valori validi: 1 - 999
Modello valido: `^(|[1-9]|[1-9][0-9]|[1-9][0-9][0-9])$`
`PollingReadType`
Il tipo di dati letto dal thread di polling. Si applica solo quando si utilizza la modalità Polling-Read.
Nome visualizzato nella AWS IoT console: tipo di **lettura del sondaggio**
Obbligatorio: `false`. Questa proprietà è obbligatoria quando `PollingRead` è `true`.
Tipo: `string`
Valori validi: `ascii, hex`
Modello valido: `^(|[Aa][Ss][Cc][Ii][Ii]|[Hh][Ee][Xx])$`
`RtsCts`
Indica se abilitare o meno il controllo del flusso RTS/CTS. Il valore predefinito è `false`. Per ulteriori informazioni, consulta [RTS, CTS e RTR](https://en.wikipedia.org/wiki/RS-232#RTS,_CTS,_and_RTR).
Nome visualizzato nella AWS IoT console: controllo del flusso **RTS/CTS**
Obbligatorio: `false`
Tipo: `string`
Valori validi: `true, false`
Schema valido: `^(|[Tt][Rr][Uu][Ee]|[Ff][Aa][Ll][Ss][Ee])$`
`XonXoff`
Indica se abilitare o meno il controllo del flusso del software. Il valore predefinito è `false`. Per ulteriori informazioni, consulta [Controllo del flusso software](https://en.wikipedia.org/wiki/Software_flow_control).
Nome visualizzato nella AWS IoT console: **Software flow control**
Obbligatorio: `false`
Tipo: `string`
Valori validi: `true, false`
Schema valido: `^(|[Tt][Rr][Uu][Ee]|[Ff][Aa][Ll][Ss][Ee])$`
`Parity`
La parità della porta seriale. Il valore predefinito è `N`. Per ulteriori informazioni, consulta [Parità](https://en.wikipedia.org/wiki/Serial_port#Parity).
Nome visualizzato nella AWS IoT console: **parità della porta seriale**
Obbligatorio: `false`
Tipo: `string`
Valori validi: `N, E, O, S, M`
Schema valido: `^(|[NEOSMneosm])$`
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea un `ConnectorDefinition` con una versione iniziale che contiene il connettore Serial Stream. Configura il connettore per la modalità Polling-Read.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MySerialStreamConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/SerialStream/versions/3",
"Parameters": {
"BaudRate" : "9600",
"Timeout" : "25",
"SerialPort" : "/dev/serial1",
"SerialPort-ResourceId" : "my-serial-port-resource",
"PollingRead" : "true",
"PollingReadLength" : "30",
"PollingReadInterval" : "30",
"PollingReadType" : "hex"
}
}
]
}'
```
Nella AWS IoT Greengrass console, puoi aggiungere un connettore dalla pagina **Connettori** del gruppo. Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md).
## Dati di input
Questo connettore accetta richieste di lettura o scrittura per porte seriali su due argomenti MQTT. I messaggi di input devono essere in formato JSON.
+ Richieste di lettura nell'argomento `serial/+/read/#`.
+ Richieste di scrittura nell'argomento `serial/+/write/#`.
Per pubblicare in questi argomenti, sostituire il carattere jolly `+` con il nome oggetto del core e il carattere jolly `#` con il percorso della porta seriale. Per esempio:
```
serial/core-thing-name/read/dev/serial-port
```
**Filtro di argomenti:** `serial/+/read/#`
Utilizza questo argomento per inviare richieste di lettura on demand a un pin seriale. Le richieste di lettura possono avere una lunghezza massima di 63994 byte.
**Proprietà dei messaggi**
`readLength`
La lunghezza dei dati da leggere dalla porta seriale.
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[1-9][0-9]*$`
`type`
Il tipo di dati da leggere.
Richiesto: `true`
Tipo: `string`
Valori validi: `ascii, hex`
Schema valido: `(?i)^(ascii|hex)$`
`id`
Un ID arbitrario della richiesta. Questa proprietà viene utilizzata per associare una richiesta di input a una risposta di output.
Richiesto: `false`
Tipo: `string`
Schema valido: `.+`
**Input di esempio**
```
{
"readLength": "30",
"type": "ascii",
"id": "abc123"
}
```
**Filtro di argomenti:** `serial/+/write/#`
Utilizza questo argomento per inviare richieste di scrittura a un pin seriale. Le richieste di scrittura possono avere una lunghezza massima dei dati di 128000 byte.
**Proprietà dei messaggi**
`data`
La stringa da scrivere nella porta seriale.
Richiesto: `true`
Tipo: `string`
Schema valido: `^[1-9][0-9]*$`
`type`
Il tipo di dati da leggere.
Richiesto: `true`
Tipo: `string`
Valori validi: `ascii, hex`
Schema valido: `^(ascii|hex|ASCII|HEX)$`
`id`
Un ID arbitrario della richiesta. Questa proprietà viene utilizzata per associare una richiesta di input a una risposta di output.
Richiesto: `false`
Tipo: `string`
Schema valido: `.+`
**Input di esempio: richiesta ASCII**
```
{
"data": "random serial data",
"type": "ascii",
"id": "abc123"
}
```
**Input di esempio: richiesta esadecimale**
```
{
"data": "base64 encoded data",
"type": "hex",
"id": "abc123"
}
```
## Dati di output
Il connettore pubblica i dati di output in due argomenti:
+ Le informazioni sullo stato del connettore nell'argomento `serial/+/status/#`.
+ Le risposte delle richieste di lettura nell'argomento `serial/+/read_response/#`.
Durante la pubblicazione in questo argomento, il connettore sostituisce il carattere jolly `+` con il nome oggetto del core e il carattere jolly `#` con il percorso della porta seriale. Per esempio:
```
serial/core-thing-name/status/dev/serial-port
```
**Filtro di argomenti:** `serial/+/status/#`
Utilizza questo argomento per ascoltare lo stato delle richieste di lettura e scrittura. Se la richiesta include una proprietà `id`, verrà restituita nella risposta.
**Output di esempio: Operazione riuscita**
```
{
"response": {
"status": "success"
},
"id": "abc123"
}
```
**Esempio di output: Errore**
Una risposta di errore include la proprietà `error_message` che descrive l'errore o il timeout riscontrato durante l'esecuzione dell'operazione di lettura o scrittura.
```
{
"response": {
"status": "fail",
"error_message": "Could not write to port"
},
"id": "abc123"
}
```
**Filtro di argomenti:** `serial/+/read_response/#`
Utilizza questo argomento per ricevere risposta dei dati da un'operazione di lettura. I dati della risposta hanno la codifica Base64 se il tipo è `hex`.
**Output di esempio**
```
{
"data": "output of serial read operation"
"id": "abc123"
}
```
## Esempio di utilizzo
Usa i seguenti passaggi di alto livello per configurare una funzione Lambda di esempio di Python 3.7 che puoi usare per provare il connettore.
**Nota**
Se usi altri runtime Python, puoi creare un collegamento simbolico da Python3.x a Python 3.7.
Gli argomenti [Nozioni di base sui connettori (console)](connectors-console.md) e [Nozioni di base sui connettori (CLI)](connectors-cli.md) contengono passaggi dettagliati che illustrano come configurare e distribuire un connettore Twilio Notifications di esempio.
1. Assicurarsi di soddisfare i [requisiti](#serial-stream-connector-req) per il connettore.
1. Crea e pubblica una funzione Lambda che invia dati di input al connettore.
Salvare il [codice di esempio](#serial-stream-connector-usage-example) come file PY. Scarica e decomprimi il [AWS IoT Greengrass Core SDK per Python](lambda-functions.md#lambda-sdks-core). Quindi, crea un pacchetto zip che contiene il file PY e la cartella `greengrasssdk` a livello root. Questo pacchetto zip è il pacchetto di distribuzione in cui carichi. AWS Lambda
Dopo aver creato la funzione Python 3.7 Lambda, pubblica una versione della funzione e crea un alias.
1. Configurare il gruppo Greengrass.
1. Aggiungi la funzione Lambda tramite il relativo alias (consigliato). Configura il ciclo di vita Lambda come longevo (o nella `"Pinned": true` CLI).
1. Aggiungi la risorsa del dispositivo locale richiesta e concedi l'accesso in lettura/scrittura alla funzione Lambda.
1. Aggiungere il connettore e configurarne i relativi [parametri](#serial-stream-connector-param).
1. Aggiungere sottoscrizioni al gruppo che consentono al connettore di ricevere [i dati di input](#serial-stream-connector-data-input) e inviare i [dati di output](#serial-stream-connector-data-output) nei filtri degli argomenti supportati.
+ Imposta la funzione Lambda come origine, il connettore come destinazione e utilizza un filtro per argomenti di input supportato.
+ Imposta il connettore come origine, AWS IoT Core come destinazione e utilizza un filtro per l’argomento di output supportato. Utilizzi questo abbonamento per visualizzare i messaggi di stato nella AWS IoT console.
1. Distribuisci il gruppo.
1. Nella AWS IoT console, nella pagina **Test**, sottoscrivi l'argomento relativo ai dati di output per visualizzare i messaggi di stato dal connettore. La funzione Lambda di esempio è di lunga durata e inizia a inviare messaggi subito dopo l'implementazione del gruppo.
Al termine del test, puoi impostare il ciclo di vita Lambda su richiesta (o nella CLI) e `"Pinned": false` distribuire il gruppo. Ciò impedisce alla funzione di inviare messaggi.
### Esempio
L'esempio seguente della funzione Lambda invia un messaggio di input al connettore.
```
import greengrasssdk
import json
TOPIC_REQUEST = 'serial/CORE_THING_NAME/write/dev/serial1'
# Creating a greengrass core sdk client
iot_client = greengrasssdk.client('iot-data')
def create_serial_stream_request():
request = {
"data": "TEST",
"type": "ascii",
"id": "abc123"
}
return request
def publish_basic_request():
iot_client.publish(payload=json.dumps(create_serial_stream_request()), topic=TOPIC_REQUEST)
publish_basic_request()
def lambda_handler(event, context):
return
```
## Licenze
Il connettore Serial Stream include i seguenti software/licenze di terze parti:
+ [pyserial](https://github.com/pyserial/pyserial)/BSD
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche |
| --- | --- |
| 3 | È stato aggiornato il runtime Lambda a Python 3.7, che modifica i requisiti di runtime. |
| 2 | Arn del connettore aggiornato per Regione AWS il supporto. |
| 1 | Versione iniziale. |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
# ServiceNow MetricBase Connettore di integrazione
**avvertimento**
Questo connettore è entrato nella *fase di vita prolungata* e AWS IoT Greengrass non rilascerà aggiornamenti che forniscano funzionalità, miglioramenti alle funzionalità esistenti, patch di sicurezza o correzioni di bug. Per ulteriori informazioni, consulta [AWS IoT Greengrass Version 1 politica di manutenzione](maintenance-policy.md).
Il [connettore ServiceNow MetricBase ](connectors.md) Integration pubblica le metriche delle serie temporali dai dispositivi Greengrass su. ServiceNow MetricBase In questo modo potrai archiviare, analizzare e visualizzare i dati delle serie temporali dall'ambiente core di Greengrass e agire sugli eventi locali.
Questo connettore riceve dati di serie temporali su un argomento MQTT e li pubblica nell'API a intervalli regolari. ServiceNow
Puoi utilizzare questo connettore per supportare molti scenari, ad esempio:
+ Creazione di avvisi basati su soglie e allarmi basati sui dati delle serie temporali raccolti dai dispositivi Greengrass.
+ Usa i dati dei servizi temporali dei dispositivi Greengrass con applicazioni personalizzate basate sulla ServiceNow piattaforma.
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 4 | `arn:aws:greengrass:region::/connectors/ServiceNowMetricBaseIntegration/versions/4` |
| 3 | `arn:aws:greengrass:region::/connectors/ServiceNowMetricBaseIntegration/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/ServiceNowMetricBaseIntegration/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/ServiceNowMetricBaseIntegration/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#servicenow-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 3 - 4 ]
+ AWS IoT Greengrass Software principale v1.9.3 o successivo. AWS IoT Greengrass [deve essere configurato per supportare i segreti locali, come descritto in Secrets Requirements.](secrets.md#secrets-reqs)
**Nota**
Questo requisito include l'autorizzazione all'accesso ai segreti di Secrets Manager. *Se utilizzi il ruolo di servizio Greengrass predefinito, Greengrass è autorizzato a ottenere i valori dei segreti con nomi che iniziano con greengrass-.*
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ Un account con un abbonamento attivato a. ServiceNow MetricBase Inoltre, nell'account è necessario creare un parametro e una tabella dei parametri. Per ulteriori informazioni, [MetricBase](https://docs.servicenow.com/bundle/london-servicenow-platform/page/administer/metricbase/concept/metricbase.html)consulta la ServiceNow documentazione.
+ Un tipo di testo segreto Gestione dei segreti AWS che memorizza il nome utente e la password per accedere all' ServiceNow istanza con l'autenticazione di base. Il segreto deve includere le chiavi "utente" e "password" con i valori corrispondenti. Per ulteriori informazioni, consulta [Creazione di un segreto di base](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) nella *Guida Gestione dei segreti AWS per l'utente*.
+ Una risorsa segreta del gruppo Greengrass che fa riferimento al segreto di Secrets Manager. Per ulteriori informazioni, consulta [Implementa i segreti fino al nucleo AWS IoT Greengrass](secrets.md).
------
#### [ Versions 1 - 2 ]
+ AWS IoT Greengrass Software principale v1.7 o successivo. AWS IoT Greengrass deve essere configurato per supportare i segreti locali, come descritto in [Secrets Requirements](secrets.md#secrets-reqs).
**Nota**
Questo requisito include l'autorizzazione all'accesso ai segreti di Secrets Manager. *Se utilizzi il ruolo di servizio Greengrass predefinito, Greengrass è autorizzato a ottenere i valori dei segreti con nomi che iniziano con greengrass-.*
+ [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH.
+ Un ServiceNow account con un abbonamento attivato a. MetricBase Inoltre, nell'account è necessario creare un parametro e una tabella dei parametri. Per ulteriori informazioni, [MetricBase](https://docs.servicenow.com/bundle/london-servicenow-platform/page/administer/metricbase/concept/metricbase.html)consulta la ServiceNow documentazione.
+ Un tipo di testo segreto Gestione dei segreti AWS che memorizza il nome utente e la password per accedere all' ServiceNow istanza con l'autenticazione di base. Il segreto deve includere le chiavi "utente" e "password" con i valori corrispondenti. Per ulteriori informazioni, consulta [Creazione di un segreto di base](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) nella *Guida Gestione dei segreti AWS per l'utente*.
+ Una risorsa segreta del gruppo Greengrass che fa riferimento al segreto di Secrets Manager. Per ulteriori informazioni, consulta [Implementa i segreti fino al nucleo AWS IoT Greengrass](secrets.md).
------
## Parametri del connettore
Questo connettore fornisce i seguenti parametri:
------
#### [ Version 4 ]
`PublishInterval`
Il numero massimo di secondi di attesa tra gli eventi di pubblicazione ServiceNow. Il valore massimo è 900.
Il connettore pubblica ServiceNow quando `PublishBatchSize` viene raggiunto o `PublishInterval` scade.
Nome visualizzato nella AWS IoT console: **intervallo di pubblicazione** in secondi
Obbligatorio: `true`
Tipo: `string`
Valori validi: `1 - 900`
Schema valido: `[1-9]|[1-9]\d|[1-9]\d\d|900`
`PublishBatchSize`
Il numero massimo di valori delle metriche che possono essere raggruppati in batch prima di essere pubblicati su. ServiceNow
Il connettore pubblica ServiceNow quando `PublishBatchSize` viene raggiunto o scade. `PublishInterval`
Nome visualizzato nella AWS IoT console: dimensione del batch di **pubblicazione**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[0-9]+$`
`InstanceName`
Il nome dell'istanza utilizzata per la connessione ServiceNow.
Nome visualizzato nella AWS IoT console: **nome dell' ServiceNow istanza**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `.+`
`DefaultTableName`
Il nome della tabella che contiene le informazioni `GlideRecord` associate al MetricBase database delle serie temporali. La proprietà `table` nel payload del messaggio di input può essere utilizzata per sostituire questo valore.
Nome visualizzato nella AWS IoT console: **nome della tabella che contiene la metrica**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `.+`
`MaxMetricsToRetain`
Il numero massimo di parametri da salvare in memoria prima che vengano sostituiti con nuovi parametri.
Questo limite è valido quando non è presente una connessione a Internet e il connettore inizia il buffering dei parametri da pubblicare successivamente. Quando il buffer è pieno, i parametri meno recenti vengono sostituiti da quelli nuovi.
I parametri non vengono salvati se si interrompe il processo host del connettore. Ad esempio, ciò potrebbe verificarsi durante la distribuzione dei gruppi o al riavvio del dispositivo.
Il valore deve essere superiore alle dimensioni del batch e abbastanza grande da contenere messaggi in base alla velocità in entrata dei messaggi MQTT.
Nome visualizzato nella AWS IoT console: **numero massimo di metriche da conservare in memoria**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[0-9]+$`
`AuthSecretArn`
Il segreto Gestione dei segreti AWS che memorizza il nome ServiceNow utente e la password. Deve essere un segreto in formato testo. Il segreto deve includere le chiavi "utente" e "password" con i valori corrispondenti.
Nome visualizzato nella AWS IoT console: **ARN del segreto di autenticazione**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `arn:aws:secretsmanager:[a-z0-9\-]+:[0-9]{12}:secret:([a-zA-Z0-9\\]+/)*[a-zA-Z0-9/_+=,.@\-]+-[a-zA-Z0-9]+`
`AuthSecretArn-ResourceId`
La risorsa segreta del gruppo che fa riferimento al segreto di Secrets Manager per le ServiceNow credenziali.
Nome visualizzato nella AWS IoT console: risorsa token di **autenticazione**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `.+`
`IsolationMode`
Modalità di [containerizzazione](connectors.md#connector-containerization) per questo connettore. L'impostazione predefinita è`GreengrassContainer`, il che significa che il connettore viene eseguito in un ambiente di runtime isolato all'interno del AWS IoT Greengrass contenitore.
L'impostazione predefinita della containerizzazione per il gruppo non si applica ai connettori.
Nome visualizzato nella AWS IoT console: **modalità di isolamento del contenitore**
Obbligatorio: `false`
Tipo: `string`
Valori validi: `GreengrassContainer` o `NoContainer`
Schema valido: `^NoContainer$|^GreengrassContainer$`
------
#### [ Version 1 - 3 ]
`PublishInterval`
Il numero massimo di secondi di attesa tra gli eventi di pubblicazione ServiceNow. Il valore massimo è 900.
Il connettore pubblica ServiceNow quando `PublishBatchSize` viene raggiunto o `PublishInterval` scade.
Nome visualizzato nella AWS IoT console: **intervallo di pubblicazione** in secondi
Obbligatorio: `true`
Tipo: `string`
Valori validi: `1 - 900`
Schema valido: `[1-9]|[1-9]\d|[1-9]\d\d|900`
`PublishBatchSize`
Il numero massimo di valori delle metriche che possono essere raggruppati in batch prima di essere pubblicati su. ServiceNow
Il connettore pubblica ServiceNow quando `PublishBatchSize` viene raggiunto o scade. `PublishInterval`
Nome visualizzato nella AWS IoT console: dimensione del batch di **pubblicazione**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[0-9]+$`
`InstanceName`
Il nome dell'istanza utilizzata per la connessione ServiceNow.
Nome visualizzato nella AWS IoT console: **nome dell' ServiceNow istanza**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `.+`
`DefaultTableName`
Il nome della tabella che contiene le informazioni `GlideRecord` associate al MetricBase database delle serie temporali. La proprietà `table` nel payload del messaggio di input può essere utilizzata per sostituire questo valore.
Nome visualizzato nella AWS IoT console: **nome della tabella che contiene la metrica**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `.+`
`MaxMetricsToRetain`
Il numero massimo di parametri da salvare in memoria prima che vengano sostituiti con nuovi parametri.
Questo limite è valido quando non è presente una connessione a Internet e il connettore inizia il buffering dei parametri da pubblicare successivamente. Quando il buffer è pieno, i parametri meno recenti vengono sostituiti da quelli nuovi.
I parametri non vengono salvati se si interrompe il processo host del connettore. Ad esempio, ciò potrebbe verificarsi durante la distribuzione dei gruppi o al riavvio del dispositivo.
Il valore deve essere superiore alle dimensioni del batch e abbastanza grande da contenere messaggi in base alla velocità in entrata dei messaggi MQTT.
Nome visualizzato nella AWS IoT console: **numero massimo di metriche da conservare in memoria**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[0-9]+$`
`AuthSecretArn`
Il segreto Gestione dei segreti AWS che memorizza il nome ServiceNow utente e la password. Deve essere un segreto in formato testo. Il segreto deve includere le chiavi "utente" e "password" con i valori corrispondenti.
Nome visualizzato nella AWS IoT console: **ARN del segreto di autenticazione**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `arn:aws:secretsmanager:[a-z0-9\-]+:[0-9]{12}:secret:([a-zA-Z0-9\\]+/)*[a-zA-Z0-9/_+=,.@\-]+-[a-zA-Z0-9]+`
`AuthSecretArn-ResourceId`
La risorsa segreta del gruppo che fa riferimento al segreto di Secrets Manager per le ServiceNow credenziali.
Nome visualizzato nella AWS IoT console: risorsa token di **autenticazione**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `.+`
------
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea un `ConnectorDefinition` con una versione iniziale che contiene il connettore di ServiceNow MetricBase integrazione.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyServiceNowMetricBaseIntegrationConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/ServiceNowMetricBaseIntegration/versions/4",
"Parameters": {
"PublishInterval" : "10",
"PublishBatchSize" : "50",
"InstanceName" : "myinstance",
"DefaultTableName" : "u_greengrass_app",
"MaxMetricsToRetain" : "20000",
"AuthSecretArn" : "arn:aws:secretsmanager:region:account-id:secret:greengrass-secret-hash",
"AuthSecretArn-ResourceId" : "MySecretResource",
"IsolationMode" : "GreengrassContainer"
}
}
]
}'
```
**Nota**
La funzione Lambda in questo connettore ha un ciclo di vita di [lunga durata](lambda-functions.md#lambda-lifecycle).
**Nella AWS IoT Greengrass console, puoi aggiungere un connettore dalla pagina Connettori del gruppo.** Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md).
## Dati di input
Questo connettore accetta le metriche delle serie temporali su un argomento MQTT e le pubblica su. ServiceNow I messaggi di input devono essere in formato JSON.
**Filtro argomento in sottoscrizione**
`servicenow/metricbase/metric`
**Proprietà dei messaggi**
`request`
Informazioni sulla tabella, sul record e sul parametro. Questa richiesta rappresenta l'oggetto `seriesRef` in una richiesta POST delle serie temporali. Per ulteriori informazioni, consulta [API delle serie temporali Clotho - POST](https://docs.servicenow.com/bundle/london-application-development/page/integrate/inbound-rest/concept/Clotho-Time-Series-API.html#clotho-POST-put).
Obbligatorio: `true`
Tipo: `object` che include le seguenti proprietà:
`subject`
Il valore `sys_id` del record specifico della tabella.
Obbligatorio: `true`
Tipo: `string`
`metric_name`
Il nome del campo del parametro.
Richiesto: `true`
Tipo: `string`
`table`
Il nome della tabella in cui memorizzare il record. Specifica questo valore per sostituire il parametro `DefaultTableName`.
Richiesto: `false`
Tipo: `string`
`value`
Il valore del punto dati individuale.
Richiesto: `true`
Tipo: `float`
`timestamp`
Il timestamp del punto dati individuale. Il valore predefinito è l'ora corrente.
Richiesto: `false`
Tipo: `string`
**Input di esempio**
```
{
"request": {
"subject":"ef43c6d40a0a0b5700c77f9bf387afe3",
"metric_name":"u_count",
"table": "u_greengrass_app"
"value": 1.0,
"timestamp": "2018-10-14T10:30:00"
}
}
```
## Dati di output
Questo connettore pubblica le informazioni di stato come dati di output su un argomento MQTT.
**Filtro argomento in sottoscrizione**
`servicenow/metricbase/metric/status`
**Output di esempio: Operazione riuscita**
```
{
"response": {
"metric_name": "Errors",
"table_name": "GliderProd",
"processed_on": "2018-10-14T10:35:00",
"response_id": "khjKSkj132qwr23fcba",
"status": "success",
"values": [
{
"timestamp": "2016-10-14T10:30:00",
"value": 1.0
},
{
"timestamp": "2016-10-14T10:31:00",
"value": 1.1
}
]
}
}
```
**Esempio di output: Errore**
```
{
"response": {
"error": "InvalidInputException",
"error_message": "metric value is invalid",
"status": "fail"
}
}
```
Se il connettore rileva un errore riutilizzabile (ad esempio errori di connessione), riprova la pubblicazione nel batch successivo.
## Esempio di utilizzo
Usa i seguenti passaggi di alto livello per configurare una funzione Lambda di esempio di Python 3.7 che puoi usare per provare il connettore.
**Nota**
Se usi altri runtime Python, puoi creare un collegamento simbolico da Python3.x a Python 3.7.
Gli argomenti [Nozioni di base sui connettori (console)](connectors-console.md) e [Nozioni di base sui connettori (CLI)](connectors-cli.md) contengono passaggi dettagliati che illustrano come configurare e distribuire un connettore Twilio Notifications di esempio.
1. Assicurarsi di soddisfare i [requisiti](#servicenow-connector-req) per il connettore.
1. Crea e pubblica una funzione Lambda che invia dati di input al connettore.
Salvare il [codice di esempio](#servicenow-connector-usage-example) come file PY. Scarica e decomprimi il [AWS IoT Greengrass Core SDK per Python](lambda-functions.md#lambda-sdks-core). Quindi, crea un pacchetto zip che contiene il file PY e la cartella `greengrasssdk` a livello root. Questo pacchetto zip è il pacchetto di distribuzione in cui carichi. AWS Lambda
Dopo aver creato la funzione Python 3.7 Lambda, pubblica una versione della funzione e crea un alias.
1. Configurare il gruppo Greengrass.
1. Aggiungi la funzione Lambda tramite il relativo alias (consigliato). Configura il ciclo di vita Lambda come longevo (o nella `"Pinned": true` CLI).
1. Aggiungi la risorsa segreta richiesta e concedi l'accesso in lettura alla funzione Lambda.
1. Aggiungere il connettore e configurarne i relativi [parametri](#servicenow-connector-param).
1. Aggiungere sottoscrizioni che consentono al connettore di ricevere [i dati di input](#servicenow-connector-data-input) e inviare [i dati di output](#servicenow-connector-data-output) nei filtri degli argomenti supportati.
+ Imposta la funzione Lambda come origine, il connettore come destinazione e utilizza un filtro per argomenti di input supportato.
+ Imposta il connettore come origine, AWS IoT Core come destinazione e utilizza un filtro per l’argomento di output supportato. Utilizzi questo abbonamento per visualizzare i messaggi di stato nella AWS IoT console.
1. Distribuisci il gruppo.
1. Nella AWS IoT console, nella pagina **Test**, sottoscrivi l'argomento relativo ai dati di output per visualizzare i messaggi di stato dal connettore. La funzione Lambda di esempio è di lunga durata e inizia a inviare messaggi subito dopo l'implementazione del gruppo.
Al termine del test, puoi impostare il ciclo di vita Lambda su richiesta (o nella CLI) e `"Pinned": false` distribuire il gruppo. Ciò impedisce alla funzione di inviare messaggi.
### Esempio
L'esempio seguente della funzione Lambda invia un messaggio di input al connettore.
```
import greengrasssdk
import json
iot_client = greengrasssdk.client('iot-data')
SEND_TOPIC = 'servicenow/metricbase/metric'
def create_request_with_all_fields():
return {
"request": {
"subject": '2efdf6badbd523803acfae441b961961',
"metric_name": 'u_count',
"value": 1234,
"timestamp": '2018-10-20T20:22:20',
"table": 'u_greengrass_metricbase_test'
}
}
def publish_basic_message():
messageToPublish = create_request_with_all_fields()
print("Message To Publish: ", messageToPublish)
iot_client.publish(topic=SEND_TOPIC,
payload=json.dumps(messageToPublish))
publish_basic_message()
def lambda_handler(event, context):
return
```
## Licenze
Il connettore di ServiceNow MetricBase integrazione include i seguenti software/licenze di terze parti:
+ [pysnow](https://github.com/rbw/pysnow)/MIT
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche |
| --- | --- |
| 4 | Aggiunto il parametro `IsolationMode` per configurare la modalità di containerizzazione per il connettore. |
| 3 | È stato aggiornato il runtime Lambda a Python 3.7, che modifica i requisiti di runtime. |
| 2 | Correggere per ridurre l'eccessiva registrazione di log. |
| 1 | Versione iniziale. |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
# Connettore SNS
Il [connettore](connectors.md) SNS pubblica messaggi su un argomento di Amazon SNS. Ciò consente ai server Web, agli indirizzi e-mail e agli altri abbonati al messaggio di rispondere agli eventi nel gruppo Greengrass.
Questo connettore riceve informazioni sui messaggi SNS in un argomento MQTT, quindi invia il messaggio a un argomento SNS specificato. Facoltativamente, puoi utilizzare funzioni Lambda personalizzate per implementare la logica di filtraggio o formattazione sui messaggi prima che vengano pubblicati su questo connettore.
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 4 | `arn:aws:greengrass:region::/connectors/SNS/versions/4` |
| 3 | `arn:aws:greengrass:region::/connectors/SNS/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/SNS/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/SNS/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#sns-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 3 - 4 ]
+ AWS IoT Greengrass Software principale v1.9.3 o successivo.
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ Un argomento SNS configurato. Per le istruzioni, consulta [Creazione di un argomento Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-tutorial-create-topic.html) nella *Guida per lo Sviluppatore di Amazon Simple Notification Service*.
+ Il [ruolo del gruppo Greengrass](group-role.md) è configurato per consentire l'`sns:Publish`azione sull'Amazon di destinazione SNStopic, come mostrato nel seguente esempio di policy IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Stmt1528133056761",
"Action": [
"sns:Publish"
],
"Effect": "Allow",
"Resource": [
"arn:aws:sns:us-east-1:123456789012:topic-name"
]
}
]
}
```
------
Questo connettore consente di sostituire dinamicamente l'argomento predefinito nel payload del messaggio di input. Se l'implementazione utilizza questa funzionalità, la policy IAM deve consentire l'`sns:Publish`autorizzazione su tutti gli argomenti di destinazione. Puoi concedere alle risorse un accesso granulare o condizionale (ad esempio, utilizzando uno schema di denominazione con il carattere jolly \$1).
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
------
#### [ Versions 1 - 2 ]
+ AWS IoT Greengrass Software di base v1.7 o successivo.
+ [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH.
+ Un argomento SNS configurato. Per le istruzioni, consulta [Creazione di un argomento Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-tutorial-create-topic.html) nella *Guida per lo Sviluppatore di Amazon Simple Notification Service*.
+ Il [ruolo del gruppo Greengrass](group-role.md) è configurato per consentire l'`sns:Publish`azione sull'Amazon di destinazione SNStopic, come mostrato nel seguente esempio di policy IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Stmt1528133056761",
"Action": [
"sns:Publish"
],
"Effect": "Allow",
"Resource": [
"arn:aws:sns:us-east-1:123456789012:topic-name"
]
}
]
}
```
------
Questo connettore consente di sostituire dinamicamente l'argomento predefinito nel payload del messaggio di input. Se l'implementazione utilizza questa funzionalità, la policy IAM deve consentire l'`sns:Publish`autorizzazione su tutti gli argomenti di destinazione. Puoi concedere alle risorse un accesso granulare o condizionale (ad esempio, utilizzando uno schema di denominazione con il carattere jolly \$1).
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
------
## Parametri del connettore
Questo connettore fornisce i seguenti parametri:
------
#### [ Version 4 ]
`DefaultSNSArn`
L'ARN dell'argomento SNS predefinito in cui pubblicare i messaggi. L'argomento di destinazione può essere ignorato con la proprietà `sns_topic_arn` del payload del messaggio di input.
Il ruolo del gruppo deve permettere l'autorizzazione `sns:Publish` a tutti gli argomenti di destinazione. Per ulteriori informazioni, consulta [Requisiti](#sns-connector-req).
Nome visualizzato nella AWS IoT console: **argomento SNS predefinito** ARN
Obbligatorio: `true`
Tipo: `string`
Modello valido: `arn:aws:sns:([a-z]{2}-[a-z]+-\d{1}):(\d{12}):([a-zA-Z0-9-_]+)$`
`IsolationMode`
Modalità di [containerizzazione](connectors.md#connector-containerization) per questo connettore. L'impostazione predefinita è`GreengrassContainer`, il che significa che il connettore viene eseguito in un ambiente di runtime isolato all'interno del AWS IoT Greengrass contenitore.
L'impostazione predefinita della containerizzazione per il gruppo non si applica ai connettori.
Nome visualizzato nella AWS IoT console: **modalità di isolamento del contenitore**
Obbligatorio: `false`
Tipo: `string`
Valori validi: `GreengrassContainer` o `NoContainer`
Modello valido: `^NoContainer$|^GreengrassContainer$`
------
#### [ Versions 1 - 3 ]
`DefaultSNSArn`
L'ARN dell'argomento SNS predefinito in cui pubblicare i messaggi. L'argomento di destinazione può essere ignorato con la proprietà `sns_topic_arn` del payload del messaggio di input.
Il ruolo del gruppo deve permettere l'autorizzazione `sns:Publish` a tutti gli argomenti di destinazione. Per ulteriori informazioni, consulta [Requisiti](#sns-connector-req).
Nome visualizzato nella AWS IoT console: **argomento SNS predefinito** ARN
Obbligatorio: `true`
Tipo: `string`
Modello valido: `arn:aws:sns:([a-z]{2}-[a-z]+-\d{1}):(\d{12}):([a-zA-Z0-9-_]+)$`
------
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea un file `ConnectorDefinition` con una versione iniziale che contiene il connettore SNS.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MySNSConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/SNS/versions/4",
"Parameters": {
"DefaultSNSArn": "arn:aws:sns:region:account-id:topic-name",
"IsolationMode" : "GreengrassContainer"
}
}
]
}'
```
Nella AWS IoT Greengrass console, puoi aggiungere un connettore dalla pagina **Connettori** del gruppo. Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md).
## Dati di input
Questo connettore accetta informazioni sui messaggi SNS su un argomento MQTT, quindi pubblica il messaggio così com'è nell'argomento SNS di destinazione. I messaggi di input devono essere in formato JSON.
**Filtro argomento in sottoscrizione**
`sns/message`
**Proprietà dei messaggi**
`request`
Informazioni sul messaggio da inviare all'argomento SNS.
Obbligatorio: `true`
Tipo: `object` che include le seguenti proprietà:
`message`
Il contenuto del messaggio come stringa o in formato JSON. Per degli esempi, vedi [Input di esempio](#sns-connector-data-input-example).
Per inviare JSON, la proprietà `message_structure` deve essere impostata su `json` e il messaggio deve essere un oggetto JSON codificato come stringa che contiene una chiave `default`.
Obbligatorio: `true`
Tipo: `string`
Modello valido: `.*`
`subject`
L'oggetto del messaggio.
Obbligatorio: `false`
Tipo: testo ASCII, fino a 100 caratteri. Deve iniziare con una lettera, un numero o un segno di punteggiatura. Non deve contenere interruzioni di riga né caratteri di controllo.
Modello valido: `.*`
`sns_topic_arn`
L'ARN dell'argomento SNS in cui pubblicare i messaggi. Se specificato, il connettore effettua la pubblicazione in questo argomento anziché in quello predefinito.
Il ruolo del gruppo deve permettere l'autorizzazione `sns:Publish` a qualsiasi argomento di destinazione. Per ulteriori informazioni, consulta [Requisiti](#sns-connector-req).
Obbligatorio: `false`
Tipo: `string`
Schema valido: `arn:aws:sns:([a-z]{2}-[a-z]+-\d{1}):(\d{12}):([a-zA-Z0-9-_]+)$`
`message_structure`
La struttura del messaggio.
Obbligatorio: `false`. Questo deve essere specificato per inviare un messaggio JSON.
Tipo: `string`
Valori validi: `json`
`id`
Un ID arbitrario della richiesta. Questa proprietà viene utilizzata per associare una richiesta di input a una risposta di output. Quando specificato, la proprietà `id` nell'oggetto della risposta è impostata su questo valore. Se non utilizzi questa funzione, puoi omettere la proprietà oppure specificare una stringa vuota.
Obbligatorio: `false`
Tipo: `string`
Schema valido: `.*`
**Limiti**
Le dimensioni dei messaggi SNS non devono superare i 256 KB.
**Input di esempio: messaggio in formato stringa**
In questo esempio viene inviato un messaggio in formato stringa. Specifica la proprietà facoltativa `sns_topic_arn`, che sostituisce l'argomento di destinazione predefinito.
```
{
"request": {
"subject": "Message subject",
"message": "Message data",
"sns_topic_arn": "arn:aws:sns:region:account-id:topic2-name"
},
"id": "request123"
}
```
**Input di esempio: messaggio JSON**
Questo esempio invia un messaggio come oggetto JSON codificato come stringa che include la chiave `default`.
```
{
"request": {
"subject": "Message subject",
"message": "{ \"default\": \"Message data\" }",
"message_structure": "json"
},
"id": "request123"
}
```
## Dati di output
Questo connettore pubblica le informazioni di stato come dati di output su un argomento MQTT.
**Filtro argomento in sottoscrizione**
`sns/message/status`
**Output di esempio: Operazione riuscita**
```
{
"response": {
"sns_message_id": "f80a81bc-f44c-56f2-a0f0-d5af6a727c8a",
"status": "success"
},
"id": "request123"
}
```
**Esempio di output: Errore**
```
{
"response" : {
"error": "InvalidInputException",
"error_message": "SNS Topic Arn is invalid",
"status": "fail"
},
"id": "request123"
}
```
## Esempio di utilizzo
Usa i seguenti passaggi di alto livello per configurare una funzione Lambda di esempio di Python 3.7 che puoi usare per provare il connettore.
**Nota**
Se usi altri runtime Python, puoi creare un collegamento simbolico da Python3.x a Python 3.7.
Gli argomenti [Nozioni di base sui connettori (console)](connectors-console.md) e [Nozioni di base sui connettori (CLI)](connectors-cli.md) contengono passaggi dettagliati che illustrano come configurare e distribuire un connettore Twilio Notifications di esempio.
1. Assicurarsi di soddisfare i [requisiti](#sns-connector-req) per il connettore.
Per il requisito del ruolo di gruppo, è necessario configurare il ruolo in modo da concedere le autorizzazioni necessarie e assicurarsi che il ruolo sia stato aggiunto al gruppo. Per ulteriori informazioni, consulta [Gestione del ruolo del gruppo Greengrass (console)](group-role.md#manage-group-role-console) o [Gestione del ruolo del gruppo Greengrass (CLI)](group-role.md#manage-group-role-cli).
1. Crea e pubblica una funzione Lambda che invia dati di input al connettore.
Salvare il [codice di esempio](#sns-connector-usage-example) come file PY. Scarica e decomprimi il [AWS IoT Greengrass Core SDK per Python](lambda-functions.md#lambda-sdks-core). Quindi, crea un pacchetto zip che contiene il file PY e la cartella `greengrasssdk` a livello root. Questo pacchetto zip è il pacchetto di distribuzione in cui carichi. AWS Lambda
Dopo aver creato la funzione Python 3.7 Lambda, pubblica una versione della funzione e crea un alias.
1. Configurare il gruppo Greengrass.
1. Aggiungi la funzione Lambda tramite il relativo alias (consigliato). Configura il ciclo di vita Lambda come longevo (o nella `"Pinned": true` CLI).
1. Aggiungere il connettore e configurarne i relativi [parametri](#sns-connector-param).
1. Aggiungere sottoscrizioni che consentono al connettore di ricevere [i dati di input](#sns-connector-data-input) e inviare [i dati di output](#sns-connector-data-output) nei filtri degli argomenti supportati.
+ Imposta la funzione Lambda come origine, il connettore come destinazione e utilizza un filtro per argomenti di input supportato.
+ Imposta il connettore come origine, AWS IoT Core come destinazione e utilizza un filtro per l’argomento di output supportato. Utilizzi questo abbonamento per visualizzare i messaggi di stato nella AWS IoT console.
1. Distribuisci il gruppo.
1. Nella AWS IoT console, nella pagina **Test**, sottoscrivi l'argomento relativo ai dati di output per visualizzare i messaggi di stato dal connettore. La funzione Lambda di esempio è di lunga durata e inizia a inviare messaggi subito dopo l'implementazione del gruppo.
Al termine del test, puoi impostare il ciclo di vita Lambda su richiesta (o nella CLI) e `"Pinned": false` distribuire il gruppo. Ciò impedisce alla funzione di inviare messaggi.
### Esempio
L'esempio seguente della funzione Lambda invia un messaggio di input al connettore.
```
import greengrasssdk
import time
import json
iot_client = greengrasssdk.client('iot-data')
send_topic = 'sns/message'
def create_request_with_all_fields():
return {
"request": {
"message": "Message from SNS Connector Test"
},
"id" : "req_123"
}
def publish_basic_message():
messageToPublish = create_request_with_all_fields()
print("Message To Publish: ", messageToPublish)
iot_client.publish(topic=send_topic,
payload=json.dumps(messageToPublish))
publish_basic_message()
def lambda_handler(event, context):
return
```
## Licenze
Il connettore SNS include i seguenti software/licenze di terze parti:
+ [AWS SDK per Python (Boto3)](https://pypi.org/project/boto3/)/Apache License 2.0
+ [botocore](https://pypi.org/project/botocore/)/Apache License 2.0
+ [dateutil](https://pypi.org/project/python-dateutil/1.4/)/PSF License
+ [docutils](https://pypi.org/project/docutils/)/BSD License, GNU General Public License (GPL), Python Software Foundation License, Public Domain
+ [jmespath](https://pypi.org/project/jmespath/)/MIT License
+ [s3transfer](https://pypi.org/project/s3transfer/)/Apache License 2.0
+ [urllib3](https://pypi.org/project/urllib3/)/MIT License
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche |
| --- | --- |
| 4 | Aggiunto il parametro `IsolationMode` per configurare la modalità di containerizzazione per il connettore. |
| 3 | È stato aggiornato il runtime Lambda a Python 3.7, che modifica i requisiti di runtime. |
| 2 | Correggere per ridurre l'eccessiva registrazione di log. |
| 1 | Versione iniziale. |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
+ [Operazione di pubblicazione](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#SNS.Client.publish) nella documentazione Boto 3
+ [Cos'è Amazon Simple Notification Service?](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) nella *Guida per gli sviluppatori di Amazon Simple Notification Service*
# Connettore di integrazione Splunk
**avvertimento**
Questo connettore è entrato nella *fase di vita prolungata* e AWS IoT Greengrass non rilascerà aggiornamenti che forniscano funzionalità, miglioramenti alle funzionalità esistenti, patch di sicurezza o correzioni di bug. Per ulteriori informazioni, consulta [AWS IoT Greengrass Version 1 politica di manutenzione](maintenance-policy.md).
Il [connettore](connectors.md) Splunk Integration pubblica i dati dai dispositivi Greengrass su Splunk. In questo modo potrai utilizzare Splunk per monitorare e analizzare l'ambiente core di Greengrass e agire sugli eventi locali. Il connettore si integra con HTTP Event Collector (HEC). Per ulteriori informazioni, consulta [Introduzione a Splunk HTTP Event Collector](https://dev.splunk.com/view/event-collector/SP-CAAAE6M) nella documentazione di Splunk.
Questo connettore riceve dati di eventi e di logging in un argomento MQTT e pubblica i dati così come sono nell'API Splunk.
Puoi utilizzare questo connettore per supportare scenari industriali, ad esempio:
+ Gli operatori possono utilizzare i dati periodici di attuatori e sensori (ad esempio, letture di temperatura, pressione e acqua) per avviare allarmi quando i valori superano determinate soglie.
+ Gli sviluppatori utilizzano i dati raccolti dai macchinari industriali per creare modelli ML in grado di monitorare le apparecchiature in vista di potenziali problemi.
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 4 | `arn:aws:greengrass:region::/connectors/SplunkIntegration/versions/4` |
| 3 | `arn:aws:greengrass:region::/connectors/SplunkIntegration/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/SplunkIntegration/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/SplunkIntegration/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#splunk-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 3 - 4 ]
+ AWS IoT Greengrass Software principale v1.9.3 o versione successiva. AWS IoT Greengrass [deve essere configurato per supportare i segreti locali, come descritto in Secrets Requirements.](secrets.md#secrets-reqs)
**Nota**
Questo requisito include l'autorizzazione all'accesso ai segreti di Secrets Manager. *Se utilizzi il ruolo di servizio Greengrass predefinito, Greengrass è autorizzato a ottenere i valori dei segreti con nomi che iniziano con greengrass-.*
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ La funzionalità HTTP Event Collector deve essere abilitata in Splunk. Per ulteriori informazioni, consulta [Configurazione e utilizzo di HTTP Event Collector in Splunk Web](https://docs.splunk.com/Documentation/Splunk/7.2.0/Data/UsetheHTTPEventCollector) nella documentazione di Splunk.
+ Un tipo di testo segreto Gestione dei segreti AWS che memorizza il token Splunk HTTP Event Collector. *Per maggiori informazioni, consulta [About event collector tokens](https://docs.splunk.com/Documentation/Splunk/7.2.0/Data/UsetheHTTPEventCollector#About_Event_Collector_tokens) nella documentazione di Splunk e [Creazione di un segreto di base](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) nella Guida per l'utente.Gestione dei segreti AWS *
**Nota**
Per creare il segreto nella console Secrets Manager, inserisci il tuo token nella scheda **Plaintext**. Non includere virgolette o altri tipi di formattazione. Nell'API, specifica il token come valore per la `SecretString` proprietà.
+ Una risorsa segreta del gruppo Greengrass che fa riferimento al segreto di Secrets Manager. Per ulteriori informazioni, consulta [Implementa i segreti fino al nucleo AWS IoT Greengrass](secrets.md).
------
#### [ Versions 1 - 2 ]
+ AWS IoT Greengrass Software principale v1.7 o successivo. AWS IoT Greengrass deve essere configurato per supportare i segreti locali, come descritto in [Secrets Requirements](secrets.md#secrets-reqs).
**Nota**
Questo requisito include l'autorizzazione all'accesso ai segreti di Secrets Manager. *Se utilizzi il ruolo di servizio Greengrass predefinito, Greengrass è autorizzato a ottenere i valori dei segreti con nomi che iniziano con greengrass-.*
+ [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH.
+ La funzionalità HTTP Event Collector deve essere abilitata in Splunk. Per ulteriori informazioni, consulta [Configurazione e utilizzo di HTTP Event Collector in Splunk Web](https://docs.splunk.com/Documentation/Splunk/7.2.0/Data/UsetheHTTPEventCollector) nella documentazione di Splunk.
+ Un tipo di testo segreto Gestione dei segreti AWS che memorizza il token Splunk HTTP Event Collector. *Per maggiori informazioni, consulta [About event collector tokens](https://docs.splunk.com/Documentation/Splunk/7.2.0/Data/UsetheHTTPEventCollector#About_Event_Collector_tokens) nella documentazione di Splunk e [Creazione di un segreto di base](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) nella Guida per l'utente.Gestione dei segreti AWS *
**Nota**
Per creare il segreto nella console Secrets Manager, inserisci il tuo token nella scheda **Plaintext**. Non includere virgolette o altri tipi di formattazione. Nell'API, specifica il token come valore per la `SecretString` proprietà.
+ Una risorsa segreta del gruppo Greengrass che fa riferimento al segreto di Secrets Manager. Per ulteriori informazioni, consulta [Implementa i segreti fino al nucleo AWS IoT Greengrass](secrets.md).
------
## Parametri del connettore
Questo connettore fornisce i seguenti parametri:
------
#### [ Version 4 ]
`SplunkEndpoint`
L'endpoint dell'istanza database Splunk. Questo valore deve contenere il protocollo, il nome host e la porta.
Nome visualizzato nella AWS IoT console: **Splunk endpoint**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^(http:\/\/|https:\/\/)?[a-z0-9]+([-.]{1}[a-z0-9]+)*.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$`
`MemorySize`
La quantità di memoria (in KB) da allocare al connettore.
Nome visualizzato nella AWS IoT console: **dimensione della memoria**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[0-9]+$`
`SplunkQueueSize`
Il numero massimo di voci da salvare in memoria prima che vengono inviate o eliminate. Quando si raggiunge questo limite, le voci meno recenti in coda vengono sostituite da quelle più recenti. Questo limite si applica in genere in assenza di una connessione a Internet.
Nome visualizzato nella AWS IoT console: **numero massimo di elementi da conservare**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[0-9]+$`
`SplunkFlushIntervalSeconds`
L'intervallo di tempo (in secondi) per la pubblicazione dei dati ricevuti in Splunk HEC. Il valore massimo è 900. Per configurare il connettore in modo da pubblicare gli elementi man mano che vengono ricevuti (senza raggruppamento), specificare 0.
Nome visualizzato nella AWS IoT console: intervallo di **pubblicazione Splunk**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `[0-9]|[1-9]\d|[1-9]\d\d|900`
`SplunkTokenSecretArn`
Il segreto Gestione dei segreti AWS che contiene il token Splunk. Deve essere un segreto in formato testo.
Nome visualizzato nella AWS IoT console: **ARN del token di autenticazione Splunk secret**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `arn:aws:secretsmanager:[a-z]{2}-[a-z]+-\d{1}:\d{12}?:secret:[a-zA-Z0-9-_]+-[a-zA-Z0-9-_]+`
`SplunkTokenSecretArn-ResourceId`
La risorsa segreta nel gruppo Greengrass che fa riferimento al segreto Splunk.
Nome visualizzato nella AWS IoT console: risorsa del token di **autenticazione Splunk**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `.+`
`SplunkCustomCALocation`
Il percorso del file dell'autorità di certificazione (CA) personalizzata per Splunk (ad esempio `/etc/ssl/certs/splunk.crt`).
Nome visualizzato nella AWS IoT console: posizione **personalizzata dell'autorità di certificazione Splunk**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^$|/.*`
`IsolationMode`
Modalità di [containerizzazione](connectors.md#connector-containerization) per questo connettore. L'impostazione predefinita è`GreengrassContainer`, il che significa che il connettore viene eseguito in un ambiente di runtime isolato all'interno del AWS IoT Greengrass contenitore.
L'impostazione predefinita della containerizzazione per il gruppo non si applica ai connettori.
Nome visualizzato nella AWS IoT console: **modalità di isolamento del contenitore**
Obbligatorio: `false`
Tipo: `string`
Valori validi: `GreengrassContainer` o `NoContainer`
Schema valido: `^NoContainer$|^GreengrassContainer$`
------
#### [ Version 1 - 3 ]
`SplunkEndpoint`
L'endpoint dell'istanza database Splunk. Questo valore deve contenere il protocollo, il nome host e la porta.
Nome visualizzato nella AWS IoT console: **Splunk endpoint**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^(http:\/\/|https:\/\/)?[a-z0-9]+([-.]{1}[a-z0-9]+)*.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$`
`MemorySize`
La quantità di memoria (in KB) da allocare al connettore.
Nome visualizzato nella AWS IoT console: **dimensione della memoria**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[0-9]+$`
`SplunkQueueSize`
Il numero massimo di voci da salvare in memoria prima che vengono inviate o eliminate. Quando si raggiunge questo limite, le voci meno recenti in coda vengono sostituite da quelle più recenti. Questo limite si applica in genere in assenza di una connessione a Internet.
Nome visualizzato nella AWS IoT console: **numero massimo di elementi da conservare**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `^[0-9]+$`
`SplunkFlushIntervalSeconds`
L'intervallo di tempo (in secondi) per la pubblicazione dei dati ricevuti in Splunk HEC. Il valore massimo è 900. Per configurare il connettore in modo da pubblicare gli elementi man mano che vengono ricevuti (senza raggruppamento), specificare 0.
Nome visualizzato nella AWS IoT console: Intervallo di **pubblicazione di Splunk**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `[0-9]|[1-9]\d|[1-9]\d\d|900`
`SplunkTokenSecretArn`
Il segreto Gestione dei segreti AWS che contiene il token Splunk. Deve essere un segreto in formato testo.
Nome visualizzato nella AWS IoT console: **ARN del token di autenticazione Splunk secret**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `arn:aws:secretsmanager:[a-z]{2}-[a-z]+-\d{1}:\d{12}?:secret:[a-zA-Z0-9-_]+-[a-zA-Z0-9-_]+`
`SplunkTokenSecretArn-ResourceId`
La risorsa segreta nel gruppo Greengrass che fa riferimento al segreto Splunk.
Nome visualizzato nella AWS IoT console: risorsa del token di **autenticazione Splunk**
Obbligatorio: `true`
Tipo: `string`
Schema valido: `.+`
`SplunkCustomCALocation`
Il percorso del file dell'autorità di certificazione (CA) personalizzata per Splunk (ad esempio `/etc/ssl/certs/splunk.crt`).
Nome visualizzato nella AWS IoT console: posizione **personalizzata dell'autorità di certificazione Splunk**
Obbligatorio: `false`
Tipo: `string`
Schema valido: `^$|/.*`
------
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI crea una `ConnectorDefinition` versione iniziale che contiene il connettore Splunk Integration.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MySplunkIntegrationConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/SplunkIntegration/versions/4",
"Parameters": {
"SplunkEndpoint": "https://myinstance.cloud.splunk.com:8088",
"MemorySize": 200000,
"SplunkQueueSize": 10000,
"SplunkFlushIntervalSeconds": 5,
"SplunkTokenSecretArn":"arn:aws:secretsmanager:region:account-id:secret:greengrass-secret-hash",
"SplunkTokenSecretArn-ResourceId": "MySplunkResource",
"IsolationMode" : "GreengrassContainer"
}
}
]
}'
```
**Nota**
La funzione Lambda in questo connettore ha un ciclo di vita di [lunga durata](lambda-functions.md#lambda-lifecycle).
**Nella AWS IoT Greengrass console, puoi aggiungere un connettore dalla pagina Connettori del gruppo.** Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (console)](connectors-console.md).
## Dati di input
Questo connettore accetta dati di registrazione ed eventi su un argomento MQTT e pubblica i dati ricevuti così come sono nell'API Splunk. I messaggi di input devono essere in formato JSON.
**Filtro argomento in sottoscrizione**
`splunk/logs/put`
**Proprietà dei messaggi**
`request`
I dati dell'evento da inviare all'API Splunk. Gli eventi devono soddisfare le specifiche dell'API [services/collector](https://docs.splunk.com/Documentation/Splunk/latest/RESTREF/RESTinput#services.2Fcollector).
Obbligatorio: `true`
Tipo:`object`. È obbligatoria solo la proprietà `event`.
`id`
Un ID arbitrario della richiesta. Questa proprietà viene utilizzata per associare una richiesta di input a uno stato di output.
Richiesto: `false`
Tipo: `string`
**Limiti**
Tutti i limiti imposti dall'API Splunk vengono applicati quando si utilizza questo connettore. Per ulteriori informazioni, consulta [services/collector](https://docs.splunk.com/Documentation/Splunk/latest/RESTREF/RESTinput#services.2Fcollector).
**Input di esempio**
```
{
"request": {
"event": "some event",
"fields": {
"severity": "INFO",
"category": [
"value1",
"value2"
]
}
},
"id": "request123"
}
```
## Dati di output
Questo connettore pubblica i dati di output in due argomenti:
+ Informazioni di stato nell'argomento `splunk/logs/put/status`.
+ Gli errori nell'argomento `splunk/logs/put/error`.
**Filtro di argomenti:** `splunk/logs/put/status`
Utilizza questo argomento per ascoltare lo stato delle richieste. Ogni volta che il connettore invia un batch di dati ricevuti all'API Splunk, pubblica un elenco IDs delle richieste riuscite e non riuscite.
**Output di esempio**
```
{
"response": {
"succeeded": [
"request123",
...
],
"failed": [
"request789",
...
]
}
}
```
**Filtro di argomenti:** `splunk/logs/put/error`
Utilizza questo argomento per ascoltare gli errori del connettore. La proprietà `error_message` che descrive l'errore o il timeout rilevato durante l'elaborazione della richiesta.
**Output di esempio**
```
{
"response": {
"error": "UnauthorizedException",
"error_message": "invalid splunk token",
"status": "fail"
}
}
```
Se il connettore rileva un errore riutilizzabile (ad esempio errori di connessione), riprova la pubblicazione nel batch successivo.
## Esempio di utilizzo
Usa i seguenti passaggi di alto livello per configurare una funzione Lambda di esempio di Python 3.7 che puoi usare per provare il connettore.
**Nota**
Se usi altri runtime Python, puoi creare un collegamento simbolico da Python3.x a Python 3.7.
Gli argomenti [Nozioni di base sui connettori (console)](connectors-console.md) e [Nozioni di base sui connettori (CLI)](connectors-cli.md) contengono passaggi dettagliati che illustrano come configurare e distribuire un connettore Twilio Notifications di esempio.
1. Assicurarsi di soddisfare i [requisiti](#splunk-connector-req) per il connettore.
1. Crea e pubblica una funzione Lambda che invia dati di input al connettore.
Salvare il [codice di esempio](#splunk-connector-usage-example) come file PY. Scarica e decomprimi il [AWS IoT Greengrass Core SDK per Python](lambda-functions.md#lambda-sdks-core). Quindi, crea un pacchetto zip che contiene il file PY e la cartella `greengrasssdk` a livello root. Questo pacchetto zip è il pacchetto di distribuzione in cui carichi. AWS Lambda
Dopo aver creato la funzione Python 3.7 Lambda, pubblica una versione della funzione e crea un alias.
1. Configurare il gruppo Greengrass.
1. Aggiungi la funzione Lambda tramite il relativo alias (consigliato). Configura il ciclo di vita Lambda come longevo (o nella `"Pinned": true` CLI).
1. Aggiungi la risorsa segreta richiesta e concedi l'accesso in lettura alla funzione Lambda.
1. Aggiungere il connettore e configurarne i relativi [parametri](#splunk-connector-param).
1. Aggiungere sottoscrizioni che consentono al connettore di ricevere [i dati di input](#splunk-connector-data-input) e inviare [i dati di output](#splunk-connector-data-output) nei filtri degli argomenti supportati.
+ Imposta la funzione Lambda come origine, il connettore come destinazione e utilizza un filtro per argomenti di input supportato.
+ Imposta il connettore come origine, AWS IoT Core come destinazione e utilizza un filtro per l’argomento di output supportato. Utilizzi questo abbonamento per visualizzare i messaggi di stato nella AWS IoT console.
1. Distribuisci il gruppo.
1. Nella AWS IoT console, nella pagina **Test**, sottoscrivi l'argomento relativo ai dati di output per visualizzare i messaggi di stato dal connettore. La funzione Lambda di esempio è di lunga durata e inizia a inviare messaggi subito dopo l'implementazione del gruppo.
Al termine del test, puoi impostare il ciclo di vita Lambda su richiesta (o nella CLI) e `"Pinned": false` distribuire il gruppo. Ciò impedisce alla funzione di inviare messaggi.
### Esempio
L'esempio seguente della funzione Lambda invia un messaggio di input al connettore.
```
import greengrasssdk
import time
import json
iot_client = greengrasssdk.client('iot-data')
send_topic = 'splunk/logs/put'
def create_request_with_all_fields():
return {
"request": {
"event": "Access log test message."
},
"id" : "req_123"
}
def publish_basic_message():
messageToPublish = create_request_with_all_fields()
print("Message To Publish: ", messageToPublish)
iot_client.publish(topic=send_topic,
payload=json.dumps(messageToPublish))
publish_basic_message()
def lambda_handler(event, context):
return
```
## Licenze
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche |
| --- | --- |
| 4 | Aggiunto il parametro `IsolationMode` per configurare la modalità di containerizzazione per il connettore. |
| 3 | È stato aggiornato il runtime Lambda a Python 3.7, che modifica i requisiti di runtime. |
| 2 | Correggere per ridurre l'eccessiva registrazione di log. |
| 1 | Versione iniziale. |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
# Connettore di notifica Twilio
**avvertimento**
Questo connettore è entrato nella *fase di vita prolungata* e AWS IoT Greengrass non rilascerà aggiornamenti che forniscano funzionalità, miglioramenti alle funzionalità esistenti, patch di sicurezza o correzioni di bug. Per ulteriori informazioni, consulta [AWS IoT Greengrass Version 1 politica di manutenzione](maintenance-policy.md).
Il [connettore](connectors.md) Twilio Notifications effettua chiamate telefoniche automatiche o invia messaggi di testo tramite Twilio. Puoi utilizzare questo connettore per inviare notifiche in risposta a eventi nel gruppo Greengrass. Per le telefonate, il connettore è in grado di inoltrare un messaggio vocale al destinatario.
Questo connettore riceve le informazioni sui messaggi Twilio in un argomento MQTT, quindi attiva una notifica Twilio.
**Nota**
Per un tutorial che mostra come utilizzare il connettore Twilio Notifications, consulta o. [Nozioni di base sui connettori Greengrass (console)](connectors-console.md) [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
Questo connettore ha le seguenti versioni.
| Versione | ARN |
| --- | --- |
| 5 | `arn:aws:greengrass:region::/connectors/TwilioNotifications/versions/5` |
| 4 | `arn:aws:greengrass:region::/connectors/TwilioNotifications/versions/4` |
| 3 | `arn:aws:greengrass:region::/connectors/TwilioNotifications/versions/3` |
| 2 | `arn:aws:greengrass:region::/connectors/TwilioNotifications/versions/2` |
| 1 | `arn:aws:greengrass:region::/connectors/TwilioNotifications/versions/1` |
Per informazioni sulle modifiche di ogni versione, consulta [Changelog](#twilio-notifications-connector-changelog).
## Requisiti
Questo connettore presenta i seguenti requisiti:
------
#### [ Version 4 - 5 ]
+ AWS IoT Greengrass Software principale v1.9.3 o successivo. AWS IoT Greengrass [deve essere configurato per supportare i segreti locali, come descritto in Secrets Requirements.](secrets.md#secrets-reqs)
**Nota**
Questo requisito include l'autorizzazione all'accesso ai segreti di Secrets Manager. *Se utilizzi il ruolo di servizio Greengrass predefinito, Greengrass è autorizzato a ottenere i valori dei segreti con nomi che iniziano con greengrass-.*
+ [Python](https://www.python.org/) versione 3.7 o 3.8 installata sul dispositivo principale e aggiunta alla variabile di ambiente PATH.
**Nota**
Per usare Python 3.8, esegui il seguente comando per creare un collegamento simbolico dalla cartella di installazione predefinita di Python 3.7 ai binari Python 3.8 installati.
```
sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7
```
Questo configura il dispositivo in modo che soddisfi il requisito Python per AWS IoT Greengrass.
+ SID dell'account Twilio, token di autorizzazione e numero di telefono abilitato per Twilio. Dopo avere creato un progetto Twilio, questi valori sono disponibili nel pannello di controllo del progetto.
**Nota**
Puoi utilizzare un account di prova Twilio. Se utilizzi un account di prova, devi aggiungere i numeri di telefono dei destinatari diversi da Twilio a un elenco di numeri di telefono verificati. Per ulteriori informazioni, vedi [Come lavorare con il tuo account di prova Twilio gratuito](https://www.twilio.com/docs/usage/tutorials/how-to-use-your-free-trial-account).
+ Un tipo di testo segreto Gestione dei segreti AWS che memorizza il token di autenticazione Twilio. Per ulteriori informazioni, consulta [Creazione di un segreto di base nella Guida](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) per l'*Gestione dei segreti AWS utente*.
**Nota**
Per creare il segreto nella console Secrets Manager, inserisci il tuo token nella scheda **Plaintext**. Non includere virgolette o altri tipi di formattazione. Nell'API, specifica il token come valore per la `SecretString` proprietà.
+ Una risorsa segreta del gruppo Greengrass che fa riferimento al segreto di Secrets Manager. Per ulteriori informazioni, consulta [Implementa i segreti fino al nucleo AWS IoT Greengrass](secrets.md).
------
#### [ Versions 1 - 3 ]
+ AWS IoT Greengrass Software principale v1.7 o successivo. AWS IoT Greengrass deve essere configurato per supportare i segreti locali, come descritto in [Secrets Requirements](secrets.md#secrets-reqs).
**Nota**
Questo requisito include l'autorizzazione all'accesso ai segreti di Secrets Manager. *Se utilizzi il ruolo di servizio Greengrass predefinito, Greengrass è autorizzato a ottenere i valori dei segreti con nomi che iniziano con greengrass-.*
+ [Python](https://www.python.org/) versione 2.7 installato sul dispositivo principale e aggiunto alla variabile di ambiente PATH.
+ SID dell'account Twilio, token di autorizzazione e numero di telefono abilitato per Twilio. Dopo avere creato un progetto Twilio, questi valori sono disponibili nel pannello di controllo del progetto.
**Nota**
Puoi utilizzare un account di prova Twilio. Se utilizzi un account di prova, devi aggiungere numeri di telefono dei destinatari diversi da Twilio a un elenco di numeri di telefono verificati. Per ulteriori informazioni, vedi [Come lavorare con il tuo account di prova Twilio gratuito](https://www.twilio.com/docs/usage/tutorials/how-to-use-your-free-trial-account).
+ Un tipo di testo segreto Gestione dei segreti AWS che memorizza il token di autenticazione Twilio. Per ulteriori informazioni, consulta [Creazione di un segreto di base nella Guida](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) per l'*Gestione dei segreti AWS utente*.
**Nota**
Per creare il segreto nella console Secrets Manager, inserisci il tuo token nella scheda **Plaintext**. Non includere virgolette o altri tipi di formattazione. Nell'API, specifica il token come valore per la `SecretString` proprietà.
+ Una risorsa segreta del gruppo Greengrass che fa riferimento al segreto di Secrets Manager. Per ulteriori informazioni, consulta [Implementa i segreti fino al nucleo AWS IoT Greengrass](secrets.md).
------
## Parametri del connettore
Questo connettore fornisce i seguenti parametri.
------
#### [ Version 5 ]
`TWILIO_ACCOUNT_SID`
Il SID dell'account Twilio utilizzato per chiamare l'API Twilio.
Nome visualizzato nella AWS IoT console: SID dell'**account Twilio**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `.+`
`TwilioAuthTokenSecretArn`
L'ARN del segreto Secrets Manager che memorizza il token di autenticazione Twilio.
Viene utilizzato per accedere al valore del segreto locale nel core.
Nome visualizzato nella AWS IoT console: **ARN del token di autenticazione segreto di Twilio**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `arn:aws:secretsmanager:[a-z0-9\-]+:[0-9]{12}:secret:([a-zA-Z0-9\\]+/)*[a-zA-Z0-9/_+=,.@\-]+-[a-zA-Z0-9]+`
`TwilioAuthTokenSecretArn-ResourceId`
L'ID della risorsa segreta del gruppo Greengrass che fa riferimento al segreto del token di autorizzazione Twilio.
Nome visualizzato nella AWS IoT console: risorsa del token di **autenticazione Twilio**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `.+`
`DefaultFromPhoneNumber`
Il numero di telefono predefinito abilitato per Twilio che Twilio utilizza per l'invio di messaggi. Twilio utilizza questo numero per iniziare il messaggio di testo o la chiamata.
+ Se non configuri un numero di telefono predefinito, dovrai specificare un numero di telefono nella proprietà `from_number` nel corpo del messaggio di input.
+ Se configuri un numero di telefono predefinito, potrai ignorarlo specificando la proprietà `from_number` nel corpo del messaggio di input.
Nome visualizzato nella AWS IoT console: **predefinito dal numero di telefono**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^$|\+[0-9]+`
`IsolationMode`
Modalità di [containerizzazione](connectors.md#connector-containerization) per questo connettore. L'impostazione predefinita è`GreengrassContainer`, il che significa che il connettore viene eseguito in un ambiente di runtime isolato all'interno del AWS IoT Greengrass contenitore.
L'impostazione predefinita della containerizzazione per il gruppo non si applica ai connettori.
Nome visualizzato nella AWS IoT console: **modalità di isolamento del contenitore**
Obbligatorio: `false`
Tipo: `string`
Valori validi: `GreengrassContainer` o `NoContainer`
Modello valido: `^NoContainer$|^GreengrassContainer$`
------
#### [ Version 1 - 4 ]
`TWILIO_ACCOUNT_SID`
Il SID dell'account Twilio utilizzato per chiamare l'API Twilio.
Nome visualizzato nella AWS IoT console: SID dell'**account Twilio**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `.+`
`TwilioAuthTokenSecretArn`
L'ARN del segreto Secrets Manager che memorizza il token di autenticazione Twilio.
Viene utilizzato per accedere al valore del segreto locale nel core.
Nome visualizzato nella AWS IoT console: **ARN del token di autenticazione segreto di Twilio**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `arn:aws:secretsmanager:[a-z0-9\-]+:[0-9]{12}:secret:([a-zA-Z0-9\\]+/)*[a-zA-Z0-9/_+=,.@\-]+-[a-zA-Z0-9]+`
`TwilioAuthTokenSecretArn-ResourceId`
L'ID della risorsa segreta del gruppo Greengrass che fa riferimento al segreto del token di autorizzazione Twilio.
Nome visualizzato nella AWS IoT console: risorsa del token di **autenticazione Twilio**
Obbligatorio: `true`
Tipo: `string`
Modello valido: `.+`
`DefaultFromPhoneNumber`
Il numero di telefono predefinito abilitato per Twilio che Twilio utilizza per l'invio di messaggi. Twilio utilizza questo numero per iniziare il messaggio di testo o la chiamata.
+ Se non configuri un numero di telefono predefinito, dovrai specificare un numero di telefono nella proprietà `from_number` nel corpo del messaggio di input.
+ Se configuri un numero di telefono predefinito, potrai ignorarlo specificando la proprietà `from_number` nel corpo del messaggio di input.
Nome visualizzato nella AWS IoT console: **predefinito dal numero di telefono**
Obbligatorio: `false`
Tipo: `string`
Modello valido: `^$|\+[0-9]+`
------
### Esempio di creazione di un connettore (AWS CLI)
Il seguente comando CLI di esempio crea un comando `ConnectorDefinition` con una versione iniziale che contiene il connettore Twilio Notifications.
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyTwilioNotificationsConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/TwilioNotifications/versions/5",
"Parameters": {
"TWILIO_ACCOUNT_SID": "abcd12345xyz",
"TwilioAuthTokenSecretArn": "arn:aws:secretsmanager:region:account-id:secret:greengrass-secret-hash",
"TwilioAuthTokenSecretArn-ResourceId": "MyTwilioSecret",
"DefaultFromPhoneNumber": "+19999999999",
"IsolationMode" : "GreengrassContainer"
}
}
]
}'
```
Per i tutorial che mostrano come aggiungere il connettore Twilio Notifications a un gruppo, consulta e. [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md) [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
## Dati di input
Questo connettore accetta informazioni sui messaggi Twilio su due argomenti MQTT. I messaggi di input devono essere in formato JSON.
+ Informazioni sui messaggi di testo nell'argomento `twilio/txt`.
+ Informazioni sui messaggi vocali nell'argomento `twilio/call`.
**Nota**
Il payload del messaggio di input può includere un messaggio di testo (`message`) o un messaggio vocale (`voice_message_location`), ma non entrambi.
**Filtro di argomenti: `twilio/txt`**
**Proprietà dei messaggi**
`request`
Informazioni sulla notifica Twilio.
Obbligatorio: `true`
Tipo: `object` che include le seguenti proprietà:
`recipient`
Il destinatario del messaggio. È supportato solo un destinatario.
Richiesto: `true`
Tipo: `object` che include le seguenti proprietà:
`name`
Il nome del destinatario.
Obbligatorio: `true`
Tipo: `string`
Modello valido: `.*`
`phone_number`
Il numero di telefono del destinatario.
Richiesto: `true`
Tipo: `string`
Modello valido: `\+[1-9]+`
`message`
Il contenuto del messaggio di testo. In questo argomento sono supportati solo i messaggi di testo. Per i messaggi vocali, utilizzare `twilio/call`.
Richiesto: `true`
Tipo: `string`
Modello valido: `.+`
`from_number`
Il numero di telefono del mittente. Twilio utilizza questo numero di telefono per iniziare il messaggio. Questa proprietà è obbligatoria se il parametro `DefaultFromPhoneNumber` non è configurato. Se `DefaultFromPhoneNumber` è stato configurato, puoi utilizzare questa proprietà per ignorare quello predefinito.
Richiesto: `false`
Tipo: `string`
Modello valido: `\+[1-9]+`
`retries`
Il numero di tentativi. Il valore predefinito è 0.
Richiesto: `false`
Tipo: `integer`
`id`
Un ID arbitrario della richiesta. Questa proprietà viene utilizzata per associare una richiesta di input a una risposta di output.
Richiesto: `true`
Tipo: `string`
Modello valido: `.+`
**Input di esempio**
```
{
"request": {
"recipient": {
"name": "Darla",
"phone_number": "+12345000000",
"message": "Hello from the edge"
},
"from_number": "+19999999999",
"retries": 3
},
"id": "request123"
}
```
**Filtro di argomenti: `twilio/call`**
**Proprietà dei messaggi**
`request`
Informazioni sulla notifica Twilio.
Richiesto: `true`
Tipo: `object` che include le seguenti proprietà:
`recipient`
Il destinatario del messaggio. È supportato solo un destinatario.
Richiesto: `true`
Tipo: `object` che include le seguenti proprietà:
`name`
Il nome del destinatario.
Obbligatorio: `true`
Tipo: `string`
Modello valido: `.+`
`phone_number`
Il numero di telefono del destinatario.
Richiesto: `true`
Tipo: `string`
Modello valido: `\+[1-9]+`
`voice_message_location`
L'URL del contenuto audio del messaggio vocale. Deve essere in formato TwiML. In questo argomento sono supportati solo i messaggi vocali. Per i messaggi di testo, utilizzare `twilio/txt`.
Richiesto: `true`
Tipo: `string`
Modello valido: `.+`
`from_number`
Il numero di telefono del mittente. Twilio utilizza questo numero di telefono per iniziare il messaggio. Questa proprietà è obbligatoria se il parametro `DefaultFromPhoneNumber` non è configurato. Se `DefaultFromPhoneNumber` è stato configurato, puoi utilizzare questa proprietà per ignorare quello predefinito.
Richiesto: `false`
Tipo: `string`
Modello valido: `\+[1-9]+`
`retries`
Il numero di tentativi. Il valore predefinito è 0.
Richiesto: `false`
Tipo: `integer`
`id`
Un ID arbitrario della richiesta. Questa proprietà viene utilizzata per associare una richiesta di input a una risposta di output.
Richiesto: `true`
Tipo: `string`
Modello valido: `.+`
**Input di esempio**
```
{
"request": {
"recipient": {
"name": "Darla",
"phone_number": "+12345000000",
"voice_message_location": "https://some-public-TwiML"
},
"from_number": "+19999999999",
"retries": 3
},
"id": "request123"
}
```
## Dati di output
Questo connettore pubblica le informazioni di stato come dati di output su un argomento MQTT.
**Filtro argomento in sottoscrizione**
`twilio/message/status`
**Output di esempio: Operazione riuscita**
```
{
"response": {
"status": "success",
"payload": {
"from_number": "+19999999999",
"messages": {
"message_status": "queued",
"to_number": "+12345000000",
"name": "Darla"
}
}
},
"id": "request123"
}
```
**Esempio di output: Errore**
```
{
"response": {
"status": "fail",
"error_message": "Recipient name cannot be None",
"error": "InvalidParameter",
"payload": None
}
},
"id": "request123"
}
```
La proprietà `payload` nell'output è la risposta dall'API Twilio al momento dell'invio del messaggio. Se il connettore rileva che i dati di input non sono validi (ad esempio, non è specificato un campo di input obbligatorio), il connettore restituisce un errore e imposta il valore su `None`. Di seguito vengono riportati payload di esempio:
```
{
'from_number':'+19999999999',
'messages': {
'name':'Darla',
'to_number':'+12345000000',
'message_status':'undelivered'
}
}
```
```
{
'from_number':'+19999999999',
'messages': {
'name':'Darla',
'to_number':'+12345000000',
'message_status':'queued'
}
}
```
## Esempio di utilizzo
Usa i seguenti passaggi di alto livello per configurare una funzione Lambda di esempio di Python 3.7 che puoi usare per provare il connettore.
**Nota**
[Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)Gli argomenti [Nozioni di base sui connettori Greengrass (console)](connectors-console.md) e contengono end-to-end passaggi che mostrano come configurare, distribuire e testare il connettore Twilio Notifications.
1. Assicurarsi di soddisfare i [requisiti](#twilio-notifications-connector-req) per il connettore.
1. Crea e pubblica una funzione Lambda che invia dati di input al connettore.
Salvare il [codice di esempio](#twilio-notifications-connector-usage-example) come file PY. Scarica e decomprimi il [AWS IoT Greengrass Core SDK per Python](lambda-functions.md#lambda-sdks-core). Quindi, crea un pacchetto zip che contiene il file PY e la cartella `greengrasssdk` a livello root. Questo pacchetto zip è il pacchetto di distribuzione in cui carichi. AWS Lambda
Dopo aver creato la funzione Python 3.7 Lambda, pubblica una versione della funzione e crea un alias.
1. Configurare il gruppo Greengrass.
1. Aggiungi la funzione Lambda tramite il relativo alias (consigliato). Configura il ciclo di vita Lambda come longevo (o nella `"Pinned": true` CLI).
1. Aggiungi la risorsa segreta richiesta e concedi l'accesso in lettura alla funzione Lambda.
1. Aggiungere il connettore e configurarne i relativi [parametri](#twilio-notifications-connector-param).
1. Aggiungere sottoscrizioni che consentono al connettore di ricevere [i dati di input](#twilio-notifications-connector-data-input) e inviare [i dati di output](#twilio-notifications-connector-data-output) nei filtri degli argomenti supportati.
+ Imposta la funzione Lambda come origine, il connettore come destinazione e utilizza un filtro per argomenti di input supportato.
+ Imposta il connettore come origine, AWS IoT Core come destinazione e utilizza un filtro per l’argomento di output supportato. Utilizzi questo abbonamento per visualizzare i messaggi di stato nella AWS IoT console.
1. Distribuisci il gruppo.
1. Nella AWS IoT console, nella pagina **Test**, sottoscrivi l'argomento relativo ai dati di output per visualizzare i messaggi di stato dal connettore. La funzione Lambda di esempio è di lunga durata e inizia a inviare messaggi subito dopo l'implementazione del gruppo.
Al termine del test, puoi impostare il ciclo di vita Lambda su richiesta (o nella CLI) e `"Pinned": false` distribuire il gruppo. Ciò impedisce alla funzione di inviare messaggi.
### Esempio
L'esempio seguente della funzione Lambda invia un messaggio di input al connettore. Questo esempio attiva un messaggio di testo.
```
import greengrasssdk
import json
iot_client = greengrasssdk.client('iot-data')
TXT_INPUT_TOPIC = 'twilio/txt'
CALL_INPUT_TOPIC = 'twilio/call'
def publish_basic_message():
txt = {
"request": {
"recipient" : {
"name": "Darla",
"phone_number": "+12345000000",
"message": 'Hello from the edge'
},
"from_number" : "+19999999999"
},
"id" : "request123"
}
print("Message To Publish: ", txt)
client.publish(topic=TXT_INPUT_TOPIC,
payload=json.dumps(txt))
publish_basic_message()
def lambda_handler(event, context):
return
```
## Licenze
Il connettore Twilio Notifications include i seguenti software/licenze di terze parti:
+ [twilio-python](https://github.com/twilio/twilio-python)/MIT
Questo connettore è rilasciato ai sensi del contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Changelog
La tabella seguente descrive le modifiche apportate a ciascuna versione del connettore.
| Versione | Modifiche |
| --- | --- |
| 5 | Aggiunto il parametro `IsolationMode` per configurare la modalità di containerizzazione per il connettore. |
| 4 | È stato aggiornato il runtime Lambda a Python 3.7, che modifica i requisiti di runtime. |
| 3 | Correggere per ridurre l'eccessiva registrazione di log. |
| 2 | Miglioramenti e correzioni di bug minori. |
| 1 | Versione iniziale. |
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Nozioni di base sui connettori Greengrass (CLI)](connectors-cli.md)
+ [Riferimento all'API Twilio](https://www.twilio.com/docs/api)
# Nozioni di base sui connettori Greengrass (console)
Questa funzionalità è disponibile per AWS IoT Greengrass Core v1.7 e versioni successive.
Questo tutorial mostra come utilizzarlo per Console di gestione AWS lavorare con i connettori.
Utilizza i connettori per accelerare il ciclo di vita dello sviluppo. I connettori sono moduli precostituiti e riutilizzabili che semplificano l'interazione con servizi, protocolli e risorse. Possono aiutarti a distribuire più rapidamente la logica di business ai dispositivi Greengrass. Per ulteriori informazioni, consulta [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md).
In questo tutorial, configuri e distribuisci il connettore [Twilio Notifications](twilio-notifications-connector.md). Il connettore riceve le informazioni sui messaggi Twilio come dati di input, quindi attiva un messaggio di testo Twilio. Il flusso di dati viene mostrato nel seguente schema.
![\[Flusso di dati dalla funzione Lambda al connettore Twilio Notifications a Twilio.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/connectors/twilio-solution.png)
Dopo aver configurato il connettore, crei una funzione Lambda e un abbonamento.
+ La funzione valuta i dati simulati da un sensore di temperatura. Pubblica in base a condizioni le informazioni sul messaggio Twilio in un argomento MQTT. Questo è l'argomento a cui il connettore effettua la sottoscrizione.
+ La sottoscrizione consente alla funzione di effettuare la pubblicazione nell'argomento e al connettore di ricevere i dati dall'argomento.
Il connettore Twilio Notifications richiede un token di autenticazione Twilio per interagire con l'API Twilio. Il token è un tipo di testo segreto creato Gestione dei segreti AWS e referenziato da una risorsa di gruppo. Ciò consente di AWS IoT Greengrass creare una copia locale del segreto sul core di Greengrass, dove viene crittografato e reso disponibile al connettore. Per ulteriori informazioni, consulta [Implementa i segreti fino al nucleo AWS IoT Greengrass](secrets.md).
Il tutorial include le seguenti fasi di alto livello:
1. [Crea un segreto di Secrets Manager](#connectors-console-create-secret)
1. [Aggiunta di una risorsa segreta a un gruppo](#connectors-console-create-resource)
1. [Aggiunta di un connettore al gruppo](#connectors-console-create-connector)
1. [Creare un pacchetto di distribuzione della funzione Lambda](#connectors-console-create-deployment-package)
1. [Creazione di una funzione Lambda ](#connectors-console-create-function)
1. [Aggiunta di una funzione al gruppo](#connectors-console-create-gg-function)
1. [Aggiunta di sottoscrizioni al gruppo](#connectors-console-create-subscription)
1. [Distribuzione del gruppo.](#connectors-console-create-deployment)
1. [Test della soluzione](#connectors-console-test-solution)
Il completamento di questo tutorial richiede circa 20 minuti.
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Un gruppo Greengrass e un core Greengrass (v1.9.3 or later). Per informazioni su come creare un gruppo e un core Greengrass, consulta [Iniziare con AWS IoT Greengrass](gg-gs.md). Nel tutorial Nozioni di base sono descritte anche le fasi per l'installazione del software AWS IoT Greengrass Core.
+ Python 3.7 installato sul dispositivo principale AWS IoT Greengrass .
+ AWS IoT Greengrass deve essere configurato per supportare i segreti locali, come descritto in [Secrets](secrets.md#secrets-reqs) Requirements.
**Nota**
Questo requisito include l'autorizzazione all'accesso ai segreti di Secrets Manager. *Se utilizzi il ruolo di servizio Greengrass predefinito, Greengrass è autorizzato a ottenere i valori dei segreti con nomi che iniziano con greengrass-.*
+ SID dell'account Twilio, token di autorizzazione e numero di telefono abilitato per Twilio. Dopo avere creato un progetto Twilio, questi valori sono disponibili nel pannello di controllo del progetto.
**Nota**
Puoi utilizzare un account di prova Twilio. Se utilizzi un account di prova, devi aggiungere i numeri di telefono dei destinatari diversi da Twilio a un elenco di numeri di telefono verificati. Per ulteriori informazioni, vedi [Come lavorare con il tuo account di prova Twilio gratuito](https://www.twilio.com/docs/usage/tutorials/how-to-use-your-free-trial-account).
## Fase 1: Creare un segreto di Secrets Manager
In questo passaggio, utilizzi la Gestione dei segreti AWS console per creare un tipo di testo segreto per il tuo token di autenticazione Twilio.
1. Accedi alla [console Gestione dei segreti AWS](https://console.aws.amazon.com/secretsmanager/).
**Nota**
Per ulteriori informazioni su questo processo, consulta [Fase 1: Creare e archiviare il segreto Gestione dei segreti AWS nella Guida](https://docs.aws.amazon.com/secretsmanager/latest/userguide/tutorials_basic.html) per l'*Gestione dei segreti AWS utente*.
1. Scegli **Archivia un nuovo segreto**.
1. In **Scegli il tipo di segreto**, scegli **Altro tipo di segreto**.
1. In **Specificare le key/value coppie da archiviare per questo segreto**, nella scheda **Plaintext**, inserisci il tuo token di autenticazione Twilio. Rimuovi tutta la formattazione JSON e immetti solo il valore del token.
1. **Mantieni **aws/secretsmanager** selezionato per la chiave di crittografia, quindi scegli Avanti.**
**Nota**
Non ti viene addebitato alcun costo AWS KMS se utilizzi la chiave AWS gestita predefinita creata da Secrets Manager nel tuo account.
1. In **Secret name (Nome segreto)**, immetti **greengrass-TwilioAuthToken**, quindi seleziona **Next (Avanti)**.
**Nota**
Per impostazione predefinita, il ruolo di servizio Greengrass consente di AWS IoT Greengrass ottenere il valore dei segreti con nomi che iniziano con *greengrass* -. Per ulteriori informazioni, consulta [Requisiti dei segreti](secrets.md#secrets-reqs).
1. **Questo tutorial non richiede la rotazione, quindi scegli disabilita la rotazione automatica, quindi scegli Avanti.**
1. Nella pagina **Review (Revisione)**, rivedi le impostazioni e quindi scegli **Store (Archivia)**.
Dovrai quindi creare una risorsa segreta nel gruppo Greengrass che faccia riferimento al segreto.
## Fase 2: aggiunta di una risorsa segreta a un gruppo Greengrass
In questa fase, aggiungerai una *risorsa segreta* al gruppo Greengrass. Questa risorsa è un riferimento al segreto creato nella fase precedente.
1. Nel riquadro di navigazione della AWS IoT console, in **Gestione**, espandi **i dispositivi Greengrass**, quindi scegli **Gruppi (V1**).
1. Scegli il gruppo a cui aggiungere la risorsa segreta.
1. Nella pagina di configurazione del gruppo, scegli la scheda **Risorse**, quindi scorri verso il basso fino alla sezione **Segreti**. La sezione **Segreti** mostra le risorse segrete che appartengono al gruppo. È possibile aggiungere, modificare e rimuovere risorse segrete da questa sezione.
**Nota**
In alternativa, la console consente di creare una risorsa segreta e segreta quando si configura un connettore o una funzione Lambda. È possibile eseguire questa operazione dalla pagina **Configura parametri** del connettore o dalla pagina **Risorse** della funzione Lambda.
1. Scegli **Aggiungi** nella sezione **Segreti**.
1. Nella pagina **Aggiungi una risorsa segreta**, inserisci **MyTwilioAuthToken** il **nome della risorsa**.
1. Per il **Segreto**, scegli **greengrass-. TwilioAuthToken**
1. Nella sezione **Seleziona etichette (opzionale)**, l'etichetta AWSCURRENT staging rappresenta la versione più recente del segreto. Questa etichetta è sempre inclusa in una risorsa segreta.
**Nota**
Questo tutorial richiede solo l' AWSCURRENT etichetta. Facoltativamente, puoi includere le etichette richieste dalla funzione o dal connettore Lambda.
1. Scegliere **Add resource (Aggiungi risorsa)**.
## Fase 3: aggiunta di un connettore al gruppo Greengrass
In questo passaggio, configuri i parametri per il [connettore Twilio Notifications](twilio-notifications-connector.md) e lo aggiungi al gruppo.
1. Nella pagina di configurazione del gruppo, scegliere **Connectors (Connettori)**, quindi **Add a connector (Aggiungi un connettore)**.
1. Nella pagina **Aggiungi connettore**, scegli Notifiche **Twilio**.
1. Scegliere la versione .
1. Nella sezione **Configurazione**:
+ Per la **risorsa del token di autenticazione Twilio**, inserisci la risorsa che hai creato nel passaggio precedente.
**Nota**
Quando si immette la risorsa, l'**ARN della proprietà segreta del token di autenticazione Twilio** viene compilato automaticamente.
+ In **Default from phone number (Impostazione predefinita da numero di telefono)**, immettere il numero di telefono abilitato per Twilio.
+ In **Twilio account SID (SID account Twilio)**, immettere il SID dell'account Twilio.
1. Scegliere **Add resource (Aggiungi risorsa)**.
## Fase 4: Creare un pacchetto di distribuzione della funzione Lambda
Per creare una funzione Lambda, devi prima creare un *pacchetto di distribuzione* della funzione Lambda che contenga il codice della funzione e le dipendenze. Le funzioni Greengrass Lambda richiedono il [AWS IoT Greengrass Core SDK](lambda-functions.md#lambda-sdks-core) per attività come la comunicazione con i messaggi MQTT nell'ambiente principale e l'accesso ai segreti locali. Questo tutorial crea una funzione Python, quindi utilizzi la versione Python dell'SDK nel pacchetto di distribuzione.
1. Dalla pagina dei download di [AWS IoT Greengrass Core SDK](what-is-gg.md#gg-core-sdk-download), scarica AWS IoT Greengrass Core SDK per Python sul tuo computer.
1. Decomprimere il pacchetto scaricato per ottenere l'SDK. Il kit SDK è la cartella `greengrasssdk`.
1. Salvare la seguente funzione del codice Python nel file locale `temp_monitor.py`.
```
import greengrasssdk
import json
import random
client = greengrasssdk.client('iot-data')
# publish to the Twilio Notifications connector through the twilio/txt topic
def function_handler(event, context):
temp = event['temperature']
# check the temperature
# if greater than 30C, send a notification
if temp > 30:
data = build_request(event)
client.publish(topic='twilio/txt', payload=json.dumps(data))
print('published:' + str(data))
print('temperature:' + str(temp))
return
# build the Twilio request from the input data
def build_request(event):
to_name = event['to_name']
to_number = event['to_number']
temp_report = 'temperature:' + str(event['temperature'])
return {
"request": {
"recipient": {
"name": to_name,
"phone_number": to_number,
"message": temp_report
}
},
"id": "request_" + str(random.randint(1,101))
}
```
1. Comprimere le voci seguenti nel file `temp_monitor_python.zip`. Al momento della creazione del file ZIP, includere solo il codice e le dipendenze, non la cartella che li contiene.
+ **temp\$1monitor.py**. La logica dell'app.
+ **greengrasssdk**. Libreria richiesta per le funzioni Python Greengrass Lambda che pubblicano messaggi MQTT.
Questo è il tuo pacchetto di implementazione della funzione Lambda.
Ora, crea una funzione Lambda che utilizzi il pacchetto di distribuzione.
## Fase 5: Creare una funzione Lambda nella console AWS Lambda
In questo passaggio, si utilizza la AWS Lambda console per creare una funzione Lambda e configurarla per utilizzare il pacchetto di distribuzione. In seguito, pubblicherai una versione della funzione e creerai un alias.
1. Innanzitutto, crea la funzione Lambda.
1. In Console di gestione AWS, scegli **Servizi** e apri la AWS Lambda console.
1. Scegli **Crea funzione**, quindi scegli **Autore da zero**.
1. Nella sezione **Basic information (Informazioni di base)**, specifica i seguenti valori:
+ Nel campo **Function name (Nome funzione)**, immettere **TempMonitor**.
+ In **Runtime**, scegliere **Python 3.7**.
+ Per **le autorizzazioni**, mantieni l'impostazione predefinita. Questo crea un ruolo di esecuzione che concede le autorizzazioni Lambda di base. Questo ruolo non viene utilizzato da. AWS IoT Greengrass
1. Nella parte inferiore della pagina, scegli **Crea funzione**.
1. Quindi, registra il gestore e carica il pacchetto di distribuzione della funzione Lambda.
1. Nella scheda **Codice**, in **Codice sorgente**, scegli **Carica** da. Dal menu a discesa, scegli un **file.zip.**
![\[Il menu a discesa Carica da con il file.zip evidenziato.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png)
1. Scegli **Carica**, quindi scegli il pacchetto di `temp_monitor_python.zip` distribuzione. Poi, scegli **Salva**.
1. Nella scheda **Codice** della funzione, in **Impostazioni di runtime**, scegliete **Modifica**, quindi immettete i seguenti valori.
+ In **Runtime**, scegliere **Python 3.7**.
+ In **Handler (Gestore)**, immetti **temp\$1monitor.function\$1handler**
1. Scegli **Save** (Salva).
**Nota**
Il pulsante **Test** sulla AWS Lambda console non funziona con questa funzione. Il AWS IoT Greengrass Core SDK non contiene moduli necessari per eseguire le funzioni Greengrass Lambda in modo indipendente nella console. AWS Lambda Questi moduli (ad esempio,`greengrass_common`) vengono forniti alle funzioni dopo essere stati distribuiti nel core Greengrass.
1. Ora, pubblica la prima versione della tua funzione Lambda e crea un [alias per la](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html) versione.
**Nota**
I gruppi Greengrass possono fare riferimento a una funzione Lambda tramite alias (consigliato) o per versione. L'utilizzo di un alias semplifica la gestione degli aggiornamenti del codice perché non è necessario modificare la tabella di sottoscrizione o la definizione del gruppo quando il codice della funzione viene aggiornato. Invece, è sufficiente indirizzare l'alias alla nuova versione della funzione.
1. Nel menu **Actions (Operazioni)**, seleziona **Publish new version (Pubblica nuova versione)**.
1. Per **Version description (Descrizione versione)**, immettere **First version**, quindi scegliere **Publish (Pubblica)**.
1. Nella pagina di configurazione **TempMonitor: 1**, dal menu **Azioni**, scegli **Crea alias**.
1. Nella pagina **Create a new alias (Crea un nuovo alias)**, utilizza i seguenti valori:
+ In **Nome**, inserisci **GG\$1TempMonitor**.
+ In **Version (Versione)**, selezionare **1**.
**Nota**
AWS IoT Greengrass **non supporta gli alias Lambda per le versioni \$1LATEST.**
1. Scegli **Create** (Crea).
Ora sei pronto per aggiungere la funzione Lambda al tuo gruppo Greengrass.
## Fase 6: Aggiungere una funzione Lambda al gruppo Greengrass
In questo passaggio, aggiungi la funzione Lambda al gruppo e quindi configuri il ciclo di vita e le variabili di ambiente. Per ulteriori informazioni, consulta [Controllo dell'esecuzione delle funzioni Greengrass Lambda utilizzando la configurazione specifica del gruppo](lambda-group-config.md).
1. Nella pagina di configurazione del gruppo, scegli la scheda **Funzioni Lambda**.
1. **In **Funzioni My Lambda**, scegli Aggiungi.**
1. Nella pagina **Aggiungi funzione Lambda, scegli **TempMonitor**la tua funzione** Lambda.
1. Per la **versione della funzione Lambda**, scegli **Alias**: GG\$1. TempMonitor
1. Scegli **Aggiungi funzione Lambda**.
## Fase 7: aggiunta di sottoscrizioni al gruppo Greengrass
In questo passaggio, aggiungi un abbonamento che consente alla funzione Lambda di inviare dati di input al connettore. Il connettore definisce gli argomenti MQTT a cui è sottoscritto. Pertanto, questa sottoscrizione utilizza uno degli argomenti. Si tratta dello argomento in cui la funzione di esempio effettua la pubblicazione.
Per questo tutorial, creerai anche abbonamenti che consentono alla funzione di ricevere letture simulate della temperatura AWS IoT e di AWS IoT ricevere informazioni sullo stato dal connettore.
1. **Nella pagina di configurazione del gruppo, scegli la scheda **Abbonamenti**, quindi scegli Aggiungi abbonamento.**
1. Nella pagina **Crea un abbonamento**, configura l'origine e la destinazione come segue:
1. Per **Tipo di sorgente**, scegli la **funzione Lambda**, quindi scegli. **TempMonitor**
1. Per **Tipo di destinazione**, scegli **Connettore**, quindi scegli Notifiche **Twilio**.
1. Per il **filtro Argomento**, scegli**twilio/txt**.
1. Scegli **Create Subscription** (Crea sottoscrizione).
1. Ripeti i passaggi da 1 a 4 per creare un abbonamento che AWS IoT consenta di pubblicare messaggi sulla funzione.
1. Per **Tipo di origine**, scegli **Servizio**, quindi scegli **IoT Cloud**.
1. Per **Seleziona un obiettivo**, scegli **Funzione Lambda**, quindi scegli. **TempMonitor**
1. In **Topic filter (Filtro argomento)**, immettere **temperature/input**.
1. Ripetere le fasi da 1 a 4 per creare una sottoscrizione che consenta al connettore di pubblicare messaggi in AWS IoT.
1. Per **Tipo di sorgente**, scegli **Connettore**, quindi scegli Notifiche **Twilio**.
1. Per il **tipo di Target**, scegli **Service**, quindi scegli **IoT Cloud**.
1. In **Topic filter (Filtro argomento)**, viene inserito **twilio/message/status**. Si tratta dell'argomento predefinito in cui pubblica il connettore.
## Fase 8: distribuzione del gruppo Greengrass
Distribuire il gruppo al nuovo dispositivo core.
1. Assicurati che il AWS IoT Greengrass core sia in funzione. Esegui i seguenti comandi nel terminale di Raspberry Pi in base alle esigenze.
1. Per controllare se il daemon è in esecuzione:
```
ps aux | grep -E 'greengrass.*daemon'
```
Se l'output contiene una voce `root` per `/greengrass/ggc/packages/ggc-version/bin/daemon`, allora il daemon è in esecuzione.
**Nota**
La versione indicata nel percorso dipende dalla versione del software AWS IoT Greengrass Core installata sul dispositivo principale.
1. Per avviare il demone:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. **Nella pagina di configurazione del gruppo, scegli Deploy.**
1.
1. **Nella scheda **Funzioni Lambda, nella sezione Funzioni** **System Lambda**, seleziona **Rilevatore IP** e scegli Modifica.**
1. Nella finestra di dialogo **Modifica impostazioni del rilevatore IP**, seleziona Rileva **e sostituisci automaticamente gli endpoint del broker MQTT**.
1. Scegli **Save** (Salva).
Questo consente ai dispositivi di acquisire automaticamente informazioni di base sulla connettività, come, ad esempio indirizzo IP, DNS e numero della porta. Il rilevamento automatico è consigliato, ma supporta AWS IoT Greengrass anche gli endpoint specificati manualmente. Ti viene chiesto il metodo di individuazione solo la prima volta che il gruppo viene distribuito.
**Nota**
Se richiesto, concedi l'autorizzazione a creare il ruolo di [servizio Greengrass](service-role.md) e associarlo al Account AWS tuo ruolo attuale. Regione AWS Questo ruolo consente di accedere AWS IoT Greengrass alle tue risorse nei AWS servizi.
Nella pagina **Deployments (Distribuzioni)** vengono visualizzati il timestamp della distribuzione, l'ID versione e lo stato. Una volta completata, lo stato visualizzato per la distribuzione dovrebbe essere **Completato**.
Per la risoluzione dei problemi, consultare [Risoluzione dei problemi AWS IoT Greengrass](gg-troubleshooting.md).
**Nota**
Un gruppo Greengrass può contenere una sola versione del connettore alla volta. Per informazioni sull'aggiornamento di una versione del connettore, consulta [Aggiornamento delle versioni dei connettori](connectors.md#upgrade-connector-versions).
## Test della soluzione
1. Nella home page della AWS IoT console, scegli **Test**.
1. Per **Sottoscrivi all'argomento**, utilizza i seguenti valori, quindi scegli **Sottoscrivi**. Il connettore Twilio Notifications pubblica informazioni sullo stato di questo argomento.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-console.html)
1. **Per Pubblica su argomento**, utilizzate i seguenti valori, quindi scegliete **Pubblica** per richiamare la funzione.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-console.html)
Se l'operazione viene completata, il destinatario riceve il messaggio di testo e la console mostra lo stato `success` dai [dati di output](twilio-notifications-connector.md#twilio-notifications-connector-data-output).
A questo punto, è necessario modificare `temperature` nel messaggio di input in **29** e pubblicare. Poiché è inferiore a 30, la TempMonitor funzione non attiva un messaggio Twilio.
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [AWS-connettori Greengrass forniti](connectors-list.md)
# Nozioni di base sui connettori Greengrass (CLI)
Questa funzionalità è disponibile per AWS IoT Greengrass Core v1.7 e versioni successive.
Questo tutorial mostra come utilizzarlo per AWS CLI lavorare con i connettori.
Utilizza i connettori per accelerare il ciclo di vita dello sviluppo. I connettori sono moduli precostituiti e riutilizzabili che semplificano l'interazione con servizi, protocolli e risorse. Possono aiutarti a distribuire più rapidamente la logica di business ai dispositivi Greengrass. Per ulteriori informazioni, consulta [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md).
In questo tutorial, configuri e distribuisci il connettore [Twilio Notifications](twilio-notifications-connector.md). Il connettore riceve le informazioni sui messaggi Twilio come dati di input, quindi attiva un messaggio di testo Twilio. Il flusso di dati viene mostrato nel seguente schema.
![\[Flusso di dati dalla funzione Lambda al connettore Twilio Notifications a Twilio.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/connectors/twilio-solution.png)
Dopo aver configurato il connettore, crei una funzione Lambda e un abbonamento.
+ La funzione valuta i dati simulati da un sensore di temperatura. Pubblica in base a condizioni le informazioni sul messaggio Twilio in un argomento MQTT. Questo è l'argomento a cui il connettore effettua la sottoscrizione.
+ La sottoscrizione consente alla funzione di effettuare la pubblicazione nell'argomento e al connettore di ricevere i dati dall'argomento.
Il connettore Twilio Notifications richiede un token di autenticazione Twilio per interagire con l'API Twilio. Il token è un tipo di testo segreto creato Gestione dei segreti AWS e referenziato da una risorsa di gruppo. Ciò consente di AWS IoT Greengrass creare una copia locale del segreto sul core di Greengrass, dove viene crittografato e reso disponibile al connettore. Per ulteriori informazioni, consulta [Implementa i segreti fino al nucleo AWS IoT Greengrass](secrets.md).
Il tutorial include le seguenti fasi di alto livello:
1. [Crea un segreto di Secrets Manager](#connectors-cli-create-secret)
1. [Creazione della versione e della definizione della risorsa](#connectors-cli-create-resource-definition)
1. [Creazione della versione e della definizione del connettore](#connectors-cli-create-connector-definition)
1. [Creare un pacchetto di distribuzione della funzione Lambda](#connectors-cli-create-deployment-package)
1. [Creazione di una funzione Lambda ](#connectors-cli-create-function)
1. [Creazione della versione e della definizione della funzione](#connectors-cli-create-function-definition)
1. [Creazione della versione e della definizione dell'abbonamento](#connectors-cli-create-subscription-definition)
1. [Creazione di una versione del gruppo](#connectors-cli-create-group-version)
1. [Crea distribuzione](#connectors-cli-create-deployment)
1. [Test della soluzione](#connectors-cli-test-solution)
Il completamento di questo tutorial richiede circa 30 minuti.
**Utilizzando l'API AWS IoT Greengrass **
È utile comprendere i seguenti schemi quando lavori con i gruppi Greengrass e i componenti dei gruppi (ad esempio connettori, funzioni e risorse del gruppo).
+ In alto nella gerarchia, un componente dispone di un oggetto *definizione*, ovvero un container di oggetti *versione*. Una versione è invece un container dei connettori, delle funzioni o di altri tipi di componenti.
+ Quando effettui una distribuzione nel core Greengrass, distribuisci una specifica versione del gruppo. Una versione del gruppo può contenere una versione di ciascun tipo di componente. È necessario un core, ma gli altri sono inclusi in base alle necessità.
+ Le versioni non possono essere modificate. Pertanto, se desideri apportare modifiche, dovrai crearne di nuove.
**Suggerimento**
Se ricevi un errore quando esegui un AWS CLI comando, aggiungi il `--debug` parametro e quindi esegui nuovamente il comando per ottenere ulteriori informazioni sull'errore.
L' AWS IoT Greengrass API consente di creare più definizioni per un tipo di componente. Ad esempio, puoi creare un oggetto `FunctionDefinition` ogni volta che crei una `FunctionDefinitionVersion` oppure puoi aggiungere nuove versioni a una definizione esistente. Questa flessibilità ti consente di personalizzare il sistema di gestione delle versioni.
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Un gruppo Greengrass e un core Greengrass (v1.9.3 or later). Per informazioni su come creare un gruppo e un core Greengrass, consulta [Iniziare con AWS IoT Greengrass](gg-gs.md). Nel tutorial Nozioni di base sono descritte anche le fasi per l'installazione del software AWS IoT Greengrass Core.
+ Python 3.7 installato sul dispositivo principale AWS IoT Greengrass .
+ AWS IoT Greengrass deve essere configurato per supportare i segreti locali, come descritto in [Secrets](secrets.md#secrets-reqs) Requirements.
**Nota**
Questo requisito include l'autorizzazione all'accesso ai segreti di Secrets Manager. *Se utilizzi il ruolo di servizio Greengrass predefinito, Greengrass è autorizzato a ottenere i valori dei segreti con nomi che iniziano con greengrass-.*
+ SID dell'account Twilio, token di autorizzazione e numero di telefono abilitato per Twilio. Dopo avere creato un progetto Twilio, questi valori sono disponibili nel pannello di controllo del progetto.
**Nota**
Puoi utilizzare un account di prova Twilio. Se utilizzi un account di prova, devi aggiungere i numeri di telefono dei destinatari diversi da Twilio a un elenco di numeri di telefono verificati. Per ulteriori informazioni, vedi [Come lavorare con il tuo account di prova Twilio gratuito](https://www.twilio.com/docs/usage/tutorials/how-to-use-your-free-trial-account).
+ AWS CLI installato e configurato sul tuo computer. Per ulteriori informazioni, vedere [Installazione AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) [e configurazione di AWS CLI nella](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) *Guida per l'AWS Command Line Interface utente*.
Gli esempi in questo tutorial si riferiscono a Linux e ad altri sistemi basati su Unix. Se utilizzi Windows, consulta [Specificazione dei valori dei parametri per AWS Command Line Interface conoscere le](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html) differenze di sintassi.
Se il comando include una stringa JSON, il tutorial fornisce un esempio che ha JSON in un'unica riga. In alcuni sistemi, potrebbe essere più semplice modificare ed eseguire comandi utilizzando questo formato.
## Fase 1: Creare un segreto di Secrets Manager
In questo passaggio, utilizzi l' Gestione dei segreti AWS API per creare un segreto per il tuo token di autenticazione Twilio.
1. È necessario creare innanzitutto il segreto.
+ Sostituiscilo *twilio-auth-token* con il tuo token di autenticazione Twilio.
```
aws secretsmanager create-secret --name greengrass-TwilioAuthToken --secret-string twilio-auth-token
```
**Nota**
Per impostazione predefinita, il ruolo di servizio Greengrass consente di AWS IoT Greengrass ottenere il valore dei segreti con nomi che iniziano con *greengrass* -. Per ulteriori informazioni, consulta [Requisiti dei segreti](secrets.md#secrets-reqs).
1. Copiare l'`ARN` del segreto dall'output. Lo usi per creare la risorsa segreta e configurare il connettore Twilio Notifications.
## Fase 2: creazione della versione e della definizione della risorsa
In questo passaggio, utilizzi l' AWS IoT Greengrass API per creare una risorsa segreta per il tuo segreto di Secrets Manager.
1. Creare una definizione di risorsa che includa una versione iniziale.
+ Sostituisci *secret-arn* con il `ARN` segreto che hai copiato nel passaggio precedente.
------
#### [ JSON Expanded ]
```
aws greengrass create-resource-definition --name MyGreengrassResources --initial-version '{
"Resources": [
{
"Id": "TwilioAuthToken",
"Name": "MyTwilioAuthToken",
"ResourceDataContainer": {
"SecretsManagerSecretResourceData": {
"ARN": "secret-arn"
}
}
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws greengrass create-resource-definition \
--name MyGreengrassResources \
--initial-version '{"Resources": [{"Id": "TwilioAuthToken", "Name": "MyTwilioAuthToken", "ResourceDataContainer": {"SecretsManagerSecretResourceData": {"ARN": "secret-arn"}}}]}'
```
------
1. Copiare la `LatestVersionArn` della definizione di risorsa dall'output. È possibile utilizzare questo valore per aggiungere la definizione di risorsa alla versione del gruppo distribuita nel core.
## Fase 3: creazione della versione e della definizione del connettore
In questo passaggio, configuri i parametri per il connettore Twilio Notifications.
1. Creare una definizione del connettore con una versione iniziale.
+ *account-sid*Sostituiscilo con il SID del tuo account Twilio.
+ Sostituisci *secret-arn* con il segreto `ARN` del tuo Secrets Manager. Il connettore lo utilizzerà per ottenere il valore del segreto locale.
+ *phone-number*Sostituiscilo con il tuo numero di telefono abilitato a Twilio. Twilio lo utilizza per iniziare il messaggio di testo. Questo può essere sostituito nel payload del messaggio di input. Utilizza il seguente formato: `+19999999999`.
------
#### [ JSON Expanded ]
```
aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{
"Connectors": [
{
"Id": "MyTwilioNotificationsConnector",
"ConnectorArn": "arn:aws:greengrass:region::/connectors/TwilioNotifications/versions/4",
"Parameters": {
"TWILIO_ACCOUNT_SID": "account-sid",
"TwilioAuthTokenSecretArn": "secret-arn",
"TwilioAuthTokenSecretArn-ResourceId": "TwilioAuthToken",
"DefaultFromPhoneNumber": "phone-number"
}
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws greengrass create-connector-definition \
--name MyGreengrassConnectors \
--initial-version '{"Connectors": [{"Id": "MyTwilioNotificationsConnector", "ConnectorArn": "arn:aws:greengrass:region::/connectors/TwilioNotifications/versions/4", "Parameters": {"TWILIO_ACCOUNT_SID": "account-sid", "TwilioAuthTokenSecretArn": "secret-arn", "TwilioAuthTokenSecretArn-ResourceId": "TwilioAuthToken", "DefaultFromPhoneNumber": "phone-number"}}]}'
```
------
**Nota**
`TwilioAuthToken` è l'ID utilizzato nella fase precedente per creare la risorsa segreta.
1. Copiare il `LatestVersionArn` della definizione del connettore dall'output. È possibile utilizzare questo valore per aggiungere la definizione del connettore alla versione del gruppo distribuita nel core.
## Fase 4: Creare un pacchetto di distribuzione della funzione Lambda
Per creare una funzione Lambda, devi prima creare un *pacchetto di distribuzione* della funzione Lambda che contenga il codice della funzione e le dipendenze. Le funzioni Greengrass Lambda richiedono il [AWS IoT Greengrass Core SDK](lambda-functions.md#lambda-sdks-core) per attività come la comunicazione con i messaggi MQTT nell'ambiente principale e l'accesso ai segreti locali. Questo tutorial crea una funzione Python, quindi utilizzi la versione Python dell'SDK nel pacchetto di distribuzione.
1. Dalla pagina dei download di [AWS IoT Greengrass Core SDK](what-is-gg.md#gg-core-sdk-download), scarica AWS IoT Greengrass Core SDK per Python sul tuo computer.
1. Decomprimere il pacchetto scaricato per ottenere l'SDK. Il kit SDK è la cartella `greengrasssdk`.
1. Salvare la seguente funzione del codice Python nel file locale `temp_monitor.py`.
```
import greengrasssdk
import json
import random
client = greengrasssdk.client('iot-data')
# publish to the Twilio Notifications connector through the twilio/txt topic
def function_handler(event, context):
temp = event['temperature']
# check the temperature
# if greater than 30C, send a notification
if temp > 30:
data = build_request(event)
client.publish(topic='twilio/txt', payload=json.dumps(data))
print('published:' + str(data))
print('temperature:' + str(temp))
return
# build the Twilio request from the input data
def build_request(event):
to_name = event['to_name']
to_number = event['to_number']
temp_report = 'temperature:' + str(event['temperature'])
return {
"request": {
"recipient": {
"name": to_name,
"phone_number": to_number,
"message": temp_report
}
},
"id": "request_" + str(random.randint(1,101))
}
```
1. Comprimere le voci seguenti nel file `temp_monitor_python.zip`. Al momento della creazione del file ZIP, includere solo il codice e le dipendenze, non la cartella che li contiene.
+ **temp\$1monitor.py**. La logica dell'app.
+ **greengrasssdk**. Libreria richiesta per le funzioni Python Greengrass Lambda che pubblicano messaggi MQTT.
Questo è il tuo pacchetto di implementazione della funzione Lambda.
## Fase 5: Creare una funzione Lambda
Ora, crea una funzione Lambda che utilizzi il pacchetto di distribuzione.
1. Crea un ruolo IAM in modo da poter passare il ruolo ARN quando crei la funzione.
------
#### [ JSON Expanded ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Principal": {"Service": "lambda.amazonaws.com"},"Action": "sts:AssumeRole"}]}'
```
------
**Nota**
AWS IoT Greengrass non utilizza questo ruolo perché le autorizzazioni per le funzioni Greengrass Lambda sono specificate nel ruolo del gruppo Greengrass. Per questo tutorial, viene creato un ruolo vuoto.
1. Copia il valore `Arn` dall'output.
1. Usa l' AWS Lambda API per creare la funzione. TempMonitor Il comando seguente presuppone che il file ZIP si trovi nella directory corrente.
+ Sostituisci l’*role-arn* con l’`Arn` copiato.
```
aws lambda create-function \
--function-name TempMonitor \
--zip-file fileb://temp_monitor_python.zip \
--role role-arn \
--handler temp_monitor.function_handler \
--runtime python3.7
```
1. Pubblicare una versione della funzione.
```
aws lambda publish-version --function-name TempMonitor --description 'First version'
```
1. Creare un alias della versione pubblicata.
I gruppi Greengrass possono fare riferimento a una funzione Lambda tramite alias (consigliato) o per versione. L'utilizzo di un alias semplifica la gestione degli aggiornamenti del codice perché non è necessario modificare la tabella di sottoscrizione o la definizione del gruppo quando il codice della funzione viene aggiornato. Invece, è sufficiente indirizzare l'alias alla nuova versione della funzione.
**Nota**
AWS IoT Greengrass **non supporta gli alias Lambda per le versioni \$1LATEST.**
```
aws lambda create-alias --function-name TempMonitor --name GG_TempMonitor --function-version 1
```
1. Copia il valore `AliasArn` dall'output. Questo valore viene utilizzato quando si configura la funzione per AWS IoT Greengrass e quando si crea un abbonamento.
Ora sei pronto per configurare la funzione per AWS IoT Greengrass.
## Fase 6: creazione della versione e della definizione della funzione
Per utilizzare una funzione Lambda su un AWS IoT Greengrass core, si crea una versione di definizione della funzione che fa riferimento alla funzione Lambda tramite alias e definisce la configurazione a livello di gruppo. Per ulteriori informazioni, consulta [Controllo dell'esecuzione delle funzioni Greengrass Lambda utilizzando la configurazione specifica del gruppo](lambda-group-config.md).
1. Creare una definizione di funzione che includa una versione iniziale.
+ *alias-arn*Sostituiscila con `AliasArn` quella che hai copiato quando hai creato l'alias.
------
#### [ JSON Expanded ]
```
aws greengrass create-function-definition --name MyGreengrassFunctions --initial-version '{
"Functions": [
{
"Id": "TempMonitorFunction",
"FunctionArn": "alias-arn",
"FunctionConfiguration": {
"Executable": "temp_monitor.function_handler",
"MemorySize": 16000,
"Timeout": 5
}
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws greengrass create-function-definition \
--name MyGreengrassFunctions \
--initial-version '{"Functions": [{"Id": "TempMonitorFunction", "FunctionArn": "alias-arn", "FunctionConfiguration": {"Executable": "temp_monitor.function_handler", "MemorySize": 16000,"Timeout": 5}}]}'
```
------
1. Copia il valore `LatestVersionArn` dall'output. È possibile utilizzare questo valore per aggiungere la definizione di funzione alla versione del gruppo distribuita nel core.
1. Copia il valore `Id` dall'output. È possibile utilizzare questo valore successivamente, al momento dell'aggiornamento della funzione.
## Fase 7: creazione della versione e della definizione dell'abbonamento
In questo passaggio, aggiungi un abbonamento che consente alla funzione Lambda di inviare dati di input al connettore. Il connettore definisce gli argomenti MQTT a cui è sottoscritto. Pertanto, questa sottoscrizione utilizza uno degli argomenti. Si tratta dello argomento in cui la funzione di esempio effettua la pubblicazione.
Per questo tutorial, creerai anche abbonamenti che consentono alla funzione di ricevere letture simulate della temperatura AWS IoT e di AWS IoT ricevere informazioni sullo stato dal connettore.
1. Creare una definizione di abbonamento che includa una versione iniziale contenente gli abbonamenti.
+ *alias-arn*Sostituiscilo con `AliasArn` quello che hai copiato quando hai creato l'alias per la funzione. Utilizzare questo ARN per entrambi gli abbonamenti.
------
#### [ JSON Expanded ]
```
aws greengrass create-subscription-definition --initial-version '{
"Subscriptions": [
{
"Id": "TriggerNotification",
"Source": "alias-arn",
"Subject": "twilio/txt",
"Target": "arn:aws:greengrass:region::/connectors/TwilioNotifications/versions/4"
},
{
"Id": "TemperatureInput",
"Source": "cloud",
"Subject": "temperature/input",
"Target": "alias-arn"
},
{
"Id": "OutputStatus",
"Source": "arn:aws:greengrass:region::/connectors/TwilioNotifications/versions/4",
"Subject": "twilio/message/status",
"Target": "cloud"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws greengrass create-subscription-definition \
--initial-version '{"Subscriptions": [{"Id": "TriggerNotification", "Source": "alias-arn", "Subject": "twilio/txt", "Target": "arn:aws:greengrass:region::/connectors/TwilioNotifications/versions/4"},{"Id": "TemperatureInput", "Source": "cloud", "Subject": "temperature/input", "Target": "alias-arn"},{"Id": "OutputStatus", "Source": "arn:aws:greengrass:region::/connectors/TwilioNotifications/versions/4", "Subject": "twilio/message/status", "Target": "cloud"}]}'
```
------
1. Copia il valore `LatestVersionArn` dall'output. È possibile utilizzare questo valore per aggiungere la definizione dell'abbonamento alla versione del gruppo distribuita nel core.
## Fase 8: creazione di una versione del gruppo
A questo punto è possibile creare una versione del gruppo che contenga tutte le voci da distribuire. A questo scopo, è necessario creare una versione di gruppo che faccia riferimento alla versione di destinazione di ciascun tipo di componente.
Ottenere innanzitutto l'ID del gruppo e l'ARN della versione della definizione del core. Questi valori sono necessari per creare la versione del gruppo.
1. Ottenere l'ID del gruppo e la versione gruppo più recente:
1. Ottieni il gruppo Greengrass IDs di destinazione e la versione del gruppo. Questa procedura presuppone che questa sia la versione più recente del gruppo e del gruppo. La seguente query restituisce il gruppo creato più di recente.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
In alternativa, puoi eseguire query in base al nome. I nomi dei gruppi non devono essere univoci, pertanto potrebbero essere restituiti più gruppi.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**Nota**
Puoi trovare questi valori anche nella AWS IoT console. L'ID gruppo viene visualizzato nella pagina **Settings (Impostazioni)** del gruppo. IDs Le versioni del gruppo vengono visualizzate nella scheda **Distribuzioni del gruppo.**
1. Copiare l'`Id` del gruppo di destinazione dall'output. Questo valore viene utilizzato per ottenere la versione della definizione del core e durante la distribuzione del gruppo.
1. Copiare la `LatestVersion` dall'output, che corrisponde all'ID dell'ultima versione aggiunta al gruppo. Questo valore viene utilizzato per ottenere la versione della definizione del core.
1. Per ottenere l'ARN della versione di definizione del core:
1. Ottenere la versione del gruppo. In questa fase, si presume che la versione del gruppo più recente includa una versione della definizione del core.
+ *group-id*Sostituiscila con quella `Id` che hai copiato per il gruppo.
+ Sostituisci *group-version-id* con `LatestVersion` quello che hai copiato per il gruppo.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id group-version-id
```
1. Copia il valore `CoreDefinitionVersionArn` dall'output.
1. Creare una versione del gruppo.
+ Sostituisci *group-id* con `Id` quello che hai copiato per il gruppo.
+ Sostituiscilo *core-definition-version-arn* con `CoreDefinitionVersionArn` quello che hai copiato per la versione di definizione principale.
+ Sostituisci *resource-definition-version-arn* con `LatestVersionArn` quello che hai copiato per la definizione della risorsa.
+ *connector-definition-version-arn*Sostituiscilo con `LatestVersionArn` quello che hai copiato per la definizione del connettore.
+ *function-definition-version-arn*Sostituiscilo con `LatestVersionArn` quello che hai copiato per la definizione della funzione.
+ Sostituisci *subscription-definition-version-arn* con `LatestVersionArn` quello che hai copiato per la definizione della sottoscrizione.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--resource-definition-version-arn resource-definition-version-arn \
--connector-definition-version-arn connector-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--subscription-definition-version-arn subscription-definition-version-arn
```
1. Copia il valore di `Version` dall'output. Questo è l'ID della versione del gruppo. È possibile utilizzare questo valore per distribuire la versione del gruppo.
## Fase 9: creazione di una distribuzione
Distribuire il gruppo al nuovo dispositivo core.
1. In un terminale del dispositivo principale, assicurati che il AWS IoT Greengrass demone sia in esecuzione.
1. Per controllare se il daemon è in esecuzione:
```
ps aux | grep -E 'greengrass.*daemon'
```
Se l'output contiene una voce `root` per `/greengrass/ggc/packages/1.11.6/bin/daemon`, allora il daemon è in esecuzione.
1. Per avviare il demone:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. Crea una implementazione .
+ *group-id*Sostituiscilo con `Id` quello che hai copiato per il gruppo.
+ Sostituisci *group-version-id* con `Version` quello che hai copiato per la nuova versione del gruppo.
```
aws greengrass create-deployment \
--deployment-type NewDeployment \
--group-id group-id \
--group-version-id group-version-id
```
1. Copia il valore `DeploymentId` dall'output.
1. Ottenere lo stato della distribuzione.
+ Sostituiscilo *group-id* con `Id` quello che hai copiato per il gruppo.
+ Sostituiscilo *deployment-id* con `DeploymentId` quello che hai copiato per la distribuzione.
```
aws greengrass get-deployment-status \
--group-id group-id \
--deployment-id deployment-id
```
Se lo stato è`Success`, la distribuzione è avvenuta con successo. Per la risoluzione dei problemi, consultare [Risoluzione dei problemi AWS IoT Greengrass](gg-troubleshooting.md).
## Test della soluzione
1. Nella home page della AWS IoT console, scegli **Test**.
1. Per **Sottoscrivi all'argomento**, utilizza i seguenti valori, quindi scegli **Sottoscrivi**. Il connettore Twilio Notifications pubblica informazioni sullo stato di questo argomento.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-cli.html)
1. **Per Pubblica su argomento**, utilizzate i seguenti valori, quindi scegliete **Pubblica** per richiamare la funzione.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/connectors-cli.html)
Se l'operazione viene completata, il destinatario riceve il messaggio di testo e la console mostra lo stato `success` dai [dati di output](twilio-notifications-connector.md#twilio-notifications-connector-data-output).
A questo punto, è necessario modificare `temperature` nel messaggio di input in **29** e pubblicare. Poiché è inferiore a 30, la TempMonitor funzione non attiva un messaggio Twilio.
## Consulta anche
+ [Integrazione con servizi e protocolli tramite i connettori Greengrass](connectors.md)
+ [AWS-connettori Greengrass forniti](connectors-list.md)
+ [Nozioni di base sui connettori Greengrass (console)](connectors-console.md)
+ [Gestione dei segreti AWS comandi nel *AWS CLI Command*](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager) Reference
+ [AWS Identity and Access Management comandi (IAM) nel AWS CLI Command](https://docs.aws.amazon.com/cli/latest/reference/iam) *Reference*
+ [AWS Lambda comandi nel AWS CLI Command](https://docs.aws.amazon.com/cli/latest/reference/lambda) *Reference*
+ [AWS IoT Greengrass comandi nel AWS CLI Command](https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html) *Reference*