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à.
# Tutorial: Guida introduttiva a AWS IoT Greengrass V2
Puoi completare questo tutorial introduttivo per apprendere le funzionalità di base di AWS IoT Greengrass V2. In questo tutorial, esegui quanto indicato di seguito:
1. Installa e configura il software AWS IoT Greengrass Core su un dispositivo Linux, come un Raspberry Pi o un dispositivo Windows. Questo dispositivo è un dispositivo principale Greengrass.
1. Sviluppa un componente Hello World sul tuo dispositivo principale Greengrass. I componenti sono moduli software che funzionano sui dispositivi core Greengrass.
1. Carica quel componente AWS IoT Greengrass V2 in. Cloud AWS
1. Distribuisci quel componente dal tuo Cloud AWS dispositivo principale Greengrass.
**Nota**
Questo tutorial descrive come configurare un ambiente di sviluppo ed esplorare le funzionalità di. AWS IoT Greengrass Per ulteriori informazioni su come impostare e configurare i dispositivi di produzione, consulta quanto segue:
[Configurazione dei dispositivi AWS IoT Greengrass principali](setting-up.md)
[Installare il software AWS IoT Greengrass Core](install-greengrass-core-v2.md)
Puoi aspettarti di dedicare dai 20 ai 30 minuti per questo tutorial.
**Topics**
+ [
# Prerequisiti
](getting-started-prerequisites.md)
+ [
# Fase 1: Configura un AWS account
](getting-started-set-up-aws-account.md)
+ [
# Fase 2: Configurare l'ambiente
](getting-started-set-up-environment.md)
+ [
# Fase 3: Installare il software AWS IoT Greengrass Core
](install-greengrass-v2.md)
+ [
# Fase 4: Sviluppa e testa un componente sul tuo dispositivo
](create-first-component.md)
+ [
# Fase 5: Crea il tuo componente nel AWS IoT Greengrass servizio
](upload-first-component.md)
+ [
# Fase 6: Implementazione del componente
](deploy-first-component.md)
+ [
# Passaggi successivi
](getting-started-next-steps.md)
# Prerequisiti
Per completare questo tutorial delle nozioni di base occorrono i seguenti requisiti:
+ Un Account AWS. Se non lo hai, consultare [Fase 1: Configura un AWS account](getting-started-set-up-aws-account.md).
+ L'uso di un [Regione AWS](https://en.wikipedia.org/wiki/Amazon_Web_Services#Availability_and_topology)ventilatore che supporta AWS IoT Greengrass V2. Per l'elenco delle regioni supportate, consulta [Endpoint e quote AWS IoT Greengrass V2](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html) in *Riferimenti generali di AWS*.
+ Un utente AWS Identity and Access Management (IAM) con autorizzazioni di amministratore.
+ Un dispositivo da configurare come dispositivo principale Greengrass, ad esempio un Raspberry Pi con [sistema operativo Raspberry Pi](https://www.raspberrypi.org/downloads/) (precedentemente chiamato Raspbian) o un dispositivo Windows 10. È necessario disporre delle autorizzazioni di amministratore su questo dispositivo o della possibilità di acquisire privilegi di amministratore, ad esempio tramite. `sudo` Questo dispositivo deve disporre di una connessione Internet.
Puoi anche scegliere di utilizzare un dispositivo diverso che soddisfi i requisiti per installare ed eseguire il software AWS IoT Greengrass Core.
Se il tuo computer di sviluppo soddisfa questi requisiti, puoi configurarlo come dispositivo principale Greengrass in questo tutorial.
+ [Python](https://www.python.org/downloads/) 3.5 o successivo installato per tutti gli utenti sul dispositivo e aggiunto alla variabile di `PATH` ambiente. Su Windows, è inoltre necessario che Python Launcher per Windows sia installato per tutti gli utenti.
**Importante**
In Windows, Python non viene installato per tutti gli utenti per impostazione predefinita. Quando installi Python, devi personalizzare l'installazione per configurarla affinché il software AWS IoT Greengrass Core esegua gli script Python. Ad esempio, se usi il programma di installazione grafico di Python, procedi come segue:
Seleziona **Installa il programma di avvio per tutti gli utenti** (consigliato).
Scegliere **Customize installation**.
Scegliere **Next**.
Selezionare **Install for all users**.
Selezionare **Add Python to environment variables**.
Scegli **Installa**.
Per ulteriori informazioni, consulta [Usare Python su Windows nella documentazione](https://docs.python.org/3/using/windows.html) di *Python* 3.
+ AWS Command Line Interface (AWS CLI) installato e configurato con credenziali sul computer di sviluppo e sul dispositivo. Assicurati di utilizzarle Regione AWS per configurarle AWS CLI sul tuo computer di sviluppo e sul tuo dispositivo. Per utilizzarlo AWS IoT Greengrass V2 con AWS CLI, è necessario disporre di una delle seguenti versioni o successive:
+ Versione minima AWS CLI V1: v1.18.197
+ Versione minima AWS CLI V2: v2.1.11
**Suggerimento**
Puoi eseguire il seguente comando per verificare la versione di cui disponi AWS CLI .
```
aws --version
```
Per ulteriori informazioni, vedere [Installazione, aggiornamento e disinstallazione AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) e [configurazione](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) di AWS CLI nella Guida per l'*AWS Command Line Interface utente*.
**Nota**
Se utilizzi un dispositivo ARM a 32 bit, come un Raspberry Pi con un sistema operativo a 32 bit, installa V1. AWS CLI AWS CLI La V2 non è disponibile per i dispositivi ARM a 32 bit. Per ulteriori informazioni, vedere [Installazione, aggiornamento e disinstallazione della AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html) versione 1.
# Fase 1: Configura un AWS account
## Iscriviti per un Account AWS
Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.
**Per iscriverti a un Account AWS**
1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup)
1. Segui le istruzioni online.
Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono.
Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L'utente root dispone dell'accesso a tutte le risorse e tutti i Servizi AWS nell'account. Come best practice di sicurezza, assegna l'accesso amministrativo a un utente e utilizza solo l'utente root per eseguire [attività che richiedono l'accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**.
## Crea un utente con accesso amministrativo
Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.
**Proteggi i tuoi Utente root dell'account AWS**
1. Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.
Per informazioni sull'accesso utilizzando un utente root, consulta la pagina [Signing in as the root user](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) della *Guida per l'utente di Accedi ad AWS *.
1. Abilita l'autenticazione a più fattori (MFA) per l'utente root.
Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*.
**Crea un utente con accesso amministrativo**
1. Abilita Centro identità IAM.
Per istruzioni, consulta [Abilitazione di AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l'utente di AWS IAM Identity Center *.
1. In IAM Identity Center, assegna l'accesso amministrativo a un utente.
Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*.
**Accesso come utente amministratore**
+ Per accedere con l'utente IAM Identity Center, utilizza l'URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l'utente IAM Identity Center.
Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*.
**Assegna l'accesso a ulteriori utenti**
1. In IAM Identity Center, crea un set di autorizzazioni conforme alla best practice dell'applicazione di autorizzazioni con il privilegio minimo.
Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l'utente di AWS IAM Identity Center *.
1. Assegna al gruppo prima gli utenti e poi l'accesso con autenticazione unica (Single Sign-On).
Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l'utente di AWS IAM Identity Center *.
# Fase 2: Configurare l'ambiente
**Nota**
Questi passaggi non si applicano a nucleus lite.
Segui i passaggi in questa sezione per configurare un dispositivo Linux o Windows da utilizzare come dispositivo AWS IoT Greengrass principale.
## Configura un dispositivo Linux (Raspberry Pi)
Questi passaggi presuppongono l'utilizzo di un Raspberry Pi con sistema operativo Raspberry Pi. Se utilizzi un dispositivo o un sistema operativo diverso, consulta la documentazione pertinente del tuo dispositivo.
**Per configurare un Raspberry Pi per AWS IoT Greengrass V2**
1. Abilita SSH sul tuo Raspberry Pi per connetterti in remoto ad esso. *Per ulteriori informazioni, consulta [SSH (Secure shell)](https://www.raspberrypi.com/documentation/computers/remote-access.html#ssh) nella documentazione di Raspberry Pi.*
1. Trova l'indirizzo IP del tuo Raspberry Pi per connetterti ad esso con SSH. Per farlo, puoi eseguire il seguente comando sul tuo Raspberry Pi.
```
hostname -I
```
1. Connect al tuo Raspberry Pi con SSH.
Sul tuo computer di sviluppo, esegui il seguente comando. Sostituiscilo *username* con il nome dell'utente a cui accedere e sostituiscilo *pi-ip-address* con l'indirizzo IP che hai trovato nel passaggio precedente.
```
ssh username@pi-ip-address
```
**Importante**
Se il tuo computer di sviluppo utilizza una versione precedente di Windows, potresti non avere il `ssh` comando oppure potresti averlo `ssh` ma non riesci a connetterti al tuo Raspberry Pi. Per connetterti al tuo Raspberry Pi, puoi installare e configurare [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html), un client SSH open source gratuito. Consulta la documentazione di [PuTTY per connetterti al tuo Raspberry Pi](https://tartarus.org/~simon/putty-snapshots/htmldoc/Chapter2.html#gs).
1. Installa il runtime Java, necessario per l'esecuzione AWS IoT Greengrass del software Core. Sul tuo Raspberry Pi, usa i seguenti comandi per installare Java 11.
```
sudo apt install default-jdk
```
Al termine dell'installazione, esegui il comando seguente per verificare che Java sia in esecuzione sul tuo Raspberry Pi.
```
java -version
```
Il comando stampa la versione di Java in esecuzione sul dispositivo. L'output potrebbe essere simile all'esempio seguente.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
**Suggerimento: imposta i parametri del kernel su un Raspberry Pi**
Se il tuo dispositivo è un Raspberry Pi, puoi completare i seguenti passaggi per visualizzare e aggiornare i parametri del kernel Linux:
Apri il file `/boot/cmdline.txt`. Questo file specifica i parametri del kernel Linux da applicare all'avvio del Raspberry Pi.
Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per aprire il file.
```
sudo nano /boot/cmdline.txt
```
Verificate che il `/boot/cmdline.txt` file contenga i seguenti parametri del kernel. Il `systemd.unified_cgroup_hierarchy=0` parametro specifica di utilizzare cgroups v1 invece di cgroups v2.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Se il `/boot/cmdline.txt` file non contiene questi parametri o contiene questi parametri con valori diversi, aggiorna il file in modo che contenga questi parametri e valori.
Se hai aggiornato il `/boot/cmdline.txt` file, riavvia Raspberry Pi per applicare le modifiche.
```
sudo reboot
```
## Configura un dispositivo Linux (altro)
**Per configurare un dispositivo Linux per AWS IoT Greengrass V2**
1. Installa il runtime Java, necessario per l'esecuzione del software AWS IoT Greengrass Core. Ti consigliamo di utilizzare le versioni di supporto a lungo termine di [Amazon Corretto](https://aws.amazon.com/corretto/) o [OpenJDK](https://openjdk.java.net/). È richiesta la versione 8 o successiva. I seguenti comandi mostrano come installare OpenJDK sul tuo dispositivo.
+ Per le distribuzioni basate su Debian o basate su Ubuntuu:
```
sudo apt install default-jdk
```
+ Per le distribuzioni basate su Red Hat:
```
sudo yum install java-11-openjdk-devel
```
+ Per Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ Per Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
Al termine dell'installazione, esegui il comando seguente per verificare che Java funzioni sul tuo dispositivo Linux.
```
java -version
```
Il comando stampa la versione di Java in esecuzione sul dispositivo. Ad esempio, su una distribuzione basata su Debian, l'output potrebbe essere simile all'esempio seguente.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (Facoltativo) Crea l'utente e il gruppo di sistema predefiniti che eseguono i componenti sul dispositivo. Puoi anche scegliere di lasciare che il programma di installazione del software AWS IoT Greengrass Core crei questo utente e gruppo durante l'installazione con l'argomento `--component-default-user` installer. Per ulteriori informazioni, consulta [Argomenti dell'installatore](configure-installer.md).
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. Verificate che l'utente che esegue il software AWS IoT Greengrass Core (in genere`root`) sia autorizzato a funzionare `sudo` con qualsiasi utente e gruppo.
1. Eseguite il comando seguente per aprire il `/etc/sudoers` file.
```
sudo visudo
```
1. Verificate che l'autorizzazione per l'utente sia simile all'esempio seguente.
```
root ALL=(ALL:ALL) ALL
```
1. **(Facoltativo) Per [eseguire funzioni Lambda containerizzate](run-lambda-functions.md), è necessario abilitare [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1 e abilitare e montare i cgroup di memoria e dispositivi.** Se non intendi eseguire funzioni Lambda containerizzate, puoi saltare questo passaggio.
Per abilitare queste opzioni di cgroups, avvia il dispositivo con i seguenti parametri del kernel Linux.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Per informazioni sulla visualizzazione e l'impostazione dei parametri del kernel per il tuo dispositivo, consulta la documentazione del tuo sistema operativo e del boot loader. Segui le istruzioni per impostare in modo permanente i parametri del kernel.
1. Installa tutte le altre dipendenze richieste sul tuo dispositivo come indicato dall'elenco dei requisiti in. [Requisiti per il dispositivo](greengrass-nucleus-component.md#greengrass-v2-requirements)
## Configura un dispositivo Windows
**Per configurare un dispositivo Windows per AWS IoT Greengrass V2**
1. Installa il runtime Java, necessario per l'esecuzione del software AWS IoT Greengrass Core. Ti consigliamo di utilizzare le versioni di supporto a lungo termine di [Amazon Corretto](https://aws.amazon.com/corretto/) o [OpenJDK](https://openjdk.java.net/). È richiesta la versione 8 o successiva.
1. Controlla se Java è disponibile nella variabile di sistema [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) e aggiungilo in caso contrario. L' LocalSystem account esegue il software AWS IoT Greengrass Core, quindi è necessario aggiungere Java alla variabile di sistema PATH anziché alla variabile utente PATH per l'utente. Esegui questa operazione:
1. Premi il tasto Windows per aprire il menu di avvio.
1. Digita **environment variables** per cercare le opzioni di sistema dal menu di avvio.
1. Nei risultati della ricerca del menu di avvio, scegli **Modifica le variabili di ambiente di sistema** per aprire la finestra delle **proprietà del sistema**.
1. Scegli **le variabili di ambiente...** per aprire la finestra **Variabili d'ambiente**.
1. In **Variabili di sistema**, seleziona **Percorso**, quindi scegli **Modifica**. Nella finestra **Modifica variabile di ambiente**, puoi visualizzare ogni percorso su una riga separata.
1. Controlla se è presente il percorso della `bin` cartella di installazione di Java. Il percorso potrebbe essere simile all'esempio seguente.
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. Se la `bin` cartella di installazione Java non è presente in **Path**, scegliete **Nuovo** per aggiungerla, quindi scegliete **OK**.
1. Aprite il prompt dei comandi di Windows (`cmd.exe`) come amministratore.
1. Crea l'utente predefinito nell' LocalSystem account sul dispositivo Windows. Sostituiscilo *password* con una password sicura.
```
net user /add ggc_user password
```
**Suggerimento**
A seconda della configurazione di Windows, la password dell'utente potrebbe essere impostata per scadere in date future. Per garantire che le tue applicazioni Greengrass continuino a funzionare, tieni traccia della scadenza della password e aggiornala prima che scada. Puoi anche impostare la password dell'utente in modo che non scada mai.
Per verificare la scadenza di un utente e della relativa password, esegui il comando seguente.
```
net user ggc_user | findstr /C:expires
```
Per impostare la password di un utente in modo che non scada mai, esegui il comando seguente.
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
Se utilizzi Windows 10 o versioni successive in cui il [`wmic`comando è obsoleto, esegui il comando](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic) seguente. PowerShell
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. Scarica e installa l'[PsExecutilità](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) di Microsoft sul dispositivo.
1. Utilizzate l' PsExec utilità per memorizzare il nome utente e la password per l'utente predefinito nell'istanza di Credential Manager per l' LocalSystem account. Sostituiscila *password* con la password dell'utente che hai impostato in precedenza.
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
Se si **PsExec License Agreement**apre, scegli **Accept**di accettare la licenza ed esegui il comando.
**Nota**
Sui dispositivi Windows, l' LocalSystem account esegue il Greengrass nucleus ed è necessario utilizzare l' PsExec utilità per memorizzare le informazioni utente predefinite nell'account. LocalSystem L'utilizzo dell'applicazione Credential Manager archivia queste informazioni nell'account Windows dell'utente attualmente connesso, anziché nell'account. LocalSystem
# Fase 3: Installare il software AWS IoT Greengrass Core
**Suggerimento**
Ti consigliamo di provare [AWS IoT Greengrass AI Agents Context Pack](https://github.com/aws-greengrass/greengrass-agent-context-pack) per configurare e sperimentare rapidamente IoT AWS Greengrass. L'agent context pack consentirà agli agenti AI di configurare Greengrass Nucleus e Nucleus Lite, distribuire componenti e risolvere problemi comuni.
Segui i passaggi di questa sezione per configurare il tuo Raspberry Pi come dispositivo AWS IoT Greengrass principale da utilizzare per lo sviluppo locale. In questa sezione, scarichi ed esegui un programma di installazione che esegue le seguenti operazioni per configurare il software AWS IoT Greengrass Core per il tuo dispositivo:
+ Installa il componente Greengrass nucleus. Il nucleus è un componente obbligatorio ed è il requisito minimo per eseguire il software AWS IoT Greengrass Core su un dispositivo. Per ulteriori informazioni, vedere [Greengrass nucleus](greengrass-nucleus-component.md) component.
+ Registra il dispositivo come AWS IoT oggetto e scarica un certificato digitale che consente la connessione al dispositivo. AWS Per ulteriori informazioni, consulta [Autenticazione e autorizzazione del dispositivo per AWS IoT Greengrass](device-auth.md).
+ Aggiunge l' AWS IoT elemento del dispositivo a un gruppo di oggetti, che è un gruppo o una flotta di AWS IoT oggetti. I gruppi di cose consentono di gestire flotte di dispositivi core Greengrass. Quando distribuite componenti software sui vostri dispositivi, potete scegliere di distribuirli su singoli dispositivi o su gruppi di dispositivi. Per ulteriori informazioni, consulta [Managing devices with AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-thing-management.html) nella *AWS IoT Core Developer* Guide.
+ Crea il ruolo IAM che consente al dispositivo principale Greengrass di interagire con AWS i servizi. Per impostazione predefinita, questo ruolo consente al dispositivo di interagire AWS IoT e inviare log ad Amazon CloudWatch Logs. Per ulteriori informazioni, consulta [Autorizza i dispositivi principali a interagire con i servizi AWS](device-service-role.md).
+ Installa l'interfaccia a riga di AWS IoT Greengrass comando (`greengrass-cli`), che puoi usare per testare componenti personalizzati sviluppati sul dispositivo principale. Per ulteriori informazioni, consulta [Interfaccia a riga di comando Greengrass](gg-cli.md).
# Installare il software AWS IoT Greengrass Core (console)
1. Accedere alla [console AWS IoT Greengrass](https://console.aws.amazon.com/greengrass).
1. In **Inizia a usare Greengrass**, scegli **Configura dispositivo principale**.
1. Nel **Passaggio 1: registra un dispositivo principale Greengrass**, per **Nome dispositivo Core, inserisci il nome** dell' AWS IoT oggetto per il tuo dispositivo principale Greengrass. Se l'oggetto non esiste, il programma di installazione lo crea.
1. Nel **Passaggio 2: Aggiungi a un gruppo di oggetti per applicare una distribuzione continua**, per **Thing group**, scegli il AWS IoT gruppo di oggetti a cui desideri aggiungere il dispositivo principale.
+ Se si seleziona **Inserisci un nuovo nome di gruppo**, in **Thing group name**, inserisci il nome del nuovo gruppo da creare. Il programma di installazione crea automaticamente il nuovo gruppo.
+ Se si seleziona **Seleziona un gruppo esistente**, in **Nome gruppo** di oggetti, scegli il gruppo esistente che desideri utilizzare.
+ Se si seleziona **Nessun gruppo**, il programma di installazione non aggiunge il dispositivo principale a un gruppo di oggetti.
1. Nel **Passaggio 3: Installare il software Greengrass Core**, completare i seguenti passaggi.
------
#### [ Nucleus classic ]
1. Scegliete **Nucleus classic** come runtime software del vostro dispositivo principale.
1. Scegli il sistema operativo del tuo dispositivo principale: **Linux** o **Windows**.
1. Fornisci AWS le tue credenziali al dispositivo in modo che l'installatore possa fornire le risorse AWS IoT e IAM per il tuo dispositivo principale. Per aumentare la sicurezza, ti consigliamo di ottenere credenziali temporanee per un ruolo IAM che consenta solo le autorizzazioni minime necessarie per il provisioning. Per ulteriori informazioni, consulta [Policy IAM minima per l'installatore per il provisioning delle risorse](provision-minimal-iam-policy.md).
**Nota**
Il programma di installazione non salva né archivia le tue credenziali.
Sul dispositivo, esegui una delle seguenti operazioni per recuperare le credenziali e renderle disponibili al programma di installazione del AWS IoT Greengrass software Core:
+ (Consigliato) Utilizza credenziali temporanee da AWS IAM Identity Center
1. Fornisci l'ID della chiave di accesso, la chiave di accesso segreta e il token di sessione dall'IAM Identity Center. Per ulteriori informazioni, consulta Aggiornamento **manuale delle credenziali in Acquisizione e aggiornamento** [delle credenziali temporanee nella guida](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials) per l'utente di *IAM Identity Center*.
1. Esegui i seguenti comandi per fornire le credenziali al software Core. AWS IoT Greengrass
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ Utilizza credenziali di sicurezza temporanee da un ruolo IAM:
1. Fornisci l'ID della chiave di accesso, la chiave di accesso segreta e il token di sessione da un ruolo IAM che assumi. *Per ulteriori informazioni su come recuperare queste credenziali, consulta la sezione [Richiesta di credenziali di sicurezza temporanee nella Guida per l'utente](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) IAM.*
1. Esegui i seguenti comandi per fornire le credenziali al software Core. AWS IoT Greengrass
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ Utilizza le credenziali a lungo termine di un utente IAM:
1. Fornisci l'ID della chiave di accesso e la chiave di accesso segreta per il tuo utente IAM. Puoi creare un utente IAM per il provisioning da eliminare successivamente. Per la policy IAM da fornire all'utente, consulta[Policy IAM minima per l'installatore per il provisioning delle risorse](provision-minimal-iam-policy.md). Per ulteriori informazioni su come recuperare le credenziali a lungo termine, consulta [Managing access keys for IAM users nella IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) *User Guide*.
1. Esegui i seguenti comandi per fornire le credenziali al AWS IoT Greengrass software Core.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
```
------
1. (Facoltativo) Se hai creato un utente IAM per il provisioning del tuo dispositivo Greengrass, elimina l'utente.
1. (Facoltativo) Se hai utilizzato l'ID della chiave di accesso e la chiave di accesso segreta di un utente IAM esistente, aggiorna le chiavi dell'utente in modo che non siano più valide. Per ulteriori informazioni, consulta [Aggiornamento delle chiavi di accesso](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey) nella *guida AWS Identity and Access Management per l'utente*.
1. In **Esegui il programma di installazione**, completa i seguenti passaggi.
1. In **Scarica il programma di installazione**, scegli **Copia** ed esegui il comando copiato sul tuo dispositivo principale. Questo comando scarica l'ultima versione del software AWS IoT Greengrass Core e la decomprime sul tuo dispositivo.
1. In **Esegui il programma di installazione**, scegli **Copia** ed esegui il comando copiato sul tuo dispositivo principale. Questo comando utilizza i nomi degli AWS IoT oggetti e dei gruppi di oggetti specificati in precedenza per eseguire il programma di installazione del software AWS IoT Greengrass Core e configurare AWS le risorse per il dispositivo principale.
Questo comando esegue inoltre le seguenti operazioni:
+ Configura il software AWS IoT Greengrass Core come servizio di sistema che viene eseguito all'avvio. Sui dispositivi Linux, ciò richiede il [sistema di inizializzazione Systemd](https://en.wikipedia.org/wiki/Systemd).
**Importante**
Sui dispositivi Windows core, è necessario configurare il software AWS IoT Greengrass Core come servizio di sistema.
+ Implementa il componente [AWS IoT Greengrass CLI](gg-cli.md), che è uno strumento da riga di comando che ti consente di sviluppare componenti Greengrass personalizzati sul dispositivo principale.
+ Specificare di utilizzare l'utente `ggc_user` del sistema per eseguire componenti software sul dispositivo principale. Sui dispositivi Linux, questo comando specifica anche di utilizzare il gruppo di `ggc_group` sistema e il programma di installazione crea automaticamente l'utente e il gruppo di sistema.
Quando si esegue questo comando, dovrebbero essere visualizzati i seguenti messaggi per indicare che l'installazione è riuscita.
```
Successfully configured Nucleus with provisioned resource details!
Configured Nucleus to deploy aws.greengrass.Cli component
Successfully set up Nucleus as a system service
```
**Nota**
Se avete un dispositivo Linux che non ha [systemd](https://en.wikipedia.org/wiki/Systemd), il programma di installazione non configurerà il software come servizio di sistema e non vedrete il messaggio di successo relativo alla configurazione del nucleus come servizio di sistema.
------
#### [ Nucleus lite ]
1. Scegliete **Nucleus lite** come runtime software del vostro dispositivo principale.
1. Seleziona il metodo di configurazione del dispositivo per eseguire il provisioning del dispositivo su un dispositivo principale Greengrass.
**Opzione 1: configura un dispositivo con download del pacchetto (circa 1 MB)**
1. Crea AWS IoT qualcosa e il ruolo per Greengrass.
1. Scarica il file zip che contiene AWS IoT le risorse a cui il tuo dispositivo ha bisogno per connettersi a AWS IoT:
+ Un certificato e una chiave privata generati utilizzando l'autorità AWS IoT di certificazione.
+ Un file di schema per avviare l'installazione di Greengrass per il tuo dispositivo.
1. Scarica il pacchetto che installerà l'ultimo runtime Greengrass Nucleus lite sul tuo Raspberry Pi.
1. Fai in modo che il tuo dispositivo diventi un dispositivo AWS IoT Greengrass Core e collegalo a: AWS IoT
1. a. Trasferisci il pacchetto Greengrass e il kit di connessione sul tuo dispositivo utilizzando una chiavetta USB, SCP/FTP o schede SD.
1. b. Decomprimi il file greengrass-package.zip nella directory/sul dispositivo. GreengrassInstaller
1. c. Decomprimi il file zip del kit di connessione nella directory /del dispositivo.
1. d. Esegui il comando fornito sul dispositivo da installare AWS IoT Greengrass
1. Quindi, scegli **Visualizza i dispositivi principali**.
**Opzione 2: configura un dispositivo con il download di un'immagine di esempio dell'intero disco preconfigurata (circa 100 MB)**
1. Crea AWS IoT qualcosa e il ruolo per Greengrass.
1. Scarica il file zip che contiene AWS IoT le risorse a cui il tuo dispositivo ha bisogno per connettersi a AWS IoT:
+ Un certificato e una chiave privata generati utilizzando l'autorità AWS IoT di certificazione.
+ Un file di schema per avviare l'installazione di Greengrass per il tuo dispositivo.
1. Scarica l'immagine campione dell'intero disco preconfigurata che contiene Greengrass e il sistema operativo.
1. Per trasferire il kit di connessione e flashare l'immagine sul dispositivo, segui il file readme scaricato con l'immagine.
1. Per avviare l'installazione di Greengrass, accendi e avvia il dispositivo dall'immagine flashata
1. Quindi, scegli **Visualizza i dispositivi principali**.
**Opzione 3: configura un dispositivo con la tua build personalizzata**
1. Crea AWS IoT qualcosa e il ruolo per Greengrass.
1. Scarica il file zip che contiene AWS IoT le risorse a cui il tuo dispositivo ha bisogno per connettersi a AWS IoT:
+ Un certificato e una chiave privata generati utilizzando l'autorità AWS IoT di certificazione.
+ Un file di schema per avviare l'installazione di Greengrass per il tuo dispositivo.
1. Per personalizzare e creare la tua immagine usando Yocto dal codice sorgente, e poi usa il kit di connessione per installare nucleus lite, segui le istruzioni su. GitHub
1. Quindi, scegli **Visualizza** i dispositivi principali.
------
# Installazione del software AWS IoT Greengrass Core (CLI)
**Nota**
Questi passaggi non si applicano a nucleus lite.
**Per installare e configurare il software AWS IoT Greengrass Core**
1. Sul tuo dispositivo principale Greengrass, esegui il seguente comando per passare alla home directory.
------
#### [ Linux or Unix ]
```
cd ~
```
------
#### [ Windows Command Prompt (CMD) ]
```
cd %USERPROFILE%
```
------
#### [ PowerShell ]
```
cd ~
```
------
1. Sul tuo dispositivo principale, scarica il software AWS IoT Greengrass Core in un file denominato`greengrass-nucleus-latest.zip`.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
Scaricando questo software accetti l'[Accordo di licenza del software Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
1. Decomprimi il software AWS IoT Greengrass Core in una cartella sul dispositivo. Sostituiscilo *GreengrassInstaller* con la cartella che desideri utilizzare.
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. Esegui il comando seguente per avviare il programma di installazione del software AWS IoT Greengrass Core. Questo comando funziona nel modo seguente:
+ Crea le AWS risorse necessarie per il funzionamento del dispositivo principale.
+ Configura il software AWS IoT Greengrass Core come servizio di sistema che viene eseguito all'avvio. Sui dispositivi Linux, ciò richiede il [sistema di inizializzazione Systemd](https://en.wikipedia.org/wiki/Systemd).
**Importante**
Sui dispositivi Windows core, è necessario configurare il software AWS IoT Greengrass Core come servizio di sistema.
+ Implementa il componente [AWS IoT Greengrass CLI](gg-cli.md), che è uno strumento da riga di comando che ti consente di sviluppare componenti Greengrass personalizzati sul dispositivo principale.
+ Specificare di utilizzare l'utente `ggc_user` del sistema per eseguire componenti software sul dispositivo principale. Sui dispositivi Linux, questo comando specifica anche di utilizzare il gruppo di `ggc_group` sistema e il programma di installazione crea automaticamente l'utente e il gruppo di sistema.
Sostituite i valori degli argomenti nel comando come segue.
1. `/greengrass/v2`oppure*C:\$1greengrass\$1v2*: il percorso della cartella principale da utilizzare per installare il software AWS IoT Greengrass Core.
1. *GreengrassInstaller*. Il percorso della cartella in cui è stato decompresso il programma di installazione del software AWS IoT Greengrass Core.
1. *region*. Il Regione AWS luogo in cui trovare o creare risorse.
1. *MyGreengrassCore*. Il nome del AWS IoT dispositivo principale Greengrass. Se l'oggetto non esiste, l'installatore lo crea. Il programma di installazione scarica i certificati per autenticarsi come oggetto. AWS IoT Per ulteriori informazioni, consulta [Autenticazione e autorizzazione del dispositivo per AWS IoT Greengrass](device-auth.md).
**Nota**
Il nome dell'oggetto non può contenere i due punti (`:`).
1. *MyGreengrassCoreGroup*. Il nome del AWS IoT gruppo di oggetti per il tuo dispositivo principale Greengrass. Se il gruppo di oggetti non esiste, il programma di installazione lo crea e vi aggiunge l'oggetto. Se il gruppo di oggetti esiste e dispone di una distribuzione attiva, il dispositivo principale scarica ed esegue il software specificato dalla distribuzione.
**Nota**
Il nome del gruppo di cose non può contenere i due punti (`:`).
1. *GreengrassV2IoTThingPolicy*. Il nome della AWS IoT policy che consente ai dispositivi core Greengrass di comunicare con AWS IoT e. AWS IoT Greengrass Se la AWS IoT politica non esiste, il programma di installazione crea una AWS IoT politica permissiva con questo nome. Puoi limitare le autorizzazioni di questa politica in base al tuo caso d'uso. Per ulteriori informazioni, consulta [AWS IoT Politica minima per i dispositivi AWS IoT Greengrass V2 principali](device-auth.md#greengrass-core-minimal-iot-policy).
1. *GreengrassV2TokenExchangeRole*. Il nome del ruolo IAM che consente al dispositivo principale Greengrass di ottenere credenziali temporanee AWS . Se il ruolo non esiste, l'installatore lo crea e crea e allega una policy denominata. `GreengrassV2TokenExchangeRoleAccess` Per ulteriori informazioni, consulta [Autorizza i dispositivi principali a interagire con i servizi AWS](device-service-role.md).
1. *GreengrassCoreTokenExchangeRoleAlias*. L'alias del ruolo IAM che consente al dispositivo principale Greengrass di ottenere credenziali temporanee in un secondo momento. Se l'alias del ruolo non esiste, il programma di installazione lo crea e lo indirizza al ruolo IAM specificato. Per ulteriori informazioni, consulta [Autorizza i dispositivi principali a interagire con i servizi AWS](device-service-role.md).
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--aws-region region \
--thing-name MyGreengrassCore \
--thing-group-name MyGreengrassCoreGroup \
--thing-policy-name GreengrassV2IoTThingPolicy \
--tes-role-name GreengrassV2TokenExchangeRole \
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias \
--component-default-user ggc_user:ggc_group \
--provision true \
--setup-system-service true \
--deploy-dev-tools true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--aws-region region ^
--thing-name MyGreengrassCore ^
--thing-group-name MyGreengrassCoreGroup ^
--thing-policy-name GreengrassV2IoTThingPolicy ^
--tes-role-name GreengrassV2TokenExchangeRole ^
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias ^
--component-default-user ggc_user ^
--provision true ^
--setup-system-service true ^
--deploy-dev-tools true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--aws-region region `
--thing-name MyGreengrassCore `
--thing-group-name MyGreengrassCoreGroup `
--thing-policy-name GreengrassV2IoTThingPolicy `
--tes-role-name GreengrassV2TokenExchangeRole `
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias `
--component-default-user ggc_user `
--provision true `
--setup-system-service true `
--deploy-dev-tools true
```
------
**Nota**
Se utilizzi AWS IoT Greengrass un dispositivo con memoria limitata, puoi controllare la quantità di memoria utilizzata dal software AWS IoT Greengrass Core. Per controllare l'allocazione della memoria, è possibile impostare le opzioni relative alla dimensione dell'heap JVM nel parametro di `jvmOptions` configurazione del componente nucleus. Per ulteriori informazioni, consulta [Controlla l'allocazione della memoria con le opzioni JVM](configure-greengrass-core-v2.md#jvm-tuning).
Quando esegui questo comando, dovresti vedere i seguenti messaggi per indicare che l'installazione è riuscita.
```
Successfully configured Nucleus with provisioned resource details!
Configured Nucleus to deploy aws.greengrass.Cli component
Successfully set up Nucleus as a system service
```
**Nota**
Se avete un dispositivo Linux che non ha [systemd](https://en.wikipedia.org/wiki/Systemd), il programma di installazione non configurerà il software come servizio di sistema e non vedrete il messaggio di successo relativo alla configurazione del nucleus come servizio di sistema.
# (Facoltativo) Esegui il software Greengrass (Linux)
**Nota**
Questi passaggi non si applicano a nucleus lite.
Se il software è stato installato come servizio di sistema, il programma di installazione lo esegue automaticamente. In caso contrario, è necessario eseguire il software. Per verificare se il programma di installazione ha configurato il software come servizio di sistema, cercate la riga seguente nell'output dell'installatore.
```
Successfully set up Nucleus as a system service
```
Se non vedi questo messaggio, procedi come segue per eseguire il software:
1. Esegui il comando seguente per eseguire il software.
```
sudo /greengrass/v2/alts/current/distro/bin/loader
```
Il software stampa il seguente messaggio se viene avviato correttamente.
```
Launched Nucleus successfully.
```
1. È necessario lasciare aperta la shell dei comandi corrente per mantenere in esecuzione il software AWS IoT Greengrass Core. Se usi SSH per connetterti al dispositivo principale, esegui il comando seguente sul tuo computer di sviluppo per aprire una seconda sessione SSH da utilizzare per eseguire comandi aggiuntivi sul dispositivo principale. Sostituiscilo *username* con il nome dell'utente a cui accedere e sostituiscilo *pi-ip-address* con l'indirizzo IP del dispositivo.
```
ssh username@pi-ip-address
```
Per ulteriori informazioni su come interagire con il servizio di sistema Greengrass, vedere. [Configurare il nucleo Greengrass come servizio di sistema](configure-greengrass-core-v2.md#configure-system-service)
# Verifica l'installazione della CLI di Greengrass sul dispositivo
**Nota**
Questi passaggi non si applicano a nucleus lite.
L'implementazione della CLI di Greengrass può richiedere fino a un minuto. Esegui il comando seguente per verificare lo stato della distribuzione. Sostituiscilo *MyGreengrassCore* con il nome del tuo dispositivo principale.
```
aws greengrassv2 list-effective-deployments --core-device-thing-name MyGreengrassCore
```
`coreDeviceExecutionStatus`Indica lo stato della distribuzione sul dispositivo principale. Quando lo stato è`SUCCEEDED`, esegui il comando seguente per verificare che la CLI Greengrass sia installata e funzionante. Sostituisci `/greengrass/v2` con il percorso della cartella principale.
------
#### [ Linux or Unix ]
```
/greengrass/v2/bin/greengrass-cli help
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli help
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli help
```
------
Il comando fornisce informazioni di aiuto per la CLI di Greengrass. Se `greengrass-cli` non viene trovato, la distribuzione potrebbe non essere riuscita a installare la CLI di Greengrass. Per ulteriori informazioni, consulta [Risoluzione dei problemi AWS IoT Greengrass V2](troubleshooting.md).
Puoi anche eseguire il comando seguente per distribuire manualmente la AWS IoT Greengrass CLI sul tuo dispositivo.
+ *region*Sostituiscila con quella Regione AWS che usi. Assicurati di utilizzare lo stesso Regione AWS che hai usato per configurarli AWS CLI sul tuo dispositivo.
+ *account-id*Sostituiscilo con il tuo Account AWS ID.
+ Sostituiscilo *MyGreengrassCore* con il nome del tuo dispositivo principale.
------
#### [ Linux, macOS, or Unix ]
```
aws greengrassv2 create-deployment \
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \
--components '{
"aws.greengrass.Cli": {
"componentVersion": "2.16.1"
}
}'
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws greengrassv2 create-deployment ^
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^
--components "{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}"
```
------
#### [ PowerShell ]
```
aws greengrassv2 create-deployment `
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" `
--components '{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}'
```
------
**Suggerimento**
È possibile aggiungere `/greengrass/v2/bin` (Linux) o `C:\greengrass\v2\bin` (Windows) alla variabile di `PATH` ambiente per eseguirla `greengrass-cli` senza il percorso assoluto.
Il software AWS IoT Greengrass Core e gli strumenti di sviluppo locale vengono eseguiti sul dispositivo. Successivamente, puoi sviluppare un AWS IoT Greengrass componente Hello World sul tuo dispositivo.
# Fase 4: Sviluppa e testa un componente sul tuo dispositivo
Un componente è un modulo software che viene eseguito sui dispositivi AWS IoT Greengrass principali. I componenti consentono di creare e gestire applicazioni complesse come elementi costitutivi discreti che puoi riutilizzare da un dispositivo core Greengrass a un altro. *Ogni componente è composto da una *ricetta* e da artefatti.*
+ **Ricette**
Ogni componente contiene un file di ricette, che ne definisce i metadati. La ricetta specifica anche i parametri di configurazione del componente, le dipendenze dei componenti, il ciclo di vita e la compatibilità della piattaforma. Il ciclo di vita del componente definisce i comandi che installano, eseguono e spengono il componente. Per ulteriori informazioni, consulta [AWS IoT Greengrass riferimento alla ricetta del componente](component-recipe-reference.md).
[È possibile definire ricette in formato [JSON](https://en.wikipedia.org/wiki/JSON) o YAML.](https://en.wikipedia.org/wiki/YAML)
+ **Artefatti**
I componenti possono avere un numero qualsiasi di artefatti, che sono componenti binari. Gli artefatti possono includere script, codice compilato, risorse statiche e qualsiasi altro file utilizzato da un componente. I componenti possono anche consumare artefatti derivanti dalle dipendenze dei componenti.
Con AWS IoT Greengrass, puoi utilizzare la Greengrass CLI per sviluppare e testare i componenti localmente su un dispositivo core Greengrass senza interazione con il Cloud. AWS Una volta completato il componente locale, puoi utilizzare la ricetta e gli artefatti del componente per creare quel componente nel AWS IoT Greengrass servizio nel AWS Cloud e quindi distribuirlo su tutti i tuoi dispositivi principali Greengrass. Per ulteriori informazioni sui componenti, vedere. [Sviluppa AWS IoT Greengrass componenti](develop-greengrass-components.md)
In questa sezione, imparerai come creare ed eseguire un componente Hello World di base localmente sul tuo dispositivo principale.
**Per sviluppare un componente Hello World sul tuo dispositivo**
1. Crea una cartella per i componenti con sottocartelle per ricette e artefatti. Esegui i seguenti comandi sul tuo dispositivo principale Greengrass per creare queste cartelle e passare alla cartella dei componenti. Sostituisci *\$1/greengrassv2* o *%USERPROFILE%\$1greengrassv2* con il percorso della cartella da utilizzare per lo sviluppo locale.
------
#### [ Linux or Unix ]
```
mkdir -p ~/greengrassv2/{recipes,artifacts}
cd ~/greengrassv2
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir %USERPROFILE%\greengrassv2\\recipes, %USERPROFILE%\greengrassv2\\artifacts
cd %USERPROFILE%\greengrassv2
```
------
#### [ PowerShell ]
```
mkdir ~/greengrassv2/recipes, ~/greengrassv2/artifacts
cd ~/greengrassv2
```
------
1. Utilizza un editor di testo per creare un file di ricette che definisca i metadati, i parametri, le dipendenze, il ciclo di vita e le funzionalità della piattaforma del componente. Includi la versione del componente nel nome del file di ricetta in modo da poter identificare quale ricetta riflette quale versione del componente. Puoi scegliere il formato YAML o JSON per la tua ricetta.
Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.
------
#### [ JSON ]
```
nano recipes/com.example.HelloWorld-1.0.0.json
```
------
#### [ YAML ]
```
nano recipes/com.example.HelloWorld-1.0.0.yaml
```
------
**Nota**
AWS IoT Greengrass utilizza versioni semantiche per i componenti. *Le versioni semantiche seguono una delle principali.* *minore*. sistema di numerazione delle *patch*. Ad esempio, la versione `1.0.0` rappresenta la prima release principale di un componente. Per ulteriori informazioni, consultate la [specifica della versione semantica](https://semver.org/).
1. Incolla la seguente ricetta nel file.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
- Platform:
os: windows
Lifecycle:
run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
```
------
La `ComponentConfiguration` sezione di questa ricetta definisce un parametro`Message`, il cui valore predefinito è. `world` La `Manifests` sezione definisce un *manifesto*, che è un insieme di istruzioni e artefatti del ciclo di vita per una piattaforma. È possibile definire più manifesti per specificare istruzioni di installazione diverse per varie piattaforme, ad esempio. Nel manifesto, la `Lifecycle` sezione indica al dispositivo principale Greengrass di eseguire lo script Hello World con il valore `Message` del parametro come argomento.
1. Eseguite il comando seguente per creare una cartella per gli artefatti del componente.
------
#### [ Linux or Unix ]
```
mkdir -p artifacts/com.example.HelloWorld/1.0.0
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir artifacts\com.example.HelloWorld\1.0.0
```
------
#### [ PowerShell ]
```
mkdir artifacts\com.example.HelloWorld\1.0.0
```
------
**Importante**
È necessario utilizzare il seguente formato per il percorso della cartella degli artefatti. Includete il nome e la versione del componente specificati nella ricetta.
```
artifacts/componentName/componentVersion/
```
1. Usa un editor di testo per creare un file artefatto di script Python per il tuo componente Hello World.
Ad esempio, su un sistema basato su Linux, puoi eseguire il comando seguente per usare GNU nano per creare il file.
```
nano artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Copia e incolla il seguente script Python nel file.
```
import sys
message = "Hello, %s!" % sys.argv[1]
# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```
1. Utilizza la AWS IoT Greengrass CLI locale per gestire i componenti sul tuo dispositivo principale Greengrass.
Esegui il comando seguente per distribuire il componente nel core. AWS IoT Greengrass Sostituisci `/greengrass/v2` o *C:\$1greengrass\$1v2* con la tua cartella AWS IoT Greengrass V2 principale e sostituiscilo *\$1/greengrassv2* *%USERPROFILE%\$1greengrassv2* con la cartella di sviluppo dei componenti.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--recipeDir ~/greengrassv2/recipes \
--artifactDir ~/greengrassv2/artifacts \
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--recipeDir %USERPROFILE%\greengrassv2\recipes ^
--artifactDir %USERPROFILE%\greengrassv2\artifacts ^
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--recipeDir ~/greengrassv2/recipes `
--artifactDir ~/greengrassv2/artifacts `
--merge "com.example.HelloWorld=1.0.0"
```
------
Questo comando aggiunge il componente che utilizza la ricetta in `recipes` e lo script Python in. `artifacts` L'`--merge`opzione aggiunge o aggiorna il componente e la versione specificati.
1. Il software AWS IoT Greengrass Core salva lo stdout dal processo componente nei file di registro nella `logs` cartella. Esegui il comando seguente per verificare che il componente Hello World venga eseguito e stampi i messaggi.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
Il `type` comando scrive il contenuto del file nel terminale. Esegui questo comando più volte per osservare le modifiche nel file.
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Dovrebbero essere visualizzati messaggi simili a quelli dell'esempio seguente.
```
Hello, world!
```
**Nota**
Se il file non esiste, la distribuzione locale potrebbe non essere ancora completa. Se il file non esiste entro 15 secondi, è probabile che la distribuzione non sia riuscita. Ciò può verificarsi, ad esempio, se la ricetta non è valida. Esegui il comando seguente per visualizzare il file di registro AWS IoT Greengrass principale. Questo file include i log del servizio di distribuzione del dispositivo principale Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
```
type C:\greengrass\v2\logs\greengrass.log
```
Il `type` comando scrive il contenuto del file nel terminale. Esegui questo comando più volte per osservare le modifiche nel file.
```
gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
```
1. Modifica il componente locale per iterare e testare il codice. Apri `hello_world.py` in un editor di testo e aggiungi il codice seguente alla riga 4 per modificare il messaggio registrato dal AWS IoT Greengrass core.
```
message += " Greetings from your first Greengrass component."
```
Lo `hello_world.py` script dovrebbe ora avere i seguenti contenuti.
```
import sys
message = "Hello, %s!" % sys.argv[1]
message += " Greetings from your first Greengrass component."
# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```
1. Esegui il comando seguente per aggiornare il componente con le tue modifiche.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--recipeDir ~/greengrassv2/recipes \
--artifactDir ~/greengrassv2/artifacts \
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--recipeDir %USERPROFILE%\greengrassv2\recipes ^
--artifactDir %USERPROFILE%\greengrassv2\artifacts ^
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--recipeDir ~/greengrassv2/recipes `
--artifactDir ~/greengrassv2/artifacts `
--merge "com.example.HelloWorld=1.0.0"
```
------
Questo comando aggiorna il `com.example.HelloWorld` componente con l'ultimo artefatto Hello World.
1. Eseguite il comando seguente per riavviare il componente. Quando riavviate un componente, il dispositivo principale utilizza le ultime modifiche.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli component restart \
--names "com.example.HelloWorld"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli component restart ^
--names "com.example.HelloWorld"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli component restart `
--names "com.example.HelloWorld"
```
------
1. Controlla nuovamente il registro per verificare che il componente Hello World stampi il nuovo messaggio.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
Il `type` comando scrive il contenuto del file nel terminale. Esegui questo comando più volte per osservare le modifiche nel file.
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Dovrebbero essere visualizzati messaggi simili a quelli dell'esempio seguente.
```
Hello, world! Greetings from your first Greengrass component.
```
1. È possibile aggiornare i parametri di configurazione del componente per testare diverse configurazioni. Quando si distribuisce un componente, è possibile specificare un *aggiornamento della configurazione*, che definisce come modificare la configurazione del componente sul dispositivo principale. È possibile specificare quali valori di configurazione ripristinare ai valori predefiniti e i nuovi valori di configurazione da unire al dispositivo principale. Per ulteriori informazioni, consulta [Aggiornamento delle configurazioni dei componenti](update-component-configurations.md).
Esegui questa operazione:
1. Utilizzate un editor di testo per creare un file chiamato `hello-world-config-update.json` a contenere l'aggiornamento della configurazione
Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.
```
nano hello-world-config-update.json
```
1. Copiate e incollate il seguente oggetto JSON nel file. Questo oggetto JSON definisce un aggiornamento della configurazione che unisce il valore al `Message` parametro `friend` per aggiornarne il valore. Questo aggiornamento della configurazione non specifica alcun valore da reimpostare. Non è necessario reimpostare il `Message` parametro perché l'aggiornamento di fusione sostituisce il valore esistente.
```
{
"com.example.HelloWorld": {
"MERGE": {
"Message": "friend"
}
}
}
```
1. Esegui il comando seguente per distribuire l'aggiornamento della configurazione nel componente Hello World.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--merge "com.example.HelloWorld=1.0.0" \
--update-config hello-world-config-update.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--merge "com.example.HelloWorld=1.0.0" ^
--update-config hello-world-config-update.json
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--merge "com.example.HelloWorld=1.0.0" `
--update-config hello-world-config-update.json
```
------
1. Controlla nuovamente il registro per verificare che il componente Hello World emetta il nuovo messaggio.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
Il `type` comando scrive il contenuto del file nel terminale. Esegui questo comando più volte per osservare le modifiche nel file.
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Dovrebbero essere visualizzati messaggi simili a quelli dell'esempio seguente.
```
Hello, friend! Greetings from your first Greengrass component.
```
1. Dopo aver terminato il test del componente, rimuovilo dal dispositivo principale. Eseguire il seguente comando seguente.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create --remove="com.example.HelloWorld"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld"
```
------
**Importante**
Questo passaggio è necessario per ridistribuire il componente sul dispositivo principale dopo averlo caricato su. AWS IoT Greengrass In caso contrario, la distribuzione fallisce con un errore di compatibilità della versione perché la distribuzione locale specifica una versione diversa del componente.
Esegui il comando seguente e verifica che il `com.example.HelloWorld` componente non compaia nell'elenco dei componenti del dispositivo.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli component list
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli component list
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli component list
```
------
Il componente Hello World è completo e ora puoi caricarlo sul servizio AWS IoT Greengrass cloud. Quindi, puoi distribuire il componente sui dispositivi principali Greengrass.
# Fase 5: Crea il tuo componente nel AWS IoT Greengrass servizio
Quando finisci di sviluppare un componente sul tuo dispositivo principale, puoi caricarlo sul AWS IoT Greengrass servizio in Cloud AWS. Puoi anche creare direttamente il componente nella [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass). AWS IoT Greengrass fornisce un servizio di gestione dei componenti che ospita i componenti in modo da poterli distribuire su singoli dispositivi o flotte di dispositivi. Per caricare un componente nel AWS IoT Greengrass servizio, è necessario completare i seguenti passaggi:
+ Carica gli artefatti dei componenti in un bucket S3.
+ Aggiungi l'URI Amazon Simple Storage Service (Amazon S3) di ogni elemento alla ricetta del componente.
+ Crea un componente AWS IoT Greengrass dalla ricetta del componente.
In questa sezione, completa questi passaggi sul tuo dispositivo principale Greengrass per caricare il componente Hello World sul AWS IoT Greengrass servizio.
## Crea il tuo componente in AWS IoT Greengrass (console)
1. Usa un bucket S3 nel tuo AWS account per ospitare gli artefatti AWS IoT Greengrass dei componenti. Quando distribuisci il componente su un dispositivo principale, il dispositivo scarica gli artefatti del componente dal bucket.
Puoi usare un bucket S3 esistente oppure puoi crearne uno nuovo.
1. **Nella [console Amazon S3](https://console.aws.amazon.com/s3), in Bucket, scegli **Crea bucket**.**
1. Per **Bucket name, inserisci un nome di bucket** univoco. Per esempio, è possibile utilizzare **greengrass-component-artifacts-*region*-*123456789012***. Sostituiscilo *123456789012* con l'ID del tuo AWS account e *region* con Regione AWS quello che usi per questo tutorial.
1. Per la **AWS regione**, seleziona la AWS regione che usi per questo tutorial.
1. Seleziona **Crea bucket**.
1. In **Bucket**, scegli il bucket che hai creato, carica `hello_world.py` lo script nella `artifacts/com.example.HelloWorld/1.0.0` cartella all'interno del bucket. Per informazioni sul caricamento di oggetti nei bucket S3, consulta [Caricamento di oggetti nella Amazon Simple](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) *Storage Service User Guide*.
1. Copia l'URI S3 dell'`hello_world.py`oggetto nel bucket S3. Questo URI dovrebbe essere simile all'esempio seguente. Sostituisci amzn-s3-demo-bucket con il nome del bucket S3.
```
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
1. Consenti al dispositivo principale di accedere agli artefatti dei componenti nel bucket S3.
Ogni dispositivo principale ha un [ruolo IAM del dispositivo principale](device-service-role.md) che gli consente di interagire AWS IoT e inviare log al cloud. AWS Per impostazione predefinita, questo ruolo del dispositivo non consente l'accesso ai bucket S3, quindi è necessario creare e allegare una policy che consenta al dispositivo principale di recuperare gli artefatti dei componenti dal bucket S3.
Se il ruolo del tuo dispositivo consente già l'accesso al bucket S3, puoi saltare questo passaggio. Altrimenti, crea una policy IAM che consenta l'accesso e collegala al ruolo, come segue:
1. **Nel menu di navigazione [della console IAM](https://console.aws.amazon.com/iam), scegli Policies, quindi scegli **Crea policy**.**
1. Nella scheda **JSON**, sostituire il contenuto del segnaposto con la seguente policy. Sostituisci amzn-s3-demo-bucket con il nome del bucket S3 che contiene gli artefatti dei componenti per il dispositivo principale da scaricare.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
1. Scegli **Next (Successivo)**.
1. **Nella sezione **Dettagli della politica,** per Nome**, inserisci. **MyGreengrassV2ComponentArtifactPolicy**
1. Scegli **Crea policy**.
1. Nel menu di navigazione della [console IAM](https://console.aws.amazon.com/iam), scegli **Ruolo**, quindi scegli il nome del ruolo per il dispositivo principale. Hai specificato questo nome di ruolo quando hai installato il software AWS IoT Greengrass Core. Se non hai specificato un nome, l'impostazione predefinita è`GreengrassV2TokenExchangeRole`.
1. In **Autorizzazioni**, scegli **Aggiungi autorizzazioni**, quindi scegli **Allega** politiche.
1. **Nella pagina **Aggiungi autorizzazioni**, seleziona la casella di controllo accanto alla `MyGreengrassV2ComponentArtifactPolicy` politica che hai creato, quindi scegli Aggiungi autorizzazioni.**
1. [Usa la ricetta del componente per creare un componente nella AWS IoT Greengrass console.](https://console.aws.amazon.com/greengrass)
1. Nel menu di navigazione della [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass), scegli **Componenti**, quindi scegli **Crea componente**.
1. In **Informazioni sui componenti**, scegli **Inserisci la ricetta come JSON**. La ricetta segnaposto dovrebbe essere simile all'esempio seguente.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
}
]
}
```
1. Sostituisci l'URI segnaposto in ogni `Artifacts` sezione con l'URI S3 del tuo oggetto. `hello_world.py`
1. **Scegli Crea componente.**
1. Sul **com.example. **HelloWorld**pagina del componente, verifica che **lo stato** del componente sia Implementabile.**
## Crea il tuo componente in AWS IoT Greengrass ()AWS CLI
**Per caricare il tuo componente Hello World**
1. Usa un bucket S3 Account AWS per ospitare gli artefatti AWS IoT Greengrass dei componenti. Quando distribuisci il componente su un dispositivo principale, il dispositivo scarica gli artefatti del componente dal bucket.
Puoi utilizzare un bucket S3 esistente o eseguire il seguente comando per creare un bucket. Questo comando crea un bucket con il tuo Account AWS ID e Regione AWS per formare un nome di bucket univoco. Sostituiscilo *123456789012* con il tuo Account AWS ID e *region* con Regione AWS quello che usi per questo tutorial.
```
aws s3 mb s3://greengrass-component-artifacts-123456789012-region
```
Il comando restituisce le seguenti informazioni se la richiesta ha esito positivo.
```
make_bucket: greengrass-component-artifacts-123456789012-region
```
1. Consenti al dispositivo principale di accedere agli artefatti dei componenti nel bucket S3.
Ogni dispositivo principale ha un [ruolo IAM del dispositivo principale](device-service-role.md) che gli consente di interagire AWS IoT e inviare log a. Cloud AWS Per impostazione predefinita, questo ruolo del dispositivo non consente l'accesso ai bucket S3, quindi è necessario creare e allegare una policy che consenta al dispositivo principale di recuperare gli artefatti dei componenti dal bucket S3.
Se il ruolo del dispositivo principale consente già l'accesso al bucket S3, puoi saltare questo passaggio. Altrimenti, crea una policy IAM che consenta l'accesso e collegala al ruolo, come segue:
1. Crea un file chiamato `component-artifact-policy.json` e copia il seguente codice JSON nel file. Questa politica consente l'accesso a tutti i file in un bucket S3. Sostituisci amzn-s3-demo-bucket con il nome del bucket S3.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
1. Esegui il seguente comando per creare la politica dal documento di policy in. `component-artifact-policy.json`
------
#### [ Linux or Unix ]
```
aws iam create-policy \\
--policy-name MyGreengrassV2ComponentArtifactPolicy \\
--policy-document file://component-artifact-policy.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iam create-policy ^
--policy-name MyGreengrassV2ComponentArtifactPolicy ^
--policy-document file://component-artifact-policy.json
```
------
#### [ PowerShell ]
```
aws iam create-policy `
--policy-name MyGreengrassV2ComponentArtifactPolicy `
--policy-document file://component-artifact-policy.json
```
------
Copia la policy Amazon Resource Name (ARN) dai metadati della policy nell'output. Utilizzerai questo ARN per collegare questa policy al ruolo principale del dispositivo nel passaggio successivo.
1. Esegui il comando seguente per allegare la policy al ruolo principale del dispositivo. Sostituisci *GreengrassV2TokenExchangeRole* con il nome del ruolo per il dispositivo principale. Hai specificato questo nome di ruolo quando hai installato il software AWS IoT Greengrass Core. Sostituisci l'ARN della policy con l'ARN del passaggio precedente.
------
#### [ Linux or Unix ]
```
aws iam attach-role-policy \\
--role-name GreengrassV2TokenExchangeRole \\
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iam attach-role-policy ^
--role-name GreengrassV2TokenExchangeRole ^
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
#### [ PowerShell ]
```
aws iam attach-role-policy `
--role-name GreengrassV2TokenExchangeRole `
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
Se il comando non ha alcun risultato, è stato eseguito correttamente. Il dispositivo principale può ora accedere agli artefatti caricati in questo bucket S3.
1. Carica l'elemento dello script Hello World Python nel bucket S3.
Esegui il comando seguente per caricare lo script nello stesso percorso nel bucket in cui lo script si trova nel core. AWS IoT Greengrass Sostituisci amzn-s3-demo-bucket con il nome del bucket S3.
------
#### [ Linux or Unix ]
```
aws s3 cp \
artifacts/com.example.HelloWorld/1.0.0/hello_world.py \
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws s3 cp ^
artifacts/com.example.HelloWorld/1.0.0/hello_world.py ^
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
#### [ PowerShell ]
```
aws s3 cp `
artifacts/com.example.HelloWorld/1.0.0/hello_world.py `
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
Il comando genera una riga che inizia con se la richiesta ha esito positivo. `upload:`
1. Aggiungi l'URI Amazon S3 dell'artefatto alla ricetta del componente.
L'URI di Amazon S3 è composto dal nome del bucket e dal percorso dell'oggetto artefatto nel bucket. L'URI Amazon S3 del tuo elemento di script è l'URI in cui carichi l'artefatto nel passaggio precedente. Questo URI dovrebbe essere simile all'esempio seguente. Sostituisci amzn-s3-demo-bucket con il nome del bucket S3.
```
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Per aggiungere l'artefatto alla ricetta, aggiungi un elenco `Artifacts` contenente una struttura con l'URI di Amazon S3.
------
#### [ JSON ]
```
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
```
Apri il file della ricetta in un editor di testo.
Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.
```
nano recipes/com.example.HelloWorld-1.0.0.json
```
Aggiungi l'artefatto alla ricetta. Il file della ricetta dovrebbe essere simile all'esempio seguente.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
}
]
}
```
------
#### [ YAML ]
```
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Aprite il file delle ricette in un editor di testo.
Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.
```
nano recipes/com.example.HelloWorld-1.0.0.yaml
```
Aggiungi l'artefatto alla ricetta. Il file della ricetta dovrebbe essere simile all'esempio seguente.
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
Run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
- Platform:
os: windows
Lifecycle:
Run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
1. Crea una risorsa componente AWS IoT Greengrass dalla ricetta. Eseguite il comando seguente per creare il componente dalla ricetta, che fornite come file binario.
------
#### [ JSON ]
```
aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.json
```
------
#### [ YAML ]
```
aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.yaml
```
------
La risposta è simile all'esempio seguente se la richiesta ha esito positivo.
```
{
"arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0",
"componentName": "com.example.HelloWorld",
"componentVersion": "1.0.0",
"creationTimestamp": "Mon Nov 30 09:04:05 UTC 2020",
"status": {
"componentState": "REQUESTED",
"message": "NONE",
"errors": {}
}
}
```
Copia il file `arn` dall'output per verificare lo stato del componente nel passaggio successivo.
**Nota**
Puoi anche vedere il tuo componente Hello World nella [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass) nella pagina **Componenti**.
1. Verifica che il componente sia stato creato e sia pronto per essere distribuito. Quando create un componente, il suo stato è`REQUESTED`. Quindi, AWS IoT Greengrass verifica che il componente sia implementabile. È possibile eseguire il comando seguente per interrogare lo stato del componente e verificare che il componente sia distribuibile. Sostituisci `arn` con l'ARN del passaggio precedente.
```
aws greengrassv2 describe-component --arn "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0"
```
Se il componente viene convalidato, la risposta indica che lo stato del componente è. `DEPLOYABLE`
```
{
"arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0",
"componentName": "com.example.HelloWorld",
"componentVersion": "1.0.0",
"creationTimestamp": "2020-11-30T18:04:05.823Z",
"publisher": "Amazon",
"description": "My first Greengrass component.",
"status": {
"componentState": "DEPLOYABLE",
"message": "NONE",
"errors": {}
},
"platforms": [
{
"os": "linux",
"architecture": "all"
}
]
}
```
Il tuo componente Hello World è ora disponibile in AWS IoT Greengrass. Puoi reinstallarlo su questo dispositivo principale Greengrass o su altri dispositivi principali.
# Fase 6: Implementazione del componente
Con AWS IoT Greengrass, puoi distribuire componenti su singoli dispositivi o gruppi di dispositivi. Quando distribuisci un componente, AWS IoT Greengrass installa ed esegue il software di quel componente su ogni dispositivo di destinazione. È necessario specificare i componenti da distribuire e l'aggiornamento della configurazione da distribuire per ciascun componente. È inoltre possibile controllare il modo in cui la distribuzione viene distribuita ai dispositivi destinatari della distribuzione. Per ulteriori informazioni, consulta [Implementazione AWS IoT Greengrass dei componenti sui dispositivi](manage-deployments.md).
In questa sezione, ridistribuisci il componente Hello World sul tuo dispositivo principale Greengrass.
## Implementa il tuo componente (console)
1. Nel menu di navigazione [AWS IoT Greengrass della console](https://console.aws.amazon.com/greengrass), scegli **Componenti**.
1. Nella pagina **Componenti**, nella scheda I **miei componenti**, scegli **com.example.HelloWorld**.
1. Nella **com.example.HelloWorld**nella pagina, scegli **Deploy.**
1. Da **Aggiungi alla distribuzione**, scegli **Crea nuova distribuzione**, quindi scegli **Avanti**.
1. Nella pagina **Specifica destinazione**, procedi come segue:
1. Nella casella **Name** (Nome), inserisci **Deployment for MyGreengrassCore**.
1. Per **Deployment target**, scegli **Core device** e il nome dell' AWS IoT oggetto per il tuo dispositivo principale. Il valore predefinito in questo tutorial è*MyGreengrassCore*.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Seleziona componenti**, in **I miei componenti**, verifica che **com.example.HelloWorld**il componente è selezionato e scegli **Avanti**.
1. Nella pagina **Configura componenti**, scegli **com.example.HelloWorld**ed esegui le seguenti operazioni:
1. Scegli **Configura componente**.
1. In **Aggiornamento della configurazione**, in **Configurazione da unire**, inserisci la seguente configurazione.
```
{
"Message": "universe"
}
```
Questo aggiornamento della configurazione imposta il `Message` parametro Hello World `universe` per il dispositivo in questa distribuzione.
1. Scegli **Conferma**.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Configura impostazioni avanzate**, mantieni le impostazioni di configurazione predefinite e scegli **Avanti**.
1. Nella pagina **Review (Verifica)**, scegli **Deploy (Distribuisci)**.
1. Verifica che la distribuzione sia completata correttamente. La distribuzione può richiedere alcuni minuti. Controlla il registro di Hello World per verificare la modifica. Esegui il seguente comando sul tuo dispositivo principale Greengrass.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\\logs\\com.example.HelloWorld.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Dovresti vedere messaggi simili all'esempio seguente.
```
Hello, universe! Greetings from your first Greengrass component.
```
**Nota**
Se i messaggi di registro non vengono modificati, la distribuzione non è riuscita o non ha raggiunto il dispositivo principale. Ciò può verificarsi se il dispositivo principale non è connesso a Internet o non dispone delle autorizzazioni per recuperare artefatti dal bucket S3. Esegui il seguente comando sul tuo dispositivo principale per visualizzare il file di registro del software Core. AWS IoT Greengrass Questo file include i log del servizio di distribuzione del dispositivo principale Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
```
type C:\greengrass\v2\\logs\\greengrass.log
```
Il `type` comando scrive il contenuto del file nel terminale. Esegui questo comando più volte per osservare le modifiche nel file.
```
gc C:\greengrass\v2\\logs\\greengrass.log -Tail 10 -Wait
```
Per ulteriori informazioni, consulta [Risoluzione dei problemi AWS IoT Greengrass V2](troubleshooting.md).
## Distribuisci il tuo componente ()AWS CLI
**Per distribuire il componente Hello World**
1. Sul tuo computer di sviluppo, crea un file chiamato `hello-world-deployment.json` e copia il seguente codice JSON nel file. Questo file definisce i componenti e le configurazioni da distribuire.
```
{
"components": {
"com.example.HelloWorld": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"merge": "{\"Message\":\"universe\"}"
}
}
}
}
```
Questo file di configurazione specifica di distribuire la versione `1.0.0` del componente Hello World sviluppata e pubblicata nella procedura precedente. `configurationUpdate`Specificano di unire la configurazione del componente in una stringa con codifica JSON. Questo aggiornamento della configurazione imposta il `Message` parametro Hello World sul dispositivo in `universe` questa distribuzione.
1. Esegui il seguente comando per distribuire il componente sul tuo dispositivo principale Greengrass. È possibile eseguire la distribuzione su oggetti, che sono dispositivi singoli, o gruppi di oggetti, che sono gruppi di dispositivi. Sostituiscilo *MyGreengrassCore* con il AWS IoT nome del dispositivo principale.
------
#### [ Linux or Unix ]
```
aws greengrassv2 create-deployment \
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \
--cli-input-json file://hello-world-deployment.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws greengrassv2 create-deployment ^
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^
--cli-input-json file://hello-world-deployment.json
```
------
#### [ PowerShell ]
```
aws greengrassv2 create-deployment `
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" `
--cli-input-json file://hello-world-deployment.json
```
------
Il comando restituisce una risposta simile all'esempio seguente.
```
{
"deploymentId": "deb69c37-314a-4369-a6a1-3dff9fce73a9",
"iotJobId": "b5d92151-6348-4941-8603-bdbfb3e02b75",
"iotJobArn": "arn:aws:iot:region:account-id:job/b5d92151-6348-4941-8603-bdbfb3e02b75"
}
```
1. Verificare che la distribuzione venga completata correttamente. La distribuzione può richiedere alcuni minuti. Controlla il registro di Hello World per verificare la modifica. Esegui il seguente comando sul tuo dispositivo principale Greengrass.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\\logs\\com.example.HelloWorld.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Dovresti vedere messaggi simili all'esempio seguente.
```
Hello, universe! Greetings from your first Greengrass component.
```
**Nota**
Se i messaggi di registro non vengono modificati, la distribuzione non è riuscita o non ha raggiunto il dispositivo principale. Ciò può verificarsi se il dispositivo principale non è connesso a Internet o non dispone delle autorizzazioni per recuperare artefatti dal bucket S3. Esegui il seguente comando sul tuo dispositivo principale per visualizzare il file di registro del software Core. AWS IoT Greengrass Questo file include i log del servizio di distribuzione del dispositivo principale Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
```
type C:\greengrass\v2\\logs\\greengrass.log
```
Il `type` comando scrive il contenuto del file nel terminale. Esegui questo comando più volte per osservare le modifiche nel file.
```
gc C:\greengrass\v2\\logs\\greengrass.log -Tail 10 -Wait
```
Per ulteriori informazioni, consulta [Risoluzione dei problemi AWS IoT Greengrass V2](troubleshooting.md).
# Passaggi successivi
Hai completato questo tutorial. Il software AWS IoT Greengrass Core e il componente Hello World funzionano sul tuo dispositivo. Inoltre, il componente Hello World è disponibile nel servizio AWS IoT Greengrass cloud per essere distribuito su altri dispositivi. Per ulteriori informazioni sugli argomenti trattati in questo tutorial, consulta quanto segue:
+ [Crea AWS IoT Greengrass componenti](create-components.md)
+ [Pubblica componenti da distribuire sui tuoi dispositivi principali](publish-components.md)
+ [Implementazione AWS IoT Greengrass dei componenti sui dispositivi](manage-deployments.md)