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