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à.
# 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
```