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à. # Iniziare con AWS IoT Greengrass Questo tutorial introduttivo include diversi moduli progettati per mostrarti le AWS IoT Greengrass nozioni di base e aiutarti a iniziare a utilizzare AWS IoT Greengrass. Questo tutorial copre concetti fondamentali, come ad esempio: + Configurazione di AWS IoT Greengrass core e gruppi. + Il processo di implementazione per l'esecuzione di AWS Lambda funzioni all'edge. + Connessione di AWS IoT dispositivi, denominati dispositivi client, al AWS IoT Greengrass core. + Creazione di abbonamenti per consentire la comunicazione MQTT tra funzioni Lambda locali, dispositivi client e. AWS IoT ## Scegli come iniziare con AWS IoT Greengrass Puoi scegliere di usare questo tutorial per configurare il tuo dispositivo principale: + Esegui la [configurazione del dispositivo Greengrass](quick-start.md) sul tuo dispositivo principale, che ti porta dall'installazione AWS IoT Greengrass delle dipendenze al test di una funzione Hello World Lambda in pochi minuti. Questo script riproduce i passaggi nel modulo 1 attraverso il modulo 3-1.    oppure   + Passa attraverso i passaggi del modulo 1 attraverso il modulo 3-1 per esaminare più da vicino i requisiti e i processi di Greengrass. Questi passaggi consentono di configurare il dispositivo principale, creare e configurare un gruppo Greengrass contenente una funzione Hello World Lambda e distribuire il gruppo Greengrass. In genere, il completamento richiede un'ora o due. ![\[Moduli introduttivi\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/getting-started-modules.png) **Quick Start** [La configurazione del dispositivo Greengrass](quick-start.md) configura il dispositivo principale e le risorse Greengrass. Lo script: + Installa le AWS IoT Greengrass dipendenze. + Scarica il certificato CA principale, il certificato e le chiavi del dispositivo principale. + Scarica, installa e configura il software AWS IoT Greengrass Core sul tuo dispositivo. + Avvia il processo daemon di Greengrass sul dispositivo principale. + Crea o aggiorna il [ruolo del servizio Greengrass](service-role.md), se necessario. + Crea un gruppo Greengrass e un core Greengrass. + (Facoltativo) Crea una funzione Hello World Lambda, un abbonamento e una configurazione di registrazione locale. + (Facoltativo) Implementa il gruppo Greengrass. **Moduli 1 e 2** Il [modulo 1](module1.md) e il [modulo 2](module2.md) descrivono come configurare l'ambiente. (Oppure, utilizza la [configurazione del dispositivo Greengrass](quick-start.md) per eseguire questi moduli.) + Configura il tuo dispositivo principale per Greengrass. + Esegui lo script di controllo delle dipendenze. + Crea un gruppo Greengrass e un core Greengrass. + Scaricate e installate il software AWS IoT Greengrass Core più recente da un file tar.gz. + Avvia il processo daemon di Greengrass sul core. AWS IoT Greengrass fornisce anche altre opzioni per l'installazione del software AWS IoT Greengrass Core, incluse le `apt` installazioni su piattaforme Debian supportate. Per ulteriori informazioni, consulta [Installare il software AWS IoT Greengrass Core](install-ggc.md). **Moduli 3-1 e 3-2** [Il Modulo 3-1](module3-I.md) e il [Modulo 3-2](module3-II.md) descrivono come utilizzare le funzioni Lambda locali. (Oppure, utilizza la [configurazione del dispositivo Greengrass](quick-start.md) per eseguire il modulo 3-1.) + Crea funzioni Hello World Lambda in. AWS Lambda + Aggiungi le funzioni Lambda al tuo gruppo Greengrass. + Crea abbonamenti che consentano la comunicazione MQTT tra le funzioni Lambda e. AWS IoT + Configura la registrazione locale per i componenti del sistema Greengrass e le funzioni Lambda. + Implementa un gruppo Greengrass che contenga le funzioni e gli abbonamenti Lambda. + Invia messaggi dalle funzioni Lambda locali a. AWS IoT + Richiama funzioni Lambda locali da. AWS IoT + Provare le funzioni on-demand e a lungo termine. **Moduli 4 e 5** [Il Modulo 4](module4.md) mostra come i dispositivi client si connettono al core e comunicano tra loro. [Il Modulo 5](module5.md) mostra come i dispositivi client possono utilizzare le ombre per controllare lo stato. + Registra ed esegui il provisioning AWS IoT dei dispositivi (rappresentati da terminali a riga di comando). + Installa il SDK per dispositivi AWS IoT for Python. Viene utilizzato dai dispositivi client per scoprire il core Greengrass. + Aggiungi i dispositivi client al tuo gruppo Greengrass. + Creare sottoscrizioni che consentano la comunicazione MQTT. + Implementa un gruppo Greengrass che contiene i tuoi dispositivi client. + Verifica la comunicazione device-to-device. + Test degli aggiornamenti dello stato shadow. **Modulo 6** [Il Modulo 6](module6.md) mostra come le funzioni Lambda possono accedere a. Cloud AWS + Crea un ruolo di gruppo Greengrass che consenta l'accesso alle risorse Amazon DynamoDB. + Aggiungi una funzione Lambda al tuo gruppo Greengrass. Questa funzione utilizza l' AWS SDK per Python per interagire con DynamoDB. + Creare sottoscrizioni che consentano la comunicazione MQTT. + Verifica l'interazione con DynamoDB. **Modulo 7** Nel [Modulo 7](console-mod7.md) viene illustrato come configurare un modulo di sicurezza hardware (HSM) simulato per l'uso con un core Greengrass. Questo modulo avanzato è fornito solo per la sperimentazione e il test iniziale. Non è per uso di produzione di alcun tipo. + Installare e configurare un HSM basato su software e una chiave privata. + Configurare il core di Greengrass per utilizzare la sicurezza hardware. + Test della sicurezza hardware ## Requisiti Per completare questo tutorial, è necessario quanto segue: + Un MAC, un PC con Windows o un sistema di tipo UNIX. + Un Account AWS. Se non lo hai, consultare [Crea un Account AWS](#create-aws-account). + L'uso di una AWS [regione](https://en.wikipedia.org/wiki/Amazon_Web_Services#Availability_and_topology) che supporta AWS IoT Greengrass. Per l'elenco delle regioni supportate per AWS IoT Greengrass, consulta [AWS endpoint e quote](https://docs.aws.amazon.com/general/latest/gr/greengrass.html) in. *Riferimenti generali di AWS* **Nota** Prendi nota del tuo Regione AWS e assicurati che venga utilizzato in modo coerente in questo tutorial. Se cambi il tuo Regione AWS durante il tutorial, potresti riscontrare problemi nel completare i passaggi. + Un Raspberry Pi 4 Model B o Raspberry Pi 3 Model B/B\$1, con una scheda microSD da 8 GB o un'istanza Amazon. EC2 Dato che AWS IoT Greengrass è concepito idealmente per essere utilizzato con hardware fisico, consigliamo di utilizzare un Raspberry Pi. **Nota** Per determinare il modello del Raspberry Pi, esegui il comando seguente: ``` cat /proc/cpuinfo ``` Vicino alla fine dell'elenco, annota il valore dell'attributo `Revision`, quindi consulta la tabella [Il mio modello di Pi](https://elinux.org/RPi_HardwareHistory#Which_Pi_have_I_got.3F). Ad esempio, se il valore di `Revision` è `a02082`, la tabella indica che il Pi è un 3 modello B. Per determinare l'architettura del Raspberry Pi, esegui il comando seguente: ``` uname -m ``` Per questo tutorial, il risultato deve essere maggiore o uguale a `armv71`. + Conoscenza di base di Python. Sebbene questo tutorial sia destinato all'esecuzione AWS IoT Greengrass su un Raspberry Pi, supporta anche altre piattaforme. AWS IoT Greengrass Per ulteriori informazioni, consulta [Piattaforme supportate e requisiti](what-is-gg.md#gg-platforms). ## Crea un Account AWS Se non ne hai uno Account AWS, segui questi passaggi per creare e attivare un Account AWS: ### Registrati per un Account AWS Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno. **Per iscriverti a un Account AWS** 1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup) 1. Segui le istruzioni online. Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono. Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L'utente root dispone dell'accesso a tutte le risorse e tutti i Servizi AWS nell'account. Come best practice di sicurezza, assegna l'accesso amministrativo a un utente e utilizza solo l'utente root per eseguire [attività che richiedono l'accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks). AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**. ### Crea un utente con accesso amministrativo Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane. **Proteggi i tuoi Utente root dell'account AWS** 1. Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password. Per informazioni sull'accesso utilizzando un utente root, consulta la pagina [Signing in as the root user](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) della *Guida per l'utente di Accedi ad AWS *. 1. Abilita l'autenticazione a più fattori (MFA) per l'utente root. Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*. **Crea un utente con accesso amministrativo** 1. Abilita Centro identità IAM. Per istruzioni, consulta [Abilitazione di AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l'utente di AWS IAM Identity Center *. 1. In IAM Identity Center, assegna l'accesso amministrativo a un utente. Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*. **Accesso come utente amministratore** + Per accedere con l'utente IAM Identity Center, utilizza l'URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l'utente IAM Identity Center. Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*. **Assegna l'accesso a ulteriori utenti** 1. In IAM Identity Center, crea un set di autorizzazioni conforme alla best practice dell'applicazione di autorizzazioni con il privilegio minimo. Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l'utente di AWS IAM Identity Center *. 1. Assegna al gruppo prima gli utenti e poi l'accesso con autenticazione unica (Single Sign-On). Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l'utente di AWS IAM Identity Center *. **Importante** Per questo tutorial, supponiamo che il tuo account utente IAM disponga dei permessi di accesso di amministratore. # Avvio rapido: configurazione dispositivo Greengrass La configurazione del dispositivo Greengrass è uno script che configura il dispositivo principale in pochi minuti, in modo da poterlo iniziare a utilizzare. AWS IoT Greengrass Usa questo script per: 1. Configura il dispositivo e installa il software AWS IoT Greengrass Core. 1. Configura le tue risorse basate sul cloud. 1. Implementa facoltativamente un gruppo Greengrass con una funzione Hello World Lambda che invia messaggi MQTT dal core. AWS IoT AWS IoT Greengrass Questo imposta l'ambiente Greengrass mostrato nel diagramma seguente. ![\[Funzione Hello World Lambda che invia un messaggio MQTT AWS IoT dal core. AWS IoT Greengrass\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/quick-start-gg-architecture.png) ## Requisiti La configurazione del dispositivo Greengrass ha i seguenti requisiti: + Il dispositivo principale deve utilizzare una [piattaforma supportata](what-is-gg.md#gg-platforms). Il dispositivo deve avere installato un gestore di pacchetti appropriato: `apt`, `yum`, o `opkg`.   + L'utente Linux che esegue lo script deve disporre delle autorizzazioni per eseguire come `sudo`.   + È necessario fornire le proprie credenziali. Account AWS Per ulteriori informazioni, consulta [Fornisci le credenziali Account AWS](#gg-device-setup-credentials). **Nota** La configurazione del dispositivo Greengrass installa l'[ultima versione](what-is-gg.md#ggc-versions) del software AWS IoT Greengrass Core sul dispositivo. Installando il software AWS IoT Greengrass Core, l'utente accetta il contratto di [licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf). ## Esecuzione della configurazione del dispositivo Greengrass Puoi eseguire la configurazione del dispositivo Greengrass in pochi passaggi. Dopo aver fornito le Account AWS credenziali, lo script esegue il provisioning del dispositivo principale Greengrass e distribuisce un gruppo Greengrass in pochi minuti. Esegui i seguenti comandi in una finestra terminale sul dispositivo di destinazione. **Nota** Questi passaggi ti illustrano come eseguire lo script in modalità interattiva, che richiede di immettere o accettare ogni valore di input. Per informazioni su come eseguire lo script in modo invisibile, consulta [Esecuzione della configurazione del dispositivo Greengrass in modalità silenziosa](#gg-device-setup-silent-mode).   1. [Fornisci le tue credenziali](#gg-device-setup-credentials). In questa procedura, si suppone che vengano fornite credenziali di sicurezza temporanee come variabili di ambiente. ``` export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE= ``` **Nota** Se stai eseguendo la configurazione del dispositivo Greengrass su una piattaforma Raspbian o su una OpenWrt piattaforma, crea una copia di questi comandi. Devi fornirli nuovamente dopo il riavvio del dispositivo. 1. Scarica e avvia lo script. Puoi utilizzare `wget` o `curl` scaricare lo script. `wget`: ``` wget -q -O ./gg-device-setup-latest.sh https://d1onfpft10uf5o.cloudfront.net/greengrass-device-setup/downloads/gg-device-setup-latest.sh && chmod +x ./gg-device-setup-latest.sh && sudo -E ./gg-device-setup-latest.sh bootstrap-greengrass-interactive ``` `curl`: ``` curl https://d1onfpft10uf5o.cloudfront.net/greengrass-device-setup/downloads/gg-device-setup-latest.sh > gg-device-setup-latest.sh && chmod +x ./gg-device-setup-latest.sh && sudo -E ./gg-device-setup-latest.sh bootstrap-greengrass-interactive ``` 1. Procedi attraverso i prompt dei comandi per [i valori di input](#gg-device-setup-input). Puoi premere il tasto **Enter (Invio)** per utilizzare il valore predefinito o digitare un valore personalizzato e quindi premere **Enter (Invio)**. Lo script scrive messaggi di stato sul terminale che sono simili ai seguenti. ![\[Messaggi di output nel terminale.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/quick-start-in-progress.png) 1. Se il tuo dispositivo principale esegue Raspbian oppure OpenWrt, riavvia il dispositivo quando richiesto, fornisci le tue credenziali e quindi riavvia lo script. 1. Quando viene richiesto di riavviare il dispositivo, esegui uno dei seguenti comandi. Per le piattaforme Raspbian: ``` sudo reboot ``` Per le piattaforme: OpenWrt ``` reboot ``` 1. Dopo il riavvio avvio del dispositivo, apri il terminale e fornisci le credenziali come variabili di ambiente. ``` export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE= ``` 1. Riavvia lo script. ``` sudo -E ./gg-device-setup-latest.sh bootstrap-greengrass-interactive ``` 1. Quando viene chiesto se utilizzare i valori di input della sessione precedente o avviare una nuova installazione, immetti `yes` per riutilizzare i valori di input. **Nota** Sulle piattaforme che richiedono un riavvio, tutti i valori di input (ad eccezione delle credenziali) della sessione precedente vengono temporaneamente memorizzati nel file `GreengrassDeviceSetup.config.info`. Al termine dell'installazione, il terminale visualizza un messaggio di stato di successo simile al seguente. ![\[Messaggio di successo nell'output del terminale.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/quick-start-completed.png) 1. Esamina il nuovo gruppo Greengrass che lo script configura utilizzando i valori di input forniti. 1. Accedi a [Console di gestione AWS](https://console.aws.amazon.com/)sul tuo computer e apri la AWS IoT console. **Nota** Assicurati che quello Regione AWS selezionato nella console sia lo stesso che hai usato per configurare l'ambiente Greengrass. Per impostazione predefinita, la regione è Stati Uniti occidentali (Oregon). 1. Nel pannello di navigazione, espandi **i dispositivi Greengrass**, quindi scegli **Gruppi (V1)** per individuare il gruppo appena creato. 1. Se hai incluso la funzione Hello World Lambda, la configurazione del dispositivo Greengrass distribuisce il gruppo Greengrass sul tuo dispositivo principale. Per testare la funzione Lambda o per informazioni su come rimuovere la funzione Lambda dal gruppo, continua con il Modulo 3-1 del tutorial [Verifica che la funzione Lambda sia in esecuzione sul dispositivo principale](lambda-check.md) Getting Started. **Nota** Assicurati che quello Regione AWS selezionato nella console sia lo stesso che hai usato per configurare l'ambiente Greengrass. Per impostazione predefinita, la regione è Stati Uniti occidentali (Oregon). Se non hai incluso la funzione Hello World Lambda, puoi [creare la tua funzione Lambda o provare altre funzionalità](create-lambda.md) di Greengrass. Ad esempio, puoi aggiungere il connettore di [distribuzione dell'applicazione Docker](docker-app-connector.md) al gruppo e utilizzarlo per distribuire contenitori Docker nel dispositivo principale.   ## Risoluzione dei problemi È possibile utilizzare le seguenti informazioni per risolvere i problemi relativi alla configurazione del dispositivo. AWS IoT Greengrass ### Errore: Python (python3.7) non trovato. Tentativo di installazione in corso... **Soluzione:** potresti visualizzare questo errore quando lavori con un' EC2 istanza Amazon. Questo errore si verifica quando Python non è installato nella `/usr/bin/python3.7` cartella. Per risolvere questo errore, sposta Python nella directory corretta dopo averlo installato: ``` sudo ln -s /usr/local/bin/python3.7 /usr/bin/python3.7 ``` ### Risoluzione di problemi aggiuntivi Per risolvere altri problemi relativi alla configurazione del AWS IoT Greengrass dispositivo, puoi cercare le informazioni di debug nei file di registro: + Per problemi con la configurazione del dispositivo Greengrass, controlla il file `/tmp/greengrass-device-setup-bootstrap-epoch-timestamp.log`. + Per problemi con il gruppo Greengrass o l'impostazione dell'ambiente principale, controlla il file `GreengrassDeviceSetup-date-time.log` nella stessa directory `gg-device-setup-latest.sh` o nella posizione specificata. Per ulteriori informazioni sulla risoluzione dei problemi, consulta [Risoluzione dei problemi AWS IoT Greengrass](gg-troubleshooting.md) o controlla il [AWS IoT Greengrass tag](https://repost.aws/tags/TA4ckIed1sR4enZBey29rKTg/aws-io-t-greengrass) su re:POST. AWS ## Opzioni di configurazione del dispositivo Greengrass È possibile configurare la configurazione del dispositivo Greengrass per accedere alle AWS risorse e configurare l'ambiente Greengrass. ### Fornisci le credenziali Account AWS La configurazione del dispositivo Greengrass utilizza Account AWS le tue credenziali per accedere alle tue risorse. AWS Supporta credenziali a lungo termine per un utente IAM o credenziali di sicurezza temporanee da un ruolo IAM. Per prima cosa, devi ottenere le credenziali + Per utilizzare credenziali a lungo termine, fornisci l'ID della chiave di accesso e la chiave di accesso segreta per il tuo utente IAM. Per informazioni sulla creazione di chiavi di accesso per credenziali a lungo termine, consulta [Managing access keys for IAM users](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) nella *IAM User Guide*.   + Per utilizzare credenziali di sicurezza temporanee (consigliato), fornisci l'ID della chiave di accesso, la chiave di accesso segreta e il token di sessione relativi a un ruolo IAM presunto. *Per informazioni sull'estrazione di credenziali di sicurezza temporanee dal AWS STS `assume-role` comando, consulta [Using temporary security credenziali with the AWS CLI](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html#using-temp-creds-sdk-cli) nella IAM User Guide.* **Nota** Ai fini di questo tutorial, si presuppone che l'utente o il ruolo IAM disponga dei permessi di accesso di amministratore. Quindi, dovrai fornire tali credenziali per la configurazione del dispositivo Greengrass in uno dei due modi seguenti: + **Come variabile d’ambiente.** Imposta le variabili d’ambiente `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, e `AWS_SESSION_TOKEN` (se necessario) prima di avviare lo script, come illustrato al passaggio 1 di [Esecuzione della configurazione del dispositivo Greengrass](#run-gg-device-setup).   + **Come valori di input.** Immetti l'ID della chiave di accesso, la chiave di accesso segreta e i valori del token di sessione (se necessario) direttamente nel terminale dopo l'avvio dello script. La configurazione del dispositivo Greengrass non salva o memorizza le credenziali.   ### Fornire i valori di input In modalità interattiva, la configurazione del dispositivo Greengrass richiede i valori di input. Puoi premere il tasto **Enter (Invio)** per utilizzare il valore predefinito o digitare un valore personalizzato e quindi premere **Enter (Invio)**. In modalità silenziosa, fornisci i valori di input dopo l'avvio dello script. #### Valori di input **AWS ID chiave di accesso** L'ID della chiave di accesso dalle credenziali di sicurezza a lungo termine o temporanee. Specifica questa opzione come valore di input solo se non fornisci le credenziali come variabili di ambiente. Per ulteriori informazioni, consulta [Fornisci le credenziali Account AWS](#gg-device-setup-credentials). Nome di opzione per la modalità silenziosa: `--aws-access-key-id` **AWS chiave di accesso segreta** Chiave di accesso segreta dalle credenziali di sicurezza a lungo termine o temporanee. Specifica questa opzione come valore di input solo se non fornisci le credenziali come variabili di ambiente. Per ulteriori informazioni, consulta [Fornisci le credenziali Account AWS](#gg-device-setup-credentials). Nome di opzione per la modalità silenziosa: `--aws-secret-access-key` **AWS token di sessione** Il token di sessione dalle credenziali di sicurezza temporanee. Specifica questa opzione come valore di input solo se non fornisci le credenziali come variabili di ambiente. Per ulteriori informazioni, consulta [Fornisci le credenziali Account AWS](#gg-device-setup-credentials). Nome di opzione per la modalità silenziosa: `--aws-session-token` **Regione AWS** Regione AWS Dove vuoi creare il gruppo Greengrass. Per l'elenco dei servizi Regione AWS supportati, vedere [AWS IoT Greengrass](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)in. *Riferimenti generali di Amazon Web Services* Valore predefinito: `us-west-2` Nome di opzione per la modalità silenziosa: `--region` **Group name** (Nome gruppo) Il nome del gruppo Greengrass. Valore predefinito: `GreengrassDeviceSetup_Group_guid` Nome di opzione per la modalità silenziosa: `--group-name` **Nome principale** Il nome per il core di Greengrass. Il core è un AWS IoT dispositivo (cosa) che esegue il software AWS IoT Greengrass Core. Il core viene aggiunto al AWS IoT registro e al gruppo Greengrass. Se fornite un nome, questo deve essere univoco alla lettera Account AWS e Regione AWS. Valore predefinito: `GreengrassDeviceSetup_Core_guid` Nome di opzione per la modalità silenziosa: `--core-name` **AWS IoT Greengrass Percorso di installazione del software principale** La posizione nel file system del dispositivo in cui si desidera installare il software AWS IoT Greengrass Core. Valore predefinito: `/` Nome di opzione per la modalità silenziosa: `--ggc-root-path` **Funzione Hello World Lambda** Indica se includere una funzione Hello World Lambda nel gruppo Greengrass. La funzione pubblica un messaggio MQTT sull'argomento `hello/world` ogni cinque secondi. Lo script crea e pubblica questa funzione Lambda definita dall'utente AWS Lambda e la aggiunge al gruppo Greengrass. Lo script crea anche una sottoscrizione nel gruppo che consente alla funzione di inviare messaggi MQTT a AWS IoT. Questa è una funzione Lambda di Python 3.7. Se Python 3.7 non è installato sul dispositivo e lo script non è in grado di installarlo, lo script stampa un messaggio di errore nel terminale. Per includere la funzione Lambda nel gruppo, è necessario installare Python 3.7 manualmente e riavviare lo script. Per creare il gruppo Greengrass senza la funzione Lambda, riavviate lo script e immettete `no` quando richiesto di includere la funzione. Valore predefinito: `no` Nome di opzione per la modalità silenziosa: `--hello-world-lambda` - Questa opzione non accetta alcun valore. Includere il valore nel comando se si desidera creare la funzione. **Tempo di distribuzione** Il numero di secondi prima che l'installazione del dispositivo Greengrass interrompa il controllo dello stato della [distribuzione del gruppo Greengrass](deployments.md). Questo valore viene utilizzato solo quando il gruppo include la funzione Lambda Hello World. In caso contrario, il gruppo non viene distribuito. Il tempo di distribuzione dipende dalla velocità della rete. Per velocità di rete lente, è possibile aumentare questo valore. Valore predefinito: `180` Nome di opzione per la modalità silenziosa: `--deployment-timeout` **Log Path (Percorso log)** Il percorso del file di registro che contiene informazioni sulle operazioni di installazione di base e gruppo Greengrass. Utilizza questo registro per risolvere i problemi relativi alla distribuzione e ad altri problemi relativi al gruppo Greengrass e all'installazione principale. Valore predefinito: `./` Nome di opzione per la modalità silenziosa: `--log-path` **Livello di dettaglio** Indica se stampare informazioni di registro dettagliate nel terminale durante l'esecuzione dello script. Puoi utilizzare queste informazioni per risolvere i problemi di configurazione del dispositivo. Valore predefinito: `no` Nome di opzione per la modalità silenziosa: `--verbose` - Questa opzione non accetta alcun valore. Includi tale valore nel comando se si desidera stampare informazioni dettagliate di registro.   ### Esecuzione della configurazione del dispositivo Greengrass in modalità silenziosa Puoi eseguire l'impostazione del dispositivo Greengrass in modalità silenziosa in modo che lo script non richieda alcun valore. Per eseguire l’operazione in modalità silenziosa, specifica la modalità `bootstrap-greengrass` e i [valori di input](#gg-device-setup-input-values) dopo l'avvio dello script. Puoi omettere i valori di input se desideri utilizzare i valori predefiniti. La procedura dipende dal fatto che vengano fornite le Account AWS credenziali come variabili di ambiente prima di avviare lo script o come valori di input dopo l'avvio dello script. #### Fornire le credenziali come variabili di ambiente 1. [Fornisci le credenziali](#gg-device-setup-credentials) come variabili di ambiente. Nell'esempio seguente vengono esportate credenziali temporanee, che includono il token di sessione. ``` export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE= ``` **Nota** Se stai eseguendo la configurazione del dispositivo Greengrass su una piattaforma Raspbian o su una OpenWrt piattaforma, crea una copia di questi comandi. Devi fornirli nuovamente dopo il riavvio del dispositivo. 1. Scarica e avvia lo script. Fornisci i valori di input in base alle tue esigenze. Per esempio: + Per utilizzare tutti i valori predefiniti: ``` wget -q -O ./gg-device-setup-latest.sh https://d1onfpft10uf5o.cloudfront.net/greengrass-device-setup/downloads/gg-device-setup-latest.sh && chmod +x ./gg-device-setup-latest.sh && sudo -E ./gg-device-setup-latest.sh bootstrap-greengrass ``` + Per specificare valori personalizzati: ``` wget -q -O ./gg-device-setup-latest.sh https://d1onfpft10uf5o.cloudfront.net/greengrass-device-setup/downloads/gg-device-setup-latest.sh && chmod +x ./gg-device-setup-latest.sh && sudo -E ./gg-device-setup-latest.sh bootstrap-greengrass --region us-east-1 --group-name Custom_Group_Name --core-name Custom_Core_Name --ggc-root-path /custom/ggc/root/path --deployment-timeout 300 --log-path /customized/log/path --hello-world-lambda --verbose ``` **Nota** Per utilizzare `curl` per scaricare lo script, sostituisci `wget -q -O` con `curl` nel comando. 1. Se il tuo dispositivo principale esegue Raspbian oppure OpenWrt, riavvia il dispositivo quando richiesto, fornisci le tue credenziali e quindi riavvia lo script. 1. Quando viene richiesto di riavviare il dispositivo, esegui uno dei seguenti comandi. Per le piattaforme Raspbian: ``` sudo reboot ``` Per le piattaforme: OpenWrt ``` reboot ``` 1. Dopo il riavvio avvio del dispositivo, apri il terminale e fornisci le credenziali come variabili di ambiente. ``` export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE= ``` 1. Riavvia lo script. ``` sudo -E ./gg-device-setup-latest.sh bootstrap-greengrass ``` 1. Quando viene chiesto se utilizzare i valori di input della sessione precedente o avviare una nuova installazione, immetti `yes` per riutilizzare i valori di input. **Nota** Sulle piattaforme che richiedono un riavvio, tutti i valori di input (ad eccezione delle credenziali) della sessione precedente vengono temporaneamente memorizzati nel file `GreengrassDeviceSetup.config.info`. Al termine dell'installazione, il terminale visualizza un messaggio di stato di successo simile al seguente. ![\[Messaggio di successo nell'output del terminale.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/quick-start-completed.png) 1. Se hai incluso la funzione Hello World Lambda, la configurazione del dispositivo Greengrass distribuisce il gruppo Greengrass sul tuo dispositivo principale. Per testare la funzione Lambda o per informazioni su come rimuovere la funzione Lambda dal gruppo, continua con il Modulo 3-1 del tutorial [Verifica che la funzione Lambda sia in esecuzione sul dispositivo principale](lambda-check.md) Getting Started. **Nota** Assicurati che quello Regione AWS selezionato nella console sia lo stesso che hai usato per configurare l'ambiente Greengrass. Per impostazione predefinita, la regione è Stati Uniti occidentali (Oregon). Se non hai incluso la funzione Hello World Lambda, puoi [creare la tua funzione Lambda o provare altre funzionalità](create-lambda.md) di Greengrass. Ad esempio, puoi aggiungere il connettore di [distribuzione dell'applicazione Docker](docker-app-connector.md) al gruppo e utilizzarlo per distribuire contenitori Docker nel dispositivo principale.   #### Fornire le credenziali come valori di input 1. Scarica e avvia lo script. [Fornisci le credenziali](#gg-device-setup-credentials) e gli altri valori di input che desideri specificare. Negli esempi seguenti viene illustrato come fornire credenziali temporanee, che includono il token di sessione. + Per utilizzare tutti i valori predefiniti: ``` wget -q -O ./gg-device-setup-latest.sh https://d1onfpft10uf5o.cloudfront.net/greengrass-device-setup/downloads/gg-device-setup-latest.sh && chmod +x ./gg-device-setup-latest.sh && sudo -E ./gg-device-setup-latest.sh bootstrap-greengrass --aws-access-key-id AKIAIOSFODNN7EXAMPLE --aws-secret-access-key wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY --aws-session-token AQoDYXdzEJr1K...o5OytwEXAMPLE= ``` + Per specificare valori personalizzati: ``` wget -q -O ./gg-device-setup-latest.sh https://d1onfpft10uf5o.cloudfront.net/greengrass-device-setup/downloads/gg-device-setup-latest.sh && chmod +x ./gg-device-setup-latest.sh && sudo -E ./gg-device-setup-latest.sh bootstrap-greengrass --aws-access-key-id AKIAIOSFODNN7EXAMPLE --aws-secret-access-key wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY --aws-session-token AQoDYXdzEJr1K...o5OytwEXAMPLE= --region us-east-1 --group-name Custom_Group_Name --core-name Custom_Core_Name --ggc-root-path /custom/ggc/root/path --deployment-timeout 300 --log-path /customized/log/path --hello-world-lambda --verbose ``` **Nota** Se stai eseguendo la configurazione del dispositivo Greengrass su una piattaforma Raspbian o su una OpenWrt piattaforma, crea una copia delle tue credenziali. Devi fornirli nuovamente dopo il riavvio del dispositivo. Per utilizzare `curl` per scaricare lo script, sostituisci `wget -q -O` con `curl` nel comando. 1. Se il tuo dispositivo principale esegue Raspbian oppure OpenWrt, riavvia il dispositivo quando richiesto, fornisci le tue credenziali e quindi riavvia lo script. 1. Quando viene richiesto di riavviare il dispositivo, esegui uno dei seguenti comandi. Per le piattaforme Raspbian: ``` sudo reboot ``` Per le piattaforme: OpenWrt ``` reboot ``` 1. Riavvia lo script. Devi includere le credenziali nel comando, ma non gli altri valori di input. Per esempio: ``` sudo -E ./gg-device-setup-latest.sh bootstrap-greengrass --aws-access-key-id AKIAIOSFODNN7EXAMPLE --aws-secret-access-key wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY --aws-session-token AQoDYXdzEJr1K...o5OytwEXAMPLE= ``` 1. Quando viene chiesto se utilizzare i valori di input della sessione precedente o avviare una nuova installazione, immetti `yes` per riutilizzare i valori di input. **Nota** Sulle piattaforme che richiedono un riavvio, tutti i valori di input (ad eccezione delle credenziali) della sessione precedente vengono temporaneamente memorizzati nel file `GreengrassDeviceSetup.config.info`. Al termine dell'installazione, il terminale visualizza un messaggio di stato di successo simile al seguente. ![\[Messaggio di successo nell'output del terminale.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/quick-start-completed.png) 1. Se hai incluso la funzione Hello World Lambda, la configurazione del dispositivo Greengrass distribuisce il gruppo Greengrass sul tuo dispositivo principale. Per testare la funzione Lambda o per informazioni su come rimuovere la funzione Lambda dal gruppo, continua con il Modulo 3-1 del tutorial [Verifica che la funzione Lambda sia in esecuzione sul dispositivo principale](lambda-check.md) Getting Started. **Nota** Assicurati che quello Regione AWS selezionato nella console sia lo stesso che hai usato per configurare l'ambiente Greengrass. Per impostazione predefinita, la regione è Stati Uniti occidentali (Oregon). Se non hai incluso la funzione Hello World Lambda, puoi [creare la tua funzione Lambda o provare altre funzionalità](create-lambda.md) di Greengrass. Ad esempio, puoi aggiungere il connettore di [distribuzione dell'applicazione Docker](docker-app-connector.md) al gruppo e utilizzarlo per distribuire contenitori Docker nel dispositivo principale.   # Modulo 1: impostazione dell'ambiente per Greengrass Questo modulo mostra come preparare un out-of-the-box Raspberry Pi, un' EC2 istanza Amazon o un altro dispositivo per essere utilizzato AWS IoT Greengrass come dispositivo AWS IoT Greengrass principale. **Suggerimento** Oppure, per utilizzare uno script che configuri automaticamente il dispositivo core, consulta [Avvio rapido: configurazione dispositivo Greengrass](quick-start.md). Il completamento di questo modulo dovrebbe richiedere meno di 30 minuti. Prima di iniziare, leggi i [requisiti](gg-gs.md#gg-requirements) per questo tutorial. Segui quindi le istruzioni di installazione in uno dei seguenti argomenti. Scegli solo l'argomento che si applica al tipo di dispositivo principale. **Topics** + [Impostazione di un Raspberry Pi](setup-filter.rpi.md) + [Configurazione di un' EC2 istanza Amazon](setup-filter.ec2.md) + [Configurazione di altri dispositivi](setup-filter.other.md) **Nota** Per informazioni su come utilizzare l' AWS IoT Greengrass esecuzione in un contenitore Docker predefinito, consulta. [Esecuzione AWS IoT Greengrass in un contenitore Docker](run-gg-in-docker-container.md) # Impostazione di un Raspberry Pi Segui i passaggi descritti in questo argomento per configurare un Raspberry Pi da utilizzare come AWS IoT Greengrass core. **Suggerimento** AWS IoT Greengrass fornisce anche altre opzioni per l'installazione del software AWS IoT Greengrass Core. Ad esempio, è possibile utilizzare la [configurazione del dispositivo Greengrass](quick-start.md) per configurare l'ambiente e installare l'ultima versione del software AWS IoT Greengrass Core. Oppure, sulle piattaforme Debian supportate, è possibile utilizzare il [gestore di pacchetti APT](install-ggc.md#ggc-package-manager) per installare o aggiornare il AWS IoT Greengrass software Core. Per ulteriori informazioni, consulta [Installare il software AWS IoT Greengrass Core](install-ggc.md). Se stai impostando un Raspberry Pi per la prima volta, è necessario seguire tutti questi passaggi. In caso contrario, passa alla [fase 9](#add-ggc-user-ggc-group). Tuttavia, ti consigliamo di reimpostare il tuo Raspberry Pi con il sistema operativo come raccomandato nel passaggio 2.   1. Scaricate e installate un formattatore di schede SD come [SD Memory](https://www.sdcard.org/downloads/formatter/) Card Formatter. Inserisci la scheda SD nel computer. Avvia il programma e scegli l'unità in cui è inserita la scheda SD. È possibile formattare rapidamente la scheda SD. 1. Scarica il sistema operativo [Raspbian Buster](https://downloads.raspberrypi.org/raspbian/images/raspbian-2020-02-14/) come file `zip`. 1. Utilizzando uno strumento di scrittura su scheda SD (ad esempio [Etcher](https://etcher.io/)), segui le istruzioni per trasferire il file `zip` scaricato nella scheda SD. Poiché l'immagine del sistema operativo è di grandi dimensioni, l'operazione potrebbe richiedere alcuni minuti. Espelli la scheda SD dal computer e inserisci la scheda MicroSD nel Raspberry Pi. 1. Per il primo avvio, ti consigliamo di connettere il Raspberry Pi a un monitor (tramite HDMI), una tastiera e un mouse. Quindi, collega il Pi a una sorgente di alimentazione micro USB e il sistema operativo Raspbian dovrebbe avviarsi. 1. È possibile configurare il layout della tastiera del Pi prima di continuare. Per farlo, scegli l'icona Raspberry in alto a destra, scegli **Preferences (Preferenze)**, quindi **Mouse and Keyboard Settings (Impostazioni mouse e tastiera)**. Quindi, sulla scheda **Keyboard (Tastiera)** scegli, **Keyboard Layout (Layout tastiera)** e scegli una variante adatta di tastiera. 1. Quindi, [collega il Raspberry Pi a Internet tramite una rete Wi-Fi](https://www.raspberrypi.org/documentation/configuration/wireless/desktop.md) o un cavo Ethernet. **Nota** Collega il Raspberry Pi alla *stessa* rete a cui è connesso il computer e accertati che sia il computer che il Raspberry Pi abbiano accesso a Internet prima di continuare. Se ti trovi in un ambiente di lavoro o dietro un firewall, potrebbe essere necessario collegare il Pi e il computer alla rete guest per avere entrambi i dispositivi sulla stessa rete. Questo approccio, tuttavia, potrebbe scollegare il computer dalle risorse di rete locali, ad esempio l'Intranet. Una soluzione potrebbe essere quella di collegare il Pi alla rete Wi-Fi guest e il computer alla rete Wi-Fi guest *e* alla rete locale tramite un cavo Ethernet. Con questa configurazione dovresti essere in grado di connetterti al Raspberry Pi tramite la rete Wi-Fi guest e alle risorse di rete locali tramite il cavo Ethernet. 1. È necessario configurare [SSH](https://en.wikipedia.org/wiki/Secure_Shell) sul Pi per connetterti in remoto. Apri una [finestra del terminale](https://www.raspberrypi.org/documentation/usage/terminal/) sul Raspberry Pi ed esegui il comando seguente: ``` sudo raspi-config ``` Verrà visualizzato un codice analogo al seguente: ![\[Screenshot dello strumento di configurazione del software Raspberry Pi (raspi-config).\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-001.png) Scorri in basso e scegli **Interfacing Options (Opzioni di interfaccia)**, quindi scegli **P2 SSH**. Quando viene richiesto, scegliere **Yes (Sì)**. (Utilizza la chiave Tab seguita da Enter). L'SSH deve essere abilitata. Scegli **OK**. Usa il tasto Tab per scegliere **Finish (Fine)** e quindi premi Enter. Se il dispositivo Raspberry Pi non si riavvia automaticamente, esegui il comando seguente: ``` sudo reboot ``` 1. Esegui il comando seguente nel terminale del Raspberry Pi: ``` hostname -I ``` Questo restituisce l'indirizzo IP del Raspberry Pi. **Nota** Successivamente, se ricevi un messaggio relativo all'impronta della chiave ECDSA (`Are you sure you want to continue connecting (yes/no)?`), immetti `yes`. La password predefinita per il Raspberry Pi è **raspberry**. Se utilizzi macOS, apri una finestra del terminale e digita: ``` ssh pi@IP-address ``` *IP-address*è l'indirizzo IP del tuo Raspberry Pi che hai ottenuto utilizzando il comando. `hostname -I` Se stai usando Windows, è necessario installare e configurare [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html). Apri **Connection (Connessione)**, **Data (Dati)** e accertati che sia selezionato **Prompt**: ![\[Finestra di PuTTY con "Prompt" selezionato.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-001.4.png) Quindi, scegli **Session (Sessione)**, immetti l'indirizzo IP del Raspberry Pi e scegli **Open (Apri)** utilizzando le impostazioni predefinite. ![\[Finestra di PuTTY con l'indirizzo IP nel campo "Host Name (or IP address)".\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-001.5.png) Se viene visualizzato il messaggio " PuTTY security alert", scegli **Yes (Sì)**. I valori predefiniti di login e password di Raspberry Pi sono rispettivamente **pi** e **raspberry**. ![\[Finestra del terminale iniziale di PuTTY.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-001.6.png) **Nota** Se il computer è connesso a una rete remota tramite VPN, questo può causare difficoltà di connessione dal computer al Raspberry Pi tramite SSH. 1. Ora sei pronto per configurare il Raspberry Pi per. AWS IoT Greengrass In primo luogo, esegui i seguenti comandi da una finestra del terminale locale del Raspberry Pi o da una finestra del terminale SSH: **Suggerimento** AWS IoT Greengrass fornisce anche altre opzioni per l'installazione del software AWS IoT Greengrass Core. Ad esempio, è possibile utilizzare la [configurazione del dispositivo Greengrass](quick-start.md) per configurare l'ambiente e installare l'ultima versione del software AWS IoT Greengrass Core. Oppure, sulle piattaforme Debian supportate, è possibile utilizzare il [gestore di pacchetti APT](install-ggc.md#ggc-package-manager) per installare o aggiornare il AWS IoT Greengrass software Core. Per ulteriori informazioni, consulta [Installare il software AWS IoT Greengrass Core](install-ggc.md). ``` sudo adduser --system ggc_user sudo addgroup --system ggc_group ``` 1. Per migliorare la sicurezza sul dispositivo Pi, abilitare la protezione hardlink e softlink (symlink) sul sistema operativo all'avvio. 1. Andare al file `98-rpi.conf`. ``` cd /etc/sysctl.d ls ``` **Nota** Se non visualizzi il file `98-rpi.conf`, segui le istruzioni contenute nel file `README.sysctl`. 1. Utilizza un editor di testo (ad esempio Leafpad, GNU nano o vi) per aggiungere le seguenti due righe alla fine del file. Potresti dover utilizzare il comando `sudo` per modificare come root (ad esempio `sudo nano 98-rpi.conf`). ``` fs.protected_hardlinks = 1 fs.protected_symlinks = 1 ``` 1. Riavvia il dispositivo Pi. ``` sudo reboot ``` Dopo un minuto circa, connettiti al dispositivo Pi tramite SSH, quindi esegui il comando seguente per confermare la modifica: ``` sudo sysctl -a 2> /dev/null | grep fs.protected ``` Dovresti visualizzare `fs.protected_hardlinks = 1` e `fs.protected_symlinks = 1`. 1. Modifica il file di avvio a riga di comando per abilitare e montare cgroups di memoria. Ciò consente di AWS IoT Greengrass impostare il limite di memoria per le funzioni Lambda. I Cgroup devono inoltre essere eseguiti AWS IoT Greengrass nella modalità di [containerizzazione](lambda-group-config.md#lambda-containerization-considerations) predefinita. 1. Passa alla directory `boot`. ``` cd /boot/ ``` 1. Aprire il file `cmdline.txt` con un editor di testo. Aggiungi quanto segue alla fine della linea esistente, non come una nuova riga. Potresti dover utilizzare il comando `sudo` per modificare come root (ad esempio `sudo nano cmdline.txt`). ``` cgroup_enable=memory cgroup_memory=1 ``` 1. Ora riavvia il dispositivo Pi. ``` sudo reboot ``` Il Raspberry Pi dovrebbe essere pronto per AWS IoT Greengrass. 1. Facoltativo. Installare il runtime Java 8, richiesto dal [Gestore di flussi](stream-manager.md). Questo tutorial non utilizza Gestore di flussi, ma utilizza il flusso di lavoro **Creazione gruppo predefinito** che abilita Gestore di flussi per impostazione predefinita. Utilizzare i seguenti comandi per installare il runtime Java 8 sul dispositivo principale o disabilitare Gestore di flussi prima di distribuire il gruppo. Le istruzioni per disabilitare Gestore di flussi sono fornite nel Modulo 3. ``` sudo apt install openjdk-8-jdk ``` 1. [Per assicurarti di avere tutte le dipendenze necessarie, scarica ed esegui il controllo delle dipendenze Greengrass dal AWS IoT Greengrass repository Samples in poi.](https://github.com/aws-samples/aws-greengrass-samples) GitHub Questi comandi decomprimono ed eseguono lo script di controllo delle dipendenze nella directory. `Downloads` **Nota** Il controllo delle dipendenze potrebbe fallire se si utilizza la versione 5.4.51 del kernel Raspbian. Questa versione non monta correttamente i cgroup di memoria. Ciò potrebbe causare il fallimento delle funzioni Lambda eseguite in modalità contenitore. Per ulteriori informazioni sull'aggiornamento del kernel, consulta i [Cgroups non caricati dopo l'aggiornamento del kernel](https://www.raspberrypi.org/forums/viewtopic.php?t=280656) nei forum di Raspberry Pi. ``` cd /home/pi/Downloads mkdir greengrass-dependency-checker-GGCv1.11.x cd greengrass-dependency-checker-GGCv1.11.x wget https://github.com/aws-samples/aws-greengrass-samples/raw/master/greengrass-dependency-checker-GGCv1.11.x.zip unzip greengrass-dependency-checker-GGCv1.11.x.zip cd greengrass-dependency-checker-GGCv1.11.x sudo modprobe configs sudo ./check_ggc_dependencies | more ``` Dove viene visualizzato `more`, premi il tasto Spacebar per visualizzare un'altra schermata di testo. **Importante** Questo tutorial richiede il runtime di Python 3.7 per eseguire le funzioni Lambda locali. Quando il gestore di flusso è abilitato, richiede anche il runtime Java 8. Se lo script `check_ggc_dependencies` produce avvisi su questi prerequisiti di runtime mancanti, assicurati di installarli prima di continuare. Puoi ignorare gli avvisi relativi ad altri prerequisiti di runtime facoltativi mancanti. Per informazioni sul comando **modprobe**, esegui **man modprobe** nel terminale. La configurazione del Raspberry Pi è completa. Continua su [Modulo 2: Installazione del software AWS IoT Greengrass Core](module2.md). # Configurazione di un' EC2 istanza Amazon Segui i passaggi descritti in questo argomento per configurare un' EC2 istanza Amazon da utilizzare come AWS IoT Greengrass core. **Suggerimento** Oppure, per utilizzare uno script che configura il tuo ambiente e installa il software AWS IoT Greengrass Core per te, consulta[Avvio rapido: configurazione dispositivo Greengrass](quick-start.md). Sebbene sia possibile completare questo tutorial utilizzando un' EC2 istanza Amazon, idealmente AWS IoT Greengrass dovrebbe essere utilizzato con hardware fisico. Ti consigliamo di [configurare un Raspberry Pi](setup-filter.rpi.md) invece di utilizzare un' EC2 istanza Amazon quando possibile. Se si utilizza un Raspberry Pi, non è necessario seguire la procedura descritta in questo argomento.   1. Accedi [Console di gestione AWS](https://console.aws.amazon.com/)e avvia un' EC2 istanza Amazon utilizzando un'AMI Amazon Linux. Per informazioni sulle EC2 istanze Amazon, consulta la [Amazon EC2 Getting Started Guide](https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/). 1. Dopo l'esecuzione dell' EC2 istanza Amazon, abilita la porta 8883 per consentire le comunicazioni MQTT in entrata in modo che altri dispositivi possano connettersi al core. AWS IoT Greengrass 1. Nel pannello di navigazione della EC2 console Amazon, scegli **Gruppi di sicurezza**. ![\[Riquadro di navigazione con i gruppi di sicurezza evidenziati.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-002.6.1.png) 1. Seleziona il gruppo di sicurezza per l'istanza appena avviata, quindi scegli la scheda **Regole in entrata**. 1. Sceglere **Edit inbound rules (Modifica regole in entrata)**. Per abilitare la porta 8883, aggiungi una regola TCP personalizzata al gruppo di sicurezza. Per ulteriori informazioni, consulta [Aggiungere regole a un gruppo di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule) nella *Amazon EC2 User Guide*. 1. Nella pagina **Modifica regole in entrata**, scegli **Aggiungi regola**, inserisci le seguenti impostazioni, quindi scegli **Salva**. + Per **Type (Tipo)** seleziona **Custom TCP Rule (Regola TCP personalizzata)**. + Per **Port range**, inserisci**8883**. + Per **Source (Origine)**, selezionare **Anywhere (Ovunque)**. + Per **Descrizione**, inserisci **MQTT Communications**.   1. Connect alla tua EC2 istanza Amazon. 1. Nel riquadro di navigazione, scegli **Instances (Istanze)**, seleziona la tua istanza, quindi scegli **Connect (Connetti)**. 1. Segui le istruzioni nella pagina **Connect To Your Instance (Connettiti alla tua istanza)** per connetterti all'istanza [ tramite SSH](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html) e il tuo file della chiave privata. È possibile utilizzare [PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html) per Windows o Terminal per macOS. Per ulteriori informazioni, consulta [Connect to your Linux istance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) nella *Amazon EC2 User Guide*. Ora sei pronto per configurare la tua EC2 istanza Amazon per AWS IoT Greengrass. 1. Dopo esserti connesso alla tua EC2 istanza Amazon, crea gli `ggc_group` account `ggc_user` e: ``` sudo adduser --system ggc_user sudo groupadd --system ggc_group ``` **Nota** Se il comando `adduser` non è disponibile nel sistema, utilizza il comando seguente. ``` sudo useradd --system ggc_user ``` 1. Per migliorare la sicurezza, assicurati che le protezioni hardlink e softlink (symlink) siano abilitate sul sistema operativo dell'istanza Amazon EC2 all'avvio. **Nota** Le procedure di abilitazione hardlink e softlink possono variare a seconda del sistema operativo. Consultare la documentazione per la distribuzione. 1. Eseguire il comando seguente per controllare se le protezioni hardlink e softlink sono abilitate: ``` sudo sysctl -a | grep fs.protected ``` Se hardlink e softlink vengono impostati su `1`, le protezioni sono abilitate correttamente. Continuare con la fase 6. **Nota** I softlink sono rappresentati da `fs.protected_symlinks`. 1. Se hardlink e softlink non sono impostati su `1`, abilitare queste protezioni. Navigare al file di configurazione del sistema. ``` cd /etc/sysctl.d ls ``` 1. Utilizza il tuo editor di testo preferito (ad esempio Leafpad, GNU nano o vi) per aggiungere le seguenti due righe alla fine del file di configurazione del sistema. Su Amazon Linux 1, questo è il file `00-defaults.conf`. Su Amazon Linux 2, questo è il file `99-amazon.conf`. Potrebbe essere necessario modificare le autorizzazioni (utilizzando il comando `chmod`) per scrivere sul file oppure utilizzare il comando `sudo` per modificare come root (ad esempio `sudo nano 00-defaults.conf`). ``` fs.protected_hardlinks = 1 fs.protected_symlinks = 1 ``` 1. Riavvia l' EC2 istanza Amazon. ``` sudo reboot ``` Dopo pochi minuti, connettiti all'istanza tramite SSH, quindi esegui il comando seguente per confermare la modifica. ``` sudo sysctl -a | grep fs.protected ``` Dovresti vedere che hardlink e softlink sono impostati a 1. 1. Estrai ed esegui il seguente script per montare i [gruppi di controllo Linux](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/resource_management_guide/ch01) (cgroups). Ciò consente di AWS IoT Greengrass impostare il limite di memoria per le funzioni Lambda. I Cgroup devono inoltre essere eseguiti AWS IoT Greengrass nella modalità di [containerizzazione](lambda-group-config.md#lambda-containerization-considerations) predefinita. ``` curl https://raw.githubusercontent.com/tianon/cgroupfs-mount/951c38ee8d802330454bdede20d85ec1c0f8d312/cgroupfs-mount > cgroupfs-mount.sh chmod +x cgroupfs-mount.sh sudo bash ./cgroupfs-mount.sh ``` La tua EC2 istanza Amazon dovrebbe ora essere pronta per AWS IoT Greengrass. 1. Facoltativo. Installare il runtime Java 8, richiesto dal [Gestore di flussi](stream-manager.md). Questo tutorial non utilizza Gestore di flussi, ma utilizza il flusso di lavoro **Creazione gruppo predefinito** che abilita Gestore di flussi per impostazione predefinita. Utilizzare i seguenti comandi per installare il runtime Java 8 sul dispositivo principale o disabilitare Gestore di flussi prima di distribuire il gruppo. Le istruzioni per disabilitare Gestore di flussi sono fornite nel Modulo 3. + Per le distribuzioni basate su Debian: ``` sudo apt install openjdk-8-jdk ``` + Per le distribuzioni basate su Red Hat: ``` sudo yum install java-1.8.0-openjdk ``` 1. [Per assicurarti di avere tutte le dipendenze necessarie, scarica ed esegui il controllo delle dipendenze Greengrass dal AWS IoT Greengrass repository Samples in poi.](https://github.com/aws-samples/aws-greengrass-samples) GitHub Questi comandi scaricano, decomprimono ed eseguono lo script di controllo delle dipendenze nella tua istanza Amazon. EC2 ``` mkdir greengrass-dependency-checker-GGCv1.11.x cd greengrass-dependency-checker-GGCv1.11.x wget https://github.com/aws-samples/aws-greengrass-samples/raw/master/greengrass-dependency-checker-GGCv1.11.x.zip unzip greengrass-dependency-checker-GGCv1.11.x.zip cd greengrass-dependency-checker-GGCv1.11.x sudo ./check_ggc_dependencies | more ``` **Importante** Questo tutorial richiede il runtime di Python 3.7 per eseguire le funzioni Lambda locali. Quando il gestore di flusso è abilitato, richiede anche il runtime Java 8. Se lo script `check_ggc_dependencies` produce avvisi su questi prerequisiti di runtime mancanti, assicurati di installarli prima di continuare. Puoi ignorare gli avvisi relativi ad altri prerequisiti di runtime facoltativi mancanti. La configurazione dell' EC2 istanza Amazon è completa. Continua su [Modulo 2: Installazione del software AWS IoT Greengrass Core](module2.md). # Configurazione di altri dispositivi Segui i passaggi descritti in questo argomento per configurare un dispositivo (diverso da un Raspberry Pi) da utilizzare come AWS IoT Greengrass core. **Suggerimento** Oppure, per utilizzare uno script che configura il tuo ambiente e installa il software AWS IoT Greengrass Core per te, consulta. [Avvio rapido: configurazione dispositivo Greengrass](quick-start.md) Se non lo usi AWS IoT Greengrass, ti consigliamo di utilizzare un' EC2istanza Raspberry Pi o Amazon come dispositivo principale e di seguire i [passaggi di configurazione](module1.md) appropriati per il tuo dispositivo. Se hai intenzione di creare un sistema personalizzato basato su Linux utilizzando il progetto Yocto, puoi utilizzare la Bitbake Recipe del AWS IoT Greengrass progetto. `meta-aws` Questa ricetta aiuta anche a sviluppare una piattaforma software che supporti AWS il software edge per applicazioni integrate. La build Bitbake installa, configura ed esegue automaticamente il software AWS IoT Greengrass Core sul dispositivo. Progetto Yocto Un progetto di collaborazione open source che consente di creare sistemi personalizzati basati su Linux per applicazioni integrate indipendentemente dall'architettura hardware. [Per ulteriori informazioni, consulta il progetto Yocto.](https://www.yoctoproject.org/) `meta-aws` Un progetto AWS gestito che fornisce ricette Yocto. Puoi usare le ricette per sviluppare software AWS edge in sistemi basati su Linux creati con Yocto Project. [OpenEmbedded](https://www.openembedded.org/wiki/Main_Page) Per ulteriori informazioni su questa funzionalità supportata dalla comunità, consulta il progetto su. [https://github.com/aws/meta-aws](https://github.com/aws/meta-aws) GitHub `meta-aws-demos` Un progetto AWS gestito che contiene dimostrazioni del `meta-aws` progetto. Per altri esempi sul processo di integrazione, consulta il [https://github.com/aws-samples/meta-aws-demos](https://github.com/aws-samples/meta-aws-demos)progetto su GitHub. Per utilizzare un dispositivo diverso o un'altra [piattaforma supportata](what-is-gg.md#gg-platforms), seguire i passaggi descritti in questo argomento. 1. Se il tuo dispositivo principale è un dispositivo NVIDIA Jetson, devi prima eseguire il flashing del firmware con il JetPack programma di installazione 4.3. Se stai configurando un altro dispositivo, passa alla fase 2. **Nota** La versione di JetPack installazione che utilizzi si basa sulla versione di CUDA Toolkit di destinazione. Le seguenti istruzioni utilizzano JetPack 4.3 e CUDA Toolkit 10.0. Per informazioni sull'utilizzo delle versioni appropriate per il dispositivo, consulta [How to Install Jetpack](https://docs.nvidia.com/jetson/jetpack/install-jetpack/index.html) nella documentazione di NVIDIA. 1. Su un desktop fisico che esegue Ubuntu 16.04 o versione successiva, esegui il flashing del firmware con il programma di installazione JetPack 4.3, come descritto in [Download e installazione JetPack](https://docs.nvidia.com/jetson/archives/jetpack-archived/jetpack-33/index.html#jetpack/3.3/install.htm%3FTocPath%3D_____3) (4.3) nella documentazione NVIDIA. Segui le istruzioni del programma di installazione per installare tutti i pacchetti e le dipendenze sulla scheda Jetson, che deve essere connessa al desktop con un cavo Micro-B. 1. Riavvia la scheda in modalità normale e connetti un display alla scheda. **Nota** Quando utilizzi SSH per connetterti alla scheda Jetson, utilizza il nome utente predefinito (**nvidia**) e la password predefinita (**nvidia**). 1. Esegui i seguenti comandi per creare l'utente `ggc_user` e il gruppo `ggc_group`. I comandi che esegui variano a seconda della distribuzione installata sul dispositivo core. + Se il dispositivo principale è in esecuzione OpenWrt, esegui i seguenti comandi: ``` opkg install shadow-useradd opkg install shadow-groupadd useradd --system ggc_user groupadd --system ggc_group ``` + In caso contrario, esegui i comandi seguenti: ``` sudo adduser --system ggc_user sudo addgroup --system ggc_group ``` **Nota** Se il comando `addgroup` non è disponibile nel sistema, utilizza il comando seguente. ``` sudo groupadd --system ggc_group ``` 1. Facoltativo. Installare il runtime Java 8, richiesto dal [Gestore di flussi](stream-manager.md). Questo tutorial non utilizza Gestore di flussi, ma utilizza il flusso di lavoro **Creazione gruppo predefinito** che abilita Gestore di flussi per impostazione predefinita. Utilizzare i seguenti comandi per installare il runtime Java 8 sul dispositivo principale o disabilitare Gestore di flussi prima di distribuire il gruppo. Le istruzioni per disabilitare Gestore di flussi sono fornite nel Modulo 3. + Per le distribuzioni basate su Debian o basate su Ubuntuu: ``` sudo apt install openjdk-8-jdk ``` + Per le distribuzioni basate su Red Hat: ``` sudo yum install java-1.8.0-openjdk ``` 1. [Per assicurarti di avere tutte le dipendenze necessarie, scarica ed esegui il controllo delle dipendenze Greengrass dal AWS IoT Greengrass repository Samples in poi.](https://github.com/aws-samples/aws-greengrass-samples) GitHub Questi comandi decomprimono ed eseguono lo script di controllo delle dipendenze. ``` mkdir greengrass-dependency-checker-GGCv1.11.x cd greengrass-dependency-checker-GGCv1.11.x wget https://github.com/aws-samples/aws-greengrass-samples/raw/master/greengrass-dependency-checker-GGCv1.11.x.zip unzip greengrass-dependency-checker-GGCv1.11.x.zip cd greengrass-dependency-checker-GGCv1.11.x sudo ./check_ggc_dependencies | more ``` **Nota** Lo `check_ggc_dependencies` script viene eseguito su piattaforme AWS IoT Greengrass supportate e richiede comandi di sistema Linux specifici. Per ulteriori informazioni, consulta il file [Readme](https://github.com/aws-samples/aws-greengrass-samples/blob/master/greengrass-dependency-checker-GGCv1.11.x/README.md) dello strumento di controllo delle dipendenze. 1. Installa tutte le dipendenze necessarie sul dispositivo, come indicato dall'output dello strumento di controllo delle dipendenze. Per dipendenze mancanti a livello di kernel, potrebbe essere necessario ricompilare il kernel. Per montare i gruppi di controllo Linux (`cgroups`), è possibile eseguire lo script [cgroupfs-mount](https://raw.githubusercontent.com/tianon/cgroupfs-mount/master/cgroupfs-mount). Ciò consente di AWS IoT Greengrass impostare il limite di memoria per le funzioni Lambda. I Cgroup devono inoltre essere eseguiti AWS IoT Greengrass nella modalità di [containerizzazione](lambda-group-config.md#lambda-containerization-considerations) predefinita. Se non compaiono errori nell'output, AWS IoT Greengrass dovrebbe essere in grado di funzionare correttamente sul dispositivo. **Importante** Questo tutorial richiede il runtime di Python 3.7 per eseguire le funzioni Lambda locali. Quando il gestore di flusso è abilitato, richiede anche il runtime Java 8. Se lo script `check_ggc_dependencies` produce avvisi su questi prerequisiti di runtime mancanti, assicurati di installarli prima di continuare. Puoi ignorare gli avvisi relativi ad altri prerequisiti di runtime facoltativi mancanti. Per l'elenco dei AWS IoT Greengrass requisiti e delle dipendenze, vedi. [Piattaforme supportate e requisiti](what-is-gg.md#gg-platforms) # Modulo 2: Installazione del software AWS IoT Greengrass Core Questo modulo mostra come installare il software AWS IoT Greengrass Core sul dispositivo scelto. In questo modulo, si crea innanzitutto un gruppo e un core di Greengrass. Quindi, scaricare, configurare e avviare il software sul dispositivo core. Per ulteriori informazioni sulle funzionalità del software AWS IoT Greengrass Core, consulta [Configura il AWS IoT Greengrass core](gg-core.md). Prima di iniziare, assicurarsi di aver completato la procedura di configurazione nel [Modulo 1](module1.md) per il dispositivo scelto. **Suggerimento** AWS IoT Greengrass fornisce anche altre opzioni per l'installazione del software AWS IoT Greengrass Core. Ad esempio, è possibile utilizzare la [configurazione del dispositivo Greengrass](quick-start.md) per configurare l'ambiente e installare l'ultima versione del software AWS IoT Greengrass Core. Oppure, sulle piattaforme Debian supportate, è possibile utilizzare il [gestore di pacchetti APT](install-ggc.md#ggc-package-manager) per installare o aggiornare il AWS IoT Greengrass software Core. Per ulteriori informazioni, consulta [Installare il software AWS IoT Greengrass Core](install-ggc.md). Il completamento di questo modulo dovrebbe richiedere meno di 30 minuti. **Topics** + [Fornitura di AWS IoT qualsiasi cosa da utilizzare come core Greengrass](provision-core.md) + [Crea un AWS IoT Greengrass gruppo per il core](create-group.md) + [Installa ed esegui AWS IoT Greengrass sul dispositivo principale](start-greengrass.md) # Fornitura di AWS IoT qualsiasi cosa da utilizzare come core Greengrass I *core* Greengrass sono dispositivi che eseguono il software AWS IoT Greengrass Core per gestire i processi IoT locali. Per configurare un core Greengrass, crei un AWS IoT *oggetto*, che rappresenta un dispositivo o un'entità logica a cui si connette. AWS IoT Quando si registra un dispositivo come AWS IoT oggetto, quel dispositivo può utilizzare un certificato digitale e delle chiavi che gli consentono l'accesso AWS IoT. Si utilizza una [AWS IoT policy](https://docs.aws.amazon.com/iot/latest/developerguide/iot-policies.html) per consentire al dispositivo di comunicare con i AWS IoT Greengrass servizi AWS IoT and. In questa sezione, registri il tuo dispositivo come AWS IoT qualsiasi cosa per usarlo come core Greengrass. **Per creare qualsiasi cosa AWS IoT** 1. Passare alla [console AWS IoT](https://console.aws.amazon.com/iot). 1. In **Gestisci**, espandi **Tutti i dispositivi**, quindi scegli **Cose**. 1. Sulla pagina **Things (Oggetti)**, scegli **Create things (Creazione di oggetti)**. 1. Nella pagina **Crea elementi**, scegli **Crea un singolo elemento**, quindi scegli **Avanti**. 1. Nella pagina **Specificare le proprietà** dell'oggetto, procedi come segue: 1. Per **Nome oggetto**, immettere un nome che rappresenti il dispositivo, ad esempio**MyGreengrassV1Core**. 1. Scegli **Next (Successivo)**. 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 core, quindi scegli Crea oggetto.** Si apre una finestra modale in cui è possibile scaricare i certificati e le chiavi utilizzati dal dispositivo per connettersi a. Cloud AWS + Crea e allega una nuova politica che conceda le autorizzazioni principali del dispositivo. 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. **GreengrassV1CorePolicy** 1. Nella scheda **Dichiarazioni politiche**, in **Documento di politica**, scegli **JSON**. 1. Inserisci il seguente documento di policy. Questa policy consente al core di comunicare con il AWS IoT Core servizio, interagire con le ombre dei dispositivi e comunicare con il AWS IoT Greengrass servizio. Per informazioni su come limitare l'accesso a questa policy in base al tuo caso d'uso, consulta[AWS IoT Politica minima per il dispositivo AWS IoT Greengrass principale](device-auth.md#gg-config-sec-min-iot-policy). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iot:Publish", "iot:Subscribe", "iot:Connect", "iot:Receive" ], "Resource": [ "*" ] }, { "Effect": "Allow", "Action": [ "iot:GetThingShadow", "iot:UpdateThingShadow", "iot:DeleteThingShadow" ], "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 **GreengrassV1CorePolicy**. Se non vedi la politica, scegli il pulsante di aggiornamento. 1. Scegli **Create thing (Crea oggetto)**. Si apre una finestra modale in cui è possibile scaricare i certificati e le chiavi a cui il core utilizza per connettersi. AWS IoT 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 **GreengrassV1CorePolicy**. Se non vedi la politica, scegli il pulsante di aggiornamento. 1. Scegli **Create thing (Crea oggetto)**. Si apre una finestra modale in cui è possibile scaricare i certificati e le chiavi a cui il core utilizza per connettersi. AWS IoT 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. # Crea un AWS IoT Greengrass gruppo per il core AWS IoT Greengrass *i gruppi* contengono impostazioni e altre informazioni sui relativi componenti, come dispositivi client, funzioni Lambda e connettori. Un gruppo definisce la configurazione di un core, incluso il modo in cui i suoi componenti possono interagire tra loro. In questa sezione, crei un gruppo per il tuo core. **Suggerimento** Per un esempio che utilizza l' AWS IoT Greengrass API per creare e distribuire un gruppo, consulta il repository [gg\$1group\$1setup](https://github.com/awslabs/aws-greengrass-group-setup) su. GitHub **Per creare un gruppo per il core** 1. Passare alla [console AWS IoT](https://console.aws.amazon.com/iot). 1. In **Gestisci**, espandi **i dispositivi Greengrass** e scegli **Gruppi (V1)**. **Nota** Se non vedi il menu dei **dispositivi Greengrass**, passa a uno Regione AWS che supporti. AWS IoT Greengrass V1 Per l'elenco delle regioni supportate, consulta [Endpoint e quote AWS IoT Greengrass V1](https://docs.aws.amazon.com/general/latest/gr/greengrass.html) in *Riferimenti generali di AWS*. Devi [creare il dispositivo per AWS IoT il tuo core](provision-core.md) in una regione in cui AWS IoT Greengrass V1 è disponibile. 1. Nella pagina dei **gruppi Greengrass**, scegli **Crea** gruppo. 1. Nella pagina del **gruppo Create Greengrass**, effettuate le seguenti operazioni: 1. Per il **nome del gruppo Greengrass**, inserisci un nome che descriva il gruppo, ad esempio. **MyGreengrassGroup** 1. Per **Greengrass core**, scegli AWS IoT ciò che hai creato in precedenza, ad esempio **MyGreengrassV1Core**. La console seleziona automaticamente il certificato del dispositivo dell'oggetto. 1. Seleziona **Crea gruppo**. # Installa ed esegui AWS IoT Greengrass sul dispositivo principale **Nota** Questo tutorial fornisce istruzioni per eseguire il software AWS IoT Greengrass Core su un Raspberry Pi, ma puoi utilizzare qualsiasi dispositivo supportato. In questa sezione, configuri, installi ed esegui il software AWS IoT Greengrass Core sul tuo dispositivo principale. **Per installare ed eseguire AWS IoT Greengrass** 1. Dalla sezione [AWS IoT Greengrass Core software](what-is-gg.md#gg-core-download-tab) di questa guida, scaricate il pacchetto di installazione del software AWS IoT Greengrass Core. Scegli il pacchetto che meglio si adatta all'architettura della CPU, alla distribuzione e al sistema operativo del tuo dispositivo core. + Per Raspberry Pi, scarica il pacchetto per l'architettura ARMv7L e il sistema operativo Linux. + Per un' EC2 istanza Amazon, scarica il pacchetto per l'architettura x86\$164 e il sistema operativo Linux. + Per NVIDIA Jetson TX2, scarica il pacchetto per l'architettura Armv8 () e il sistema operativo Linux. AArch64 + Per Intel Atom, scarica il pacchetto per l'architettura x86\$164 e il sistema operativo Linux. 1. Nei passaggi precedenti, hai scaricato cinque file sul tuo computer: + `greengrass-OS-architecture-1.11.6.tar.gz`— Questo file compresso contiene il software AWS IoT Greengrass Core che viene eseguito sul dispositivo principale. + `certificateId-certificate.pem.crt`— Il file di certificato del dispositivo. + `certificateId-public.pem.key`— Il file della chiave pubblica del certificato del dispositivo. + `certificateId-private.pem.key`— Il file della chiave privata del certificato del dispositivo. + `AmazonRootCA1.pem`— Il file Amazon Root Certificate Authority (CA). In questa fase, trasferisci questi file dal computer al dispositivo principale. Esegui questa operazione: 1. Se non conosci l'indirizzo IP del tuo dispositivo principale Greengrass, apri un terminale sul dispositivo principale ed esegui il seguente comando. **Nota** Questo comando potrebbe non restituire l'indirizzo IP corretto per alcuni dispositivi. Consulta la documentazione del dispositivo per recuperare l'indirizzo IP del dispositivo. ``` hostname -I ``` 1. Trasferisci questi file dal computer al dispositivo principale. Le fasi di trasferimento dei file variano a seconda del sistema operativo del computer. Scegli il sistema operativo per le fasi che mostrano come trasferire i file sul tuo dispositivo Raspberry Pi. **Nota** Per un Raspberry Pi, il nome utente predefinito è **pi** e la password predefinita è **raspberry**. Per un NVIDIA Jetson TX2, il nome utente predefinito è **nvidia** e la password predefinita è. **nvidia** ------ #### [ Windows ] Per trasferire i file compressi dal computer a un dispositivo principale Raspberry Pi, utilizza uno strumento come [WinSCP](https://winscp.net/eng/download.php) oppure il comando [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html) **pscp** Per utilizzare il comando **pscp**, apri una finestra del prompt dei comandi sul computer ed esegui: ``` cd path-to-downloaded-files pscp -pw Pi-password greengrass-OS-architecture-1.11.6.tar.gz pi@IP-address:/home/pi pscp -pw Pi-password certificateId-certificate.pem.crt pi@IP-address:/home/pi pscp -pw Pi-password certificateId-public.pem.key pi@IP-address:/home/pi pscp -pw Pi-password certificateId-private.pem.key pi@IP-address:/home/pi pscp -pw Pi-password AmazonRootCA1.pem pi@IP-address:/home/pi ``` **Nota** Il numero di versione in questo comando deve corrispondere alla versione del pacchetto software AWS IoT Greengrass Core. ------ #### [ macOS ] Per trasferire i file compressi dal Mac a un dispositivo principale Raspberry Pi, apri una finestra del terminale sul computer ed esegui i comandi seguenti. In genere *path-to-downloaded-files* è`~/Downloads`. **Nota** Potrebbe esserti richiesto di immettere due password. In questo caso, la prima password è per il comando `sudo` del Mac e la seconda è la password per il Raspberry Pi. ``` cd path-to-downloaded-files scp greengrass-OS-architecture-1.11.6.tar.gz pi@IP-address:/home/pi scp certificateId-certificate.pem.crt pi@IP-address:/home/pi scp certificateId-public.pem.key pi@IP-address:/home/pi scp certificateId-private.pem.key pi@IP-address:/home/pi scp AmazonRootCA1.pem pi@IP-address:/home/pi ``` **Nota** Il numero di versione in questo comando deve corrispondere alla versione del pacchetto software AWS IoT Greengrass Core. ------ #### [ UNIX-like system ] Per trasferire i file compressi dal computer a un dispositivo principale Raspberry Pi, apri una finestra del terminale sul computer ed esegui i comandi seguenti: ``` cd path-to-downloaded-files scp greengrass-OS-architecture-1.11.6.tar.gz pi@IP-address:/home/pi scp certificateId-certificate.pem.crt pi@IP-address:/home/pi scp certificateId-public.pem.key pi@IP-address:/home/pi scp certificateId-private.pem.key pi@IP-address:/home/pi scp AmazonRootCA1.pem pi@IP-address:/home/pi ``` **Nota** Il numero di versione di questo comando deve corrispondere alla versione del pacchetto software AWS IoT Greengrass Core. ------ #### [ Raspberry Pi web browser ] Se hai utilizzato il browser web del Raspberry Pi per scaricare i file compressi, i file dovrebbero trovarsi nella `~/Downloads` cartella del Raspberry Pi, ad esempio. `/home/pi/Downloads` Altrimenti, i file compressi dovrebbero trovarsi nella `~` cartella del Pi, ad esempio. `/home/pi` ------ 1. Sul dispositivo principale Greengrass, apri un terminale e vai alla cartella che contiene il software e i AWS IoT Greengrass certificati Core. Sostituiscilo *path-to-transferred-files* con il percorso in cui hai trasferito i file sul dispositivo principale. Ad esempio, su un Raspberry Pi, `cd /home/pi` esegui. ``` cd path-to-transferred-files ``` 1. Disimballate il software AWS IoT Greengrass Core sul dispositivo principale. Esegui il comando seguente per decomprimere l'archivio software trasferito sul dispositivo principale. Questo comando utilizza l'`-C /`argomento per creare la `/greengrass` cartella nella cartella principale del dispositivo principale. ``` sudo tar -xzvf greengrass-OS-architecture-1.11.6.tar.gz -C / ``` **Nota** Il numero di versione di questo comando deve corrispondere alla versione del pacchetto software AWS IoT Greengrass Core. 1. Spostate i certificati e le chiavi nella cartella del software AWS IoT Greengrass Core. Esegui i seguenti comandi per creare una cartella per i certificati e spostarvi i certificati e le chiavi. Sostituiscila *path-to-transferred-files* con il percorso in cui hai trasferito i file sul dispositivo principale e *certificateId* sostituiscila con l'ID del certificato nei nomi dei file. Ad esempio, su un Raspberry Pi, sostituisci *path-to-transferred-files* con **/home/pi** ``` sudo mv path-to-transferred-files/certificateId-certificate.pem.crt /greengrass/certs sudo mv path-to-transferred-files/certificateId-public.pem.key /greengrass/certs sudo mv path-to-transferred-files/certificateId-private.pem.key /greengrass/certs sudo mv path-to-transferred-files/AmazonRootCA1.pem /greengrass/certs ``` 1. Il software AWS IoT Greengrass Core utilizza un file di configurazione che specifica i parametri del software. Questo file di configurazione specifica i percorsi dei file di certificato e gli Cloud AWS endpoint da utilizzare. In questo passaggio, crei il file di configurazione del software AWS IoT Greengrass Core per il tuo core. Esegui questa operazione: 1. Ottieni l'Amazon Resource Name (ARN) per le tue attività principali. AWS IoT Esegui questa operazione: 1. Nella [AWS IoT console](https://console.aws.amazon.com/iot), in **Gestione**, in **Dispositivi Greengrass**, scegli **Gruppi (V1**). 1. Nella pagina dei **gruppi Greengrass**, scegli il gruppo che hai creato in precedenza. 1. In **Panoramica**, scegli **Greengrass core**. 1. Nella pagina dei dettagli principali, copia l'**ARN dell'AWS IoT oggetto** e salvalo per utilizzarlo nel file di configurazione AWS IoT Greengrass Core. 1. Ottieni l'endpoint dei dati del AWS IoT dispositivo per la tua Account AWS regione corrente. I dispositivi utilizzano questo endpoint per connettersi a oggetti simili AWS . AWS IoT Esegui questa operazione: 1. Nella [AWS IoT console](https://console.aws.amazon.com/iot), scegli **Impostazioni.** 1. In **Device data endpoint**, copia l'**endpoint** e salvalo per utilizzarlo nel file di configurazione AWS IoT Greengrass principale. 1. Crea il file di configurazione del software AWS IoT Greengrass Core. Ad esempio, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file. ``` sudo nano /greengrass/config/config.json ``` Sostituisci il contenuto del file con il seguente documento JSON. ``` { "coreThing" : { "caPath": "AmazonRootCA1.pem", "certPath": "certificateId-certificate.pem.crt", "keyPath": "certificateId-private.pem.key", "thingArn": "arn:aws:iot:region:account-id:thing/MyGreengrassV1Core", "iotHost": "device-data-prefix-ats.iot.region.amazonaws.com", "ggHost": "greengrass-ats.iot.region.amazonaws.com", "keepAlive": 600 }, "runtime": { "cgroup": { "useSystemd": "yes" } }, "managedRespawn": false, "crypto": { "caPath": "file:///greengrass/certs/AmazonRootCA1.pem", "principals": { "SecretsManager": { "privateKeyPath": "file:///greengrass/certs/certificateId-private.pem.key" }, "IoTCertificate": { "privateKeyPath": "file:///greengrass/certs/certificateId-private.pem.key", "certificatePath": "file:///greengrass/certs/certificateId-certificate.pem.crt" } } } } ``` Successivamente, esegui queste operazioni: + Se hai scaricato un certificato Amazon Root CA diverso da Amazon Root CA 1, sostituisci ogni istanza di *AmazonRootCA1.pem* con il nome del file Amazon root CA. + Sostituisci ogni istanza di *certificateId* con l'ID del certificato nel nome del certificato e dei file chiave. + Sostituiscilo *arn:aws:iot:*region*:*account-id*:thing/MyGreengrassV1Core* con l'ARN del file principale che hai salvato in precedenza. + Sostituiscilo *MyGreengrassV1core* con il nome dell'oggetto del tuo core. + *device-data-prefix-ats.iot.region.amazonaws.com*Sostituiscilo con l'endpoint dei dati del AWS IoT dispositivo che hai salvato in precedenza. + Sostituisci *region* con il tuo. Regione AWS Per ulteriori informazioni sulle opzioni di configurazione che è possibile specificare in questo file di configurazione, vedere[AWS IoT Greengrass file di configurazione principale](gg-core.md#config-json). 1. Assicurati che il dispositivo principale sia connesso a Internet. Quindi, avvia AWS IoT Greengrass dal tuo dispositivo principale. ``` cd /greengrass/ggc/core/ sudo ./greengrassd start ``` Viene visualizzato un messaggio `Greengrass successfully started`. Prendere nota del PID. **Nota** Per configurare il dispositivo principale in modo che si avvii AWS IoT Greengrass all'avvio del sistema, consulta[Configurazione del sistema di inizializzazione per avviare il daemon Greengrass](gg-core.md#start-on-boot). È possibile eseguire il comando seguente per confermare il funzionamento del software AWS IoT Greengrass Core (daemon Greengrass). Sostituisci *PID-number* con il tuo PID: ``` ps aux | grep PID-number ``` Dovresti visualizzare una voce per il PID con un percorso per il daemon Greengrass in esecuzione (ad esempio, `/greengrass/ggc/packages/1.11.6/bin/daemon`). Se riscontri problemi di avvio AWS IoT Greengrass, consulta[Risoluzione dei problemi AWS IoT Greengrass](gg-troubleshooting.md). # Modulo 3 (parte 1): funzioni Lambda su AWS IoT Greengrass Questo modulo mostra come creare e implementare una funzione Lambda che invia messaggi MQTT dal AWS IoT Greengrass dispositivo principale. Il modulo descrive le configurazioni delle funzioni Lambda, gli abbonamenti utilizzati per consentire la messaggistica MQTT e le implementazioni su un dispositivo principale. [Il Modulo 3 (parte 2)](module3-II.md) illustra le differenze tra le funzioni Lambda on-demand e quelle a lunga durata eseguite sul core. AWS IoT Greengrass Prima di iniziare, assicurati di aver completato il [Modulo 1 e il Modulo](module1.md) [2](module2.md) e di avere un dispositivo principale funzionante AWS IoT Greengrass . **Suggerimento** Oppure, per utilizzare uno script che configuri automaticamente il dispositivo core, consulta [Avvio rapido: configurazione dispositivo Greengrass](quick-start.md). Lo script può anche creare e distribuire la funzione Lambda utilizzata in questo modulo. Il completamento di questo modulo richiede circa 30 minuti. **Topics** + [Creare e impacchettare una funzione Lambda](create-lambda.md) + [Configurare la funzione Lambda per AWS IoT Greengrass](config-lambda.md) + [Distribuzione delle configurazioni cloud su un dispositivo core di Greengrass](configs-core.md) + [Verifica che la funzione Lambda sia in esecuzione sul dispositivo principale](lambda-check.md) # Creare e impacchettare una funzione Lambda La funzione Python Lambda di esempio in questo modulo utilizza Core [AWS IoT Greengrass SDK for Python per](lambda-functions.md#lambda-sdks-core) pubblicare messaggi MQTT. In questa fase, si: + Scarica il AWS IoT Greengrass Core SDK per Python sul tuo computer (non AWS IoT Greengrass sul dispositivo principale). + Crea un pacchetto di distribuzione della funzione Lambda che contenga il codice della funzione e le dipendenze. + Usa la console Lambda per creare una funzione Lambda e caricare il pacchetto di distribuzione. + Pubblica una versione della funzione Lambda e crea un alias che punti alla versione. Per completare questo modulo, Python 3.7 deve essere installato sul dispositivo principale.   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. Decomprimi il pacchetto scaricato per ottenere il codice della funzione Lambda e l'SDK. La funzione Lambda in questo modulo utilizza: + Il file `greengrassHelloWorld.py` in `examples\HelloWorld`. Questo è il codice della tua funzione Lambda. Ogni cinque secondi la funzione pubblica uno tra due possibili messaggi all'argomento `hello/world`. + La cartella `greengrasssdk`. Questo è l'SDK. 1. Copiare la cartella `greengrasssdk` nella cartella `HelloWorld` contenente `greengrassHelloWorld.py`. 1. Per creare il pacchetto di distribuzione della funzione Lambda, salva `greengrassHelloWorld.py` e la `greengrasssdk` cartella in un file compresso denominato. `zip` `hello_world_python_lambda.zip` Il file `py` e la cartella `greengrasssdk` devono trovarsi nella radice della directory. ![\[Screenshot che mostra i contenuti compressi di hello_word_python_lambda.zip.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-017.png) Sui sistemi di tipo UNIX (tra cui il terminale Mac), puoi utilizzare il seguente comando per creare il pacchetto del file e della cartella: ``` zip -r hello_world_python_lambda.zip greengrasssdk greengrassHelloWorld.py ``` **Nota** In base alla distribuzione, potrebbe essere necessario installare prima `zip` (ad esempio, eseguendo `sudo apt-get install zip`). Il comando di installazione per la distribuzione potrebbe essere diverso. Ora sei pronto per creare la tua funzione Lambda e caricare il pacchetto di distribuzione. 1. Apri la console Lambda e scegli **Crea** funzione. 1. Scegli **Crea da zero**. 1. Dai alla funzione il nome **Greengrass\$1HelloWorld** e imposta i campi rimanenti come segue: + 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 Scegli **Crea funzione**. 1. 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 `hello_world_python_lambda.zip` distribuzione. Quindi, scegliere **Save (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 **greengrassHelloWorld.function\$1handler** ![\[La sezione «Impostazioni di runtime» con il campo «Runtime» impostato su «Python 3.7" e il campo «Handler» impostato su ".function_handler». greengrassHelloWorld\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-023-2.png) 1. Seleziona **Salva**. **Nota** Il pulsante **Test** sulla console non funziona con questa funzione AWS Lambda . 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. Pubblica la funzione Lambda: 1. Dal menu **Azioni** nella parte superiore della pagina, scegli **Pubblica nuova versione**. ![\[Screenshot del menu "Actions" con "Publish new version" evidenziato.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-026.png) 1. Per **Version description (Descrizione versione)**, immettere **First version**, quindi scegliere **Publish (Pubblica)**. ![\[Screenshot con il campo "Version description" impostato su "First version" e il pulsante "Publish" evidenziato.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-027.png) 1. [Crea un [alias](https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html) per la versione della funzione Lambda:](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html) **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. Dal menu **Azioni** nella parte superiore della pagina, scegli **Crea alias**. ![\[Screenshot del menu "Actions" impostato su "Create alias".\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-028.png) 1. **Assegna un nome all'alias**GG\$1HelloWorld**, imposta la versione su **1** (che corrisponde alla versione che hai appena pubblicato), quindi scegli Salva.** **Nota** AWS IoT Greengrass **non supporta gli alias Lambda per le versioni \$1LATEST.**   ![\[Schermata di Crea un nuovo alias con il campo Nome impostato su GG_ e il campo Versione impostato su HelloWorld 1.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-029.png) # Configurare la funzione Lambda per AWS IoT Greengrass Ora sei pronto per configurare la tua funzione Lambda per. AWS IoT Greengrass In questa fase, si: + Usa la AWS IoT console per aggiungere la funzione Lambda al tuo gruppo Greengrass. + Configura le impostazioni specifiche del gruppo per la funzione Lambda. + Aggiungi un abbonamento al gruppo che consente alla funzione Lambda di pubblicare messaggi MQTT. AWS IoT + Configurano le impostazioni del log locale per il gruppo.   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 gruppo che hai creato nel [Modulo](module2.md) 2. 1. **Nella pagina di configurazione del gruppo, scegli la scheda **Funzioni Lambda**, quindi scorri verso il basso fino alla sezione Le mie **funzioni Lambda** e scegli Aggiungi funzione Lambda.** 1. Seleziona il nome della funzione Lambda che hai creato nel passaggio precedente (**Greengrass\$1 HelloWorld**, non il nome dell'alias). 1. **Per la versione, scegliete Alias: GG\$1. HelloWorld** 1. Nella sezione di **configurazione della funzione Lambda**, apporta le seguenti modifiche: + Imposta l'**utente e il gruppo di sistema** su **Use group default**. + **Imposta la **containerizzazione della funzione Lambda** su Use group default.** + Imposta **Timeout** a 25 secondi. Questa funzione Lambda dorme per 5 secondi prima di ogni chiamata. + **Per **Pinned**, scegli True.**   **Nota** Una funzione Lambda di *lunga durata* (o *bloccata*) si avvia automaticamente dopo l'avvio e continua AWS IoT Greengrass a funzionare nel proprio contenitore. Ciò è in contrasto con una funzione Lambda *su richiesta*, che si avvia quando viene richiamata e si interrompe quando non ci sono più attività da eseguire. Per ulteriori informazioni, consulta [Configurazione del ciclo di vita per le funzioni Greengrass Lambda](lambda-functions.md#lambda-lifecycle). 1. Scegli **la funzione Aggiungi Lambda** per salvare le modifiche. Per informazioni sulle proprietà della funzione Lambda, vedere. [Controllo dell'esecuzione delle funzioni Greengrass Lambda utilizzando la configurazione specifica del gruppo](lambda-group-config.md) Quindi, crea un abbonamento che consenta alla funzione Lambda di inviare messaggi [MQTT](http://mqtt.org/) a. AWS IoT Core Una funzione Greengrass Lambda può scambiare messaggi MQTT con: + [Dispositivi](what-is-gg.md#greengrass-devices) nel gruppo Greengrass. + [Connettori](connectors.md) nel gruppo. + Altre funzioni Lambda del gruppo. + AWS IoT Core. + Il servizio shadow locale. Per ulteriori informazioni, consulta [Modulo 5: interazione con dispositivi ombra](module5.md). Il gruppo utilizza le sottoscrizioni per controllare in che modo queste entità possono comunicare tra loro. Le sottoscrizioni forniscono interazioni prevedibili e un livello di sicurezza. Una sottoscrizione è costituita da origine, destinazione e argomento. L'origine è l'autore del messaggio. La destinazione è il ricevente del messaggio. L'argomento consente di filtrare i dati inviati dall'origine alla destinazione. L'origine o la destinazione può essere un dispositivo Greengrass, una funzione Lambda, un connettore, un'ombra del dispositivo o. AWS IoT Core **Nota** Una sottoscrizione è diretta, nel senso che il flusso di messaggi ha una direzione specifica: dall'origine alla destinazione. Per consentire la comunicazione bidirezionale, è necessario configurare due sottoscrizioni. **Nota** Attualmente, il filtro degli argomenti di sottoscrizione non consente più di un singolo `+` carattere in un argomento. Il filtro degli argomenti consente un solo `#` carattere alla fine di un argomento. La funzione `Greengrass_HelloWorld` Lambda invia messaggi solo all'`hello/world`argomento in AWS IoT Core, quindi è sufficiente creare un solo abbonamento dalla funzione Lambda a. AWS IoT Core Questa operazione viene eseguita nella fase successiva. 1. **Nella pagina di configurazione del gruppo, scegli la scheda **Abbonamenti**, quindi scegli Aggiungi abbonamento.** Per un esempio che mostra come creare un abbonamento utilizzando il AWS CLI, vedi [create-subscription-definition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-subscription-definition.html)nel *AWS CLI Command Reference*. 1. **Nel **tipo di origine**, scegli la **funzione Lambda** e, per la **sorgente**, scegli Greengrass\$1. HelloWorld** 1. Per il **tipo di Target**, scegli **Service** e, per **Target**, seleziona **IoT Cloud**. 1. Per il **filtro Argomento****hello/world**, inserisci, quindi scegli **Crea abbonamento**. 1. Configurare le impostazioni di registrazione del gruppo. In questo tutorial, configurerai i componenti di AWS IoT Greengrass sistema e le funzioni Lambda definite dall'utente per scrivere i log nel file system del dispositivo principale. 1. **Nella pagina di configurazione del gruppo, scegli la scheda Registri.** 1. **Nella sezione **Configurazione dei registri locali**, scegli Modifica.** 1. **Nella finestra di dialogo **Modifica configurazione dei log locali**, mantieni i valori predefiniti sia per i livelli di registro che per le dimensioni di archiviazione, quindi scegli Salva.** È possibile utilizzare i registri per risolvere eventuali problemi che potrebbero verificarsi durante l'esecuzione di questa esercitazione. Durante la risoluzione dei problemi, è possibile modificare temporaneamente il livello di registrazione in **Debug**. Per ulteriori informazioni, consulta [Accesso ai log del file system](greengrass-logs-overview.md#gg-logs-local). 1. Se il runtime Java 8 non è installato sul dispositivo core, è necessario installarlo o disabilitare Gestore di flussi. **Nota** Questo tutorial non utilizza Gestore di flussi, ma utilizza il flusso di lavoro **Creazione gruppo predefinito** che abilita Gestore di flussi per impostazione predefinita. Se Gestore di flussi è abilitato ma Java 8 non è installato, la distribuzione del gruppo ha esito negativo. Per ulteriori informazioni, consulta i [requisiti per Gestore di flussi](stream-manager.md#stream-manager-requirements). Per disabilitare Gestore di flussi: 1. Nella pagina delle impostazioni del gruppo, scegli la scheda **Funzioni Lambda**. 1. **Nella sezione **Funzioni System Lambda**, seleziona **Stream manager** e scegli Modifica.** 1. Scegliere **Abilita**, quindi **Salva**. # Distribuzione delle configurazioni cloud su un dispositivo core di Greengrass 1. Assicurati che il dispositivo core di Greengrass sia connesso a Internet. Ad esempio, provare a passare correttamente a una pagina Web. 1. Assicurati che il daemon Greengrass sia in esecuzione sul dispositivo core. Nel terminale del dispositivo principale, esegui i seguenti comandi per verificare se il demone è in esecuzione e avvialo, se necessario. 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 ``` Ora sei pronto per implementare la funzione Lambda e le configurazioni di abbonamento sul tuo dispositivo principale 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 gruppo che hai creato nel [Modulo](module2.md) 2. 1. Nella pagina di configurazione del gruppo, scegli **Deploy**. 1. **Nella scheda **Funzioni Lambda, nella sezione Funzioni** System **Lambda, scegli Rilevatore** IP.** 1. Scegli **Modifica** e seleziona **Rileva e sostituisci automaticamente** gli endpoint del broker MQTT. Questo consente ai dispositivi di acquisire automaticamente informazioni di base sulla connettività, come, ad esempio indirizzo IP, DNS e numero della porta. È consigliato il rilevamento automatico, ma AWS IoT Greengrass supporta anche endpoint specifici manualmente. Ti viene chiesto il metodo di individuazione solo la prima volta che il gruppo viene distribuito. La prima distribuzione potrebbe richiedere alcuni minuti. Al termine della distribuzione, dovresti visualizzare **Successfully completed (Completata con successo)** nella colonna **Status (Stato)** della pagina **Deployments (Distribuzioni)**: **Nota** Lo stato della distribuzione è visualizzato anche sotto il nome del gruppo nell'intestazione di pagina. Per la risoluzione dei problemi, consultare [Risoluzione dei problemi AWS IoT Greengrass](gg-troubleshooting.md). # Verifica che la funzione Lambda sia in esecuzione sul dispositivo principale 1. Dal pannello di navigazione della [AWS IoT console](https://console.aws.amazon.com/iot/), in **Test**, scegli **MQTT test client**. 1. Scegli la scheda **Iscriviti all'argomento**. 1. Entra **hello/world** nel **filtro Argomento** ed espandi la **Configurazione aggiuntiva**. 1. Inserisci le informazioni elencate in ciascuno dei seguenti campi: + Per **Quality of Service (Qualità del servizio)**, scegli **0**. + Per **MQTT payload display (Visualizzazione payload MQTT)**, scegli **Display payloads as strings (Visualizza payload come stringhe)**.   1. Scegli **Abbonati**. Supponendo che la funzione Lambda sia in esecuzione sul dispositivo, pubblica messaggi simili ai seguenti nell'argomento: `hello/world` ![\[Schermata del messaggio inviato all' hello/world argomento con il messaggio evidenziato.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-045.png) Sebbene la funzione Lambda continui a inviare messaggi MQTT all'`hello/world`argomento, non arrestate il demone. AWS IoT Greengrass I restanti moduli vengono scritti presumendo che sia in esecuzione. È possibile eliminare la funzione e la sottoscrizione dal gruppo: + **Nella pagina di configurazione dei gruppi, nella scheda **Funzioni Lambda**, seleziona la funzione Lambda che desideri rimuovere e scegli Rimuovi.** + **Nella pagina di configurazione dei gruppi, nella scheda **Sottoscrizioni**, scegli l'abbonamento, quindi scegli Elimina.** La funzione e la sottoscrizione vengono eliminate dal core durante la successiva distribuzione di gruppo. # Modulo 3 (parte 2): funzioni Lambda su AWS IoT Greengrass Questo modulo esplora le differenze tra le funzioni Lambda on-demand e quelle a lunga durata eseguite sul core. AWS IoT Greengrass Prima di iniziare, eseguire lo script di [installazione dispositivo Greengrass](quick-start.md) o assicurarsi di aver completato il [modulo 1](module1.md), il[modulo 2](module2.md), e il [modulo 3 (parte 1)](module3-I.md). Il completamento di questo modulo richiede circa 30 minuti. **Topics** + [Crea e impacchetta la funzione Lambda](package.md) + [Configura funzioni Lambda di lunga durata per AWS IoT Greengrass](long-lived.md) + [Prova le funzioni Lambda di lunga durata](long-testing.md) + [Testa le funzioni Lambda su richiesta](on-demand.md) # Crea e impacchetta la funzione Lambda In questa fase, si: + Crea un pacchetto di distribuzione della funzione Lambda che contenga il codice della funzione e le dipendenze. + Usa la console Lambda per creare una funzione Lambda e caricare il pacchetto di distribuzione. + Pubblica una versione della funzione Lambda e crea un alias che punti alla versione.   1. Sul tuo computer, vai al AWS IoT Greengrass Core SDK per Python che hai scaricato ed estratto [Creare e impacchettare una funzione Lambda](create-lambda.md) nel Modulo 3-1. La funzione Lambda in questo modulo utilizza: + Il file `greengrassHelloWorldCounter.py` in `examples\HelloWorldCounter`. Questo è il codice della tua funzione Lambda. + La cartella `greengrasssdk`. Questo è l'SDK. 1. Crea un pacchetto di distribuzione della funzione Lambda: 1. Copiare la cartella `greengrasssdk` nella cartella `HelloWorldCounter` contenente `greengrassHelloWorldCounter.py`. 1. Salvare `greengrassHelloWorldCounter.py` e la cartella `greengrasssdk` in un file `zip` denominato `hello_world_counter_python_lambda.zip`. Il file `py` e la cartella `greengrasssdk` devono trovarsi nella radice della directory. ![\[Screenshot che mostra i contenuti compressi di "hello_word_counter_python_lambda.zip".\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-046.png) Sui sistemi di tipo UNIX (tra cui il terminale Mac) che hanno `zip` installato, puoi utilizzare il seguente comando per creare il pacchetto del file e della cartella: ``` zip -r hello_world_counter_python_lambda.zip greengrasssdk greengrassHelloWorldCounter.py ``` Ora sei pronto per creare la tua funzione Lambda e caricare il pacchetto di distribuzione. 1. Apri la console Lambda e scegli **Crea** funzione. 1. Scegli **Crea da zero**. 1. Dai alla funzione il nome **Greengrass\$1HelloWorld\$1Counter** e imposta i campi rimanenti come segue: + 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 In alternativa, puoi riutilizzare il ruolo creato nel Modulo 3-1. Scegli **Crea funzione**. ![\[La sezione «Informazioni di base» con il campo «Nome funzione» impostato su «Greengrass_ HelloWorld _Counter» e il campo «Runtime» impostato su «Python 3.7".\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-023-3.png) 1. Carica il tuo pacchetto di implementazione 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 `hello_world_counter_python_lambda.zip` distribuzione. Quindi, scegliere **Save (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 **greengrassHelloWorldCounter.function\$1handler** 1. Seleziona **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. Pubblicate la prima versione della funzione. 1. Dal menu **Azioni** nella parte superiore della pagina, scegli **Pubblica nuova versione**. In **Version description (Descrizione versione)**, immetti **First version**. 1. Seleziona **Publish** (Pubblica). 1. Crea un alias per la versione della funzione. 1. Dal menu **Azioni** nella parte superiore della pagina, scegli **Crea alias**. ![\[Screenshot del menu "Actions" impostato su "Create alias".\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-028.png) 1. Per **Nome**, immetti **GG\$1HW\$1Counter**. 1. In **Version (Versione)**, selezionare **1**. 1. Seleziona **Salva**. ![\[Crea uno screenshot dell'alias con il campo Nome impostato su GG_HW_Counter e il campo Versione impostato su 1.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-048.png) Gli alias creano una singola entità per la funzione Lambda a cui i dispositivi Greengrass possono abbonarsi. In questo modo, non è necessario aggiornare gli abbonamenti con nuovi numeri di versione della funzione Lambda ogni volta che la funzione viene modificata. # Configura funzioni Lambda di lunga durata per AWS IoT Greengrass Ora sei pronto per configurare la tua funzione Lambda per. AWS IoT 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 gruppo che hai creato nel [Modulo](module2.md) 2. 1. **Nella pagina di configurazione del gruppo, scegli la scheda **Funzioni Lambda**, quindi in Le mie **funzioni Lambda**, scegli Aggiungi.** 1. Per la **funzione Lambda**, scegli **HelloWorldGreengrass\$1** \$1Counter. 1. Per la **versione della funzione Lambda**, scegli l'alias della versione che hai pubblicato. 1. Per **Timeout (secondi)**, immettere. **25** Questa funzione Lambda dorme per 20 secondi prima di ogni chiamata. 1. **Per **Pinned**, scegli True.** 1. Mantieni i valori predefiniti per tutti gli altri campi e scegli **Aggiungi funzione Lambda**. # Prova le funzioni Lambda di lunga durata Una funzione Lambda di *[lunga durata](lambda-functions.md#lambda-lifecycle)* si avvia automaticamente AWS IoT Greengrass all'avvio del core e viene eseguita in un singolo contenitore (o sandbox). Qualsiasi variabile o logica di preelaborazione definite al di fuori del gestore della funzione sono conservate per ogni richiamo del gestore della funzione. Chiamate multiple del gestore della funzione vengono messe in coda finché le chiamate precedenti non sono state eseguite. Il codice `greengrassHelloWorldCounter.py` utilizzato in questo modulo definisce una variabile `my_counter` al di fuori del gestore della funzione. **Nota** Puoi visualizzare il codice nella AWS Lambda console o nel [AWS IoT Greengrass Core SDK for GitHub Python on](https://github.com/aws/aws-greengrass-core-sdk-python/blob/master/examples/HelloWorldCounter/greengrassHelloWorldCounter.py). In questo passaggio, si creano abbonamenti che consentono la funzione Lambda AWS IoT e lo scambio di messaggi MQTT. Quindi si procede alla distribuzione del gruppo e al test della funzione. 1. **Nella pagina di configurazione del gruppo, scegli **Sottoscrizioni, quindi** scegli Aggiungi.** 1. In **Tipo di origine**, scegli **Funzione Lambda**, quindi scegli **HelloWorldGreengrass\$1** \$1Counter. 1. In **Tipo di destinazione**, scegli **Servizio**, scegli **IoT Cloud**. 1. In **Topic filter (Filtro argomento)**, immettere **hello/world/counter**. 1. Scegli **Crea sottoscrizione**. Questo abbonamento singolo va in una sola direzione: dalla funzione `Greengrass_HelloWorld_Counter` Lambda a. AWS IoT Per richiamare (o attivare) questa funzione Lambda dal cloud, devi creare un abbonamento nella direzione opposta. 1. Segui i passaggi da 1 a 5 per aggiungere un altro abbonamento che utilizzi i seguenti valori. Questo abbonamento consente alla funzione Lambda di ricevere messaggi da. AWS IoT Si utilizza questo abbonamento quando si invia un messaggio dalla AWS IoT console che richiama la funzione. + Come fonte, scegli **Servizio**, quindi scegli **IoT Cloud**. + Per la destinazione, scegli la **funzione Lambda**, quindi scegli **HelloWorldGreengrass\$1** \$1Counter. + Per il filtro di argomenti, immetti **hello/world/counter/trigger**. In questo filtro dell'argomento viene usata l'estensione `/trigger` perché hai creato due sottoscrizioni ed è necessario che non interferiscano tra loro. 1. Assicuratevi che il demone Greengrass sia in esecuzione, come descritto in. [Distribuire configurazioni cloud su un dispositivo core](configs-core.md) 1. **Nella pagina di configurazione del gruppo, scegliete Deploy.** 1. Una volta completata la distribuzione, torna alla home page della AWS IoT console e scegli **Test**. 1. Configura i campi seguenti: + Per **Argomento sottoscrizione**, immetti **hello/world/counter**. + Per **Quality of Service (Qualità del servizio)**, scegli **0**. + Per **MQTT payload display (Visualizzazione payload MQTT)**, scegli **Display payloads as strings (Visualizza payload come stringhe)**. 1. Scegliere **Subscribe (Effettua sottoscrizione)**. A differenza della [Parte 1](module3-I.md) di questo modulo, non dovresti visualizzare messaggi dopo aver effettuato la sottoscrizione a `hello/world/counter`. Questo perché il codice `greengrassHelloWorldCounter.py` che pubblica nell'argomento `hello/world/counter` si trova all'interno del gestore della funzione, che viene eseguito solo quando viene richiamata la funzione. In questo modulo, avete configurato la funzione `Greengrass_HelloWorld_Counter` Lambda per essere richiamata quando riceve un messaggio MQTT sull'argomento. `hello/world/counter/trigger` L'abbonamento **Greengrass\$1 HelloWorld \$1Counter to** **IoT Cloud** consente la funzione di inviare messaggi AWS IoT sull'argomento. `hello/world/counter` L'abbonamento **IoT Cloud** to **Greengrass\$1 HelloWorld \$1Counter** consente di AWS IoT inviare messaggi alla funzione sull'argomento. `hello/world/counter/trigger` 1. Per testare il ciclo di vita di lunga durata, richiama la funzione Lambda pubblicando un messaggio sull'argomento. `hello/world/counter/trigger` Puoi usare il messaggio predefinito. ![\[Messaggio predefinito di Hello from AWS IoT console inviato a hello/world/counter/trigger con il pulsante Pubblica sull'argomento evidenziato.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-057.png) **Nota** La funzione `Greengrass_HelloWorld_Counter` ignora il contenuto dei messaggi ricevuti. Esegue solamente il codice in `function_handler`, che invia un messaggio all'argomento `hello/world/counter`. Puoi rivedere questo codice dal [AWS IoT Greengrass Core SDK for GitHub Python on](https://github.com/aws/aws-greengrass-core-sdk-python/blob/master/examples/HelloWorldCounter/greengrassHelloWorldCounter.py). Ogni volta che un messaggio viene pubblicato nell'argomento `hello/world/counter/trigger`, la variabile `my_counter` viene incrementata. Questo conteggio delle chiamate viene visualizzato nei messaggi inviati dalla funzione Lambda. Poiché il gestore della funzione include un ciclo di sonno di 20 secondi (`time.sleep(20)`), l'attivazione ripetuta del gestore mette in coda le risposte provenienti dal core. AWS IoT Greengrass ![\[Screenshot che mostra l'incremento di Invocation Count da 1, 2 e 3.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-058.png) # Testa le funzioni Lambda su richiesta Una funzione Lambda *[su richiesta](lambda-functions.md#lambda-lifecycle)* ha funzionalità simili a quelle di una AWS Lambda funzione basata su cloud. È possibile eseguire più chiamate di una funzione Lambda su richiesta in parallelo. Una chiamata della funzione Lambda crea un contenitore separato per elaborare le chiamate o riutilizza un contenitore esistente, se le risorse lo consentono. Qualsiasi variabile o preelaborazione definite al di fuori del gestore della funzione non vengono conservate quando vengono creati i container. 1. Nella pagina di configurazione del gruppo, scegli la scheda **Funzioni Lambda**. 1. In **Funzioni My Lambda**, scegli **Greengrass\$1HelloWorld\$1Counter**Funzione Lambda. 1. Sul **Greengrass\$1HelloWorld\$1Counter**nella pagina dei dettagli, scegli **Modifica**. 1. Per **Bloccato**, scegli **False**, quindi scegli **Salva**. 1. Nella pagina di configurazione del gruppo, scegli **Deploy**. 1. Una volta completata la distribuzione, torna alla home page della AWS IoT console e scegli **Test**. 1. Configura i campi seguenti: + Per **Argomento sottoscrizione**, immetti **hello/world/counter**. + Per **Quality of Service (Qualità del servizio)**, scegli **0**. + Per **MQTT payload display (Visualizzazione payload MQTT)**, scegli **Display payloads as strings (Visualizza payload come stringhe)**. ![\[Screenshot della pagina di test Abbonamenti.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-056.png) 1. Scegliere **Subscribe (Effettua sottoscrizione)**. **Nota** Non dovresti visualizzare alcun messaggio dopo la sottoscrizione. 1. Per testare il ciclo di vita on demand, richiama la funzione pubblicando un messaggio nell'argomento `hello/world/counter/trigger`. Puoi usare il messaggio predefinito. 1. Scegli **Pubblica** tre volte velocemente, entro cinque secondi da ogni pressione del pulsante. ![\[Screenshot che mostra il pulsante "Publish to topic", che deve essere cliccato rapidamente tre volte.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-063.png) Ogni pubblicazione richiama il gestore della funzione e crea un container per ogni chiamata. Il conteggio delle chiamate non viene incrementato per le tre volte che hai attivato la funzione perché ogni funzione Lambda su richiesta ha il proprio contenitore/sandbox. ![\[Screenshot che mostra "Invocation Count" fissato a 1.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-064.png) 1. Dopo circa 30 secondi, scegli **Pubblica nell'argomento**. Il conteggio delle chiamate dovrebbe diventare 2. Questo indica che viene riutilizzato un container creato da una chiamata precedente e che le variabili di preelaborazione al di fuori del gestore della funzione sono state memorizzate. ![\[Screenshot che mostra "Invocation Count" salito a 2.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-065.png) Ora dovresti comprendere i due tipi di funzioni Lambda che possono essere eseguite sul AWS IoT Greengrass core. Il modulo successivo, [Modulo 4](module4.md), mostra come i dispositivi IoT locali possono interagire in un AWS IoT Greengrass gruppo. # Modulo 4: Interazione con i dispositivi client in un gruppo AWS IoT Greengrass Questo modulo mostra come i dispositivi IoT locali, chiamati *dispositivi o *dispositivi* client*, possono connettersi e comunicare con un dispositivo AWS IoT Greengrass principale. I dispositivi client che si connettono a un AWS IoT Greengrass core fanno parte di un AWS IoT Greengrass gruppo e possono partecipare al paradigma AWS IoT Greengrass di programmazione. In questo modulo, un dispositivo client invia un messaggio Hello World a un altro dispositivo client del gruppo Greengrass. ![\[AWS IoT connesso a un AWS IoT Greengrass core, che è collegato al dispositivo client #1 e al dispositivo client #2.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-065.5.png) Prima di iniziare, eseguire lo script [Greengrass Device Setup](quick-start.md) o completare il [modulo 1](module1.md) e il [modulo 2](module2.md). Questo modulo crea due dispositivi client simulati. Non sono necessari altri componenti o dispositivi. Il completamento di questo modulo dovrebbe richiedere meno di 30 minuti. **Topics** + [Creare dispositivi client in un AWS IoT Greengrass gruppo](device-group.md) + [Configurazione delle sottoscrizioni](config-subs.md) + [Installa il SDK per dispositivi AWS IoT for Python](IoT-SDK.md) + [Test delle comunicazioni](test-comms.md) # Creare dispositivi client in un AWS IoT Greengrass gruppo In questo passaggio, aggiungi due dispositivi client al tuo gruppo Greengrass. Questo processo include la registrazione dei dispositivi come AWS IoT oggetti e la configurazione di certificati e chiavi per consentire loro di connettersi. AWS IoT Greengrass 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, registra questo dispositivo client come**HelloWorld\$1Publisher**, 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 è possibile scaricare i certificati e le chiavi utilizzati dal dispositivo 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. Torna alla scheda del browser con la modalità **Associa un dispositivo client a questo gruppo** aperta. Esegui questa operazione: 1. Come **nome della AWS IoT cosa**, scegli la **HelloWorld\$1Publisher**cosa che hai creato. Se non vedi l'oggetto, scegli il pulsante di aggiornamento. 1. Selezionare **Associate (Associa)**. 1. Ripeti i passaggi da 3 a 10 per aggiungere un secondo dispositivo client al gruppo. Assegna un nome a questo dispositivo client**HelloWorld\$1Subscriber**. Scarica i certificati e le chiavi per questo dispositivo client sul tuo computer. Ancora una volta, prendi nota dell'ID del certificato che è comune nei nomi di file per il dispositivo HelloWorld \$1Subscriber. Ora dovresti avere due dispositivi client nel tuo gruppo Greengrass: + HelloWorld\$1Editore + HelloWorld\$1Sottoscrittore 1. Crea una cartella sul tuo computer per le credenziali di sicurezza di questi dispositivi client. Copia i certificati e le chiavi in questa cartella. # Configurazione delle sottoscrizioni In questo passaggio, si abilita il dispositivo client HelloWorld \$1Publisher per inviare messaggi MQTT al dispositivo client HelloWorld \$1Subscriber. 1. **Nella pagina di configurazione del gruppo, scegli la scheda **Abbonamenti**, quindi scegli Aggiungi.** 1. Nella pagina **Crea un abbonamento**, procedi come segue per configurare l'abbonamento: 1. Per **Tipo di origine**, scegli **Dispositivo client**, quindi scegli **HelloWorld\$1Publisher**. 1. In **Tipo di destinazione**, scegli **Dispositivo client**, quindi scegli **HelloWorld\$1Subscriber**. 1. In **Topic filter (Filtro argomento)**, immettere **hello/world/pubsub**. **Nota** Adesso puoi eliminare le sottoscrizioni indicate nei moduli precedenti. **Nella pagina **Sottoscrizioni** del gruppo, seleziona gli abbonamenti da eliminare, quindi scegli Elimina.** 1. Scegli **Crea sottoscrizione**. 1. Assicurati che il rilevamento automatico sia abilitato in modo che il core di Greengrass possa pubblicare un elenco dei suoi indirizzi IP. I dispositivi client utilizzano queste informazioni per scoprire il core. Esegui questa operazione: 1. Nella pagina di configurazione del gruppo, scegli la scheda **Funzioni Lambda**. 1. **In **Funzioni System Lambda**, scegli **Rilevatore IP**, quindi scegli Modifica.** 1. **In **Modifica le impostazioni del rilevatore IP**, scegli **Rileva automaticamente e sostituisci gli endpoint del broker MQTT**, quindi scegli Salva.** 1. Assicuratevi che il demone Greengrass sia in esecuzione, come descritto in. [Distribuire configurazioni cloud su un dispositivo core](configs-core.md) 1. **Nella pagina di configurazione del gruppo, scegliete Deploy.** Lo stato della distribuzione è visualizzato sotto il nome del gruppo nell'intestazione di pagina. Per visualizzare i dettagli della distribuzione, scegli la scheda **Distribuzioni**. # Installa il SDK per dispositivi AWS IoT for Python I dispositivi client possono utilizzare SDK per dispositivi AWS IoT for Python per comunicare con AWS IoT i dispositivi AWS IoT Greengrass principali (utilizzando il linguaggio di programmazione Python). Per ulteriori informazioni, compresi i requisiti, consultate il SDK per dispositivi AWS IoT [Readme](https://github.com/aws/aws-iot-device-sdk-python) for Python on. GitHub In questo passaggio, installerai l'SDK e otterrai la funzione di `basicDiscovery.py` esempio utilizzata dai dispositivi client simulati sul tuo computer. 1. Per installare l'SDK sul computer con tutti i componenti richiesti, scegliere il sistema operativo: ------ #### [ Windows ] 1. Apri un [prompt di comandi elevati](https://technet.microsoft.com/en-us/library/cc947813(v=ws.10).aspx) ed esegui il seguente comando: ``` python --version ``` Se non vengono restituite le informazioni relative alla versione o se il numero di versione è inferiore a 2.7 per Python 2 o meno di 3.3 per Python 3, seguire le istruzioni in [Download di Python](https://wiki.python.org/moin/BeginnersGuide/Download) per installare Python 2.7\$1 o Python 3.3\$1. Per ulteriori informazioni sulla manutenzione Windows, consulta [Utilizzo di Python su Windows](https://docs.python.org/3.6/using/windows.html). 1. Scaricate il `zip` file [SDK per dispositivi AWS IoT for Python](https://github.com/aws/aws-iot-device-sdk-python) ed estraetelo in una posizione appropriata sul vostro computer. Prendi nota del percorso file alla cartella `aws-iot-device-sdk-python-master` estratta che contiene il file `setup.py`. Nel passaggio successivo, questo percorso del file è indicato da*path-to-SDK-folder*. 1. Dal prompt di comandi elevati, esegui il comando seguente: ``` cd path-to-SDK-folder python setup.py install ``` ------ #### [ macOS ] 1. Apri una finestra del terminale ed esegui il comando seguente: ``` python --version ``` Se non vengono restituite le informazioni relative alla versione o se il numero di versione è inferiore a 2.7 per Python 2 o meno di 3.3 per Python 3, seguire le istruzioni in [Download di Python](https://wiki.python.org/moin/BeginnersGuide/Download) per installare Python 2.7\$1 o Python 3.3\$1. Per ulteriori informazioni sulla manutenzione Windows, consulta [Utilizzo di Python su Macintosh](https://docs.python.org/3/using/mac.html). 1. Nella finestra del terminale, esegui i seguenti comandi per determinare la versione di OpenSSL: ``` python >>>import ssl >>>print ssl.OPENSSL_VERSION ``` Annota il valore della versione di OpenSSL. **Nota** Se Python 3 è in esecuzione, utilizza **print(ssl.OPENSSL\$1VERSION)**. Per chiudere lo shell di Python, esegui il seguente comando: ``` >>>exit() ``` Se la versione di OpenSSL è 1.0.1 o successiva, vai alla [fase c](#step-c-install-python-sdk). In caso contrario, procedi come descritto: 1. Nella finestra del terminale, esegui il comando seguente per determinare se il computer sta utilizzando Simple Python Version Management: ``` which pyenv ``` Se viene restituito un percorso di file, scegli la `pyenv` scheda **Utilizzo**. Se non viene restituito nulla, scegli la `pyenv` scheda **Non in uso**. ------ #### [ Using pyenv ] 1. Consulta [Versioni di Python per Mac OS X](https://www.python.org/downloads/mac-osx/) (o simile) per determinare la versione stabile più recente di Python. Nell'esempio seguente, questo valore è indicato da*latest-Python-version*. 1. Dalla finestra di terminale, esegui i comandi seguenti: ``` pyenv install latest-Python-version pyenv global latest-Python-version ``` Ad esempio, se la versione più recente per Python 2 è 2.7.14, i comandi sono: ``` pyenv install 2.7.14 pyenv global 2.7.14 ``` 1. Chiudi e riapri la finestra del terminale ed esegui i comandi seguenti: ``` python >>>import ssl >>>print ssl.OPENSSL_VERSION ``` La versione di OpenSSL deve essere almeno 1.0.1. Se la versione è precedente a 1.0.1, l'aggiornamento non è riuscito. Controlla la versione di Python usata nei comandi **pyenv install** e **pyenv global** e riprova. 1. Esegui il comando seguente per uscire dallo shell di Python: ``` exit() ``` ------ #### [ Not using pyenv ] 1. Da una finestra del terminale, esegui il comando seguente per determinare se [brew](https://brew.sh/) è installato: ``` which brew ``` Se non viene restituito un percorso di file, installa `brew` come segue: ``` /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" ``` **Nota** Segui le istruzioni di installazione. Il download degli strumenti a riga di comando Xcode può richiedere del tempo. 1. Esegui i comandi seguenti: ``` brew update brew install openssl brew install python@2 ``` SDK per dispositivi AWS IoT for Python richiede OpenSSL versione 1.0.1 (o successiva) compilata con l'eseguibile Python. Il comando **brew install python** installa un eseguibile `python2` che soddisfa questa esigenza. L'eseguibile `python2` è installato nella directory `/usr/local/bin`, che dovrebbe essere parte della variabile di ambiente `PATH`. Per averne la conferma, esegui il comando seguente: ``` python2 --version ``` Se le informazioni di versione di `python2` vengono fornite, vai alla fase successiva. In caso contrario, aggiungi definitivamente il percorso `/usr/local/bin` alla variabile di ambiente `PATH` aggiungendo la seguente riga al profilo shell: ``` export PATH="/usr/local/bin:$PATH" ``` Ad esempio, se stai utilizzando `.bash_profile` o non disponi di un profilo shell, esegui il seguente comando da una finestra del terminale: ``` echo 'export PATH="/usr/local/bin:$PATH"' >> ~/.bash_profile ``` Quindi, [rintraccia l'origine](https://en.wikipedia.org/wiki/Source_(command)) del profilo shell e conferma che `python2 --version` fornisca le informazioni sulla versione. Ad esempio, se utilizzi `.bash_profile`, esegui i comandi seguenti: ``` source ~/.bash_profile python2 --version ``` Le informazioni sulla versione di `python2` dovrebbero essere restituite. 1. Aggiungi la riga seguente al profilo shell: ``` alias python="python2" ``` Ad esempio, se stai utilizzando `.bash_profile` o non disponi di un profilo shell, esegui il seguente comando: ``` echo 'alias python="python2"' >> ~/.bash_profile ``` 1. Quindi, [rintraccia l'origine](https://en.wikipedia.org/wiki/Source_(command)) del profilo shell. Ad esempio, se utilizzi `.bash_profile`, esegui il comando seguente: ``` source ~/.bash_profile ``` Richiamando il comando **python** verrà avviato l'eseguibile Python che contiene la versione di OpenSSL richiesta (`python2`). 1. Esegui i comandi seguenti: ``` python import ssl print ssl.OPENSSL_VERSION ``` La versione di OpenSSL deve essere almeno 1.0.1. o successiva. 1. Per uscire dallo shell di Python, esegui il comando seguente: ``` exit() ``` ------ 1. Esegui i seguenti comandi per installare il SDK per dispositivi AWS IoT for Python: ``` cd ~ git clone https://github.com/aws/aws-iot-device-sdk-python.git cd aws-iot-device-sdk-python sudo python setup.py install ``` ------ #### [ UNIX-like system ] 1. Dalla finestra di un terminale, eseguire il comando riportato qui sotto: ``` python --version ``` Se non vengono restituite le informazioni relative alla versione o se il numero di versione è inferiore a 2.7 per Python 2 o meno di 3.3 per Python 3, seguire le istruzioni in [Download di Python](https://wiki.python.org/moin/BeginnersGuide/Download) per installare Python 2.7\$1 o Python 3.3\$1. Per ulteriori informazioni, consulta [Utilizzo di Python su piattaforme Unix](https://docs.python.org/3.6/using/unix.html). 1. Nel terminale, esegui i seguenti comandi per determinare la versione di OpenSSL: ``` python >>>import ssl >>>print ssl.OPENSSL_VERSION ``` Annota il valore della versione di OpenSSL. **Nota** Se Python 3 è in esecuzione, utilizza **print(ssl.OPENSSL\$1VERSION)**. Per chiudere lo shell di Python, esegui il seguente comando: ``` exit() ``` Se la versione di OpenSSL è 1.0.1 o successiva, vai alla fase successiva. In caso contrario, esegui il comando/i per aggiornare OpenSSL per la distribuzione (ad esempio, `sudo yum update openssl`, `sudo apt-get update` e così via). Verifica che la versione di OpenSSL sia 1.0.1 o successiva eseguendo i comandi seguenti: ``` python >>>import ssl >>>print ssl.OPENSSL_VERSION >>>exit() ``` 1. Esegui i seguenti comandi per installare il SDK per dispositivi AWS IoT for Python: ``` cd ~ git clone https://github.com/aws/aws-iot-device-sdk-python.git cd aws-iot-device-sdk-python sudo python setup.py install ``` ------ 1. Dopo aver installato SDK per dispositivi AWS IoT for Python, vai alla `samples` cartella e apri la `greengrass` cartella. Per questo tutorial si copia la funzione di esempio `basicDiscovery.py`, che utilizza i certificati e le chiavi che sono stati scaricati in [Creare dispositivi client in un AWS IoT Greengrass gruppo](device-group.md). 1. Copia `basicDiscovery.py` nella cartella che contiene i certificati e le chiavi dei dispositivi HelloWorld \$1Publisher e HelloWorld \$1Subscriber. # Test delle comunicazioni 1. Assicurati che il computer e il dispositivo AWS IoT Greengrass principale siano connessi a Internet utilizzando la stessa rete. 1. Sul dispositivo AWS IoT Greengrass principale, esegui il comando seguente per trovare il relativo indirizzo IP. ``` hostname -I ``` 1. Sul computer, esegui il comando seguente utilizzando l'indirizzo IP del core. È possibile utilizzare Ctrl \$1 C per arrestare il comando **ping**. ``` ping IP-address ``` Un output simile al seguente indica una comunicazione riuscita tra il computer e il dispositivo AWS IoT Greengrass principale (perdita di pacchetti pari allo 0%): ![\[Output del comando "ping" eseguito con successo.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-075.5.png) **Nota** Se non riesci a eseguire il ping di un' EC2 istanza in esecuzione AWS IoT Greengrass, assicurati che le regole del gruppo di sicurezza in entrata relative all'istanza consentano il traffico ICMP per i messaggi di richiesta [Echo](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html#sg-rules-ping). Per ulteriori informazioni, consulta [Aggiungere regole a un gruppo di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule) nella *Amazon EC2 User Guide*. Sui computer host Windows, nell'app Windows Firewall with Advanced Security, potrebbe anche essere necessario abilitare una regola in entrata che consenta le richieste echo in entrata (ad esempio, **condivisione di file e stampanti (Echo Request - ICMPv4 -In))** o crearne una. 1. Ottieni il tuo endpoint. AWS IoT 1. Dal pannello di navigazione [AWS IoT della console](https://console.aws.amazon.com/iot/), scegli **Impostazioni**. 1. In **Device data endpoint**, prendi nota del valore di **Endpoint**. Si utilizza questo valore per sostituire il *AWS\$1IOT\$1ENDPOINT* segnaposto nei comandi nei passaggi seguenti. **Nota** Assicurati che gli [endpoint corrispondano al tipo di certificato](gg-core.md#certificate-endpoints). 1. Sul computer (non sul dispositivo AWS IoT Greengrass principale), apri due finestre della [riga di comando](https://en.wikipedia.org/wiki/Command-line_interface) (terminale o prompt dei comandi). Una finestra rappresenta il dispositivo client HelloWorld \$1Publisher e l'altra rappresenta il dispositivo client \$1Subscriber. HelloWorld Al momento dell'esecuzione, `basicDiscovery.py` tenta di raccogliere informazioni sulla posizione del AWS IoT Greengrass core nei relativi punti terminali. Queste informazioni vengono memorizzate dopo che il dispositivo client è stato scoperto e connesso correttamente al core. In questo modo le operazioni e la messaggistica future saranno eseguite in locale (senza bisogno di una connessione a Internet). **Nota** Il client IDs utilizzato per le connessioni MQTT deve corrispondere al nome dell'oggetto del dispositivo client. Lo `basicDiscovery.py` script imposta l'ID client per le connessioni MQTT sul nome dell'oggetto specificato quando si esegue lo script. Eseguite il comando seguente dalla cartella che contiene il `basicDiscovery.py` file per informazioni dettagliate sull'utilizzo dello script: ``` python basicDiscovery.py --help ``` 1. Dalla finestra del dispositivo client HelloWorld \$1Publisher, esegui i comandi seguenti. + Sostituisci *path-to-certs-folder* con il percorso della cartella che contiene i certificati, le chiavi e`basicDiscovery.py`. + Sostituisci *AWS\$1IOT\$1ENDPOINT* con il tuo endpoint. + Sostituisci le due *publisherCertId* istanze con l'ID del certificato nel nome del file per il tuo dispositivo client HelloWorld \$1Publisher. ``` cd path-to-certs-folder python basicDiscovery.py --endpoint AWS_IOT_ENDPOINT --rootCA AmazonRootCA1.pem --cert publisherCertId-certificate.pem.crt --key publisherCertId-private.pem.key --thingName HelloWorld_Publisher --topic 'hello/world/pubsub' --mode publish --message 'Hello, World! Sent from HelloWorld_Publisher' ``` L'output risultante dovrebbe essere analogo al seguente, con voci come `Published topic 'hello/world/pubsub': {"message": "Hello, World! Sent from HelloWorld_Publisher", "sequence": 1}`. **Nota** Se lo script restituisce un messaggio `error: unrecognized arguments`, cambia le virgolette singole in virgolette doppie per i parametri `--topic` e `--message` ed esegui nuovamente il comando. Per risolvere un problema di connessione, puoi provare a usare il [rilevamento IP manuale](#corp-network-manual-detection). ![\[Screenshot dell'output del publisher.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-076.png) 1. Dalla finestra del dispositivo client HelloWorld \$1Subscriber, esegui i seguenti comandi. + Sostituisci *path-to-certs-folder* con il percorso della cartella che contiene i certificati, le chiavi e. `basicDiscovery.py` + Sostituisci *AWS\$1IOT\$1ENDPOINT* con il tuo endpoint. + Sostituisci le due *subscriberCertId* istanze con l'ID del certificato nel nome del file per il tuo dispositivo client HelloWorld \$1Subscriber. ``` cd path-to-certs-folder python basicDiscovery.py --endpoint AWS_IOT_ENDPOINT --rootCA AmazonRootCA1.pem --cert subscriberCertId-certificate.pem.crt --key subscriberCertId-private.pem.key --thingName HelloWorld_Subscriber --topic 'hello/world/pubsub' --mode subscribe ``` L'output risultante dovrebbe essere il seguente, con voci come `Received message on topic hello/world/pubsub: {"message": "Hello, World! Sent from HelloWorld_Publisher", "sequence": 1}`. ![\[Screenshot dell'output del sottoscrittore.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-077.png) Chiudi il HelloWorld\$1Publisher finestra per impedire l'accumulo di messaggi nel HelloWorld\$1Subscriber finestra. Il test su una rete aziendale potrebbe interferire con la connessione al core. Come soluzione alternativa, puoi immettere manualmente l'endpoint. Ciò garantisce che lo `basicDiscovery.py` script si connetta all'indirizzo IP corretto del dispositivo AWS IoT Greengrass principale. **Per immettere manualmente l'endpoint** 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. Configura il core per gestire manualmente gli endpoint del broker MQTT. Esegui questa operazione: 1. Nella pagina di configurazione del gruppo, scegli la scheda **Funzioni Lambda**. 1. **In **Funzioni System Lambda**, scegli **Rilevatore IP**, quindi scegli Modifica.** 1. **In **Modifica le impostazioni del rilevatore IP**, scegli **Gestisci manualmente gli endpoint del broker MQTT**, quindi scegli Salva.** 1. Inserisci l'endpoint del broker MQTT per il core. Esegui questa operazione: 1. In **Panoramica**, scegli il core **Greengrass**. 1. **In Endpoints del **broker MQTT, scegli Gestisci endpoints**.** 1. Scegli **Aggiungi endpoint** e assicurati di avere un solo valore di endpoint. Questo valore deve essere l'endpoint dell'indirizzo IP per la porta 8883 del dispositivo AWS IoT Greengrass principale (ad esempio,). `192.168.1.4` 1. Scegli **Aggiorna**. # Modulo 5: interazione con dispositivi ombra Questo modulo avanzato mostra come i dispositivi client possono interagire con [le ombre dei AWS IoT dispositivi](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html) in un AWS IoT Greengrass gruppo. Una *shadow* è un documento JSON utilizzato per archiviare informazioni di stato correnti o desiderate per un oggetto. In questo modulo, scoprite come un dispositivo client (`GG_Switch`) può modificare lo stato di un altro dispositivo client (`GG_TrafficLight`) e come questi stati possono essere sincronizzati con il AWS IoT Greengrass cloud: ![\[AWS IoT Greengrass core è collegato a un dispositivo semaforico shadow e a un dispositivo di commutazione della luce.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-077.5.png) Prima di iniziare, eseguire lo script [Greengrass Device Setup](quick-start.md) o assicurarsi di aver completato il [modulo 1](module1.md) e il [modulo 2](module2.md). Dovresti anche capire come connettere i dispositivi client a un AWS IoT Greengrass core ([Modulo 4](module4.md)). Non sono necessari altri componenti o dispositivi. Il completamento di questo modulo richiede circa 30 minuti. **Topics** + [Configurazione di dispositivi e sottoscrizioni](config-dev-subs.md) + [Scarica i file richiesti](file-download.md) + [Test delle comunicazioni (sincronizzazione dispositivi disattivata)](comms-disabled.md) + [Test delle comunicazioni (sincronizzazione dispositivi attivata)](comms-enabled.md) # Configurazione di dispositivi e sottoscrizioni Le ombre possono essere sincronizzate AWS IoT quando il AWS IoT Greengrass core è connesso a Internet. In questo modulo utilizzerai prima di tutto le copie shadow locali senza sincronizzarle con il cloud. In seguito, abiliterai la sincronizzazione cloud. Ogni dispositivo client ha la propria ombra. Per ulteriori informazioni, consulta [Device shadow service AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html) nella *AWS IoT Device Shadow Guide*. 1. Nella pagina di configurazione del gruppo, scegli la scheda **Dispositivi client**. 1. Dalla scheda **Dispositivi client**, aggiungi due nuovi dispositivi client al tuo AWS IoT Greengrass gruppo. Per una procedura dettagliata di questo processo, consulta [Creare dispositivi client in un AWS IoT Greengrass gruppo](device-group.md). + Assegna un nome ai dispositivi client **GG\$1Switch** e**GG\$1TrafficLight**. + Genera e scarica le risorse di sicurezza per entrambi i dispositivi client. + Prendi nota dell'ID del certificato nei nomi dei file delle risorse di sicurezza per i dispositivi client. Questi valori verranno usati in seguito. 1. Crea una cartella sul tuo computer per le credenziali di sicurezza di questi dispositivi client. Copia i certificati e le chiavi in questa cartella. 1. Assicurati che i dispositivi client siano impostati per utilizzare le ombre locali e non si sincronizzino con. Cloud AWS In caso contrario, seleziona il dispositivo client, scegli **Sincronizza shadow**, quindi scegli **Disabilita la sincronizzazione delle ombre con il cloud**. 1. Aggiungi le sottoscrizioni nella tabella seguente al tuo gruppo. Ad esempio, per creare la prima sottoscrizione: 1. Nella pagina di configurazione del gruppo, scegli la scheda **Abbonamenti**, quindi scegli **Aggiungi**. 1. Per **Tipo di sorgente**, scegli **Dispositivo client**, quindi scegli **GG\$1Switch**. 1. Per **Tipo di destinazione**, scegliete **Servizio**, quindi scegliete **Local** Shadow Service. 1. In **Filtro di argomenti**, immetti **\$1aws/things/GG\$1TrafficLight/shadow/update**. 1. Scegli **Crea sottoscrizione**. Gli argomenti devono essere immessi esattamente come mostrato nella tabella. Anche se è possibile utilizzare i caratteri jolly per consolidare alcune delle sottoscrizioni, è sconsigliato ricorrere a questa pratica. Per ulteriori informazioni, consultate gli [argomenti relativi a Shadow MQTT](https://docs.aws.amazon.com/iot/latest/developerguide/device-shadow-mqtt.html) nella *AWS IoT Developer Guide*. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/config-dev-subs.html) **I nuovi abbonamenti vengono visualizzati nella scheda Abbonamenti.** **Nota** Per ulteriori informazioni sul carattere `$`, consulta [Argomenti riservati](https://docs.aws.amazon.com/iot/latest/developerguide/topics.html#reserved-topics). 1. Assicurati che il rilevamento automatico sia abilitato in modo che il core di Greengrass possa pubblicare un elenco dei suoi indirizzi IP. I dispositivi client utilizzano queste informazioni per scoprire il core. Esegui questa operazione: 1. Nella pagina di configurazione del gruppo, scegli la scheda **Funzioni Lambda**. 1. **In **Funzioni System Lambda**, scegli **Rilevatore IP**, quindi scegli Modifica.** 1. **In **Modifica le impostazioni del rilevatore IP**, scegli **Rileva automaticamente e sostituisci gli endpoint del broker MQTT**, quindi scegli Salva.** 1. Assicuratevi che il demone Greengrass sia in esecuzione, come descritto in. [Distribuire configurazioni cloud su un dispositivo core](configs-core.md) 1. **Nella pagina di configurazione del gruppo, scegliete Deploy.** # Scarica i file richiesti 1. Se non l'hai già fatto, installa il SDK per dispositivi AWS IoT for Python. Per istruzioni, consulta il passaggio 1 in [Installa il SDK per dispositivi AWS IoT for Python](IoT-SDK.md). Questo SDK viene utilizzato dai dispositivi client per comunicare con AWS IoT e con i dispositivi AWS IoT Greengrass principali. 1. Dalla cartella degli [ TrafficLight](https://github.com/aws/aws-greengrass-core-sdk-python/tree/master/examples/TrafficLight)esempi in poi GitHub, scarica i `trafficLight.py` file `lightController.py` and sul tuo computer. Salvateli nella cartella che contiene i certificati e le chiavi dei dispositivi TrafficLight client GG\$1Switch e GG\$1. Lo `lightController.py` script corrisponde al dispositivo client GG\$1Switch e lo script corrisponde al dispositivo client GG\$1. `trafficLight.py` TrafficLight ![\[Screenshot di file, tra cui i due script di Python, i certificati e le chiavi dei dispositivi.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-082.png) **Nota** I file Python di esempio sono archiviati nel repository AWS IoT Greengrass Core SDK for Python per comodità, ma non utilizzano Core SDK. AWS IoT Greengrass # Test delle comunicazioni (sincronizzazione dispositivi disattivata) 1. Assicurati che il computer e il dispositivo AWS IoT Greengrass principale siano connessi a Internet utilizzando la stessa rete. 1. Sul dispositivo AWS IoT Greengrass principale, esegui il comando seguente per trovare il relativo indirizzo IP. ``` hostname -I ``` 1. Sul computer, esegui il comando seguente utilizzando l'indirizzo IP del core. È possibile utilizzare Ctrl \$1 C per arrestare il comando **ping**. ``` ping IP-address ``` Un output simile al seguente indica una comunicazione riuscita tra il computer e il dispositivo AWS IoT Greengrass principale (perdita di pacchetti pari allo 0%): ![\[Output del comando "ping" eseguito con successo.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-075.5.png) **Nota** Se non riesci a eseguire il ping di un' EC2 istanza in esecuzione AWS IoT Greengrass, assicurati che le regole del gruppo di sicurezza in entrata relative all'istanza consentano il traffico ICMP per i messaggi di richiesta [Echo](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html#sg-rules-ping). Per ulteriori informazioni, consulta [Aggiungere regole a un gruppo di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule) nella *Amazon EC2 User Guide*. Sui computer host Windows, nell'app Windows Firewall with Advanced Security, potrebbe anche essere necessario abilitare una regola in entrata che consenta le richieste echo in entrata (ad esempio, **condivisione di file e stampanti (Echo Request - ICMPv4 -In))** o crearne una. 1. Ottieni il tuo endpoint. AWS IoT 1. Dal pannello di navigazione [AWS IoT della console](https://console.aws.amazon.com/iot/), scegli **Impostazioni**. 1. In **Device data endpoint**, prendi nota del valore di **Endpoint**. Si utilizza questo valore per sostituire il *AWS\$1IOT\$1ENDPOINT* segnaposto nei comandi nei passaggi seguenti. **Nota** Assicurati che gli [endpoint corrispondano al tipo di certificato](gg-core.md#certificate-endpoints). 1. Sul computer (non sul dispositivo AWS IoT Greengrass principale), apri due finestre della [riga di comando](https://en.wikipedia.org/wiki/Command-line_interface) (terminale o prompt dei comandi). Una finestra rappresenta il dispositivo client GG\$1Switch e l'altra rappresenta il dispositivo client GG\$1. TrafficLight 1. Dalla finestra del dispositivo client GG\$1Switch, esegui i seguenti comandi. + Sostituisci *path-to-certs-folder* con il percorso della cartella che contiene i certificati, le chiavi e i file Python. + *AWS\$1IOT\$1ENDPOINT*Sostituiscilo con il tuo endpoint. + Sostituisci le due *switchCertId* istanze con l'ID del certificato nel nome del file per il tuo dispositivo client GG\$1Switch. ``` cd path-to-certs-folder python lightController.py --endpoint AWS_IOT_ENDPOINT --rootCA AmazonRootCA1.pem --cert switchCertId-certificate.pem.crt --key switchCertId-private.pem.key --thingName GG_TrafficLight --clientId GG_Switch ``` 1. Dalla finestra del dispositivo TrafficLight client GG\$1, esegui i seguenti comandi. + Sostituisci *path-to-certs-folder* con il percorso della cartella che contiene i certificati, le chiavi e i file Python. + *AWS\$1IOT\$1ENDPOINT*Sostituiscilo con il tuo endpoint. + Sostituisci le due *lightCertId* istanze con l'ID del certificato nel nome del file per il tuo dispositivo client GG\$1TrafficLight . ``` cd path-to-certs-folder python trafficLight.py --endpoint AWS_IOT_ENDPOINT --rootCA AmazonRootCA1.pem --cert lightCertId-certificate.pem.crt --key lightCertId-private.pem.key --thingName GG_TrafficLight --clientId GG_TrafficLight ``` Ogni 20 secondi, lo switch aggiorna lo stato shadow a G, Y e R e la luce mostra il nuovo stato, come mostrato di seguito. Output di GG\$1Switch: ![\[Screenshot di output associati a GG_Switch.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-083.png) Uscita GG\$1: TrafficLight ![\[Schermata dell'output associato a GG_. TrafficLight\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-084.png) Quando viene eseguito per la prima volta, ogni script del dispositivo client esegue il servizio di AWS IoT Greengrass rilevamento per connettersi al AWS IoT Greengrass core (tramite Internet). Dopo che un dispositivo client è stato scoperto e connesso correttamente al AWS IoT Greengrass core, le operazioni future possono essere eseguite localmente. **Nota** Gli script `trafficLight.py` e `lightController.py` memorizzano informazioni di connessione nella cartella `groupCA`, che viene creata nella stessa cartella degli script. Se ricevi errori di connessione, assicurati che l'indirizzo IP nel `ggc-host` file corrisponda all'endpoint dell'indirizzo IP del core. 1. Nella AWS IoT console, scegli il tuo AWS IoT Greengrass gruppo, scegli la scheda **Dispositivi client**, quindi scegli **GG\$1 TrafficLight** per aprire la pagina dei dettagli dell' AWS IoT oggetto del dispositivo client. 1. Scegli la scheda **Device Shadows**. Dopo che GG\$1Switch ha cambiato lo stato, non dovrebbero esserci aggiornamenti a questa ombra. Questo perché GG\$1 TrafficLight è impostato su **Disabilita** la sincronizzazione delle ombre con il cloud. 1. Premete Ctrl \$1 C nella finestra del dispositivo client GG\$1switch ()`lightController.py`. Dovresti vedere che la finestra GG\$1 TrafficLight (`trafficLight.py`) smette di ricevere messaggi di cambio di stato. Tieni aperte queste finestre per poter eseguire i comandi nella sezione successiva. # Test delle comunicazioni (sincronizzazione dispositivi attivata) Per questo test, si configura l'ombra del TrafficLight dispositivo GG\$1 con cui sincronizzarsi. AWS IoT Si eseguono gli stessi comandi del test precedente, ma questa volta lo stato shadow nel cloud viene stato aggiornato quando GG\$1Switch invia una richiesta di aggiornamento. 1. Nella AWS IoT console, scegli il tuo AWS IoT Greengrass gruppo, quindi scegli la scheda **Dispositivi client**. 1. Seleziona il TrafficLight dispositivo GG\$1, scegli **Sincronizza shadow, quindi scegli Abilita la sincronizzazione** **delle ombre con** il cloud. Dovresti ricevere una notifica che lo stato di sincronizzazione dello shadow del dispositivo è stato aggiornato. 1. Nella pagina di configurazione del gruppo, scegli **Deploy.** 1. [Nelle due finestre a riga di comando, esegui i comandi del test precedente per i dispositivi client [GG\$1Switch e GG\$1](comms-disabled.md#run-switch-device). TrafficLight](comms-disabled.md#run-trafficlight-device) 1. Ora controlla lo stato dell'ombra nella console. AWS IoT **Scegli il tuo AWS IoT Greengrass gruppo, scegli la scheda **Dispositivi client**, scegli **GG\$1 TrafficLight**, scegli la scheda **Device Shadows**, quindi scegli Classic Shadow.** Poiché hai abilitato la sincronizzazione di GG\$1 TrafficLight shadow con AWS IoT, lo stato ombra nel cloud dovrebbe essere aggiornato ogni volta che GG\$1Switch invia un aggiornamento. Questa funzionalità può essere utilizzata per esporre lo stato di un dispositivo client a. AWS IoT **Nota** Se necessario, è possibile risolvere i problemi visualizzando i log AWS IoT Greengrass principali, in particolare: `runtime.log` ``` cd /greengrass/ggc/var/log sudo cat system/runtime.log | more ``` Puoi anche visualizzare `GGShadowSyncManager.log` e `GGShadowService.log`. Per ulteriori informazioni, consulta [Risoluzione dei problemi AWS IoT Greengrass](gg-troubleshooting.md). Mantieni configurati i dispositivi client e gli abbonamenti. Li utilizzerai nel modulo successiva. Eseguirai anche gli stessi comandi. # Modulo 6: Accesso ad altri AWS servizi Questo modulo avanzato mostra come AWS IoT Greengrass i core possono interagire con altri AWS servizi nel cloud. Si basa sull'esempio del semaforo tratto dal [Modulo 5](module5.md) e aggiunge una funzione Lambda che elabora gli stati ombra e carica un riepilogo in una tabella Amazon DynamoDB. ![\[AWS IoT collegato a un AWS IoT Greengrass nucleo, che è collegato a un interruttore della luce e all'ombra di un dispositivo semaforico. L'ombra del dispositivo semaforo è collegata a una funzione Lambda, che è connessa a una tabella DynamoDB.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-089.5.png) Prima di iniziare, eseguire lo script [Greengrass Device Setup](quick-start.md) o assicurarsi di aver completato il [modulo 1](module1.md) e il [modulo 2](module2.md). È inoltre necessario completare il [modulo 5](module5.md). Non sono necessari altri componenti o dispositivi. Il completamento di questo modulo richiede circa 30 minuti. **Nota** Questo modulo crea e aggiorna una tabella in DynamoDB. Sebbene la maggior parte delle operazioni sia di piccole dimensioni e rientri nel piano gratuito di Amazon Web Services, l'esecuzione di alcuni passaggi di questo modulo potrebbe comportare addebiti sul tuo account. Per informazioni sui prezzi, consulta la documentazione sui prezzi di [DynamoDB](https://aws.amazon.com/dynamodb/pricing/). **Topics** + [Configurazione del ruolo del gruppo](config-iam-roles.md) + [Creazione e configurazione della funzione Lambda](create-config-lambda.md) + [Configurazione delle sottoscrizioni](config_subs.md) + [Test delle comunicazioni](comms-test.md) # Configurazione del ruolo del gruppo Il ruolo di gruppo è un [ruolo IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) che crei e colleghi al tuo gruppo Greengrass. Questo ruolo contiene le autorizzazioni utilizzate dalle funzioni Lambda distribuite (e altre AWS IoT Greengrass funzionalità) per accedere ai servizi. AWS Per ulteriori informazioni, consulta [Ruolo del gruppo Greengrass](group-role.md). Utilizza i seguenti passaggi di alto livello per creare un ruolo di gruppo nella console IAM. 1. Creare una policy che consente o rifiuta operazioni su una o più risorse. 1. Creare un ruolo che utilizza il servizio Greengrass come un'entità attendibile. 1. Collegare la policy al ruolo. Quindi, nella AWS IoT console, aggiungi il ruolo al gruppo Greengrass. **Nota** Un gruppo Greengrass dispone di un ruolo del gruppo. Se desideri aggiungere autorizzazioni, puoi modificare le policy collegate o collegare altre policy.   Per questo tutorial, crei una politica di autorizzazioni che consenta di descrivere, creare e aggiornare azioni su una tabella Amazon DynamoDB. La policy viene quindi collegata a un nuovo ruolo e questo viene associato al gruppo Greengrass. Innanzitutto, crea una politica gestita dal cliente che conceda le autorizzazioni richieste dalla funzione Lambda in questo modulo. 1. **Nella console IAM, nel pannello di navigazione, scegli Policies, quindi scegli Crea **policy**.** 1. Nella scheda **JSON**, sostituire il contenuto del segnaposto con la seguente policy. La funzione Lambda di questo modulo utilizza queste autorizzazioni per creare e aggiornare una tabella DynamoDB denominata. `CarStats` ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "PermissionsForModule6", "Effect": "Allow", "Action": [ "dynamodb:DescribeTable", "dynamodb:CreateTable", "dynamodb:PutItem" ], "Resource": "arn:aws:dynamodb:*:*:table/CarStats" } ] } ``` ------ 1. Scegli **Successivo: Tag**, quindi **Successivo: Rivedi**. In questo tutorial non vengono utilizzati tag. 1. Per **Name (Nome)**, immettere **greengrass\$1CarStats\$1Table**, quindi scegliere **Create policy (Crea criterio)**.   Quindi, creare un ruolo che utilizza la nuova policy. 1. Nel pannello di navigazione, scegli **Ruoli** e quindi **Crea ruolo**. 1. In **Tipo di entità attendibile**, scegli **Servizio AWS **. 1. **In Caso d'******uso, Casi d'uso per altri AWS servizi** scegli **Greengrass**, seleziona **Greengrass** e quindi scegli Avanti.** 1. **In **Politiche di autorizzazione**, seleziona la nuova **greengrass\$1CarStats\$1Table** politica, quindi scegli Avanti.** 1. Per **Nome ruolo**, inserisci **Greengrass\$1Group\$1Role**. 1. Per **Descrizione**, inserisci **Greengrass group role for connectors and user-defined Lambda functions**. 1. Scegli **Crea ruolo**. Ora, aggiungi il ruolo al 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 **Impostazioni**, quindi scegli **Ruolo associato**. 1. Scegli **Greengrass\$1Group\$1Role**dal tuo elenco di ruoli, quindi scegli **Ruolo associato**. # Creazione e configurazione della funzione Lambda In questo passaggio, crei una funzione Lambda che tiene traccia del numero di auto che superano il semaforo. Ogni volta che passa allo stato `GG_TrafficLight` ombra`G`, la funzione Lambda simula il passaggio di un numero casuale di auto (da 1 a 20). Ogni terzo cambio di `G` luce, la funzione Lambda invia statistiche di base, come min e max, a una tabella DynamoDB. 1. Sul computer, crea una cartella denominata `car_aggregator`. 1. Dalla cartella degli [TrafficLight ](https://github.com/aws/aws-greengrass-core-sdk-python/tree/master/examples/TrafficLight)esempi in poi GitHub, scarica il `carAggregator.py` file nella cartella. `car_aggregator` Questo è il codice della tua funzione Lambda. **Nota** Questo file Python di esempio è archiviato nel repository AWS IoT Greengrass Core SDK per comodità, ma non utilizza Core SDK. AWS IoT Greengrass 1. Se non lavorate nella regione Stati Uniti orientali (Virginia settentrionale), aprite `carAggregator.py` e modificate la riga seguente con Regione AWS quella attualmente selezionata `region_name` nella console. AWS IoT Per l'elenco dei servizi supportati Regione AWS, vedi [AWS IoT Greengrass](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)in. *Riferimenti generali di Amazon Web Services* ``` dynamodb = boto3.resource('dynamodb', region_name='us-east-1') ``` 1. Esegui il comando seguente in una finestra [della riga](https://en.wikipedia.org/wiki/Command-line_interface) di comando per installare il [AWS SDK per Python (Boto3)](https://github.com/boto/boto3/blob/develop/README.rst)pacchetto e le sue dipendenze nella cartella. `car_aggregator` Le funzioni Greengrass Lambda utilizzano l' AWS SDK per accedere ad altri servizi. AWS Per Windows, utilizza un [prompt di comandi elevati](https://technet.microsoft.com/en-us/library/cc947813(v=ws.10).aspx). ``` pip install boto3 -t path-to-car_aggregator-folder ``` Questo risulta in un elenco di directory simile al seguente: ![\[Screenshot di elenco di directory che mostra "carAggregator.py".\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-095.png) 1. Comprimi i contenuti della cartella `car_aggregator` in un file `.zip` denominato `car_aggregator.zip`. Comprimi il contenuto della cartella, non la cartella stessa. Questo è il tuo pacchetto di implementazione della funzione Lambda. 1. Nella console Lambda, crea una funzione denominata **GG\$1Car\$1Aggregator** e imposta i campi rimanenti come segue: + 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 Scegli **Crea funzione**. ![\[Sezione Basic information con Function name impostato su GG_Car_Aggregator e Runtime impostato su Python 3.7.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/gg-get-started-095.5.png) 1. 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 il caricamento, quindi scegli il pacchetto di `car_aggregator.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 **carAggregator.function\$1handler** 1. Scegli **Save** (Salva). 1. Pubblica la funzione Lambda, quindi crea un alias denominato. **GG\$1CarAggregator** Per step-by-step istruzioni, consulta i passaggi per [pubblicare la funzione Lambda](create-lambda.md#publish-function-version) e [creare un alias](create-lambda.md#create-version-alias) nel Modulo 3 (parte 1). 1. Nella AWS IoT console, aggiungi la funzione Lambda che hai appena creato al tuo AWS IoT Greengrass gruppo: 1. **Nella pagina di configurazione del gruppo, scegli Funzioni **Lambda, quindi in Le mie funzioni** **Lambda**, scegli Aggiungi.** 1. **Per la **funzione Lambda**, scegli GG\$1CAR\$1Aggregator.** 1. Per la **versione della funzione Lambda**, scegli l'alias della versione che hai pubblicato. 1. Per **Memory limit (Limite memoria)**, immettere **64 MB**. 1. **Per **Pinned**, scegli True.** 1. Scegli **Aggiungi funzione Lambda**. **Nota** Puoi rimuovere altre funzioni Lambda dai moduli precedenti. # Configurazione delle sottoscrizioni In questo passaggio, si crea una sottoscrizione che consente a GG\$1 TrafficLight shadow di inviare informazioni aggiornate sullo stato alla funzione GG\$1CAR\$1Aggregator Lambda. Questa sottoscrizione viene aggiunta alle sottoscrizioni create nel [Modulo 5](module5.md), che sono tutte necessarie per questo modulo. 1. ****Nella pagina di configurazione del gruppo, scegli la scheda Sottoscrizioni, quindi scegli Aggiungi.**** 1. Nella pagina **Crea un abbonamento**, procedi come segue: 1. Per **Tipo di origine**, scegli **Servizio**, quindi scegli **Local Shadow Service**. 1. Per **Tipo di destinazione**, scegli la **funzione Lambda**, quindi scegli **GG\$1Car\$1Aggregator**. 1. In **Filtro di argomenti**, immetti **\$1aws/things/GG\$1TrafficLight/shadow/update/documents**. 1. Scegli **Crea sottoscrizione**. Questo modulo richiede la nuova sottoscrizione e le [sottoscrizioni](config-dev-subs.md#module5-subscriptions) create nel Modulo 5. 1. Assicuratevi che il demone Greengrass sia in esecuzione, come descritto in. [Distribuire configurazioni cloud su un dispositivo core](configs-core.md) 1. **Nella pagina di configurazione del gruppo, scegliete Deploy.** # Test delle comunicazioni 1. Sul computer, apri due finestre [a riga di comando](https://en.wikipedia.org/wiki/Command-line_interface). Proprio come nel [Modulo 5](module5.md), una finestra è per il dispositivo client GG\$1Switch e l'altra è per il dispositivo client TrafficLight GG\$1. Vengono usati per eseguire gli stessi comandi eseguiti nel Modulo 5. Esegui i seguenti comandi per il dispositivo client GG\$1Switch: ``` cd path-to-certs-folder python lightController.py --endpoint AWS_IOT_ENDPOINT --rootCA AmazonRootCA1.pem --cert switchCertId-certificate.pem.crt --key switchCertId-private.pem.key --thingName GG_TrafficLight --clientId GG_Switch ``` Esegui i seguenti comandi per il dispositivo client GG\$1: TrafficLight ``` cd path-to-certs-folder python trafficLight.py --endpoint AWS_IOT_ENDPOINT --rootCA AmazonRootCA1.pem --cert lightCertId-certificate.pem.crt --key lightCertId-private.pem.key --thingName GG_TrafficLight --clientId GG_TrafficLight ``` Ogni 20 secondi, lo switch aggiorna lo stato shadow a G, Y e R e la luce mostra il nuovo stato. 1. Il gestore di funzioni della funzione Lambda viene attivato ogni tre semafori verdi (ogni tre minuti) e viene creato un nuovo record DynamoDB. Dopo `trafficLight.py` aver `lightController.py` eseguito per tre minuti, vai alla console DynamoDB e apri la console DynamoDB. Console di gestione AWS 1. Scegli **Stati Uniti orientali (Virginia settentrionale) nel menu.** Regione AWS Questa è la regione dove la funzione `GG_Car_Aggregator` crea la tabella. 1. Nel riquadro di navigazione, scegli **Tabelle**, quindi scegli la **CarStats**tabella. 1. Scegli **Visualizza elementi** per visualizzare le voci nella tabella. Dovresti visualizzare le voci con statistiche di base sulle auto passate (una voce ogni tre minuti). Potrebbe essere necessario scegliere il pulsante di aggiornamento per visualizzare gli aggiornamenti alla tabella. 1. Se il test non viene completato correttamente, è possibile cercare le informazioni di risoluzione dei problemi nei log di Greengrass. 1. Passare all'utente root e navigare alla directory `log`. L'accesso ai AWS IoT Greengrass log richiede i permessi di root. ``` sudo su cd /greengrass/ggc/var/log ``` 1. Controllare in `runtime.log` se ci sono errori. ``` cat system/runtime.log | grep 'ERROR' ``` 1. Controlla il registro generato dalla funzione Lambda. ``` cat user/region/account-id/GG_Car_Aggregator.log ``` Gli script `trafficLight.py` e `lightController.py` memorizzano informazioni di connessione nella cartella `groupCA`, che viene creata nella stessa cartella degli script. Se ricevi errori di connessione, assicurati che l'indirizzo IP nel `ggc-host` file corrisponda all'endpoint dell'indirizzo IP del tuo core. Per ulteriori informazioni, consulta [Risoluzione dei problemi AWS IoT Greengrass](gg-troubleshooting.md). Questo è il termine del tutorial di base. Ora dovresti comprendere il modello di AWS IoT Greengrass programmazione e i suoi concetti fondamentali, inclusi AWS IoT Greengrass core, gruppi, sottoscrizioni, dispositivi client e il processo di distribuzione delle funzioni Lambda in esecuzione sull'edge. È possibile eliminare la tabella DynamoDB e le funzioni e gli abbonamenti Greengrass Lambda. Per interrompere le comunicazioni tra il dispositivo AWS IoT Greengrass principale e il AWS IoT cloud, apri un terminale sul dispositivo principale ed esegui uno dei seguenti comandi: + Per spegnere il dispositivo AWS IoT Greengrass principale: ``` sudo halt ``` + Per fermare il AWS IoT Greengrass demone: ``` cd /greengrass/ggc/core/ sudo ./greengrassd stop ``` # Modulo 7: simulazione dell'integrazione di sicurezza hardware Questa funzionalità è disponibile per AWS IoT Greengrass Core v1.7 e versioni successive. In questo modulo avanzato viene illustrato come configurare un modulo di sicurezza hardware (HSM) simulato per l'uso con un core Greengrass. La configurazione utilizza SoftHSM, che è un'implementazione software che utilizza l'API [PKCS\$111](#console-mod7-see-also). Lo scopo di questo modulo è quello di consentirti di configurare un ambiente in cui potrai apprendere ed effettuare i test iniziali grazie a un'implementazione software dell'API PKCS\$111. Il modulo viene fornito solo a scopo informativo e per il test iniziale e non per scopi produttivi di alcun tipo. Puoi utilizzare questa configurazione per effettuare esperimenti con l'utilizzo di un servizio compatibile con PKCS\$111 per l'archiviazione delle chiavi private. Per ulteriori informazioni sulle implementazioni software, consulta [SoftHSM](https://www.opendnssec.org/softhsm/). Per ulteriori informazioni sull'integrazione della sicurezza hardware su un AWS IoT Greengrass core, inclusi i requisiti generali, consulta. [Integrazione della sicurezza hardware](hardware-security.md) **Importante** Questo modulo viene fornito unicamente a scopo di sperimentazione. Sconsigliamo l'utilizzo di SoftHSM in un ambiente di produzione, in quanto potrebbe fornire un falso senso di maggiore sicurezza. La configurazione risultante non fornisce prestazioni di sicurezza effettive. Le chiavi archiviate in SoftHSM non sono archiviate in modo più sicuro rispetto ad altri mezzi di storage dei segreti dell'ambiente Greengrass. Lo scopo di questo modulo è quello di fornire nozioni di base sulla specifica PKCS\$111 e di eseguire il test iniziale del software, se prevedi di utilizzare in futuro un vero HSM basato sull'hardware. Dovrai effettuare il test della futura implementazione hardware separatamente e in modo completo prima di qualsiasi utilizzo in produzione, poiché potrebbero esservi differenze tra l'implementazione PKCS\$111 fornita in SoftHSM e un'implementazione basata sull'hardware. Se hai bisogno di assistenza per l'onboarding di un [modulo di sicurezza hardware supportato](hardware-security.md#hardware-security-reqs), contatta il tuo rappresentante Enterprise AWS Support. Prima di iniziare, eseguire lo script di [installazione dispositivo Greengrass](quick-start.md) o assicurarsi di aver completato il [modulo 1](module1.md) e il [modulo 2](module2.md) dell'esercitazione introduttiva. In questo modulo, si presuppone che il core sia già predisposto e con cui sia in comunicazione. AWS Il completamento di questo modulo richiede circa 30 minuti. ## Installazione del software SoftHSM In questa fase, installerai SoftHSM e gli strumenti pkcs11, utilizzati per gestire l'istanza SoftHSM. + In un terminale del dispositivo AWS IoT Greengrass principale, esegui il seguente comando: ``` sudo apt-get install softhsm2 libsofthsm2-dev pkcs11-dump ``` Per ulteriori informazioni su questi pacchetti, consulta [Installazione di softhsm2](https://www.howtoinstall.co/en/ubuntu/xenial/softhsm2), [Installazione di libsofthsm2-dev](https://www.howtoinstall.co/en/ubuntu/xenial/libsofthsm2-dev) e [Installazione di pkcs11-dump](https://www.howtoinstall.co/en/ubuntu/xenial/pkcs11-dump). **Nota** Se si riscontrano problemi durante l'utilizzo di questo comando sul sistema, vedere [SofthSM versione 2](https://github.com/opendnssec/SoftHSMv2) in poi. GitHub Questo sito fornisce ulteriori informazioni di installazione, incluse quelle relative alla compilazione a partire dal codice sorgente. ## Configurazione di SoftHSM In questa fase, [configurerai SoftHSM](https://github.com/opendnssec/SoftHSMv2#configure-1). 1. Accedi come utente root. ``` sudo su ``` 1. Utilizza la pagina del manuale per trovare la posizione `softhsm2.conf` a livello di sistema. Una posizione comune è `/etc/softhsm/softhsm2.conf`, ma la posizione potrebbe essere diversa su alcuni sistemi. ``` man softhsm2.conf ``` 1. Crea la directory per il file di configurazione softhsm2 nella posizione a livello di sistema. In questo esempio si presuppone che la posizione sia `/etc/softhsm/softhsm2.conf`. ``` mkdir -p /etc/softhsm ``` 1. Crea la directory del token nella directory `/greengrass`. **Nota** Se questa fase viene ignorata, softhsm2-util riporta `ERROR: Could not initialize the library`. ``` mkdir -p /greengrass/softhsm2/tokens ``` 1. Configurare la directory del token. ``` echo "directories.tokendir = /greengrass/softhsm2/tokens" > /etc/softhsm/softhsm2.conf ``` 1. Configurare un back-end basato su file. ``` echo "objectstore.backend = file" >> /etc/softhsm/softhsm2.conf ``` **Nota** Queste impostazioni di configurazione vengono fornite unicamente a scopo di sperimentazione. Per visualizzare tutte le opzioni di configurazione, leggi la pagina del manuale del file di configurazione. ``` man softhsm2.conf ``` ## Importazione della chiave privata in SoftHSM. In questa fase, inizializzerai il token SoftHSM, convertirai il formato della chiave privata, quindi importerai la chiave privata. 1. Inizializzare il token SoftHSM. ``` softhsm2-util --init-token --slot 0 --label greengrass --so-pin 12345 --pin 1234 ``` **Nota** Se richiesto, immettere il PIN SO `12345` e il PIN utente `1234`. AWS IoT Greengrass non utilizza il PIN SO (supervisore), pertanto è possibile usare qualsiasi valore. Se si riceve l'errore `CKR_SLOT_ID_INVALID: Slot 0 does not exist`, provare il seguente comando: ``` softhsm2-util --init-token --free --label greengrass --so-pin 12345 --pin 1234 ``` 1. Convertire la chiave privata in un formato che possa essere utilizzato dallo strumento di importazione di SoftHSM. In questo tutorial, convertirai la chiave privata ottenuta con l'opzione **Creazione gruppo predefinito** del [Modulo 2](module2.md) del tutorial Nozioni di base. ``` openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in hash.private.key -out hash.private.pem ``` 1. Importare la chiave privata in SoftHSM. Eseguire solo uno dei seguenti comandi, a seconda della versione di softhsm2-util. Sintassi **Raspbian softhsm2-util v2.2.0** ``` softhsm2-util --import hash.private.pem --token greengrass --label iotkey --id 0000 --pin 12340 ``` Sintassi **Ubuntu softhsm2-util v2.0.0** ``` softhsm2-util --import hash.private.pem --slot 0 --label iotkey --id 0000 --pin 1234 ``` Questo comando identifica lo slot come `0` e definisce l'etichetta della chiave come `iotkey`. Utilizzerai questi valori nella sezione successiva. Dopo avere importato la chiave privata, potrai rimuoverla facoltativamente dalla directory `/greengrass/certs`. Assicurati di conservare il certificati CA root e quello del dispositivo nella directory. ## Configurazione del core Greengrass per l'utilizzo di SoftHSM In questa fase, modificherai la configurazione core di Greengrass per utilizzare SoftHSM. 1. Individuare il percorso della libreria del provider SoftHSM (`libsofthsm2.so`) nel sistema: 1. Ottenere l'elenco dei pacchetti installati per la libreria. ``` sudo dpkg -L libsofthsm2 ``` Il file `libsofthsm2.so` è disponibile nella directory `softhsm`. 1. Copiare il percorso completo del file (ad esempio, `/usr/lib/x86_64-linux-gnu/softhsm/libsofthsm2.so`). Utilizzerai questo valore in un secondo momento. 1. Arrestare il daemon Greengrass. ``` cd /greengrass/ggc/core/ sudo ./greengrassd stop ``` 1. Aprire il file di configurazione Greengrass. Si tratta del file [`config.json`](gg-core.md#config-json) nella directory `/greengrass/config`. **Nota** Gli esempi in questa procedura sono scritti presupponendo che il file `config.json` utilizzi il formato generato dall'opzione **Creazione gruppo definito** del [Modulo 2](module2.md) del tutorial Nozioni di base. 1. Nell'oggetto `crypto.principals`, inserire il seguente oggetto del certificato del server MQTT. Aggiungere una virgola dove necessario per creare un file JSON valido. ``` "MQTTServerCertificate": { "privateKeyPath": "path-to-private-key" } ``` 1. Nell'oggetto `crypto`, inserisci il seguente oggetto `PKCS11`. Aggiungere una virgola dove necessario per creare un file JSON valido. ``` "PKCS11": { "P11Provider": "/path-to-pkcs11-provider-so", "slotLabel": "crypto-token-name", "slotUserPin": "crypto-token-user-pin" } ``` Il file si presenta in maniera simile a quanto riportato di seguito: ``` { "coreThing" : { "caPath" : "root.ca.pem", "certPath" : "hash.cert.pem", "keyPath" : "hash.private.key", "thingArn" : "arn:partition:iot:region:account-id:thing/core-thing-name", "iotHost" : "host-prefix.iot.region.amazonaws.com", "ggHost" : "greengrass.iot.region.amazonaws.com", "keepAlive" : 600 }, "runtime" : { "cgroup" : { "useSystemd" : "yes" } }, "managedRespawn" : false, "crypto": { "PKCS11": { "P11Provider": "/path-to-pkcs11-provider-so", "slotLabel": "crypto-token-name", "slotUserPin": "crypto-token-user-pin" }, "principals" : { "MQTTServerCertificate": { "privateKeyPath": "path-to-private-key" }, "IoTCertificate" : { "privateKeyPath" : "file:///greengrass/certs/hash.private.key", "certificatePath" : "file:///greengrass/certs/hash.cert.pem" }, "SecretsManager" : { "privateKeyPath" : "file:///greengrass/certs/hash.private.key" } }, "caPath" : "file:///greengrass/certs/root.ca.pem" } } ``` **Nota** Per utilizzare gli aggiornamenti over-the-air (OTA) con sicurezza hardware, l'`PKCS11`oggetto deve contenere anche la `OpenSSLEngine` proprietà. Per ulteriori informazioni, consulta [Configura il supporto per gli aggiornamenti over-the-air](hardware-security.md#hardware-security-ota-updates). 1. Modificare l'oggetto `crypto`: 1. Configura l'oggetto `PKCS11`. + In `P11Provider`, immettere il percorso completo di `libsofthsm2.so`. + In `slotLabel`, immettere `greengrass`. + In `slotUserPin`, immettere `1234`. 1. Configurare i percorsi delle chiavi private dell'oggetto `principals`. Non modificare la proprietà `certificatePath`. + Nelle proprietà `privateKeyPath`, immettere il seguente percorso PKCS\$111 RFC 7512 (che specifica l'etichetta della chiave). Effettuare questa operazione per i principali `IoTCertificate`, `SecretsManager` e `MQTTServerCertificate`. ``` pkcs11:object=iotkey;type=private ``` 1. Controllare l'oggetto `crypto`. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente: ``` "crypto": { "PKCS11": { "P11Provider": "/usr/lib/x86_64-linux-gnu/softhsm/libsofthsm2.so", "slotLabel": "greengrass", "slotUserPin": "1234" }, "principals": { "MQTTServerCertificate": { "privateKeyPath": "pkcs11:object=iotkey;type=private" }, "SecretsManager": { "privateKeyPath": "pkcs11:object=iotkey;type=private" }, "IoTCertificate": { "certificatePath": "file://certs/core.crt", "privateKeyPath": "pkcs11:object=iotkey;type=private" } }, "caPath": "file://certs/root.ca.pem" } ``` 1. Rimuovere i valori `caPath`, `certPath` e `keyPath` dall'oggetto `coreThing`. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente: ``` "coreThing" : { "thingArn" : "arn:partition:iot:region:account-id:thing/core-thing-name", "iotHost" : "host-prefix-ats.iot.region.amazonaws.com", "ggHost" : "greengrass-ats.iot.region.amazonaws.com", "keepAlive" : 600 } ``` **Nota** In questo tutorial, specificherai la stessa chiave privata per tutti i principali. Per ulteriori informazioni sulla scelta della chiave privata per il server MQTT locale, consulta [Prestazioni](hardware-security.md#hsm-performance). Per ulteriori informazioni sul Secrets Manager locale, consulta [Implementa i segreti fino al nucleo AWS IoT Greengrass](secrets.md). ## Test della configurazione + Avviare il daemon Greengrass. ``` cd /greengrass/ggc/core/ sudo ./greengrassd start ``` Se il daemon viene avviato, il core è stato configurato con successo. A questo punto puoi acquisire familiarità con la specifica PKCS\$111 ed effettuare il test iniziale con l'API PKCS\$111 fornita dall'implementazione SoftHSM. **Importante** Ribadiamo che è estremamente importante sapere che questo modulo è destinato solamente all'apprendimento e al test. Non aumenta la sicurezza dell'ambiente Greengrass. Lo scopo del modulo è quello di consentirti di acquisire familiarità e di effettuare test in vista dell'utilizzo futuro di un vero HSM basato sull'hardware. In quel momento, dovrai effettuare il test del software rispetto all'HSM basato sull'hardware separatamente e in modo completo prima di qualsiasi utilizzo produttivo, poiché potrebbero esservi differenze tra l'implementazione PKCS\$111 fornita in SoftHSM e una basata sull'hardware. ## Consulta anche + *PKCS \$111 Cryptographic Token Interface Usage Guide Version 2.40*. Pubblicato da John Leiseboer e Robert Griffin. 16 Novembre 2014. Nota 02 del Comitato OASIS. [http://docs.oasis-open. org/pkcs11/pkcs11-ug/v2.40/cn02/pkcs11-ug-v2.40-cn02.html](http://docs.oasis-open.org/pkcs11/pkcs11-ug/v2.40/cn02/pkcs11-ug-v2.40-cn02.html). [Ultima versione: http://docs.oasis-open. org/pkcs11/pkcs11-ug/v2.40/pkcs11-ug-v2.40.html](http://docs.oasis-open.org/pkcs11/pkcs11-ug/v2.40/pkcs11-ug-v2.40.html). + [RFC 7512](https://tools.ietf.org/html/rfc7512)