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à.
# Installa il software AWS IoT Greengrass Core con provisioning manuale delle risorse
Il software AWS IoT Greengrass Core include un programma di installazione che configura il dispositivo come dispositivo principale Greengrass. Per configurare un dispositivo manualmente, puoi creare le risorse IAM necessarie AWS IoT e le risorse IAM da utilizzare per il dispositivo. Se crei queste risorse manualmente, non è necessario fornire AWS le credenziali all'installatore.
Quando installi manualmente il software AWS IoT Greengrass Core, puoi anche configurare il dispositivo per utilizzare un proxy di rete o connetterti alla porta AWS 443. Potrebbe essere necessario specificare queste opzioni di configurazione se il dispositivo è protetto da un firewall o da un proxy di rete, ad esempio. Per ulteriori informazioni, consulta [Connessione alla porta 443 o tramite un proxy di rete](configure-greengrass-core-v2.md#configure-alpn-network-proxy).
È inoltre possibile configurare il software AWS IoT Greengrass Core per utilizzare un modulo di sicurezza hardware (HSM) tramite l'interfaccia [PKCS \$111](https://en.wikipedia.org/wiki/PKCS_11). Questa funzionalità consente di archiviare in modo sicuro i file di chiavi e certificati privati in modo che non vengano esposti o duplicati nel software. È possibile archiviare chiavi e certificati privati su un modulo hardware come un HSM, un Trusted Platform Module (TPM) o un altro elemento crittografico. Questa funzionalità è disponibile solo sui dispositivi Linux. Per ulteriori informazioni sulla sicurezza dell'hardware e sui requisiti per utilizzarla, vedere[Integrazione della sicurezza hardware](hardware-security.md).
**Importante**
Prima di scaricare il software AWS IoT Greengrass Core, verifica che il dispositivo principale soddisfi i [requisiti](greengrass-nucleus-component.md#greengrass-v2-requirements) per installare ed eseguire il software AWS IoT Greengrass Core v2.0.
**Topics**
+ [Recupera AWS IoT gli endpoint](#retrieve-iot-endpoints)
+ [Crea qualsiasi cosa AWS IoT](#create-iot-thing)
+ [Crea il certificato dell'oggetto](#create-thing-certificate)
+ [Configura il certificato del oggetto](#configure-thing-certificate)
+ [Crea un ruolo di scambio di token](#create-token-exchange-role)
+ [Scarica i certificati sul dispositivo](#download-thing-certificates)
+ [Configura l'ambiente del dispositivo](#set-up-device-environment)
+ [Scaricate il software Core AWS IoT Greengrass](#download-greengrass-core-v2)
+ [Installa il software Core AWS IoT Greengrass](#run-greengrass-core-v2-installer-manual)
## Recupera AWS IoT gli endpoint
Ottieni gli AWS IoT endpoint per te e salvali per Account AWS utilizzarli in un secondo momento. Il tuo dispositivo utilizza questi endpoint per connettersi a. AWS IoT Esegui questa operazione:
1. Ottieni l'endpoint di AWS IoT dati per il tuo. Account AWS
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
La risposta è simile all'esempio seguente, se la richiesta ha esito positivo.
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. Ottieni l'endpoint delle AWS IoT credenziali per il tuo. Account AWS
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
La risposta è simile all'esempio seguente, se la richiesta ha esito positivo.
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## Crea qualsiasi cosa AWS IoT
AWS IoT *le cose* rappresentano dispositivi ed entità logiche a cui si connettono AWS IoT. I dispositivi core Greengrass sono AWS IoT cose. Quando registri un dispositivo come AWS IoT oggetto, quel dispositivo può utilizzare un certificato digitale con cui autenticarsi. AWS
In questa sezione, crei AWS IoT qualcosa che rappresenta il tuo dispositivo.
**Per creare qualsiasi AWS IoT cosa**
1. Crea AWS IoT qualcosa per il tuo dispositivo. Sul tuo computer di sviluppo, esegui il seguente comando.
+ Sostituisci *MyGreengrassCore* con il nome dell'oggetto da usare. Questo nome è anche il nome del dispositivo principale Greengrass.
**Nota**
Il nome dell'oggetto non può contenere i due punti (`:`).
```
aws iot create-thing --thing-name MyGreengrassCore
```
La risposta è simile all'esempio seguente, se la richiesta ha esito positivo.
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. (Facoltativo) Aggiungere l' AWS IoT oggetto a un gruppo di oggetti nuovo o esistente. Utilizzi i gruppi di cose per gestire flotte di dispositivi core Greengrass. Quando distribuisci componenti software sui tuoi dispositivi, puoi scegliere come target singoli dispositivi o gruppi di dispositivi. È possibile aggiungere un dispositivo a un gruppo di cose con una distribuzione Greengrass attiva per distribuire i componenti software di quel gruppo di cose sul dispositivo. Esegui questa operazione:
1. (Facoltativo) Crea un gruppo di AWS IoT cose.
+ Sostituirlo *MyGreengrassCoreGroup* con il nome del gruppo di oggetti da creare.
**Nota**
Il nome del gruppo di cose non può contenere i due punti (`:`).
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
La risposta è simile all'esempio seguente, se la richiesta ha esito positivo.
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. Aggiungere l' AWS IoT oggetto a un gruppo di oggetti.
+ Sostituiscilo *MyGreengrassCore* con il nome del tuo AWS IoT oggetto.
+ Sostituisci *MyGreengrassCoreGroup* con il nome del gruppo di oggetti.
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
Il comando non produce alcun output se la richiesta ha esito positivo.
## Crea il certificato dell'oggetto
Quando si registra un dispositivo come AWS IoT oggetto, quel dispositivo può utilizzare un certificato digitale con AWS cui autenticarsi. Questo certificato consente al dispositivo di comunicare con AWS IoT e AWS IoT Greengrass.
In questa sezione, crei e scarichi certificati a cui il tuo dispositivo può connettersi AWS.
Se desideri configurare il software AWS IoT Greengrass Core per utilizzare un modulo di sicurezza hardware (HSM) per archiviare in modo sicuro la chiave privata e il certificato, segui i passaggi per creare il certificato da una chiave privata in un HSM. Altrimenti, segui i passaggi per creare il certificato e la chiave privata nel servizio. AWS IoT La funzionalità di sicurezza hardware è disponibile solo sui dispositivi Linux. Per ulteriori informazioni sulla sicurezza dell'hardware e sui requisiti per utilizzarla, vedere[Integrazione della sicurezza hardware](hardware-security.md).
### Creare il certificato e la chiave privata nel AWS IoT servizio
**Per creare il certificato dell'oggetto**
1. Crea una cartella in cui scaricare i certificati relativi all' AWS IoT oggetto.
```
mkdir greengrass-v2-certs
```
1. Crea e scarica i certificati relativi all' AWS IoT oggetto.
```
aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
```
La risposta è simile all'esempio seguente, se la richiesta ha esito positivo.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\
MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
FQIDAQAB\
-----END PUBLIC KEY-----\
",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
key omitted for security reasons\
-----END RSA PRIVATE KEY-----\
"
}
}
```
Salva l'Amazon Resource Name (ARN) del certificato da utilizzare per configurare il certificato in un secondo momento.
### Crea il certificato da una chiave privata in un HSM
**Nota**
[Questa funzionalità è disponibile per la versione 2.5.3 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md) AWS IoT Greengrass attualmente non supporta questa funzionalità sui dispositivi Windows core.
**Per creare il certificato Thing**
1. Sul dispositivo principale, inizializza un token PKCS \$111 nell'HSM e genera una chiave privata. La chiave privata deve essere una chiave RSA con una dimensione di chiave RSA-2048 (o superiore) o una chiave ECC.
**Nota**
Per utilizzare un modulo di sicurezza hardware con chiavi ECC, è necessario utilizzare [Greengrass nucleus](greengrass-nucleus-component.md) v2.5.6 o versione successiva.
Per utilizzare un modulo di sicurezza hardware e un [gestore segreto](secret-manager-component.md), è necessario utilizzare un modulo di sicurezza hardware con chiavi RSA.
Consulta la documentazione del tuo HSM per scoprire come inizializzare il token e generare la chiave privata. Se il tuo HSM supporta gli oggetti IDs, specifica un ID dell'oggetto quando generi la chiave privata. Salva l'ID dello slot, il PIN utente, l'etichetta dell'oggetto, l'ID dell'oggetto (se il tuo HSM ne utilizza uno) che specifichi quando inizializzi il token e generi la chiave privata. Questi valori vengono utilizzati successivamente quando si importa il certificato dell'oggetto nell'HSM e si configura il AWS IoT Greengrass software Core.
1. Crea una richiesta di firma del certificato (CSR) dalla chiave privata. AWS IoT utilizza questa CSR per creare un thing certificate per la chiave privata generata nell'HSM. Per informazioni su come creare una CSR dalla chiave privata, consulta la documentazione del tuo HSM. La CSR è un file, ad esempio. `iotdevicekey.csr`
1. Copia la CSR dal dispositivo al tuo computer di sviluppo. Se SSH e SCP sono abilitati sul computer di sviluppo e sul dispositivo, puoi usare il `scp` comando sul tuo computer di sviluppo per trasferire la CSR. Sostituiscilo *device-ip-address* con l'indirizzo IP del dispositivo e sostituiscilo *\$1/iotdevicekey.csr* con il percorso del file CSR sul dispositivo.
```
scp device-ip-address:~/iotdevicekey.csr iotdevicekey.csr
```
1. Sul tuo computer di sviluppo, crea una cartella in cui scaricare il certificato relativo all' AWS IoT oggetto.
```
mkdir greengrass-v2-certs
```
1. Usa il file CSR per creare e scaricare il certificato relativo all' AWS IoT oggetto sul tuo computer di sviluppo.
```
aws iot create-certificate-from-csr --set-as-active --certificate-signing-request=file://iotdevicekey.csr --certificate-pem-outfile greengrass-v2-certs/device.pem.crt
```
La risposta è simile all'esempio seguente, se la richiesta ha esito positivo.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----"
}
```
Salva l'ARN del certificato da utilizzare per configurare il certificato in un secondo momento.
## Configura il certificato del oggetto
Allega il thing certificate all' AWS IoT oggetto che hai creato in precedenza e aggiungi una AWS IoT policy al certificato per definire le AWS IoT autorizzazioni per il dispositivo principale.
**Per configurare il certificato dell'oggetto**
1. Allega il certificato all' AWS IoT oggetto.
+ Sostituiscilo *MyGreengrassCore* con il nome del tuo AWS IoT oggetto.
+ Sostituisci il certificato Amazon Resource Name (ARN) con l'ARN del certificato che hai creato nel passaggio precedente.
```
aws iot attach-thing-principal --thing-name MyGreengrassCore --principal arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
Il comando non produce alcun output se la richiesta ha esito positivo.
1. Crea e allega una AWS IoT policy che definisca le AWS IoT autorizzazioni per il tuo dispositivo principale Greengrass. La seguente politica consente l'accesso a tutti gli argomenti MQTT e alle operazioni di Greengrass, in modo che il dispositivo funzioni con applicazioni personalizzate e modifiche future che richiedono nuove operazioni Greengrass. È possibile limitare questa politica in base al proprio 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).
Se hai già configurato un dispositivo Greengrass core, puoi allegare la AWS IoT relativa policy invece di crearne una nuova.
Esegui questa operazione:
1. Crea un file che contenga il documento di AWS IoT policy richiesto dai dispositivi core Greengrass.
Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.
```
nano greengrass-v2-iot-policy.json
```
Copiate il seguente codice JSON nel file.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
}
]
}
```
1. Crea una AWS IoT politica dal documento di policy.
+ Sostituisci *GreengrassV2IoTThingPolicy* con il nome della politica da creare.
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
La risposta è simile all'esempio seguente, se la richiesta ha esito positivo.
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\\"Version\\": \\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": [
\\"iot:Publish\\",
\\"iot:Subscribe\\",
\\"iot:Receive\\",
\\"iot:Connect\\",
\\"greengrass:*\\"
],
\\"Resource\\": [
\\"*\\"
]
}
]
}",
"policyVersionId": "1"
}
```
1. Allega la AWS IoT policy al certificato dell' AWS IoT oggetto.
+ Sostituisci *GreengrassV2IoTThingPolicy* con il nome della politica da allegare.
+ Sostituisci l'ARN di destinazione con l'ARN del certificato per il tuo oggetto. AWS IoT
```
aws iot attach-policy --policy-name GreengrassV2IoTThingPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
Il comando non ha alcun output se la richiesta ha esito positivo.
## Crea un ruolo di scambio di token
I dispositivi core Greengrass utilizzano un ruolo di servizio IAM, chiamato *token exchange role*, per autorizzare le chiamate ai servizi. AWS Il dispositivo utilizza il provider di AWS IoT credenziali per ottenere AWS credenziali temporanee per questo ruolo, che consente al dispositivo di interagire AWS IoT, inviare log ad Amazon CloudWatch Logs e scaricare elementi dei componenti personalizzati da Amazon S3. Per ulteriori informazioni, consulta [Autorizza i dispositivi principali a interagire con i servizi AWS](device-service-role.md).
Si utilizza un *alias di AWS IoT ruolo* per configurare il ruolo di scambio di token per i dispositivi principali Greengrass. Gli alias di ruolo consentono di modificare il ruolo di scambio di token per un dispositivo ma mantengono invariata la configurazione del dispositivo. Per ulteriori informazioni, consulta [Autorizzazione delle chiamate dirette ai AWS servizi nella Guida per](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html) gli *AWS IoT Core sviluppatori*.
In questa sezione, crei un ruolo IAM per lo scambio di token e un alias di AWS IoT ruolo che rimanda al ruolo. Se hai già configurato un dispositivo principale Greengrass, puoi utilizzare il ruolo di scambio di token e l'alias del ruolo invece di crearne di nuovi. Quindi, configuri il dispositivo in modo che utilizzi quel ruolo e quell'alias. AWS IoT
**Per creare un ruolo IAM per lo scambio di token**
1. Crea un ruolo IAM che il tuo dispositivo possa utilizzare come ruolo di scambio di token. Esegui questa operazione:
1. Crea un file che contenga il documento sulla politica di fiducia richiesto dal ruolo di scambio di token.
Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.
```
nano device-role-trust-policy.json
```
Copiate il seguente codice JSON nel file.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Crea il ruolo di scambio di token con il documento sulla politica di fiducia.
+ Sostituiscilo *GreengrassV2TokenExchangeRole* con il nome del ruolo IAM da creare.
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
La risposta è simile all'esempio seguente, se la richiesta ha esito positivo.
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. Crea un file che contenga il documento sulla politica di accesso richiesto dal ruolo di scambio di token.
Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.
```
nano device-role-access-policy.json
```
Copiate il seguente codice JSON nel file.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**Nota**
Questa politica di accesso non consente l'accesso agli artefatti dei componenti nei bucket S3. Per distribuire componenti personalizzati che definiscono gli artefatti in Amazon S3, devi aggiungere autorizzazioni al ruolo per consentire al dispositivo principale di recuperare gli artefatti dei componenti. Per ulteriori informazioni, consulta [Consenti l'accesso ai bucket S3 per gli artefatti dei componenti](device-service-role.md#device-service-role-access-s3-bucket).
Se non disponi ancora di un bucket S3 per gli artefatti dei componenti, puoi aggiungere queste autorizzazioni in un secondo momento dopo aver creato un bucket.
1. Crea la policy IAM dal documento di policy.
+ Sostituiscila *GreengrassV2TokenExchangeRoleAccess* con il nome della policy IAM da creare.
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
La risposta è simile all'esempio seguente, se la richiesta ha esito positivo.
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. Allega la policy IAM al ruolo di scambio di token.
+ Sostituisci *GreengrassV2TokenExchangeRole* con il nome del ruolo IAM.
+ Sostituisci l'ARN della policy con l'ARN della policy IAM che hai creato nel passaggio precedente.
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
Il comando non ha alcun output se la richiesta ha esito positivo.
1. Crea un alias di AWS IoT ruolo che punti al ruolo di scambio di token.
+ Sostituiscilo *GreengrassCoreTokenExchangeRoleAlias* con il nome dell'alias del ruolo da creare.
+ Sostituisci il ruolo ARN con l'ARN del ruolo IAM creato nel passaggio precedente.
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
La risposta è simile all'esempio seguente, se la richiesta ha esito positivo.
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**Nota**
Per creare un alias di ruolo, devi disporre dell'autorizzazione a passare il ruolo IAM per lo scambio di token a. AWS IoT Se ricevi un messaggio di errore quando tenti di creare un alias di ruolo, verifica che AWS l'utente disponga di questa autorizzazione. *Per ulteriori informazioni, consulta [Concessione a un utente delle autorizzazioni per il trasferimento di un ruolo a un AWS servizio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html) nella Guida per l'AWS Identity and Access Management utente.*
1. Crea e allega una AWS IoT policy che consenta al tuo dispositivo principale Greengrass di utilizzare l'alias del ruolo per assumere il ruolo di scambio di token. Se hai già configurato un dispositivo principale Greengrass, puoi allegare la sua AWS IoT politica di alias di ruolo invece di crearne uno nuovo. Esegui questa operazione:
1. (Facoltativo) Create un file che contenga il documento di AWS IoT policy richiesto dall'alias di ruolo.
Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.
```
nano greengrass-v2-iot-role-alias-policy.json
```
Copiate il seguente codice JSON nel file.
+ Sostituisci l'ARN della risorsa con l'ARN del tuo alias di ruolo.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. Crea una AWS IoT politica dal documento di policy.
+ Sostituisci *GreengrassCoreTokenExchangeRoleAliasPolicy* con il nome della AWS IoT politica da creare.
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
La risposta è simile all'esempio seguente, se la richiesta ha esito positivo.
```
{
"policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyDocument": "{
\\"Version\\":\\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
\\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
}
]
}",
"policyVersionId": "1"
}
```
1. Allega la AWS IoT policy al certificato dell' AWS IoT oggetto.
+ Sostituisci *GreengrassCoreTokenExchangeRoleAliasPolicy* con il nome della AWS IoT politica relativa agli alias del ruolo.
+ Sostituisci l'ARN di destinazione con l'ARN del certificato per il tuo oggetto. AWS IoT
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
Il comando non ha alcun output se la richiesta ha esito positivo.
## Scarica i certificati sul dispositivo
In precedenza, avevi scaricato il certificato del dispositivo sul computer di sviluppo. In questa sezione, si copia il certificato sul dispositivo principale per configurare il dispositivo con i certificati a cui viene utilizzato per la connessione AWS IoT. Puoi anche scaricare il certificato Amazon Root Certificate Authority (CA). Se utilizzi un HSM, in questa sezione importi anche il file del certificato nell'HSM.
+ Se in precedenza hai creato il certificato e la chiave privata nel AWS IoT servizio, segui i passaggi per scaricare i certificati con chiave privata e file di certificato.
+ Se in precedenza hai creato il certificato dell'oggetto da una chiave privata in un modulo di sicurezza hardware (HSM), segui i passaggi per scaricare i certificati con la chiave privata e il certificato in un HSM.
### Scarica i certificati con chiave privata e file di certificato
**Per scaricare i certificati sul dispositivo**
1. Copia il certificato AWS IoT Thing dal tuo computer di sviluppo al dispositivo. Se SSH e SCP sono abilitati sul computer di sviluppo e sul dispositivo, puoi usare il `scp` comando sul tuo computer di sviluppo per trasferire il certificato. *device-ip-address*Sostituiscilo con l'indirizzo IP del tuo dispositivo.
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. Crea la cartella principale Greengrass sul dispositivo. Successivamente installerai il software AWS IoT Greengrass Core in questa cartella.
**Nota**
In Windows esiste un limite di lunghezza del percorso di 260 caratteri. Se usi Windows, usa una cartella principale come `C:\greengrass\v2` o `D:\greengrass\v2` per mantenere i percorsi dei componenti Greengrass al di sotto del limite di 260 caratteri.
------
#### [ Linux or Unix ]
+ `/greengrass/v2`Sostituiscilo con la cartella da usare.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ Sostituisci *C:\$1greengrass\$1v2* con la cartella da usare.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ Sostituisci *C:\$1greengrass\$1v2* con la cartella da usare.
```
mkdir C:\greengrass\v2
```
------
1. (Solo Linux) Imposta le autorizzazioni del genitore della cartella principale di Greengrass.
+ Sostituiscilo */greengrass* con quello principale della cartella principale.
```
sudo chmod 755 /greengrass
```
1. Copia i AWS IoT Thing Certificates nella cartella principale di Greengrass.
------
#### [ Linux or Unix ]
+ Sostituisci `/greengrass/v2` con la cartella principale di Greengrass.
```
sudo cp -R ~/greengrass-v2-certs/* /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ Sostituisci *C:\$1greengrass\$1v2* con la cartella da usare.
```
robocopy %USERPROFILE%\greengrass-v2-certs C:\greengrass\v2 /E
```
------
#### [ PowerShell ]
+ Sostituisci *C:\$1greengrass\$1v2* con la cartella da usare.
```
cp -Path ~\greengrass-v2-certs\* -Destination C:\greengrass\v2
```
------
1. Scarica il certificato Amazon Root Certificate Authority (CA). AWS IoT per impostazione predefinita, i certificati sono associati al certificato CA root di Amazon.
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
### Scarica i certificati con la chiave privata e il certificato in un HSM
**Nota**
[Questa funzionalità è disponibile per la versione 2.5.3 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md) AWS IoT Greengrass attualmente non supporta questa funzionalità sui dispositivi Windows core.
**Per scaricare i certificati sul dispositivo**
1. Copia il certificato AWS IoT Thing dal tuo computer di sviluppo al dispositivo. Se SSH e SCP sono abilitati sul computer di sviluppo e sul dispositivo, puoi usare il `scp` comando sul tuo computer di sviluppo per trasferire il certificato. *device-ip-address*Sostituiscilo con l'indirizzo IP del tuo dispositivo.
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. Crea la cartella principale Greengrass sul dispositivo. Successivamente installerai il software AWS IoT Greengrass Core in questa cartella.
**Nota**
In Windows esiste un limite di lunghezza del percorso di 260 caratteri. Se usi Windows, usa una cartella principale come `C:\greengrass\v2` o `D:\greengrass\v2` per mantenere i percorsi dei componenti Greengrass al di sotto del limite di 260 caratteri.
------
#### [ Linux or Unix ]
+ `/greengrass/v2`Sostituiscilo con la cartella da usare.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ Sostituisci *C:\$1greengrass\$1v2* con la cartella da usare.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ Sostituisci *C:\$1greengrass\$1v2* con la cartella da usare.
```
mkdir C:\greengrass\v2
```
------
1. (Solo Linux) Imposta le autorizzazioni del genitore della cartella principale di Greengrass.
+ Sostituiscilo */greengrass* con quello principale della cartella principale.
```
sudo chmod 755 /greengrass
```
1. Importa il file del certificato dell'oggetto`~/greengrass-v2-certs/device.pem.crt`, nell'HSM. Consulta la documentazione del tuo HSM per scoprire come importare i certificati al suo interno. Importa il certificato utilizzando lo stesso token, ID slot, PIN utente, etichetta dell'oggetto e ID oggetto (se il tuo HSM ne utilizza uno) con cui hai generato la chiave privata nell'HSM in precedenza.
**Nota**
Se hai generato la chiave privata in precedenza senza un ID di oggetto e il certificato ha un ID oggetto, imposta l'ID dell'oggetto della chiave privata sullo stesso valore del certificato. Consultate la documentazione del vostro HSM per scoprire come impostare l'ID dell'oggetto per l'oggetto chiave privata.
1. (Facoltativo) Eliminare il file del certificato dell'oggetto, in modo che esista solo nell'HSM.
```
rm ~/greengrass-v2-certs/device.pem.crt
```
1. Scarica il certificato Amazon Root Certificate Authority (CA). AWS IoT per impostazione predefinita, i certificati sono associati al certificato CA root di Amazon.
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## Configura l'ambiente del dispositivo
Segui i passaggi di questa sezione per configurare un dispositivo Linux o Windows da utilizzare come dispositivo AWS IoT Greengrass principale.
### Configura un dispositivo Linux
**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
**Nota**
Questa funzionalità è disponibile per la versione 2.5.0 e successive del componente [Greengrass](greengrass-nucleus-component.md) nucleus.
**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 **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
## Scaricate il software Core AWS IoT Greengrass
È possibile scaricare la versione più recente del software AWS IoT Greengrass Core dal seguente indirizzo:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**Nota**
È possibile scaricare una versione specifica del software AWS IoT Greengrass Core dal seguente percorso. Sostituiscila *version* con la versione da scaricare.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Per scaricare il software AWS IoT Greengrass Core**
1. Sul dispositivo principale, scaricate 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. (Facoltativo) Per verificare la firma del software Greengrass nucleus
**Nota**
Questa funzionalità è disponibile con Greengrass nucleus versione 2.9.5 e successive.
1. Usa il seguente comando per verificare la firma del tuo artefatto Greengrass nucleus:
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
Il nome del file potrebbe avere un aspetto diverso a seconda della versione di JDK installata. *`jdk17.0.6_10`*Sostituiscilo con la versione JDK che hai installato.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
Il nome del file potrebbe avere un aspetto diverso a seconda della versione di JDK installata. *`jdk17.0.6_10`*Sostituiscilo con la versione JDK che hai installato.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. L'`jarsigner`invocazione produce un output che indica i risultati della verifica.
1. Se il file zip Greengrass nucleus è firmato, l'output contiene la seguente dichiarazione:
```
jar verified.
```
1. Se il file zip Greengrass nucleus non è firmato, l'output contiene la seguente dichiarazione:
```
jar is unsigned.
```
1. Se hai fornito l'`-certs`opzione Jarsigner insieme alle `-verbose` opzioni `-verify` e, l'output include anche informazioni dettagliate sul certificato del firmatario.
1. Decomprimi il software AWS IoT Greengrass Core in una cartella sul tuo 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. (Facoltativo) Eseguite il comando seguente per visualizzare la versione del software AWS IoT Greengrass Core.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**Importante**
Se installi una versione del nucleo Greengrass precedente alla v2.4.0, non rimuovere questa cartella dopo aver installato il software Core. AWS IoT Greengrass Il software AWS IoT Greengrass Core utilizza i file in questa cartella per l'esecuzione.
Se hai scaricato la versione più recente del software, installi la versione 2.4.0 o successiva e puoi rimuovere questa cartella dopo aver installato il software AWS IoT Greengrass Core.
## Installa il software Core AWS IoT Greengrass
Esegui il programma di installazione con argomenti che specificano le seguenti azioni:
+ Esegui l'installazione da un file di configurazione parziale che specifica di utilizzare le AWS risorse e i certificati creati in precedenza. Il software AWS IoT Greengrass Core utilizza un file di configurazione che specifica la configurazione di ogni componente Greengrass sul dispositivo. Il programma di installazione crea un file di configurazione completo a partire dal file di configurazione parziale fornito dall'utente.
+ Specificate di utilizzare l'utente `ggc_user` del sistema per eseguire i 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.
+ 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.
Per ulteriori informazioni sugli argomenti che è possibile specificare, vedere[Argomenti dell'installatore](configure-installer.md).
**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).
+ Se in precedenza hai creato il certificato e la chiave privata nel AWS IoT servizio, segui i passaggi per installare il software AWS IoT Greengrass Core con la chiave privata e i file di certificato.
+ Se in precedenza hai creato il certificato dell'oggetto da una chiave privata in un modulo di sicurezza hardware (HSM), segui i passaggi per installare il software AWS IoT Greengrass Core con la chiave privata e il certificato in un HSM.
### Installa il software AWS IoT Greengrass Core con chiave privata e file di certificato
**Per installare il software AWS IoT Greengrass Core**
1. Controlla la versione del software AWS IoT Greengrass Core.
+ Sostituisci *GreengrassInstaller* con il percorso della cartella che contiene il software.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Utilizzate un editor di testo per creare un file di configurazione denominato `config.yaml` da fornire all'installatore.
Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.
```
nano GreengrassInstaller/config.yaml
```
Copiate il seguente contenuto YAML nel file. Questo file di configurazione parziale specifica i parametri di sistema e i parametri del nucleo di Greengrass.
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.17.0"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
```
Successivamente, esegui queste operazioni:
+ Sostituisci ogni istanza di `/greengrass/v2` con la cartella principale di Greengrass.
+ Sostituisci *MyGreengrassCore* con il nome della AWS IoT cosa.
+ Sostituire *2.17.0* con la versione del software AWS IoT Greengrass Core.
+ Sostituisci *us-west-2* con la Regione AWS posizione in cui hai creato le risorse.
+ Sostituisci *GreengrassCoreTokenExchangeRoleAlias* con il nome dell'alias del ruolo di scambio di token.
+ Sostituiscilo `iotDataEndpoint` con il tuo endpoint di AWS IoT dati.
+ Sostituisci l'`iotCredEndpoint`endpoint con AWS IoT le tue credenziali.
**Nota**
In questo file di configurazione, è possibile personalizzare altre opzioni di configurazione del nucleo, come le porte e il proxy di rete da utilizzare, come mostrato nell'esempio seguente. Per ulteriori informazioni, vedere [Greengrass nucleus](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration) configuration.
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.17.0"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
```
1. Eseguite il programma di installazione e specificate di `--init-config` fornire il file di configurazione.
+ Sostituisci `/greengrass/v2` o *C:\$1greengrass\$1v2* con la cartella principale di Greengrass.
+ Sostituisci ogni istanza di *GreengrassInstaller* con la cartella in cui hai decompresso il programma di installazione.
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**Importante**
Nei dispositivi Windows Core, è necessario specificare `--setup-system-service true` di configurare il software AWS IoT Greengrass Core come servizio di sistema.
Se si specifica`--setup-system-service true`, il programma di installazione stampa `Successfully set up Nucleus as a system service` se ha configurato ed eseguito il software come servizio di sistema. Altrimenti, il programma di installazione non emette alcun messaggio se installa il software correttamente.
**Nota**
Non è possibile utilizzare l'`deploy-dev-tools`argomento per distribuire strumenti di sviluppo locali quando si esegue il programma di installazione senza l'argomento. `--provision true` Per informazioni sulla distribuzione della CLI Greengrass direttamente sul dispositivo, consulta. [Interfaccia a riga di comando Greengrass](gg-cli.md)
1. Verifica l'installazione visualizzando i file nella cartella principale.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Se l'installazione è riuscita, la cartella principale contiene diverse cartelle, ad esempio `config``packages`, e`logs`.
### Installa il software AWS IoT Greengrass Core con la chiave privata e il certificato in un HSM
**Nota**
[Questa funzionalità è disponibile per la versione 2.5.3 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md) AWS IoT Greengrass attualmente non supporta questa funzionalità sui dispositivi Windows core.
**Per installare il software AWS IoT Greengrass Core**
1. Controlla la versione del software AWS IoT Greengrass Core.
+ Sostituisci *GreengrassInstaller* con il percorso della cartella che contiene il software.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Per consentire al software AWS IoT Greengrass Core di utilizzare la chiave privata e il certificato nell'HSM, installate il [componente del provider PKCS \$111](pkcs11-provider-component.md) quando installate il software AWS IoT Greengrass Core. Il componente del provider PKCS \$111 è un plug-in che è possibile configurare durante l'installazione. È possibile scaricare la versione più recente del componente del provider PKCS \$111 dalla seguente posizione:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/Pkcs11Provider/aws.greengrass.crypto.pkcs11Provider-latest.jar](https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar)
Scarica il plugin del provider PKCS \$111 in un file denominato. `aws.greengrass.crypto.Pkcs11Provider.jar` Sostituiscilo *GreengrassInstaller* con la cartella che desideri utilizzare.
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar > GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar
```
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. Utilizzate un editor di testo per creare un file di configurazione denominato `config.yaml` da fornire all'installatore.
Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.
```
nano GreengrassInstaller/config.yaml
```
Copiate il seguente contenuto YAML nel file. Questo file di configurazione parziale specifica i parametri di sistema, i parametri Greengrass nucleus e i parametri del provider PKCS \$111.
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.17.0"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
Successivamente, esegui queste operazioni:
+ Sostituisci ogni istanza di *iotdevicekey* PKCS \$111 URIs con l'etichetta dell'oggetto in cui hai creato la chiave privata e importato il certificato.
+ Sostituisci ogni istanza di `/greengrass/v2` con la cartella principale di Greengrass.
+ Sostituisci *MyGreengrassCore* con il nome della AWS IoT cosa.
+ Sostituire *2.17.0* con la versione del software AWS IoT Greengrass Core.
+ Sostituisci *us-west-2* con la Regione AWS posizione in cui hai creato le risorse.
+ Sostituisci *GreengrassCoreTokenExchangeRoleAlias* con il nome dell'alias del ruolo di scambio di token.
+ Sostituiscilo `iotDataEndpoint` con il tuo endpoint di AWS IoT dati.
+ Sostituisci l'`iotCredEndpoint`endpoint con AWS IoT le tue credenziali.
+ Sostituisci i parametri di configurazione per il `aws.greengrass.crypto.Pkcs11Provider` componente con i valori per la configurazione HSM sul dispositivo principale.
**Nota**
In questo file di configurazione, è possibile personalizzare altre opzioni di configurazione del nucleo, come le porte e il proxy di rete da utilizzare, come mostrato nell'esempio seguente. Per ulteriori informazioni, vedere [Greengrass nucleus](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration) configuration.
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.17.0"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
1. Eseguite il programma di installazione e specificate di `--init-config` fornire il file di configurazione.
+ Sostituisci `/greengrass/v2` con la cartella principale di Greengrass.
+ Sostituisci ogni istanza di *GreengrassInstaller* con la cartella in cui hai decompresso il programma di installazione.
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
**Importante**
Nei dispositivi Windows Core, è necessario specificare `--setup-system-service true` di configurare il software AWS IoT Greengrass Core come servizio di sistema.
Se si specifica`--setup-system-service true`, il programma di installazione stampa `Successfully set up Nucleus as a system service` se ha configurato ed eseguito il software come servizio di sistema. Altrimenti, il programma di installazione non emette alcun messaggio se installa il software correttamente.
**Nota**
Non è possibile utilizzare l'`deploy-dev-tools`argomento per distribuire strumenti di sviluppo locali quando si esegue il programma di installazione senza l'argomento. `--provision true` Per informazioni sulla distribuzione della CLI Greengrass direttamente sul dispositivo, consulta. [Interfaccia a riga di comando Greengrass](gg-cli.md)
1. Verifica l'installazione visualizzando i file nella cartella principale.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Se l'installazione è riuscita, la cartella principale contiene diverse cartelle, ad esempio `config``packages`, e`logs`.
Se avete installato il software AWS IoT Greengrass Core come servizio di sistema, il programma di installazione esegue il software automaticamente. In caso contrario, è necessario eseguire il software manualmente. Per ulteriori informazioni, consulta [Esegui il software AWS IoT Greengrass Core](run-greengrass-core-v2.md).
**Nota**
Quando il software AWS IoT Greengrass Core si connette al cloud, il dispositivo verrà riconosciuto come dispositivo Core.
Per ulteriori informazioni su come configurare e utilizzare il software e AWS IoT Greengrass, consulta quanto segue:
+ [Configurare il software AWS IoT Greengrass Core](configure-greengrass-core-v2.md)
+ [Sviluppa AWS IoT Greengrass componenti](develop-greengrass-components.md)
+ [Implementazione AWS IoT Greengrass dei componenti sui dispositivi](manage-deployments.md)
+ [Interfaccia a riga di comando Greengrass](gg-cli.md)