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à.
# Come configurare l'inferenza ottimizzata dell'apprendimento automatico utilizzando Console di gestione AWS
Per seguire i passaggi di questo tutorial, devi utilizzare AWS IoT Greengrass Core v1.10 o versione successiva.
Puoi utilizzare il compilatore di deep learning SageMaker AI Neo per ottimizzare l'efficienza di previsione dei modelli di inferenza nativi di machine learning in Tensorflow, Apache MXNet PyTorch, ONNX e framework per un ingombro ridotto e prestazioni più veloci. XGBoost Puoi quindi scaricare il modello ottimizzato e installare il runtime di deep learning SageMaker AI Neo e distribuirlo sui tuoi dispositivi per un'inferenza più rapida. AWS IoT Greengrass
Questo tutorial descrive come utilizzare Console di gestione AWS per configurare un gruppo Greengrass per eseguire un esempio di inferenza Lambda che riconosce le immagini da una fotocamera localmente, senza inviare dati al cloud. L'esempio di inferenza seguente consente di accedere al modulo della telecamera in un Raspberry Pi. In questo tutorial, scarichi un modello preconfezionato addestrato da Resnet-50 e ottimizzato nel compilatore di deep learning Neo. Il modello viene quindi utilizzato per eseguire la classificazione locale delle immagini sul dispositivo. AWS IoT Greengrass
Il tutorial include le seguenti fasi di alto livello:
1. [Configurare il dispositivo Raspberry Pi](#config-raspberry-pi-dlc)
1. [Installazione di Neo Deep Learning Runtime](#install-dlr)
1. [Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda)
1. [Aggiungere la funzione Lambda al gruppo](#ml-console-dlc-config-lambda)
1. [Aggiunta della risorsa del modello ottimizzato Neo al gruppo](#ml-console-dlc-add-resources)
1. [Aggiunta della risorsa del dispositivo della telecamera al gruppo](#ml-console-dlc-add-cam-resource)
1. [Aggiunta di sottoscrizioni al gruppo](#ml-console-dlc-add-subscription)
1. [Distribuzione del gruppo.](#ml-console-dlc-deploy-group)
1. [Test dell'esempio](#ml-console-dlc-test-app)
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Raspberry Pi 4 Model B o Raspberry Pi 3 Model B/B\$1, configurati e configurati per l'uso con. AWS IoT Greengrass Per configurare Raspberry Pi con AWS IoT Greengrass, eseguire lo script di [configurazione del dispositivo Greengrass](quick-start.md) o assicurarsi di aver completato il [modulo 1](https://docs.aws.amazon.com/greengrass/latest/developerguide/module1.html) e il [modulo 2](https://docs.aws.amazon.com/greengrass/latest/developerguide/module2.html) di [Iniziare con AWS IoT Greengrass](gg-gs.md).
**Nota**
Il Raspberry Pi potrebbe richiedere un [alimentatore](https://www.raspberrypi.org/documentation/hardware/raspberrypi/power/) da 2,5 A per eseguire i framework di deep learning generalmente utilizzati per la classificazione delle immagini. Un alimentatore con una potenza nominale inferiore potrebbe causare il riavvio del dispositivo.
+ [Modulo della telecamera Raspberry Pi V2 da 8 Megapixel, 1080p](https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS). Per informazioni sulla configurazione della telecamera, consulta [Connessione della telecamera](https://www.raspberrypi.org/documentation/usage/camera/) nella documentazione di Raspberry Pi.
+ Un gruppo e un core Greengrass. Per informazioni su come creare un gruppo o un core Greengrass, consulta [Iniziare con AWS IoT Greengrass](gg-gs.md).
**Nota**
Questo tutorial utilizza un Raspberry Pi, ma AWS IoT Greengrass supporta altre piattaforme, come [Intel Atom](#atom-lambda-dlc-config) e [NVIDIA](#jetson-lambda-dlc-config) Jetson. TX2 Se si utilizza l'esempio Intel Atom, potrebbe essere necessario installare Python 3.6 invece di Python 3.7. Per informazioni sulla configurazione del dispositivo in modo da poter installare il software Core, consulta AWS IoT Greengrass . [Configurazione di altri dispositivi](setup-filter.other.md)
Per le piattaforme di terze parti che AWS IoT Greengrass non supportano, è necessario eseguire la funzione Lambda in modalità non containerizzata. Per l'esecuzione in modalità non containerizzata, è necessario eseguire la funzione Lambda come utente root. Per ulteriori informazioni, consultare [Considerazioni sulla scelta della containerizzazione delle funzioni Lambda](lambda-group-config.md#lambda-containerization-considerations) e [Impostazione dell'identità di accesso predefinita per le funzioni Lambda in un gruppo](lambda-group-config.md#lambda-access-identity-groupsettings).
## Fase 1: Configurare il dispositivo Raspberry Pi
In questa fase, verranno installati gli aggiornamenti del sistema operativo Raspbian, il software del modulo della telecamera e le dipendenze Python e verrà abilitata l'interfaccia della telecamera.
Esegui i seguenti comandi nel terminale Raspberry Pi.
1. Installare gli aggiornamenti in Raspbian.
```
sudo apt-get update
sudo apt-get dist-upgrade
```
1. Installare l'interfaccia `picamera` per il modulo della telecamera e le altre librerie Python necessarie per questo tutorial.
```
sudo apt-get install -y python3-dev python3-setuptools python3-pip python3-picamera
```
Convalidare l'installazione:
+ Assicurati che l'installazione di Python 3.7 includa pip.
```
python3 -m pip
```
Se pip non è installato, scaricarlo dal [sito Web pip](https://pip.pypa.io/en/stable/installing/) ed eseguire il comando seguente.
```
python3 get-pip.py
```
+ Assicurati che la versione Python sia 3.7 o superiore.
```
python3 --version
```
Se l'output elenca una versione precedente, eseguire il comando seguente.
```
sudo apt-get install -y python3.7-dev
```
+ Assicurati che Setuptools e Picamera siano stati installati correttamente.
```
sudo -u ggc_user bash -c 'python3 -c "import setuptools"'
sudo -u ggc_user bash -c 'python3 -c "import picamera"'
```
Se l'output non contiene errori, la convalida ha esito positivo.
**Nota**
Se l'eseguibile Python installato sul dispositivo è `python3.7`, utilizzare `python3.7` invece di `python3` per i comandi in questo tutorial. Assicurati che l'installazione di pip sia mappata alla versione `python3.7` o `python3` corretta per evitare errori di dipendenza.
1. Riavvia il dispositivo Raspberry Pi.
```
sudo reboot
```
1. Apri lo strumento di configurazione di Raspberry Pi.
```
sudo raspi-config
```
1. Utilizza i tasti freccia per aprire **Interfacing Options (Opzioni di interfaccia)** e abilita l'interfaccia della telecamera. Se richiesto, consenti il riavvio del dispositivo.
1. Utilizza il seguente comando per eseguire il test della configurazione della telecamera.
```
raspistill -v -o test.jpg
```
Viene visualizzata una finestra di anteprima sul dispositivo Raspberry Pi, viene salvata un'immagine denominata `test.jpg` nella directory corrente e vengono visualizzati informazioni sulla telecamera nel terminale Raspberry Pi.
## Fase 2: installa il runtime di deep learning di Amazon SageMaker Neo
In questo passaggio, installa il Neo deep learning runtime (DLR) sul tuo Raspberry Pi.
**Nota**
Per questo tutorial si consiglia di installare la versione 1.1.0.
1. Accedere al Raspberry Pi da remoto.
```
ssh pi@your-device-ip-address
```
1. Aprire la documentazione DLR, aprire [Installazione DLR](https://neo-ai-dlr.readthedocs.io/en/latest/install.html) e individuare il wheel URL dei dispositivi Raspberry Pi. Seguire quindi le istruzioni per installare il DLR sul dispositivo. Ad esempio, è possibile utilizzare pip:
```
pip3 install rasp3b-wheel-url
```
1. Dopo aver installato il DLR, convalidare la seguente configurazione:
+ Assicurarsi che l'account di sistema `ggc_user` possa utilizzare la libreria DLR.
```
sudo -u ggc_user bash -c 'python3 -c "import dlr"'
```
+ Assicurati che NumPy sia installato.
```
sudo -u ggc_user bash -c 'python3 -c "import numpy"'
```
## Fase 3: Creare una funzione Lambda di inferenza
In questo passaggio, crea un pacchetto di distribuzione della funzione Lambda e una funzione Lambda. Quindi pubblicare una versione della funzione e creare un alias.
1. Sul computer, scaricare l'esempio DLR per Raspberry Pi da [Esempi di Machine Learning](what-is-gg.md#gg-ml-samples).
1. Decomprimere il file `dlr-py3-armv7l.tar.gz` scaricato.
```
cd path-to-downloaded-sample
tar -xvzf dlr-py3-armv7l.tar.gz
```
La directory `examples` nel pacchetto di esempio estratto contiene il codice di funzione e le dipendenze.
+ `inference.py` è il codice di inferenza utilizzato in questo tutorial. È possibile utilizzare questo codice come modello per creare la propria funzione di inferenza.
+ `greengrasssdk`è la versione 1.5.0 del AWS IoT Greengrass Core SDK for Python.
**Nota**
Se è disponibile una nuova versione, è possibile scaricarla e aggiornare la versione dell'SDK nel pacchetto di distribuzione. Per ulteriori informazioni, consulta [AWS IoT Greengrass Core SDK for GitHub Python on](https://github.com/aws/aws-greengrass-core-sdk-python/).
1. Comprimere il contenuto della directory `examples` in un file denominato `optimizedImageClassification.zip`. Questo è il pacchetto di distribuzione.
```
cd path-to-downloaded-sample/dlr-py3-armv7l/examples
zip -r optimizedImageClassification.zip .
```
Il pacchetto di distribuzione contiene il codice di funzione e le dipendenze. Ciò include il codice che richiama il runtime di Neo deep learning Python APIs per eseguire inferenze con i modelli del compilatore Neo deep learning.
**Nota**
Assicurarsi inoltre che i file `.py` e le dipendenze si trovino nella radice della directory.
1. Ora aggiungete la funzione Lambda al vostro gruppo Greengrass.
Dalla pagina della console Lambda, scegli **Funzioni** e scegli **Crea** funzione.
1. Scegli **Author da zero** e usa i seguenti valori per creare la tua funzione:
+ Nel campo **Function name (Nome funzione)**, immettere **optimizedImageClassification**.
+ 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
![\[La sezione sulle informazioni di base della pagina Crea funzione.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-dlc-inference/gg-dlr-lambda-creation.png)
1. Scegli **Crea funzione**.
Ora carica il pacchetto di distribuzione della funzione Lambda e registra il gestore.
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 pacchetto `optimizedImageClassification.zip` di distribuzione, quindi scegli Salva.**
1. Nella scheda **Codice** della funzione, in **Impostazioni di runtime**, scegli **Modifica**, quindi inserisci i seguenti valori.
+ In **Runtime**, scegliere **Python 3.7**.
+ Per **Gestore**, inserisci **inference.handler**.
Scegli **Save** (Salva).
![\[La sezione Impostazioni di runtime con Upload evidenziata.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-lambda-upload.png)
Successivamente, pubblica la prima versione della tua funzione Lambda. Quindi, creare un [alias per la versione](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. È sufficiente invece indirizzare l'alias alla nuova versione della funzione.
1. Nel menu **Actions (Operazioni)**, seleziona **Publish new version (Pubblica nuova versione)**.
![\[L'opzione Publish new version (Pubblica nuova versione) nel menu Actions (Azioni).\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-publish-new.png)
1. Per **Version description (Descrizione versione)**, immettere **First version**, quindi scegliere **Publish (Pubblica)**.
1. Nella pagina di configurazione **optimizedImageClassification: 1**, dal menu **Azioni**, scegli **Crea alias**.
![\[L'opzione Create alias (Crea alias) nel menu Actions (Azioni).\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-create-alias.png)
1. Nella pagina **Create a new alias (Crea un nuovo alias)**, utilizza i seguenti valori:
+ In **Nome**, inserisci **mlTestOpt**.
+ Per **Version (Versione)**, immettere **1**.
**Nota**
AWS IoT Greengrass **non supporta gli alias Lambda per le versioni \$1LATEST.**
1. Scegli **Create** (Crea).
Ora aggiungete la funzione Lambda al vostro gruppo Greengrass.
## Fase 4: Aggiungere la funzione Lambda al gruppo Greengrass
In questo passaggio, aggiungi la funzione Lambda al gruppo, quindi configura il suo ciclo di vita.
Innanzitutto, aggiungi la funzione Lambda al tuo gruppo Greengrass.
1. Nel riquadro di navigazione della AWS IoT console, in **Gestione**, espandi **i dispositivi Greengrass**, quindi scegli **Gruppi (V1**).
1. **Nella pagina di configurazione dei gruppi, scegli la scheda **Funzioni Lambda** e scegli Aggiungi.**
1. Scegli la **funzione Lambda** e seleziona. **optimizedImageClassification**
1. Nella **versione della funzione Lambda**, scegli l'alias della versione che hai pubblicato.
Quindi, configura il ciclo di vita della funzione Lambda.
1. Nella sezione di **configurazione della funzione Lambda**, apporta i seguenti aggiornamenti.
**Nota**
Ti consigliamo di eseguire la funzione Lambda senza containerizzazione a meno che il tuo business case non lo richieda. Ciò consente l'accesso alla GPU e alla fotocamera del dispositivo senza configurare le risorse del dispositivo. Se esegui senza containerizzazione, devi anche concedere l'accesso root alle tue funzioni Lambda AWS IoT Greengrass .
1. **Per eseguire senza containerizzazione:**
+ Per **Utente e gruppo di sistema, scegli**. **Another user ID/group ID** Per **ID utente di sistema**, immettere**0**. Per **ID del gruppo di sistema**, immettere**0**.
Ciò consente alla funzione Lambda di funzionare come root. Per ulteriori informazioni sull'esecuzione come root, consulta[Impostazione dell'identità di accesso predefinita per le funzioni Lambda in un gruppo](lambda-group-config.md#lambda-access-identity-groupsettings).
**Suggerimento**
È inoltre necessario aggiornare il `config.json` file per concedere l'accesso root alla funzione Lambda. Per la procedura, vedi[Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
+ **Per la **containerizzazione della funzione Lambda**, scegli Nessun contenitore.**
Per ulteriori informazioni sull'esecuzione senza containerizzazione, consulta. [Considerazioni sulla scelta della containerizzazione delle funzioni Lambda](lambda-group-config.md#lambda-containerization-considerations)
+ Per **Timeout**, immettere **10 seconds**.
+ **Per **Pinned**, scegli True.**
Per ulteriori informazioni, consulta [Configurazione del ciclo di vita per le funzioni Greengrass Lambda](lambda-functions.md#lambda-lifecycle).
+ **In **Parametro aggiuntivo**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
1. **Per eseguire invece in modalità containerizzata:**
**Nota**
Si sconsiglia l'esecuzione in modalità containerizzata a meno che il business case non lo richieda.
+ Per **Utente e gruppo di sistema**, scegli **Usa i valori predefiniti del gruppo**.
+ **Per la **containerizzazione delle funzioni Lambda**, scegli Usa default di gruppo.**
+ Per **Memory limit (Limite memoria)**, immettere **1024 MB**.
+ Per **Timeout**, immettere **10 seconds**.
+ **Per **Pinned**, scegli True.**
Per ulteriori informazioni, consulta [Configurazione del ciclo di vita per le funzioni Greengrass Lambda](lambda-functions.md#lambda-lifecycle).
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
1. Scegli **Aggiungi funzione Lambda**.
## Passaggio 5: aggiungere una risorsa modello ottimizzata per SageMaker AI NEO al gruppo Greengrass
In questo passaggio, crea una risorsa per il modello di inferenza ML ottimizzato e caricala in un bucket Amazon S3. Quindi, individua il modello caricato da Amazon S3 nella AWS IoT Greengrass console e associa la risorsa appena creata alla funzione Lambda. In questo modo la funzione potrà accedere alle risorse nel dispositivo core.
1. Nel computer, passare alla directory `resnet50` nel pacchetto di esempio decompresso in [Fase 3: Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda).
**Nota**
Se si utilizza l'esempio NVIDIA Jetson, è necessario utilizzare la directory `resnet18` nel pacchetto di esempio. Per ulteriori informazioni, consulta [Configurazione di un NVIDIA Jetson TX2](#jetson-lambda-dlc-config).
```
cd path-to-downloaded-sample/dlr-py3-armv7l/models/resnet50
```
Questa directory contiene artefatti di modelli precompilati di un modello di classificazione delle immagini basato su Resnet-50.
1. Comprimere i file all'interno della directory `resnet50` in un file denominato `resnet50.zip`.
```
zip -r resnet50.zip .
```
1. Nella pagina di configurazione del AWS IoT Greengrass gruppo, scegli la scheda **Risorse**. Accedi alla sezione **Machine Learning** e scegli **Add Machine Learning resource (Aggiungi risorsa Machine Learning)**. Nella pagina **Create a Machine Learning resource (Crea una risorsa Machine Learning)**, per **Resource name (Nome risorsa)**, immetti **resnet50\$1model**.
1. Per **Model source**, scegli **Usa un modello archiviato in S3, ad esempio un modello ottimizzato tramite Deep Learning Compiler**.
1. **In **URI S3**, scegli Browse S3.**
**Nota**
Attualmente, i modelli di SageMaker intelligenza artificiale ottimizzati vengono archiviati automaticamente in Amazon S3. Puoi trovare il modello ottimizzato nel tuo bucket Amazon S3 utilizzando questa opzione. Per ulteriori informazioni sull'ottimizzazione dei modelli nell' SageMaker intelligenza artificiale, consulta la documentazione di [SageMaker AI Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).
1. Scegli **Upload a model (Carica un modello)**.
1. Nella scheda della console Amazon S3, carica il file zip in un bucket Amazon S3. Per informazioni, vedi [Come faccio a caricare file e cartelle in un bucket S3](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html)? nella *Guida per l'utente di Amazon Simple Storage Service*.
**Nota**
Il nome del bucket deve contenere la stringa **greengrass**. Scegliere un nome univoco (ad esempio **greengrass-dlr-bucket-*user-id*-*epoch-time***). Non utilizzare un punto (`.`) nel nome del bucket.
1. Nella scheda AWS IoT Greengrass console, individua e scegli il tuo bucket Amazon S3. Individuare e il file `resnet50.zip` caricato e scegliere **Select (Seleziona)**. Potrebbe essere necessario aggiornare la pagina per aggiornare l'elenco dei bucket e dei file disponibili.
1. In **Percorso di destinazione, inserisci**. **/ml\$1model**
![\[Il percorso di destinazione aggiornato.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-dlc-inference/local-path.png)
Questa è la destinazione del modello locale nello spazio dei nomi di runtime Lambda. Quando distribuisci il gruppo, AWS IoT Greengrass recupera il pacchetto del modello sorgente e quindi estrae il contenuto nella directory specificata.
**Nota**
Ti consigliamo di utilizzare lo stesso percorso fornito per il percorso locale. Se in questa fase utilizzi un percorso di destinazione del modello locale diverso, alcuni comandi di risoluzione dei problemi specificati in questo tutorial potrebbero risultare imprecisi. Se utilizzi un percorso diverso, dovrai impostare una variabile di ambiente `MODEL_PATH` che utilizzi lo stesso percorso specificato qui. Per informazioni sulle variabili di ambiente, consulta [Variabili di ambiente AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/env_variables.html).
1. **Se è in esecuzione in modalità containerizzata:**
1. In **Proprietario del gruppo di sistema e autorizzazioni di accesso ai file, scegli **Specificare il gruppo di sistema** e le autorizzazioni**.
1. **Scegli **Accesso in sola lettura**, quindi scegli Aggiungi risorsa.**
## Fase 6: aggiunta della risorsa del dispositivo della telecamera al gruppo Greengrass
In questo passaggio, crea una risorsa per il modulo fotocamera e associala alla funzione Lambda. Ciò consente alla funzione Lambda di accedere alla risorsa sul dispositivo principale.
**Nota**
Se si esegue in modalità non containerizzata, è AWS IoT Greengrass possibile accedere alla GPU e alla fotocamera del dispositivo senza configurare questa risorsa del dispositivo.
1. **Nella pagina di configurazione del gruppo, scegli la scheda Risorse.**
1. Nella scheda **Risorse locali**, scegli **Aggiungi risorsa locale**.
1. Nella pagina **Aggiungi una risorsa locale**, utilizza i seguenti valori:
+ Per **Resource Name (Nome risorsa)** immetti **videoCoreSharedMemory**.
+ Per **Resource type (Tipo di risorsa)**, scegli **Device (Dispositivo)**.
+ Per **Percorso del dispositivo locale**, immettere**/dev/vcsm**.
Il percorso del dispositivo è il percorso assoluto locale della risorsa del dispositivo. Questo percorso fa riferimento solo a un dispositivo a caratteri o un dispositivo a blocchi in `/dev`.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file****, scegli Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
L'opzione **Group owner file access permission (Autorizzazione per l'accesso al file del proprietario del gruppo)** consente di concedere al processo Lambda ulteriori autorizzazioni di accesso ai file. Per ulteriori informazioni, consulta [Autorizzazione di accesso ai file dell'owner del gruppo](access-local-resources.md#lra-group-owner).
1. Nella parte inferiore della pagina, scegli **Aggiungi** risorsa.
1. Dalla scheda **Risorse**, crea un'altra risorsa locale scegliendo **Aggiungi** e utilizza i seguenti valori:
+ Per **Resource Name (Nome risorsa)** immetti **videoCoreInterface**.
+ Per **Resource type (Tipo di risorsa)**, scegli **Device (Dispositivo)**.
+ Per **Percorso del dispositivo locale**, immettere**/dev/vchiq**.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file****, scegli Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
1. Scegliere **Add resource (Aggiungi risorsa)**.
## Fase 7: aggiunta di sottoscrizioni al gruppo Greengrass
In questa fase, si aggiungono le sottoscrizioni al gruppo. Questi abbonamenti consentono alla funzione Lambda di inviare risultati AWS IoT di previsione pubblicandoli su un argomento MQTT.
1. **Nella pagina di configurazione del gruppo, scegli la scheda **Abbonamenti**, quindi scegli Aggiungi abbonamento.**
1. Nella pagina **Crea un abbonamento**, configura l'origine e la destinazione come segue:
1. In **Tipo di sorgente**, scegli **Funzione Lambda**, quindi scegli. **optimizedImageClassification**
1. Nel **tipo di Target**, scegli **Servizio**, quindi scegli **IoT Cloud**.
1. Nel **filtro Argomento****/resnet-50/predictions**, inserisci, quindi scegli **Crea abbonamento**.
1. Aggiungere un secondo abbonamento. Scegli la scheda **Abbonamenti**, scegli **Aggiungi abbonamento** e configura l'origine e la destinazione come segue:
1. In **Tipo di origine**, scegli **Servizi**, quindi scegli **IoT Cloud**.
1. In **Tipo di destinazione**, scegli **Funzione Lambda**, quindi scegli. **optimizedImageClassification**
1. Nel **filtro Argomento**, inserisci**/resnet-50/test**, quindi scegli **Crea abbonamento**.
## Fase 8: distribuzione del gruppo Greengrass
In questa fase, distribuire la versione corrente della definizione del gruppo nel dispositivo core Greengrass. La definizione contiene la funzione Lambda, le risorse e le configurazioni di sottoscrizione che hai aggiunto.
1. Assicurati che il AWS IoT Greengrass core sia in esecuzione. Esegui i seguenti comandi nel terminale di Raspberry Pi in base alle esigenze.
1. Per controllare se il daemon è in esecuzione:
```
ps aux | grep -E 'greengrass.*daemon'
```
Se l'output contiene una voce `root` per `/greengrass/ggc/packages/latest-core-version/bin/daemon`, allora il daemon è in esecuzione.
1. Per avviare il demone:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. **Nella pagina di configurazione del gruppo, scegli Deploy.**
1. **Nella scheda **Funzioni Lambda**, seleziona **Rilevatore IP** e scegli Modifica.**
1. **Nella finestra di dialogo **Modifica impostazioni del rilevatore IP**, seleziona Rileva **automaticamente e sostituisci gli endpoint del broker MQTT e** scegli Salva.**
Questo consente ai dispositivi di acquisire automaticamente informazioni di base sulla connettività, come, ad esempio indirizzo IP, DNS e numero della porta. Il rilevamento automatico è consigliato, ma supporta AWS IoT Greengrass anche gli endpoint specificati manualmente. Ti viene chiesto il metodo di individuazione solo la prima volta che il gruppo viene distribuito.
**Nota**
Se richiesto, concedi l'autorizzazione a creare il ruolo di [servizio Greengrass](service-role.md) e associarlo al Account AWS tuo ruolo attuale. Regione AWS Questo ruolo consente di accedere AWS IoT Greengrass alle tue risorse nei AWS servizi.
Nella pagina **Deployments (Distribuzioni)** vengono visualizzati il timestamp della distribuzione, l'ID versione e lo stato. Una volta completata, lo stato visualizzato per la distribuzione dovrebbe essere **Completato**.
Per ulteriori informazioni sulle implementazioni, consulta [Distribuisci AWS IoT Greengrass i gruppi su un core AWS IoT Greengrass](deployments.md). Per la risoluzione dei problemi, consultare [Risoluzione dei problemi AWS IoT Greengrass](gg-troubleshooting.md).
## Esecuzione del test dell'esempio di inferenza
Ora puoi verificare se la distribuzione è configurata correttamente. Per eseguire il test, devi abbonarti all'argomento `/resnet-50/predictions` e pubblicare eventuali messaggi nell'argomento `/resnet-50/test`. Questo attiva la funzione Lambda per scattare una foto con il tuo Raspberry Pi ed eseguire inferenze sull'immagine che cattura.
**Nota**
Se si utilizza l'esempio di NVIDIA Jetson, assicurarsi di utilizzare invece gli argomenti `resnet-18/predictions` e `resnet-18/test`.
**Nota**
Se a dispositivo Raspberry Pi è collegato un monitor, il segnale attivo della telecamera viene visualizzato in una finestra di anteprima.
1. **Nella home page della AWS IoT console, in Test, scegli MQTT **test client**.**
1. Per **gli abbonamenti**, scegliete **Iscriviti a un argomento**. Utilizzare i seguenti valori. Non modificare i valori predefiniti delle altre opzioni:
+ Per **Argomento sottoscrizione**, immetti **/resnet-50/predictions**.
+ In **Configurazione aggiuntiva**, per la visualizzazione del **payload MQTT, scegli **Visualizza i payload**** come stringhe.
1. Scegli **Abbonati**.
1. **Scegliete **Pubblica su un argomento**, immettetelo **/resnet-50/test** come **nome dell'argomento** e scegliete Pubblica.**
1. Se il test viene completato senza errori, il messaggio pubblicato richiederà a Raspberry Pi di acquisire un'immagine. Nella parte inferiore della pagina viene visualizzato un messaggio della funzione Lambda. Questo messaggio contiene il risultato predittivo dell'immagine nel formato: nome classe prevista, probabilità e picco di utilizzo della memoria.
## Configurazione di un dispositivo Intel Atom
Per eseguire questo tutorial su un dispositivo Intel Atom, è necessario fornire immagini di origine, configurare la funzione Lambda e aggiungere un'altra risorsa del dispositivo locale. Per utilizzare la GPU per l'inferenza, assicurarsi che sul dispositivo sia installato il seguente software:
+ OpenCL versione 1.0 o successiva
+ Python 3.7 e pip
+ [NumPy](https://pypi.org/project/numpy/)
+ [OpenCV su Wheels](https://pypi.org/project/opencv-python/)
1. Scarica immagini PNG o JPG statiche per la funzione Lambda da utilizzare per la classificazione delle immagini. L'esempio funziona in modo ottimale con file immagine di dimensioni ridotte.
Salva i file immagine nella directory contenente il file `inference.py` (o in una sottodirectory di questa directory). Si trova nel pacchetto di distribuzione della funzione Lambda in cui carichi. [Fase 3: Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda)
**Nota**
Se la utilizzi AWS DeepLens, puoi utilizzare la videocamera di bordo o montare la tua fotocamera per eseguire inferenze sulle immagini acquisite anziché sulle immagini statiche. Tuttavia, ti consigliamo di iniziare con le immagini statiche.
Se si utilizza una telecamera, assicurarsi che il pacchetto APT `awscam` sia installato e aggiornato. Per ulteriori informazioni, consulta [Aggiorna il tuo AWS DeepLens dispositivo nella Guida](https://docs.aws.amazon.com/deeplens/latest/dg/deeplens-manual-updates.html) per gli *AWS DeepLens sviluppatori*.
1. Modifica la configurazione della funzione Lambda. Segui la procedura riportata in [Fase 4: Aggiungere la funzione Lambda al gruppo Greengrass](#ml-console-dlc-config-lambda).
**Nota**
Ti consigliamo di eseguire la funzione Lambda senza containerizzazione a meno che il tuo business case non lo richieda. Ciò consente l'accesso alla GPU e alla fotocamera del dispositivo senza configurare le risorse del dispositivo. Se esegui senza containerizzazione, devi anche concedere l'accesso root alle tue funzioni Lambda AWS IoT Greengrass .
1. **Per eseguire senza containerizzazione:**
+ Per **Utente e gruppo di sistema, scegli**. **Another user ID/group ID** Per **ID utente di sistema**, immettere**0**. Per **ID del gruppo di sistema**, immettere**0**.
Ciò consente alla funzione Lambda di funzionare come root. Per ulteriori informazioni sull'esecuzione come root, consulta[Impostazione dell'identità di accesso predefinita per le funzioni Lambda in un gruppo](lambda-group-config.md#lambda-access-identity-groupsettings).
**Suggerimento**
È inoltre necessario aggiornare il `config.json` file per concedere l'accesso root alla funzione Lambda. Per la procedura, vedi[Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
+ **Per la **containerizzazione della funzione Lambda**, scegli Nessun contenitore.**
Per ulteriori informazioni sull'esecuzione senza containerizzazione, consulta. [Considerazioni sulla scelta della containerizzazione delle funzioni Lambda](lambda-group-config.md#lambda-containerization-considerations)
+ Aumenta il valore di **Timeout** a 2 minuti. In questo modo, il timeout della richiesta non viene eseguito troppo presto. L'esecuzione dell'inferenza richiede alcuni minuti dopo la configurazione.
+ **Per **Pinned**, scegli True.**
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
1. **Per eseguire invece in modalità containerizzata:**
**Nota**
Si sconsiglia l'esecuzione in modalità containerizzata a meno che il business case non lo richieda.
+ Aumenta il valore di **Memory limit (Limite memoria)** a 3000 MB.
+ Aumenta il valore di **Timeout** a 2 minuti. In questo modo, il timeout della richiesta non viene eseguito troppo presto. L'esecuzione dell'inferenza richiede alcuni minuti dopo la configurazione.
+ **Per **Pinned**, scegli True.**
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
1. Aggiungere la risorsa del modello ottimizzato Neo al gruppo Caricare le risorse del modello nella directory `resnet50` del pacchetto di esempio decompresso in [Fase 3: Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda). Questa directory contiene artefatti di modelli precompilati di un modello di classificazione delle immagini basato su Resnet-50. Segui la procedura descritta in [Passaggio 5: aggiungere una risorsa modello ottimizzata per SageMaker AI NEO al gruppo Greengrass](#ml-console-dlc-add-resources), con i seguenti aggiornamenti:
+ Comprimere i file all'interno della directory `resnet50` in un file denominato `resnet50.zip`.
+ Nella pagina **Create a Machine Learning resource (Crea una risorsa Machine Learning)**, per **Resource name (Nome risorsa)**, immetti **resnet50\$1model**.
+ Caricare il file `resnet50.zip`
1. **Se è in esecuzione in modalità containerizzata**, aggiungi la risorsa del dispositivo locale richiesta per concedere l'accesso alla GPU del dispositivo.
**Nota**
Se esegui in modalità non containerizzata, AWS IoT Greengrass puoi accedere alla GPU del dispositivo senza configurare le risorse del dispositivo.
1. **Nella pagina di configurazione del gruppo, scegli la scheda Risorse.**
1. Nella sezione **Risorse locali**, scegli **Aggiungi risorsa locale**.
1. Definisci la risorsa:
+ Per **Resource Name (Nome risorsa)** immetti **renderD128**.
+ Per **Resource type (Tipo di risorsa)**, scegli **Device (Dispositivo)**.
+ Per **Percorso del dispositivo locale**, immettere**/dev/dri/renderD128**.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file****, scegli Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
## Configurazione di un NVIDIA Jetson TX2
Per eseguire questo tutorial su un NVIDIA Jetson TX2, fornisci immagini sorgente, configura la funzione Lambda e aggiungi altre risorse locali del dispositivo.
1. Assicurati che il tuo dispositivo Jetson sia configurato in modo da poter installare il software AWS IoT Greengrass Core e utilizzare la GPU per l'inferenza. Per ulteriori informazioni sulla configurazione del dispositivo, consulta [Configurazione di altri dispositivi](setup-filter.other.md). Per utilizzare la GPU per l'inferenza su un NVIDIA Jetson TX2, devi installare CUDA 10.0 e cuDNN 7.0 sul tuo dispositivo quando immagini la tua scheda con Jetpack 4.3.
1. Scarica immagini PNG o JPG statiche per la funzione Lambda da utilizzare per la classificazione delle immagini. L'esempio funziona in modo ottimale con file immagine di dimensioni ridotte.
Salvare i file immagine nella directory contenente il file `inference.py`. È possibile salvarli anche in una sottodirectory di questa directory. Questa directory si trova nel pacchetto di distribuzione della funzione Lambda in cui carichi. [Fase 3: Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda)
**Nota**
In alternativa, puoi scegliere di implementare una telecamera sulla scheda Jetson per acquisire le immagini di origine. Tuttavia, ti consigliamo di iniziare con le immagini statiche.
1. Modifica la configurazione della funzione Lambda. Segui la procedura riportata in [Fase 4: Aggiungere la funzione Lambda al gruppo Greengrass](#ml-console-dlc-config-lambda).
**Nota**
Ti consigliamo di eseguire la funzione Lambda senza containerizzazione a meno che il tuo business case non lo richieda. Ciò consente l'accesso alla GPU e alla fotocamera del dispositivo senza configurare le risorse del dispositivo. Se esegui senza containerizzazione, devi anche concedere l'accesso root alle tue funzioni Lambda AWS IoT Greengrass .
1. **Per eseguire senza containerizzazione:**
+ Per **Esegui come, scegli**. **Another user ID/group ID** Per **UID**, inserisci**0**. Per **GUID, immettere**. **0**
Ciò consente alla funzione Lambda di funzionare come root. Per ulteriori informazioni sull'esecuzione come root, consulta[Impostazione dell'identità di accesso predefinita per le funzioni Lambda in un gruppo](lambda-group-config.md#lambda-access-identity-groupsettings).
**Suggerimento**
È inoltre necessario aggiornare il `config.json` file per concedere l'accesso root alla funzione Lambda. Per la procedura, vedi[Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
+ **Per la **containerizzazione della funzione Lambda**, scegli Nessun contenitore.**
Per ulteriori informazioni sull'esecuzione senza containerizzazione, consulta. [Considerazioni sulla scelta della containerizzazione delle funzioni Lambda](lambda-group-config.md#lambda-containerization-considerations)
+ Aumenta il valore **Timeout** a 5 minuti. In questo modo, il timeout della richiesta non viene eseguito troppo presto. L'esecuzione dell'inferenza richiede alcuni minuti dopo la configurazione.
+ **Per **Pinned**, scegli True.**
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
1. **Per eseguire invece in modalità containerizzata:**
**Nota**
Si sconsiglia l'esecuzione in modalità containerizzata a meno che il business case non lo richieda.
+ Aumenta il valore di **Memory limit (Limite memoria)**. Per utilizzare il modello fornito in modalità GPU, utilizza almeno 2000 MB.
+ Aumenta il valore **Timeout** a 5 minuti. In questo modo, il timeout della richiesta non viene eseguito troppo presto. L'esecuzione dell'inferenza richiede alcuni minuti dopo la configurazione.
+ **Per **Pinned**, scegli True.**
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
1. Aggiungere la risorsa del modello ottimizzato Neo al gruppo Caricare le risorse del modello nella directory `resnet18` del pacchetto di esempio decompresso in [Fase 3: Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda). Questa directory contiene artefatti di modelli precompilati di un modello di classificazione delle immagini basato su Resnet-18. Segui la procedura descritta in [Passaggio 5: aggiungere una risorsa modello ottimizzata per SageMaker AI NEO al gruppo Greengrass](#ml-console-dlc-add-resources), con i seguenti aggiornamenti:
+ Comprimere i file all'interno della directory `resnet18` in un file denominato `resnet18.zip`.
+ Nella pagina **Create a Machine Learning resource (Crea una risorsa Machine Learning)**, per **Resource name (Nome risorsa)**, immetti **resnet18\$1model**.
+ Caricare il file `resnet18.zip`
1. **Se è in esecuzione in modalità containerizzata**, aggiungi le risorse del dispositivo locale necessarie per concedere l'accesso alla GPU del dispositivo.
**Nota**
Se esegui in modalità non containerizzata, AWS IoT Greengrass puoi accedere alla GPU del dispositivo senza configurare le risorse del dispositivo.
1. **Nella pagina di configurazione del gruppo, scegli la scheda Risorse.**
1. Nella sezione **Risorse locali**, scegli **Aggiungi risorsa locale**.
1. Definisci ogni risorsa:
+ Per **Resource name (Nome risorsa)** e **Device path (Percorso dispositivo)**, utilizza i valori nella tabella seguente. Crea una risorsa del dispositivo per ogni riga nella tabella.
+ Per **Resource type (Tipo di risorsa)**, scegli **Device (Dispositivo)**.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file****, scegli Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/ml-dlc-console.html)
1. **Se è in esecuzione in modalità containerizzata**, aggiungi la seguente risorsa di volume locale per concedere l'accesso alla fotocamera del tuo dispositivo. Segui la procedura riportata in [Passaggio 5: aggiungere una risorsa modello ottimizzata per SageMaker AI NEO al gruppo Greengrass](#ml-console-dlc-add-resources).
**Nota**
Se si esegue in modalità non containerizzata, è AWS IoT Greengrass possibile accedere alla fotocamera del dispositivo senza configurare le risorse del dispositivo.
+ Per **Resource type (Tipo di risorsa)**, scegli **Volume**.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file**, scegli **Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/ml-dlc-console.html)
1. Aggiornare le sottoscrizioni di gruppo per utilizzare la directory corretta. Segui la procedura descritta in [Fase 7: aggiunta di sottoscrizioni al gruppo Greengrass](#ml-console-dlc-add-subscription), con i seguenti aggiornamenti:
+ Per il primo filtro di argomenti, immettere **/resnet-18/predictions**.
+ Per il secondo filtro di argomenti, immettere **/resnet-18/test**.
1. Aggiornare le sottoscrizioni di test per utilizzare la directory corretta. Segui la procedura descritta in [Esecuzione del test dell'esempio di inferenza](#ml-console-dlc-test-app), con i seguenti aggiornamenti:
+ Per **Abbonamenti**, scegli **Sottoscrivi a un argomento.** Per **Argomento sottoscrizione**, immetti **/resnet-18/predictions**.
+ Nella pagina `/resnet-18/predictions`, specificare l'argomento `/resnet-18/test` in cui effettuare la pubblicazione.
## Risoluzione dei problemi di AWS IoT Greengrass inferenza ML
Se il test non viene completato correttamente, puoi provare a eseguire la procedura di risoluzione dei problemi riportata di seguito. Esegui i comandi nel terminale Raspberry Pi.
### Controlla i log degli errori
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. Verifica la presenza `runtime.log` di eventuali errori.
```
cat system/runtime.log | grep 'ERROR'
```
Puoi anche cercare eventuali errori nel registro delle funzioni Lambda definito dall'utente:
```
cat user/your-region/your-account-id/lambda-function-name.log | grep 'ERROR'
```
Per ulteriori informazioni, consulta [Risoluzione dei problemi con i log](gg-troubleshooting.md#troubleshooting-logs).
### Verifica che la funzione Lambda sia implementata correttamente
1. Elenca il contenuto della Lambda distribuita nella `/lambda` directory. Prima di eseguire il comando, sostituisci i valori dei segnaposti.
```
cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-version
ls -la
```
1. Verifica che la directory contenga gli stessi file inclusi nel pacchetto di distribuzione `optimizedImageClassification.zip` caricato in [Fase 3: Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda).
Assicurati inoltre che i file `.py` e le dipendenze si trovino nella root della directory.
### Verifica che il modello di inferenza sia stato distribuito correttamente
1. Trova il numero di identificazione del processo (PID) del processo di runtime Lambda:
```
ps aux | grep lambda-function-name
```
Nell'output, il PID appare nella seconda colonna della riga per il processo di runtime Lambda.
1. Inserisci lo spazio dei nomi di runtime Lambda. Assicurati di sostituire il *pid* valore segnaposto prima di eseguire il comando.
**Nota**
Questa directory e il suo contenuto si trovano nello spazio dei nomi di runtime Lambda, quindi non sono visibili in un normale spazio dei nomi Linux.
```
sudo nsenter -t pid -m /bin/bash
```
1. Elenca i contenuti della directory locale specificata per la risorsa ML.
**Nota**
Se il percorso della risorsa ML è diverso da `ml_model`, dovrai sostituirlo qui.
```
cd /ml_model
ls -ls
```
Dovrebbero essere visualizzati i seguenti file:
```
56 -rw-r--r-- 1 ggc_user ggc_group 56703 Oct 29 20:07 model.json
196152 -rw-r--r-- 1 ggc_user ggc_group 200855043 Oct 29 20:08 model.params
256 -rw-r--r-- 1 ggc_user ggc_group 261848 Oct 29 20:07 model.so
32 -rw-r--r-- 1 ggc_user ggc_group 30564 Oct 29 20:08 synset.txt
```
### La funzione Lambda non trova `/dev/dri/renderD128`
Questa situazione può verificarsi se OpenCL non è in grado di connettersi ai dispositivi GPU necessari. È necessario creare risorse di dispositivo per i dispositivi necessari per la funzione Lambda.
## Fasi successive
Esplorare altri modelli ottimizzati. Per informazioni, consulta la [documentazione di SageMaker AI Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).