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 dell'apprendimento automatico utilizzando Console di gestione AWS
Per seguire i passaggi di questo tutorial, è necessario AWS IoT Greengrass Core v1.10 o versione successiva.
Puoi eseguire l'inferenza di Machine Learning (ML) in locale su un dispositivo core Greengrass utilizzando i dati generati localmente. Per informazioni, inclusi i requisiti e i vincoli, consulta [Esecuzione dell'inferenza di Machine Learning](ml-inference.md).
Questo tutorial descrive come utilizzare Console di gestione AWS per configurare un gruppo Greengrass per eseguire un'app di inferenza Lambda che riconosce le immagini da una fotocamera localmente, senza inviare dati al cloud. L'app di inferenza accede al modulo fotocamera su un Raspberry Pi ed esegue l'inferenza utilizzando il modello open source. [SqueezeNet](https://github.com/DeepScale/SqueezeNet)
Il tutorial include le seguenti fasi di alto livello:
1. [Configurare il dispositivo Raspberry Pi](#config-raspberry-pi)
1. [Installa il MXNet framework](#install-mxnet)
1. [Crea un pacchetto di modelli](#package-ml-model)
1. [Creare e pubblicare una funzione Lambda](#ml-console-create-lambda)
1. [Aggiungere la funzione Lambda al gruppo](#ml-console-config-lambda)
1. [Aggiunta di risorse al gruppo](#ml-console-add-resources)
1. [Aggiunta di una sottoscrizione al gruppo](#ml-console-add-subscription)
1. [Distribuzione del gruppo.](#ml-console-deploy-group)
1. [Esecuzione del test dell'app](#ml-console-test-app)
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Raspberry Pi 4 Model B o Raspberry Pi 3 Model B/B\$1, configurato e configurato 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 su come configurare la fotocamera, consulta [Collegamento della fotocamera](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 nucleo Greengrass, vedere. [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-config) e [NVIDIA](#jetson-lambda-config) Jetson. TX2 Nell'esempio di Jetson TX2, è possibile utilizzare immagini statiche anziché immagini trasmesse in streaming da una fotocamera. Se si utilizza l' TX2 esempio Jetson, potrebbe essere necessario installare Python 3.6 anziché 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: Installare il framework MXNet
In questo passaggio, installa MXNet le librerie sul tuo Raspberry Pi.
1. Accedere al Raspberry Pi da remoto.
```
ssh pi@your-device-ip-address
```
1. Apri la MXNet documentazione, apri [Installazione MXNet](https://mxnet.apache.org/get_started/?) e segui le istruzioni per l'installazione MXNet sul dispositivo.
**Nota**
Ti consigliamo di installare la versione 1.5.0 e di compilarlo MXNet dal codice sorgente per questo tutorial per evitare conflitti tra dispositivi.
1. Dopo l'installazione MXNet, convalida la seguente configurazione:
+ Assicurati che l'account `ggc_user` di sistema possa utilizzare il MXNet framework.
```
sudo -u ggc_user bash -c 'python3 -c "import mxnet"'
```
+ Assicurati che NumPy sia installato.
```
sudo -u ggc_user bash -c 'python3 -c "import numpy"'
```
## Fase 3: Creare un pacchetto MXNet modello
In questo passaggio, crea un pacchetto modello che contenga un MXNet modello preaddestrato di esempio da caricare su Amazon Simple Storage Service (Amazon S3). AWS IoT Greengrass può utilizzare un pacchetto modello di Amazon S3, a condizione che utilizzi il formato tar.gz o zip.
1. Sul tuo computer, scarica l' MXNet esempio per Raspberry Pi da. [Esempi di Machine Learning](what-is-gg.md#gg-ml-samples)
1. Decomprimere il file `mxnet-py3-armv7l.tar.gz` scaricato.
1. Passa alla directory `squeezenet`.
```
cd path-to-downloaded-sample/mxnet-py3-armv7l/models/squeezenet
```
Il file `squeezenet.zip` in questa directory è il pacchetto del modello. Contiene elementi del modello SqueezeNet open source per un modello di classificazione delle immagini. Successivamente, carichi questo pacchetto modello su Amazon S3.
## Fase 4: Creare e pubblicare una funzione Lambda
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.
Innanzitutto, crea il pacchetto di distribuzione della funzione Lambda.
1. Nel computer, passare alla directory `examples` nel pacchetto di esempio decompresso in [Fase 3: Creare un pacchetto MXNet modello](#package-ml-model).
```
cd path-to-downloaded-sample/mxnet-py3-armv7l/examples
```
La directory `examples` contiene il codice di funzione e le dipendenze.
+ `greengrassObjectClassification.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 `greengrassObjectClassification.zip`. Questo è il pacchetto di distribuzione.
```
zip -r greengrassObjectClassification.zip .
```
**Nota**
Assicurarsi inoltre che i file `.py` e le dipendenze si trovino nella radice della directory.
Quindi, crea la funzione Lambda.
1. Dalla AWS IoT console, scegli **Funzioni** e **Crea funzione**.
1. Scegli **Author da zero** e usa i seguenti valori per creare la tua funzione:
+ Nel campo **Function name (Nome funzione)**, immettere **greengrassObjectClassification**.
+ In **Runtime**, scegliere **Python 3.7**.
Per **le autorizzazioni**, mantieni l'impostazione predefinita. Questo crea un ruolo di esecuzione che concede le autorizzazioni Lambda di base. Questo ruolo non viene utilizzato da. AWS IoT Greengrass
1. Scegli **Crea funzione**.
Ora carica il pacchetto di distribuzione della funzione Lambda e registra il gestore.
1. Scegli la tua funzione Lambda e carica il 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 `greengrassObjectClassification.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**.
+ Per **Gestore**, inserisci **greengrassObjectClassification.function\$1handler**.
Scegli **Save** (Salva).
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. Invece, è sufficiente 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-inference/lambda-publish-version.png)
1. Per **Version description (Descrizione versione)**, immettere **First version**, quindi scegliere **Publish (Pubblica)**.
1. Nella pagina di configurazione **greengrassObjectClassification: 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-inference/lambda-create-alias.png)
1. Nella pagina **Create a new alias (Crea un nuovo alias)**, utilizza i seguenti valori:
+ In **Nome**, inserisci **mlTest**.
+ Per **Version (Versione)**, immettere **1**.
**Nota**
AWS IoT Greengrass **non supporta gli alias Lambda per le versioni \$1LATEST.**
1. Scegli **Save** (Salva).
Ora aggiungete la funzione Lambda al vostro gruppo Greengrass.
## Fase 5: Aggiungere la funzione Lambda al gruppo Greengrass
In questo passaggio, aggiungi la funzione Lambda al gruppo e quindi configura il ciclo di vita e le variabili di ambiente.
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. Dalla pagina di configurazione del gruppo, scegli la scheda **Funzioni Lambda**.
1. **Nella sezione **Funzioni My Lambda**, scegli Aggiungi.**
1. Per la **funzione Lambda, scegli**. **greengrassObjectClassification**
1. **Per la **versione della funzione Lambda**, scegliete Alias:MLTest.**
Quindi, configura il ciclo di vita e le variabili di ambiente 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).
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 **96 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).
1. In **Environment variables (Variabili di ambiente)**, creare una coppia chiave-valore. Una coppia chiave-valore è richiesta dalle funzioni che interagiscono con i MXNet modelli su un Raspberry Pi.
Per la chiave, utilizzare MXNET\$1ENGINE\$1TYPE. Per il valore, usa. NaiveEngine
**Nota**
Nelle funzioni Lambda definite dall'utente, puoi facoltativamente impostare la variabile di ambiente nel codice della funzione.
1. Mantieni i valori predefiniti per tutte le altre proprietà e scegli **Aggiungi funzione Lambda**.
## Fase 6: aggiunta di risorse al gruppo Greengrass
In questo passaggio, crea risorse per il modulo telecamera e il modello di inferenza ML e associa le risorse alla funzione Lambda. Ciò consente alla funzione Lambda di accedere alle risorse 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 queste risorse del dispositivo.
Innanzitutto, crea due risorse locali per la telecamera: una per la memoria condivisa e una per l'interfaccia del dispositivo. Per ulteriori informazioni sull'accesso alle risorse locali, consulta [Accedi alle risorse locali con funzioni e connettori Lambda](access-local-resources.md).
1. **Nella pagina di configurazione del gruppo, scegli la scheda Risorse.**
1. Nella sezione **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 può fare 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 **System group owner and file access permissions (proprietario del gruppo di sistema e autorizzazioni** di accesso ai file) consente di concedere ulteriori autorizzazioni di accesso ai file al processo Lambda. Per ulteriori informazioni, consulta [Autorizzazione di accesso ai file dell'owner del gruppo](access-local-resources.md#lra-group-owner).
1. A questo punto, aggiungi una risorsa del dispositivo locale per l'interfaccia della telecamera.
1. Scegli **Aggiungi risorsa locale**.
1. Nella pagina **Aggiungi una risorsa locale**, 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. Nella parte inferiore della pagina, scegli **Aggiungi** risorsa.
Ora aggiungi il modello di inferenza come una risorsa Machine Learning. Questo passaggio include il caricamento del pacchetto `squeezenet.zip` modello su Amazon S3.
1. Nella scheda **Risorse** per il tuo gruppo, nella sezione **Machine Learning**, scegli **Aggiungi risorsa di machine learning**.
1. Nella pagina **Aggiungi una risorsa di machine learning**, per **Nome risorsa**, inserisci**squeezenet\$1model**.
1. Per **Model source**, scegli **Usa un modello archiviato in S3, ad esempio un modello ottimizzato tramite Deep Learning Compiler**.
1. Per **S3 URI**, inserisci un percorso in cui viene salvato il bucket S3.
1. Seleziona **Sfoglia S3**. Si apre una nuova scheda nella console Amazon S3.
1. Nella scheda della console Amazon S3, carica il `squeezenet.zip` file in un bucket 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**
Affinché il bucket S3 sia accessibile, il nome del bucket deve contenere la stringa **greengrass** e il bucket deve trovarsi nella stessa regione per cui lo utilizzi. AWS IoT Greengrass Scegliere un nome univoco (ad esempio **greengrass-bucket-*user-id*-*epoch-time***). Non utilizzare un punto (`.`) nel nome del bucket.
1. Nella scheda della AWS IoT Greengrass console, individua e scegli il tuo bucket S3. Individuare e il file `squeezenet.zip` caricato e scegliere **Select (Seleziona)**. Potrebbe essere necessario scegliere **Refresh (Aggiorna)** per aggiornare l'elenco dei bucket e dei file disponibili.
1. Per **Destination path (Percorso di destinazione)**, immetti **/greengrass-machine-learning/mxnet/squeezenet**.
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. La funzione Lambda di esempio per questo tutorial è già configurata per utilizzare questo percorso (nella `model_path` variabile).
1. In **Proprietario del gruppo di sistema e autorizzazioni di accesso ai file**, scegli **Nessun gruppo di sistema**.
1. Scegliere **Add resource (Aggiungi risorsa)**.
### Utilizzo di modelli addestrati all' SageMaker intelligenza artificiale
Questo tutorial utilizza un modello archiviato in Amazon S3, ma puoi utilizzare facilmente anche modelli SageMaker AI. La AWS IoT Greengrass console ha un'integrazione SageMaker AI integrata, quindi non è necessario caricare manualmente questi modelli su Amazon S3. Per i requisiti e le limitazioni per l'utilizzo dei modelli di SageMaker intelligenza artificiale, consulta[Origini di modello supportate](ml-inference.md#supported-model-sources).
Per utilizzare un modello di SageMaker intelligenza artificiale:
+ Per **Model source**, scegli **Usa un modello addestrato all' AWS SageMaker intelligenza artificiale**, quindi scegli il nome del processo di formazione del modello.
+ Per **Percorso di destinazione**, inserisci il percorso della directory in cui la funzione Lambda cerca il modello.
## Fase 7: aggiunta di una sottoscrizione al gruppo Greengrass
In questa fase, aggiungere una sottoscrizione al gruppo. Questo abbonamento consente alla funzione Lambda di inviare risultati di previsione AWS IoT pubblicandoli su un argomento MQTT.
1. **Nella pagina di configurazione del gruppo, scegli la scheda **Abbonamenti**, quindi scegli Aggiungi abbonamento.**
1. Nella pagina dei **dettagli dell'abbonamento**, configura l'origine e la destinazione come segue:
1. In **Tipo di sorgente**, scegli **Funzione Lambda**, quindi scegli. **greengrassObjectClassification**
1. Nel **tipo di Target**, scegli **Servizio**, quindi scegli **IoT Cloud**.
1. Nel **filtro per argomenti****hello/world**, inserisci, 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/1.11.6/bin/daemon`, allora il daemon è in esecuzione.
**Nota**
La versione indicata nel percorso dipende dalla versione del software AWS IoT Greengrass Core installata sul dispositivo principale.
1. Per avviare il demone:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. **Nella pagina di configurazione del gruppo, scegli Deploy.**
![\[La pagina del gruppo con le opzioni Deployments (Distribuzioni) e Deploy (Distribuisci) evidenziate.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/console-group-deployments-deploy.png)
1. **Nella scheda **Funzioni Lambda, nella sezione Funzioni** **System Lambda**, seleziona **Rilevatore IP** e scegli Modifica.**
1. Nella finestra di dialogo **Modifica impostazioni del rilevatore IP**, seleziona Rileva **e sostituisci automaticamente gli endpoint del broker MQTT**.
1. Scegli **Save** (Salva).
Questo consente ai dispositivi di acquisire automaticamente informazioni di base sulla connettività, come, ad esempio indirizzo IP, DNS e numero della porta. Il rilevamento automatico è consigliato, ma supporta AWS IoT Greengrass anche gli endpoint specificati manualmente. Ti viene chiesto il metodo di individuazione solo la prima volta che il gruppo viene distribuito.
**Nota**
Se richiesto, concedi l'autorizzazione a creare il ruolo di [servizio Greengrass](service-role.md) e associarlo al Account AWS tuo ruolo attuale. Regione AWS Questo ruolo consente di accedere AWS IoT Greengrass alle tue risorse nei AWS servizi.
Nella pagina **Deployments (Distribuzioni)** vengono visualizzati il timestamp della distribuzione, l'ID versione e lo stato. Una volta completata, lo stato visualizzato per la distribuzione dovrebbe essere **Completato**.
Per 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).
## Fase 9: esecuzione del test dell'app di inferenza
Ora puoi verificare se la distribuzione è configurata correttamente. Per eseguire il test, è necessario abbonarsi all'`hello/world`argomento e visualizzare i risultati della previsione pubblicati dalla funzione Lambda.
**Nota**
Se a dispositivo Raspberry Pi è collegato un monitor, il segnale attivo della telecamera viene visualizzato in una finestra di anteprima.
1. Nella AWS IoT console, in **Test**, scegli **MQTT** test client.
1. In **Subscriptions (Sottoscrizioni)**, utilizza i seguenti valori:
+ Per l’argomento della sottoscrizione, utilizzare ciao/mondo.
+ In **Configurazione aggiuntiva**, per la visualizzazione del **payload MQTT, scegli **Visualizza i payload**** come stringhe.
1. Scegli **Abbonati**.
Se il test ha esito positivo, i messaggi della funzione Lambda vengono visualizzati nella parte inferiore della pagina. Ogni messaggio contiene i primi cinque risultati predittivi dell'immagine nel formato: probabilità, ID classe prevista e nome della classe corrispondente.
![\[La pagina Subscriptions (Sottoscrizioni) in cui sono visualizzati i risultati del test con i dati del messaggio.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-inference/prediction-results.png)
### 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. Nella directory `system`, controllare `runtime.log` o `python_runtime.log`.
Nella directory `user/region/account-id`, controllare `greengrassObjectClassification.log`.
Per ulteriori informazioni, consulta [Risoluzione dei problemi con i log](gg-troubleshooting.md#troubleshooting-logs).
##### Errore di decompressione in runtime.log
Se `runtime.log` contiene un errore simile al seguente, assicurati che il pacchetto del modello di origine `tar.gz` contenga una directory principale.
```
Greengrass deployment error: unable to download the artifact model-arn: Error while processing.
Error while unpacking the file from /tmp/greengrass/artifacts/model-arn/path to /greengrass/ggc/deployment/path/model-arn,
error: open /greengrass/ggc/deployment/path/model-arn/squeezenet/squeezenet_v1.1-0000.params: no such file or directory
```
Se il pacchetto non dispone di una directory principale contenente i file del modello, ricomprimi il modello utilizzando il seguente comando:
```
tar -zcvf model.tar.gz ./model
```
Esempio:
```
─$ tar -zcvf test.tar.gz ./test
./test
./test/some.file
./test/some.file2
./test/some.file3
```
**Nota**
Non includere i caratteri finali `/*` in questo comando.
#### 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 `greengrassObjectClassification.zip` caricato in [Fase 4: Creare e pubblicare una funzione Lambda](#ml-console-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.
```
cd /greengrass-machine-learning/mxnet/squeezenet/
ls -ls
```
Dovrebbero essere visualizzati i seguenti file:
```
32 -rw-r--r-- 1 ggc_user ggc_group 31675 Nov 18 15:19 synset.txt
32 -rw-r--r-- 1 ggc_user ggc_group 28707 Nov 18 15:19 squeezenet_v1.1-symbol.json
4832 -rw-r--r-- 1 ggc_user ggc_group 4945062 Nov 18 15:19 squeezenet_v1.1-0000.params
```
## Fasi successive
Successivamente, esplora altre app di inferenza. AWS IoT Greengrass fornisce altre funzioni Lambda che è possibile utilizzare per provare l'inferenza locale. Il pacchetto degli esempi è disponibile nella cartella delle librerie precompilate scaricata nella [Fase 2: Installare il framework MXNet](#install-mxnet).
## 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
**Nota**
Se il dispositivo è preconfigurato con Python 3.6, puoi invece creare un collegamento simbolico a Python 3.7. Per ulteriori informazioni, consulta [Step 2](#python-symlink).
+ [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 `greengrassObjectClassification.py` (o in una sottodirectory di questa directory). Si trova nel pacchetto di distribuzione della funzione Lambda in cui carichi. [Fase 4: Creare e pubblicare una funzione Lambda](#ml-console-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. Se non stai usando Python 3.7, assicurati di creare un collegamento simbolico da Python 3.x a Python 3.7. Questo configura il tuo dispositivo per usare Python 3 con. AWS IoT Greengrass Eseguire il seguente comando per individuare l'installazione di Python:
```
which python3
```
Eseguire il comando seguente per creare il collegamento simbolico.
```
sudo ln -s path-to-python-3.x/python3.x path-to-python-3.7/python3.7
```
Riavviare il dispositivo.
1. Modifica la configurazione della funzione Lambda. Segui la procedura riportata in [Fase 5: Aggiungere la funzione Lambda al gruppo Greengrass](#ml-console-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)
+ Aggiornare il valore **Timeout** a 5 secondi. In questo modo, il timeout della richiesta non viene eseguito troppo presto. L'esecuzione dell'inferenza richiede alcuni minuti dopo la configurazione.
+ **In **Bloccato, scegli** True.**
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
+ Per **Lambda lifecycle (Ciclo di vita Lambda)**, scegli **Make this function long-lived and keep it running indefinitely (Rendi questa funzione di lunga durata e mantieni in esecuzione a tempo indeterminato)**.
1. **Per eseguire invece in modalità containerizzata:**
**Nota**
Si sconsiglia l'esecuzione in modalità containerizzata a meno che il business case non lo richieda.
+ Aggiornare il valore **Timeout** a 5 secondi. 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. **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. Scegli **Aggiungi risorsa locale**.
1. Definisci la risorsa:
+ Per **Resource Name (Nome risorsa)** immetti **renderD128**.
+ Per **Tipo di risorsa**, scegli **Dispositivo locale**.
+ Per **Device path (Percorso dispositivo)**, immetti **/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**.
+ Per le **affiliazioni alle funzioni Lambda**, concedi l'**accesso in lettura e scrittura alla** tua funzione Lambda.
## Configurazione di un NVIDIA Jetson TX2
Per eseguire questo tutorial su un NVIDIA Jetson TX2, fornisci immagini sorgente e configura la funzione Lambda. Se stai utilizzando la GPU, devi anche aggiungere le risorse locali del dispositivo.
1. Assicurati che il tuo dispositivo Jetson sia configurato in modo da poter installare il software Core. AWS IoT Greengrass Per ulteriori informazioni sulla configurazione del dispositivo, consulta [Configurazione di altri dispositivi](setup-filter.other.md).
1. Apri la MXNet documentazione, vai a [Installazione MXNet su un Jetson](https://mxnet.apache.org/get_started/jetson_setup) e segui le istruzioni per l'installazione MXNet sul dispositivo Jetson.
**Nota**
Se vuoi creare MXNet dal codice sorgente, segui le istruzioni per creare la libreria condivisa. Modifica le seguenti impostazioni nel tuo `config.mk` file per lavorare con un dispositivo Jetson TX2 :
Aggiungere `-gencode arch=compute-62, code=sm_62` all'impostazione `CUDA_ARCH`.
Attivare CUDA.
```
USE_CUDA = 1
```
1. Scarica immagini PNG o JPG statiche per la funzione Lambda da utilizzare per la classificazione delle immagini. L'app funziona in modo ottimale con i file immagine di dimensioni ridotte. In alternativa, puoi implementare una telecamera sulla scheda Jetson per acquisire le immagini di origine.
Salvare i file immagine nella directory contenente il file `greengrassObjectClassification.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 4: Creare e pubblicare una funzione Lambda](#ml-console-create-lambda)
1. Crea un collegamento simbolico da Python 3.7 a Python 3.6 con cui usare Python 3. AWS IoT Greengrass Eseguire il seguente comando per individuare l'installazione di Python:
```
which python3
```
Eseguire il comando seguente per creare il collegamento simbolico.
```
sudo ln -s path-to-python-3.6/python3.6 path-to-python-3.7/python3.7
```
Riavviare il dispositivo.
1. Assicurati che l'account di `ggc_user` sistema possa utilizzare il framework: MXNet
```
“sudo -u ggc_user bash -c 'python3 -c "import mxnet"'
```
1. Modifica la configurazione della funzione Lambda. Segui la procedura riportata in [Fase 5: Aggiungere la funzione Lambda al gruppo Greengrass](#ml-console-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)
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
+ In **Variabili di ambiente**, aggiungi le seguenti coppie chiave-valore alla tua funzione Lambda. Questo configura l'utilizzo del framework AWS IoT Greengrass . MXNet
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/ml-console.html)
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)**. Utilizzare 500 MB per la CPU o almeno 2000 MB per la GPU.
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
+ In **Variabili di ambiente**, aggiungi le seguenti coppie chiave-valore alla tua funzione Lambda. Questo configura l'utilizzo del framework AWS IoT Greengrass . MXNet
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/ml-console.html)
1. **Se è in esecuzione in modalità containerizzata**, aggiungi le seguenti risorse del dispositivo locale per concedere l'accesso alla GPU del dispositivo. Segui la procedura riportata in [Fase 6: aggiunta di risorse al gruppo Greengrass](#ml-console-add-resources).
**Nota**
Se esegui in modalità non containerizzata, AWS IoT Greengrass puoi accedere alla GPU del dispositivo senza configurare le risorse del dispositivo.
Per ogni risorsa:
+ 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-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 [Fase 6: aggiunta di risorse al gruppo Greengrass](#ml-console-add-resources).
**Nota**
Se si esegue in modalità non containerizzata, è AWS IoT Greengrass possibile accedere alla fotocamera del dispositivo senza configurare le risorse di volume.
+ 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-console.html)