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à.
# Endpoint FIPS
AWS IoT Greengrass supporta l'uso di endpoint FIPS ([Federal Information Processing Standard (FIPS) ](https://aws.amazon.com/compliance/fips/) 140-2). Quando la modalità FIPS è abilitata, tutte le trasmissioni di dati, inclusi i protocolli HTTP e MQTT, ai Cloud AWS servizi devono richiamare e stabilire connessioni con gli FIPS-compliant endpoint corrispondenti (FIPS - Amazon Web Services ()). [AWS](https://aws.amazon.com/compliance/fips/)
Comunicazioni MQTT per AWS IoT utilizzare l'endpoint FIPS del dataplane IoT (Connecting to FIPS endpoints -) e la libreria crittografica sviluppata da aws-lc. [AWS IoTAWS IoT Core](https://docs.aws.amazon.com/iot/latest/developerguide/iot-connect-fips.html#iot-connect-fips-data) AWS FIPS-compliant
Per le comunicazioni HTTP in Greengrass:
+ Per i componenti nucleus e plugin, tutti i client HTTP SDK sono configurati con endpoint FIPS impostando la proprietà di sistema su true; AWS\_USE\_FIPS\_ENDPOINT
+ Per i componenti generici, tutti i componenti iniziano con la proprietà AWS\_USE\_FIPS\_ENDPOINT di sistema impostata su true. Questo processo garantisce che i client HTTP SDK utilizzati da questi componenti generici inviino richieste agli FIPS-compliant endpoint.
**Nota**
Nel caso di Stream manager, Nucleus passa la variabile di ambiente. AWS\_GG\_FIPS\_MODE Questa variabile di ambiente consente ai client HTTP utilizzati all'interno di Stream Manager di identificare e connettersi all'endpoint corrispondente FIPS-compliant.
AWS IoT Greengrass offre due metodi per abilitare la modalità FIPS: provisioning e distribuzione. Per attivare la modalità FIPS, è necessario impostare il parametro `fipsMode` di configurazione su true, Nucleus imposta quindi la proprietà di sistema su true e la AWS\_USE\_FIPS\_ENDPOINT propaga come variabile di ambiente a tutti gli altri componenti. Inoltre, AWS IoT Greengrass scaricherà un certificato CA root (CA3) e lo aggiungerà al file root CA.pem (o) esistente. AmazonRootCA1.pem Se abiliti FIPS tramite una nuova distribuzione, Nucleus si riavvierà per garantire che la proprietà di sistema abbia effetto dopo aver abilitato la modalità FIPS.
Oltre a configurare il `fipsMode` parametro, è necessario configurare anche i parametri e. `iotDataEndpoint` `iotCredEndpoint` `greengrassDataEndpoint` Per ulteriori informazioni, consulta il documento pertinente riportato di seguito.
## Abilita gli endpoint FIPS con l'implementazione
Ottieni gli AWS IoT endpoint per te e salvali per utilizzarli in seguito. Account AWS Il tuo dispositivo utilizza questi endpoint per connettersi a. AWS IoT Sono necessari due endpoint, il `iotDataEndpoint` e il. `iotCredEndpoint` Esegui questa operazione:
1. Ottieni l'endpoint di dati FIPS per la tua regione negli endpoint del piano dati [AWS IoT Core FIPS. ](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#iot-core-data-plane-endpoints) L'endpoint di dati FIPS per il tuo Account AWS dovrebbe assomigliare a questo: {{data.iot-fips.us-west-2.amazonaws.com}}
1. Ottieni l'endpoint delle credenziali FIPS per la tua regione negli endpoint del [AWS IoT Core piano dati FIPS. ](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#iot-core-data-plane-endpoints) L'endpoint delle credenziali FIPS per te Account AWS dovrebbe assomigliare a questo: {{data.credentials.iot-fips.us-west-2.amazonaws.com}}
Quindi, per abilitare FIPS con una distribuzione, è necessario applicare la seguente configurazione a Nucleus. La configurazione da unire nella distribuzione è la seguente.
------
#### [ Console ]
**Configurazione da unire **
```
{
"fipsMode": "true",
"iotDataEndpoint": "data.iot-fips.us-west-2.amazonaws.com",
"greengrassDataPlaneEndpoint": "iotData",
"iotCredEndpoint": "data.credentials.iot-fips.us-west-2.amazonaws.com"
}
```
------
#### [ AWS CLI ]
Il comando seguente crea una distribuzione su un dispositivo principale.
```
aws greengrassv2 create-deployment --cli-input-json file://dashboard-deployment.json
```
Il `dashboard-deployment.json` file contiene il seguente documento JSON.
```
{
"targetArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"deploymentName": "Deployment for MyGreengrassCore",
"components": {
"aws.greengrass.Nucleus": {
"componentVersion": "2.13.0",
"configurationUpdate": {
"merge":{\"fipsMode\":\"true\",\"iotDataEndpoint\":\"data.iot-fips.us-west-2.amazonaws.com\",\"greengrassDataPlaneEndpoint\":\"iotData\",\"iotCredEndpoint\":\"data.credentials.iot-fips.us-west-2.amazonaws.com\"}"
}
}
}
}
```
------
#### [ Greengrass CLI ]
Il seguente [ comando CLI di ](greengrass-cli-component.md) Greengrass crea una distribuzione locale su un dispositivo principale.
```
sudo greengrass-cli deployment create \
--recipeDir recipes \
--artifactDir artifacts \
--merge "aws.greengrass.Nucleus=2.13.0" \
--update-config dashboard-configuration.json
```
Il `dashboard-configuration.json` file contiene il seguente documento JSON.
```
{
"aws.greengrass.Nucleus": {
"MERGE": {
"fipsMode": "true",
"iotDataEndpoint": "data.iot-fips.us-west-2.amazonaws.com",
"greengrassDataPlaneEndpoint": "iotData",
"iotCredEndpoint": "data.credentials.iot-fips.us-west-2.amazonaws.com"
}
}
}
```
------
## Installa Nucleus con endpoint FIPS con provisioning manuale delle risorse
Esegui il provisioning manuale AWS delle risorse per i dispositivi AWS IoT Greengrass V2 principali con endpoint FIPS
**Importante**
Prima di scaricare il software AWS IoT Greengrass Core, verifica che il tuo 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**
+ [Retrieve AWS IoT endpoint](#w2ab1c58c44c23b9)
+ [Crea un AWS IoT thing](#create-iot-thing)
+ [Crea il certificato dell'oggetto](#create-thing-certificate-fips)
+ [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)
+ [Scarica il AWS IoT Greengrass Software di base](#download-greengrass-core-v2)
+ [Installa il AWS IoT Greengrass Software di base](#run-greengrass-core-v2-installer-manual-fips)
### Retrieve AWS IoT endpoint
Ottieni gli AWS IoT endpoint per te e salvali per utilizzarli in seguito. Account AWS Il tuo dispositivo utilizza questi endpoint per connettersi a. AWS IoT Sono necessari due endpoint, il `iotDataEndpoint` e il. `iotCredEndpoint` Esegui questa operazione:
1. Ottieni l'endpoint di dati FIPS per la tua regione negli endpoint del piano dati [AWS IoT Core FIPS. ](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#iot-core-data-plane-endpoints) L'endpoint di dati FIPS per il tuo Account AWS dovrebbe assomigliare a questo: {{data.iot-fips.us-west-2.amazonaws.com}}
1. Ottieni l'endpoint delle credenziali FIPS per la tua regione negli endpoint del [AWS IoT Core piano dati FIPS. ](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#iot-core-data-plane-endpoints) L'endpoint delle credenziali FIPS per te Account AWS dovrebbe assomigliare a questo: {{data.credentials.iot-fips.us-west-2.amazonaws.com}}
### Crea un AWS IoT thing
AWS IoT *le cose * rappresentano dispositivi ed entità logiche a cui si connettono AWS IoT. I dispositivi principali di Greengrass sono AWS IoT oggetti. Quando registri un dispositivo come AWS IoT oggetto, quel dispositivo può utilizzare un certificato digitale per autenticarsi. AWS
In questa sezione, crei un AWS IoT oggetto che rappresenta il tuo dispositivo.
**Per creare un AWS IoT thing**
1. Crea un AWS IoT oggetto per il tuo dispositivo. Sul tuo computer di sviluppo, esegui il comando seguente.
+ 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) Aggiungete l' AWS IoT oggetto a un gruppo di oggetti nuovo o esistente. I gruppi di oggetti vengono utilizzati per gestire flotte di dispositivi principali di 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 oggetti con una distribuzione Greengrass attiva per distribuire i componenti software di quel gruppo di oggetti sul dispositivo. Esegui questa operazione:
1. (Facoltativo) Crea un gruppo di oggetti AWS IoT .
+ Sostituisci {{MyGreengrassCoreGroup}} con il nome del gruppo di oggetti da creare.
**Nota**
Il nome del gruppo di oggetti 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. Aggiungete 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 per l'autenticazione. AWS Questo certificato consente al dispositivo di comunicare con AWS IoT e AWS IoT Greengrass.
In questa sezione, puoi creare e scaricare certificati a cui il tuo dispositivo può utilizzare per 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 hardware e sui requisiti per utilizzarla, vedere[Integrazione della sicurezza hardware](hardware-security.md).
#### Crea il certificato e la chiave privata nel AWS IoT service
**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 per l' 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. [Nucleo di Greengrass](greengrass-nucleus-component.md) AWS IoT Greengrass attualmente non supporta questa funzionalità sui dispositivi Windows core.
**Per creare il certificato dell'oggetto**
1. Sul dispositivo principale, inizializza un token PKCS \#11 nell'HSM e genera una chiave privata. La chiave privata deve essere una chiave RSA con una dimensione della RSA-2048 chiave (o maggiore) 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 successivo.
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 ID oggetto, specifica un ID oggetto quando generi la chiave privata. Salva l'ID dello slot, il PIN utente, l'etichetta dell'oggetto, l'ID dell'oggetto (se l'HSM ne utilizza uno) che specifichi quando inizializzi il token e generi la chiave privata. Questi valori verranno utilizzati in un secondo momento quando si importa il certificato 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 questo CSR per creare un certificato oggetto per la chiave privata generata nell'HSM. Per informazioni su come creare un CSR dalla chiave privata, consulta la documentazione del tuo HSM. Il CSR è un file, ad esempio. `iotdevicekey.csr`
1. Copia il CSR dal dispositivo al tuo computer di sviluppo. Se SSH e SCP sono abilitati sul computer di sviluppo e sul dispositivo, puoi utilizzare il `scp` comando sul tuo computer di sviluppo per trasferire il CSR. Sostituiscilo {{device-ip-address}} con l'indirizzo IP del tuo dispositivo e sostituiscilo {{\~/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 dell' 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.
Quindi, configura il certificato oggetto. Per ulteriori informazioni, consulta [Configura il certificato del oggetto](manual-installation.md#configure-thing-certificate).
### Crea un ruolo di scambio di token
I dispositivi principali di Greengrass utilizzano un ruolo di servizio IAM, chiamato ruolo di scambio di * token*, per autorizzare le chiamate ai AWS servizi. Il dispositivo utilizza il provider di AWS IoT credenziali per ottenere AWS credenziali temporanee per questo ruolo, che gli consentono di interagire AWS IoT, inviare log ad Amazon CloudWatch Logs e scaricare elementi di 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 di Greengrass. Gli alias di ruolo consentono di modificare il ruolo di scambio di token per un dispositivo mantenendo invariata la configurazione del dispositivo. Per ulteriori informazioni, consulta [ Autorizzazione delle chiamate dirette ai AWS servizi ](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html) nella Guida per 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 avete già configurato un dispositivo principale di Greengrass, potete utilizzarne il ruolo e l'alias di ruolo per lo scambio di token 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 Linux-based sistema, puoi eseguire il seguente comando per usare GNU nano per creare il file.
```
nano device-role-trust-policy.json
```
Copia il seguente 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 Linux-based sistema, puoi eseguire il seguente comando per usare GNU nano per creare il file.
```
nano device-role-access-policy.json
```
Copia il seguente 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 relativo alla 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. Associa 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 l'ARN del ruolo con l'ARN del ruolo IAM che hai 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, è necessario disporre dell'autorizzazione a passare il ruolo IAM di scambio di token. AWS IoT Se ricevi un messaggio di errore quando provi a creare un alias di ruolo, verifica che il tuo AWS utente disponga di questa autorizzazione. Per ulteriori informazioni, consulta [ Concessione a un utente delle autorizzazioni per passare 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. Create e allegate una AWS IoT policy che consenta al dispositivo principale di Greengrass di utilizzare l'alias di ruolo per assumere il ruolo di scambio di token. Se avete già configurato un dispositivo principale di Greengrass, potete allegare la AWS IoT relativa policy sugli alias di ruolo invece di crearne una nuova. Esegui questa operazione:
1. (Facoltativo) Create un file che contenga il documento AWS IoT di policy richiesto dall'alias di ruolo.
Ad esempio, su un Linux-based sistema, puoi eseguire il seguente comando per usare GNU nano per creare il file.
```
nano greengrass-v2-iot-role-alias-policy.json
```
Copia il seguente JSON nel file.
+ Sostituisci l'ARN della risorsa con l'ARN dell'alias del tuo 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 policy dal documento relativo alla policy.
+ Sostituiscila {{GreengrassCoreTokenExchangeRoleAliasPolicy}} con il nome della AWS IoT policy 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 policy sugli alias del ruolo.
+ Sostituisci l'ARN di destinazione con l'ARN del certificato del 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, hai scaricato il certificato del dispositivo sul tuo computer di sviluppo. In questa sezione, copi il certificato sul tuo dispositivo principale per configurare il dispositivo con i certificati a cui utilizza per connettersi 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 avete creato il certificato thing e la chiave privata nel AWS IoT servizio in precedenza, seguite i passaggi per scaricare i certificati con chiave privata e file di certificato.
+ Se in precedenza hai creato il certificato thing 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 i file di certificato
**Per scaricare i certificati sul dispositivo**
1. Copia il certificato dell' AWS IoT oggetto dal tuo computer di sviluppo al dispositivo. Se SSH e SCP sono abilitati sul computer di sviluppo e sul dispositivo, puoi utilizzare il `scp` comando sul tuo computer di sviluppo per trasferire il certificato. Sostituiscilo {{device-ip-address}} con l'indirizzo IP del tuo dispositivo.
```
scp -r greengrass-v2-certs/ {{device-ip-address}}:~
```
1. Create la cartella principale di 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 utilizzate Windows, utilizzate una cartella principale come `C:\greengrass\v2` o `D:\greengrass\v2` per mantenere i percorsi dei componenti di Greengrass al di sotto del limite di 260 caratteri.
------
#### [ Linux or Unix ]
+ Sostituisci `{{/greengrass/v2}}` con la cartella da usare.
```
sudo mkdir -p {{/greengrass/v2}}
```
------
#### [ Windows Command Prompt ]
+ Sostituisci {{C:\\greengrass\\v2}} con la cartella da usare.
```
mkdir {{C:\greengrass\v2}}
```
------
#### [ PowerShell ]
+ Sostituisci {{C:\\greengrass\\v2}} con la cartella da usare.
```
mkdir {{C:\greengrass\v2}}
```
------
1. (Solo Linux) Imposta i permessi dell'elemento principale della cartella principale di Greengrass.
+ Sostituisci {{/greengrass}} con il file principale della cartella principale.
```
sudo chmod 755 {{/greengrass}}
```
1. Copia i AWS IoT certificati degli oggetti nella cartella principale di Greengrass.
------
#### [ Linux or Unix ]
+ `{{/greengrass/v2}}`Sostituiscili con la cartella principale di Greengrass.
```
sudo cp -R ~/greengrass-v2-certs/* {{/greengrass/v2}}
```
------
#### [ Windows Command Prompt ]
+ Sostituisci {{C:\\greengrass\\v2}} con la cartella da usare.
```
robocopy %USERPROFILE%\greengrass-v2-certs {{C:\greengrass\v2}} /E
```
------
#### [ PowerShell ]
+ Sostituisci {{C:\\greengrass\\v2}} 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 principale di Amazon. Scarica il certificato CA1 e il certificato [ CA3. ](https://www.amazontrust.com/repository/)
------
#### [ Linux or Unix ]
+ Sostituisci `{{/greengrass/v2}}` o {{C:\\greengrass\\v2}} con la cartella principale di Greengrass.
```
sudo curl -o {{/greengrass/v2}}/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
sudo curl -o - https://www.amazontrust.com/repository/AmazonRootCA3.pem >> {{/greengrass/v2}}/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. [Nucleo di Greengrass](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 dell' AWS IoT oggetto dal tuo computer di sviluppo al dispositivo. Se SSH e SCP sono abilitati sul computer di sviluppo e sul dispositivo, puoi utilizzare il `scp` comando sul tuo computer di sviluppo per trasferire il certificato. Sostituiscilo {{device-ip-address}} con l'indirizzo IP del tuo dispositivo.
```
scp -r greengrass-v2-certs/ {{device-ip-address}}:~
```
1. Create la cartella principale di 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 utilizzate Windows, utilizzate una cartella principale come `C:\greengrass\v2` o `D:\greengrass\v2` per mantenere i percorsi dei componenti di Greengrass al di sotto del limite di 260 caratteri.
------
#### [ Linux or Unix ]
+ Sostituisci `{{/greengrass/v2}}` con la cartella da usare.
```
sudo mkdir -p {{/greengrass/v2}}
```
------
#### [ Windows Command Prompt ]
+ Sostituisci {{C:\\greengrass\\v2}} con la cartella da usare.
```
mkdir {{C:\greengrass\v2}}
```
------
#### [ PowerShell ]
+ Sostituisci {{C:\\greengrass\\v2}} con la cartella da usare.
```
mkdir {{C:\greengrass\v2}}
```
------
1. (Solo Linux) Imposta i permessi dell'elemento principale della cartella principale di Greengrass.
+ Sostituisci {{/greengrass}} con il file principale della cartella principale.
```
sudo chmod 755 {{/greengrass}}
```
1. Importa il file del certificato dell'oggetto nell'HSM. `~/greengrass-v2-certs/device.pem.crt` 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 oggetto e ID oggetto (se il tuo HSM ne utilizza uno) con cui hai generato la chiave privata nell'HSM in precedenza.
**Nota**
Se in precedenza hai generato la chiave privata senza un ID oggetto e il certificato ha un ID oggetto, imposta l'ID oggetto della chiave privata sullo stesso valore del certificato. Consulta la documentazione del tuo HSM per scoprire come impostare l'ID 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 principale di Amazon. Scarica sia il certificato CA1 che il certificato [ CA3. ](https://www.amazontrust.com/repository/)
------
#### [ Linux or Unix ]
+ Sostituisci `{{/greengrass/v2}}` o {{C:\\greengrass\\v2}} con la cartella principale di Greengrass.
```
sudo curl -o {{/greengrass/v2}}/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
sudo curl -o - https://www.amazontrust.com/repository/AmazonRootCA3.pem >> {{/greengrass/v2}}/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 descritti in 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 ](https://openjdk.java.net/) OpenJDK. È richiesta la versione 8 o successiva. I seguenti comandi mostrano come installare OpenJDK sul tuo dispositivo.
+ Per Debian-based le nostre distribuzioni: Ubuntu-based
```
sudo apt install default-jdk
```
+ Per le Hat-based distribuzioni Red:
```
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 Debian-based distribuzione, 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 esegue 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`) disponga dell'autorizzazione per l'esecuzione `sudo` con qualsiasi utente e gruppo.
1. Esegui il comando seguente per aprire il `/etc/sudoers` file.
```
sudo visudo
```
1. Verifica 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), devi abilitare [ cgroups ](https://en.wikipedia.org/wiki/Cgroups) v1 e devi abilitare e montare i cgroup di memoria e dispositivi. * * * * Se non prevedi di 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 dispositivo, consultate la documentazione del sistema operativo e del boot loader. Segui le istruzioni per impostare permanentemente 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 nucleus. ](greengrass-nucleus-component.md)
**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 ](https://openjdk.java.net/) OpenJDK. È richiesta la versione 8 o successiva.
1. Verifica se Java è disponibile nella variabile di [ sistema ](https://en.wikipedia.org/wiki/PATH_(variable)) PATH e aggiungila 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 del 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. Sostituisci {{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 una data futura. Per garantire che le 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](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), esegui il comando 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. Utilizza 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 Greengrass Nucleus ed è necessario utilizzare l' PsExec utilità per memorizzare le informazioni utente predefinite nell' LocalSystem account. L'utilizzo dell'applicazione Credential Manager memorizza queste informazioni nell'account Windows dell'utente attualmente connesso, anziché nell'account. LocalSystem
### Scarica il AWS IoT Greengrass Software di base
È possibile scaricare la versione più recente del software AWS IoT Greengrass Core dalla seguente posizione:
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)
**Nota**
È possibile scaricare una versione specifica del software AWS IoT Greengrass Core dalla seguente posizione. Sostituiscila {{version}} con la versione da scaricare.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-{{version}}.zip
```
**Per scaricare il AWS IoT Greengrass Software di base**
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. (Facoltativo) Per verificare la firma del software Greengrass Nucleus
**Nota**
Questa funzionalità è disponibile con Greengrass nucleus versione 2.9.5 e successive.
1. Utilizzate il seguente comando per verificare la firma del vostro 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 JDK installata. Sostituiscilo {{`jdk17.0.6_10`}} 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 JDK installata. Sostituiscilo {{`jdk17.0.6_10`}} 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 avete fornito l'`-certs`opzione Jarsigner insieme alle `-verbose` opzioni `-verify` and, 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) Esegui il comando seguente per visualizzare la versione del software AWS IoT Greengrass Core.
```
java -jar ./{{GreengrassInstaller}}/lib/Greengrass.jar --version
```
**Importante**
Se installate una versione di Greengrass nucleus precedente alla v2.4.0, non rimuovete questa cartella dopo aver installato il software Core. AWS IoT Greengrass Il software AWS IoT Greengrass Core utilizza i file contenuti in questa cartella per l'esecuzione.
Se hai scaricato la versione più recente del software, installi la v2.4.0 o successiva e puoi rimuovere questa cartella dopo aver installato il software AWS IoT Greengrass Core.
### Installa il AWS IoT Greengrass Software di base
Esegui il programma di installazione con argomenti che specificano le seguenti azioni:
+ Effettua 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 principale 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 dal file di configurazione parziale fornito.
+ Specifica di utilizzare l'utente `ggc_user` del sistema per eseguire i componenti software sul dispositivo principale. Sui dispositivi Linux, questo comando specifica anche l'uso del gruppo di `ggc_group` sistema e il programma di installazione crea l'utente e il gruppo di sistema al posto tuo.
+ 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, puoi impostare le opzioni di 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 thing e la chiave privata nel AWS IoT servizio, segui i passaggi per installare il software AWS IoT Greengrass Core con chiave privata e file di certificato.
+ Se in precedenza hai creato il certificato thing 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 AWS IoT Greengrass Software di base con chiave privata e file di certificato
**Per installare AWS IoT Greengrass Software di base**
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 Linux-based sistema, puoi eseguire il seguente comando per usare GNU nano per creare il file.
```
nano {{GreengrassInstaller}}/config.yaml
```
Copia 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.18.0}}"
configuration:
awsRegion: "{{us-west-2}}"
iotRoleAlias: "{{GreengrassCoreTokenExchangeRoleAlias}}"
fipsMode: "true"
iotDataEndpoint: "{{data.iot-fips.us-west-2.amazonaws.com}}"
greengrassDataPlaneEndpoint: "iotData"
iotCredEndpoint: "{{data.credentials.iot-fips.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 dell' AWS IoT oggetto.
+ Sostituisci {{2.18.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.
1. Esegui il programma di installazione e specifica di `--init-config` fornire il file di configurazione.
+ Sostituisci `{{/greengrass/v2}}` o {{C:\\greengrass\\v2}} con la cartella principale di Greengrass.
+ Sostituisci ogni istanza {{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**
Sui 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 di Greengrass direttamente sul tuo 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 AWS IoT Greengrass Software di base con chiave privata e certificato in un HSM
**Nota**
Questa funzionalità è disponibile per la versione 2.5.3 e successive del componente Greengrass nucleus. [Nucleo di Greengrass](greengrass-nucleus-component.md) AWS IoT Greengrass attualmente non supporta questa funzionalità sui dispositivi Windows core.
**Per installare AWS IoT Greengrass Software di base**
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, installa il componente provider [ PKCS \#11 ](pkcs11-provider-component.md) quando installi il software AWS IoT Greengrass Core. Il componente provider PKCS \#11 è un plug-in che è possibile configurare durante l'installazione. È possibile scaricare la versione più recente del componente provider PKCS \#11 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)
Scaricare il plug-in del provider PKCS \#11 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 Linux-based sistema, puoi eseguire il seguente comando per usare GNU nano per creare il file.
```
nano {{GreengrassInstaller}}/config.yaml
```
Copia 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 \#11.
```
---
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.18.0}}"
configuration:
awsRegion: "{{us-west-2}}"
iotRoleAlias: "{{GreengrassCoreTokenExchangeRoleAlias}}"
fipsMode: "true"
iotDataEndpoint: "{{data.iot-fips.us-west-2.amazonaws.com}}"
greengrassDataPlaneEndpoint: "iotData"
iotCredEndpoint: "{{data.credentials.iot-fips.us-west-2.amazonaws.com}}"
```
Successivamente, esegui queste operazioni:
+ Sostituisci ogni istanza degli URI PKCS \#11 con l'etichetta dell'oggetto {{iotdevicekey}} 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 dell' AWS IoT oggetto.
+ Sostituisci {{2.18.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 del `aws.greengrass.crypto.Pkcs11Provider` componente con i valori per la configurazione HSM sul dispositivo principale.
1. Esegui il programma di installazione e specifica di `--init-config` fornire il file di configurazione.
+ Sostituisci `{{/greengrass/v2}}` con la cartella principale di Greengrass.
+ Sostituisci ogni istanza {{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**
Sui 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 di Greengrass direttamente sul tuo 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 il software AWS IoT Greengrass Core è stato installato come servizio di sistema, il programma di installazione esegue il software per conto dell'utente. Altrimenti, è necessario eseguire il software manualmente. Per ulteriori informazioni, consulta [Esegui il software AWS IoT Greengrass Core](run-greengrass-core-v2.md).
Per ulteriori informazioni su come configurare e utilizzare il software e AWS IoT Greengrass, vedere quanto segue:
+ [Configura il AWS IoT Greengrass Software di base](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)
## Installa gli endpoint FIPS con il provisioning della flotta
Questa funzionalità è disponibile per la versione 2.4.0 e successive del componente [ Greengrass nucleus. ](greengrass-nucleus-component.md)
Installa gli endpoint FIPS sul tuo software AWS IoT Greengrass Core con il provisioning AWS IoT della flotta per i tuoi dispositivi principali.
**Nota**
Il plugin di fleet provisioning per [ Greengrass nucleus attualmente ](greengrass-nucleus-component.md) non supporta la memorizzazione di file di chiavi e certificati privati in un modulo di sicurezza hardware (HSM). Per utilizzare un HSM, [ installate il software AWS IoT Greengrass Core con provisioning manuale. ](#FIPS-fleet-provisioning)
Per installare il software AWS IoT Greengrass Core con provisioning del AWS IoT parco veicoli, è necessario configurare le risorse nel proprio Account AWS ambiente per il provisioning dei AWS IoT dispositivi principali di Greengrass. Queste risorse includono un modello di provisioning, certificati di reclamo e un ruolo IAM per lo scambio di [ token. ](device-service-role.md) Dopo aver creato queste risorse, puoi riutilizzarle per eseguire il provisioning di più dispositivi principali in una flotta. Per ulteriori informazioni, consulta [Configura il provisioning AWS IoT della flotta per i dispositivi core Greengrass](fleet-provisioning-setup.md).
**Importante**
Prima di scaricare il software AWS IoT Greengrass Core, verifica che il tuo 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**
+ [Prerequisiti](#fleet-provisioning-prerequisites)
+ [Retrieve AWS IoT endpoint](#retrieve-iot-endpoints)
+ [Scarica i certificati sul dispositivo](#download-claim-certificates)
+ [Configura l'ambiente del dispositivo](#set-up-device-environment-fleet-provisioning)
+ [Scarica il AWS IoT Greengrass Software di base](#download-greengrass-core-v2-fleet)
+ [Scarica il AWS IoT plugin per il provisioning della flotta](#download-fleet-provisioning-plugin)
+ [Installa AWS IoT Greengrass Software di base](#run-greengrass-core-v2-installer-fleet-provisioning)
### Prerequisiti
Per installare il software AWS IoT Greengrass Core con AWS IoT fleet provisioning, dovete prima [ configurare il AWS IoT fleet provisioning per i dispositivi core Greengrass. ](fleet-provisioning-setup.md) Dopo aver completato questi passaggi una volta, puoi utilizzare il fleet provisioning per installare il software AWS IoT Greengrass Core su un numero qualsiasi di dispositivi.
### Retrieve AWS IoT endpoint
Ottieni gli endpoint FIPS per te e salvali per utilizzarli in seguito. Account AWS Il tuo dispositivo utilizza questi endpoint per connettersi a. AWS IoT Esegui questa operazione:
1. Ottieni l'endpoint di dati FIPS per la tua regione negli endpoint del piano dati [AWS IoT Core FIPS. ](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#iot-core-data-plane-endpoints) L'endpoint di dati FIPS per il tuo Account AWS dovrebbe assomigliare a questo: {{data.iot-fips.us-west-2.amazonaws.com}}
1. Ottieni l'endpoint delle credenziali FIPS per la tua regione negli endpoint del [AWS IoT Core piano dati FIPS. ](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#iot-core-data-plane-endpoints) L'endpoint delle credenziali FIPS per te Account AWS dovrebbe assomigliare a questo: {{data.credentials.iot-fips.us-west-2.amazonaws.com}}
### Scarica i certificati sul dispositivo
Il dispositivo utilizza un certificato di attestazione e una chiave privata per autenticare la richiesta di provisioning AWS delle risorse e acquisire un certificato X.509 del dispositivo. È possibile incorporare il certificato di attestazione e la chiave privata nel dispositivo durante la produzione oppure copiare il certificato e la chiave nel dispositivo durante l'installazione. In questa sezione, puoi copiare il certificato di reclamo e la chiave privata nel dispositivo. Inoltre, scarichi il certificato Amazon Root Certificate Authority (CA) sul dispositivo.
**Importante**
Il provisioning delle chiavi private delle richieste deve essere protetto in ogni momento, anche sui dispositivi principali di Greengrass. Ti consigliamo di utilizzare le CloudWatch metriche e i log di Amazon per monitorare eventuali indicazioni di uso improprio, ad esempio l'uso non autorizzato del certificato di reclamo per il provisioning dei dispositivi. Se rilevi un uso improprio, disabilita il certificato di attestazione di provisioning in modo che non possa essere utilizzato per il provisioning dei dispositivi. Per ulteriori informazioni, consulta [ Monitoring AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) nella Developer Guide. *AWS IoT Core *
Per aiutarti a gestire meglio il numero di dispositivi e quali dispositivi si registrano nel tuo Account AWS, puoi specificare un hook di pre-provisioning quando crei un modello di provisioning del parco veicoli. Un hook di pre-provisioning è una AWS Lambda funzione che convalida i parametri del modello forniti dai dispositivi durante la registrazione. Ad esempio, potresti creare un hook di pre-provisioning che confronta l'ID di un dispositivo con un database per verificare che il dispositivo disponga dell'autorizzazione per il provisioning. Per ulteriori informazioni, consulta gli [ Pre-provisioning hook ](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) nella Developer Guide. *AWS IoT Core *
**Per scaricare i certificati di rimborso sul dispositivo**
1. Copia il certificato di reclamo e la chiave privata sul dispositivo. Se SSH e SCP sono abilitati sul computer di sviluppo e sul dispositivo, puoi utilizzare il `scp` comando sul tuo computer di sviluppo per trasferire il certificato di attestazione e la chiave privata. Il comando di esempio seguente trasferisce questi file nel dispositivo `claim-certs` in una cartella denominata nel computer di sviluppo. Sostituiscili {{device-ip-address}} con l'indirizzo IP del tuo dispositivo.
```
scp -r claim-certs/ {{device-ip-address}}:~
```
1. Create la cartella principale di 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 utilizzate Windows, utilizzate una cartella principale come `C:\greengrass\v2` o `D:\greengrass\v2` per mantenere i percorsi dei componenti di Greengrass al di sotto del limite di 260 caratteri.
------
#### [ Linux or Unix ]
+ Sostituisci `{{/greengrass/v2}}` con la cartella da usare.
```
sudo mkdir -p {{/greengrass/v2}}
```
------
#### [ Windows Command Prompt ]
+ Sostituisci {{C:\\greengrass\\v2}} con la cartella da usare.
```
mkdir {{C:\greengrass\v2}}
```
------
#### [ PowerShell ]
+ Sostituisci {{C:\\greengrass\\v2}} con la cartella da usare.
```
mkdir {{C:\greengrass\v2}}
```
------
1. (Solo Linux) Imposta i permessi dell'elemento principale della cartella principale di Greengrass.
+ Sostituisci {{/greengrass}} con il file principale della cartella principale.
```
sudo chmod 755 {{/greengrass}}
```
1. Sposta i certificati di reclamo nella cartella principale di Greengrass.
+ Sostituisci `{{/greengrass/v2}}` o {{C:\\greengrass\\v2}} con la cartella principale di Greengrass.
------
#### [ Linux or Unix ]
```
sudo mv ~/claim-certs {{/greengrass/v2}}
```
------
#### [ Windows Command Prompt (CMD) ]
```
move %USERPROFILE%\claim-certs {{C:\greengrass\v2}}
```
------
#### [ PowerShell ]
```
mv -Path ~\claim-certs -Destination {{C:\greengrass\v2}}
```
------
1. Scarica sia il certificato CA1 che il certificato [ CA3. ](https://www.amazontrust.com/repository/)
------
#### [ Linux or Unix ]
```
sudo curl -o - https://www.amazontrust.com/repository/AmazonRootCA3.pem >> {{/greengrass/v2}}/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 descritti in 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 ](https://openjdk.java.net/) OpenJDK. È richiesta la versione 8 o successiva. I seguenti comandi mostrano come installare OpenJDK sul tuo dispositivo.
+ Per Debian-based le nostre distribuzioni: Ubuntu-based
```
sudo apt install default-jdk
```
+ Per le Hat-based distribuzioni Red:
```
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 Debian-based distribuzione, 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 esegue 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. Verifica che l'utente che esegue il software AWS IoT Greengrass Core (in genere`root`) disponga dell'autorizzazione per l'esecuzione `sudo` con qualsiasi utente e gruppo.
1. Esegui il comando seguente per aprire il `/etc/sudoers` file.
```
sudo visudo
```
1. Verifica 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), devi abilitare [ cgroups ](https://en.wikipedia.org/wiki/Cgroups) v1 e devi abilitare e montare i cgroup di memoria e dispositivi. * * * * Se non prevedi di eseguire funzioni Lambda containerizzate, puoi saltare questo passaggio.
Per abilitare queste opzioni di cgroups, avviate 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 dispositivo, consultate la documentazione del sistema operativo e del boot loader. Segui le istruzioni per impostare permanentemente 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 Nucleus. ](greengrass-nucleus-component.md)
**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 ](https://openjdk.java.net/) OpenJDK. È richiesta la versione 8 o successiva.
1. Verifica se Java è disponibile nella variabile di [ sistema ](https://en.wikipedia.org/wiki/PATH_(variable)) PATH e aggiungila 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 del 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. Sostituisci {{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 una data futura. Per garantire che le 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](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), esegui il comando 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. Utilizza 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 Greengrass Nucleus ed è necessario utilizzare l' PsExec utilità per memorizzare le informazioni utente predefinite nell' LocalSystem account. L'utilizzo dell'applicazione Credential Manager memorizza queste informazioni nell'account Windows dell'utente attualmente connesso, anziché nell'account. LocalSystem
### Scarica il AWS IoT Greengrass Software di base
È possibile scaricare la versione più recente del software AWS IoT Greengrass Core dalla seguente posizione:
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)
**Nota**
È possibile scaricare una versione specifica del software AWS IoT Greengrass Core dalla seguente posizione. Sostituiscila {{version}} con la versione da scaricare.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-{{version}}.zip
```
**Per scaricare il AWS IoT Greengrass Software di base**
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. (Facoltativo) Per verificare la firma del software Greengrass Nucleus
**Nota**
Questa funzionalità è disponibile con Greengrass nucleus versione 2.9.5 e successive.
1. Utilizzate il seguente comando per verificare la firma del vostro 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 JDK installata. Sostituiscilo {{`jdk17.0.6_10`}} 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 JDK installata. Sostituiscilo {{`jdk17.0.6_10`}} 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 avete fornito l'`-certs`opzione Jarsigner insieme alle `-verbose` opzioni `-verify` and, 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) Esegui il comando seguente per visualizzare la versione del software AWS IoT Greengrass Core.
```
java -jar ./{{GreengrassInstaller}}/lib/Greengrass.jar --version
```
**Importante**
Se installate una versione di Greengrass nucleus precedente alla v2.4.0, non rimuovete questa cartella dopo aver installato il software Core. AWS IoT Greengrass Il software AWS IoT Greengrass Core utilizza i file contenuti in questa cartella per l'esecuzione.
Se hai scaricato la versione più recente del software, installi la v2.4.0 o successiva e puoi rimuovere questa cartella dopo aver installato il software AWS IoT Greengrass Core.
### Scarica il AWS IoT plugin per il provisioning della flotta
È possibile scaricare l'ultima versione del plug-in di provisioning AWS IoT della flotta dalla seguente posizione:
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar](https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar)
**Nota**
È possibile scaricare una versione specifica del plug-in di provisioning AWS IoT della flotta dalla seguente posizione. Sostituiscilo {{version}} con la versione da scaricare. Per ulteriori informazioni su ciascuna versione del plug-in di provisioning della flotta, vedere[AWS IoT log delle modifiche del plugin per il provisioning della flotta](fleet-provisioning-changelog.md).
```
https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-{{version}}.jar
```
Il plugin per il provisioning della flotta è open source. Per visualizzarne il codice sorgente, consulta il plug-in [ di provisioning ](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim)AWS IoT della flotta su. GitHub
**Per scaricare il AWS IoT plugin per il provisioning della flotta**
+ Sul tuo dispositivo, scarica il plug-in di provisioning AWS IoT della flotta in un file denominato. `aws.greengrass.FleetProvisioningByClaim.jar` Sostituiscilo {{GreengrassInstaller}} con la cartella che desideri utilizzare.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > {{GreengrassInstaller}}/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > {{GreengrassInstaller}}/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar -OutFile {{GreengrassInstaller}}/aws.greengrass.FleetProvisioningByClaim.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).
### Installa AWS IoT Greengrass Software di base
Esegui il programma di installazione con argomenti che specificano le seguenti azioni:
+ Effettua l'installazione da un file di configurazione parziale che specifica di utilizzare il plug-in di provisioning della flotta per il provisioning delle risorse. AWS Il software AWS IoT Greengrass principale 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 e dalle AWS risorse create dal plug-in di provisioning del parco veicoli.
+ Specifica di utilizzare l'utente `ggc_user` del sistema per eseguire i componenti software sul dispositivo principale. Sui dispositivi Linux, questo comando specifica anche l'uso del gruppo di `ggc_group` sistema e il programma di installazione crea l'utente e il gruppo di sistema al posto tuo.
+ 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, puoi impostare le opzioni di 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).
**Per installare AWS IoT Greengrass Software di base**
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 Linux-based sistema, puoi eseguire il seguente comando per usare GNU nano per creare il file.
```
nano {{GreengrassInstaller}}/config.yaml
```
Copia il seguente contenuto YAML nel file. Questo file di configurazione parziale specifica i parametri per il plug-in di provisioning della flotta. Per ulteriori informazioni sulle opzioni che è possibile specificare, vedere. [Configurare il plug-in per il provisioning AWS IoT della flotta](fleet-provisioning-configuration.md)
------
#### [ Linux or Unix ]
```
---
services:
aws.greengrass.Nucleus:
version: "{{2.18.0}}"
configuration:
fipsMode: "true"
greengrassDataPlaneEndpoint: "iotData"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "{{/greengrass/v2}}"
awsRegion: "{{us-west-2}}"
iotDataEndpoint: "{{data.iot-fips.us-west-2.amazonaws.com}}"
iotCredEndpoint: "{{data.credentials.iot-fips.us-west-2.amazonaws.com}}"
iotRoleAlias: "{{GreengrassCoreTokenExchangeRoleAlias}}"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "{{/greengrass/v2}}/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "{{/greengrass/v2}}/claim-certs/claim.private.pem.key"
rootCaPath: "{{/greengrass/v2}}/AmazonRootCA1.pem"
templateParameters:
ThingName: "{{MyGreengrassCore}}"
ThingGroupName: "{{MyGreengrassCoreGroup}}"
```
------
#### [ Windows ]
```
---
services:
aws.greengrass.Nucleus:
version: "{{2.18.0}}"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "{{C:\\greengrass\\v2}}"
awsRegion: "{{us-west-2}}"
iotDataEndpoint: "{{device-data-prefix}}-ats.iot.{{us-west-2}}.amazonaws.com"
iotCredentialEndpoint: "{{device-credentials-prefix}}.credentials.iot.{{us-west-2}}.amazonaws.com"
iotRoleAlias: "{{GreengrassCoreTokenExchangeRoleAlias}}"
provisioningTemplate: "{{GreengrassFleetProvisioningTemplate}}"
claimCertificatePath: "{{C:\\greengrass\\v2\\claim-certs\\claim.pem.crt}}"
claimCertificatePrivateKeyPath: "{{C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key}}"
rootCaPath: "{{C:\\greengrass\\v2}}\\AmazonRootCA1.pem"
templateParameters:
ThingName: "{{MyGreengrassCore}}"
ThingGroupName: "{{MyGreengrassCoreGroup}}"
```
------
Successivamente, esegui queste operazioni:
+ Sostituisci {{2.18.0}} con la versione del software AWS IoT Greengrass Core.
+ Sostituisci ogni istanza di `{{/greengrass/v2}}` o {{C:\\greengrass\\v2}} con la cartella principale di Greengrass.
**Nota**
Sui dispositivi Windows, è necessario specificare i separatori di percorso mediante doppie barre rovesciate (`\\`), ad esempio. `C:\\greengrass\\v2`
+ {{us-west-2}}Sostituiscili con la AWS regione in cui hai creato il modello di provisioning e altre risorse.
+ Sostituiscilo `iotDataEndpoint` con il tuo endpoint di AWS IoT dati.
+ Sostituisci l'`iotCredentialEndpoint`endpoint con AWS IoT le tue credenziali.
+ Sostituisci {{GreengrassCoreTokenExchangeRoleAlias}} con il nome dell'alias del ruolo di scambio di token.
+ Sostituiscilo {{GreengrassFleetProvisioningTemplate}} con il nome del modello di provisioning della flotta.
+ Sostituisci il `claimCertificatePath` con il percorso del certificato di sinistro sul dispositivo.
+ Sostituisci il `claimCertificatePrivateKeyPath` con il percorso della chiave privata del certificato di reclamo sul dispositivo.
+ Sostituisci i parametri del modello (`templateParameters`) con i valori da utilizzare per il provisioning del dispositivo. Questo esempio si riferisce al modello di [ esempio ](fleet-provisioning-setup.md#example-fleet-provisioning-template) che definisce `ThingName` i `ThingGroupName` parametri.
1. Eseguire il programma di installazione. Specifica `--trusted-plugin` di fornire il plug-in di provisioning della flotta e specifica `--init-config` di fornire il file di configurazione.
+ Sostituisci `{{/greengrass/v2}}` con la cartella principale di Greengrass.
+ Sostituisci ogni istanza {{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 \
--trusted-plugin ./{{GreengrassInstaller}}/aws.greengrass.FleetProvisioningByClaim.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 ^
--trusted-plugin ./{{GreengrassInstaller}}/aws.greengrass.FleetProvisioningByClaim.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 `
--trusted-plugin ./{{GreengrassInstaller}}/aws.greengrass.FleetProvisioningByClaim.jar `
--init-config ./{{GreengrassInstaller}}/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**Importante**
Sui 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 di 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 il software AWS IoT Greengrass Core è stato installato come servizio di sistema, il programma di installazione esegue il software per conto dell'utente. Altrimenti, è necessario eseguire il software manualmente. Per ulteriori informazioni, consulta [Esegui il software AWS IoT Greengrass Core](run-greengrass-core-v2.md).
Per ulteriori informazioni su come configurare e utilizzare il software e AWS IoT Greengrass, vedere quanto segue:
+ [Configura il AWS IoT Greengrass Software di base](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)
## Installa gli endpoint FIPS con il provisioning automatico delle risorse
Il software AWS IoT Greengrass Core include un programma di installazione che configura il dispositivo come dispositivo principale Greengrass. Per configurare rapidamente un dispositivo, l'installatore può fornire l' AWS IoT oggetto, il gruppo di oggetti, AWS IoT il ruolo IAM e l'alias di AWS IoT ruolo necessari per il funzionamento del dispositivo principale. L'installatore può anche distribuire gli strumenti di sviluppo locali sul dispositivo principale, in modo da poter utilizzare il dispositivo per sviluppare e testare componenti software personalizzati. L'installatore richiede AWS le credenziali per fornire queste risorse e creare la distribuzione.
Se non riesci a fornire AWS le credenziali al dispositivo, puoi fornire AWS le risorse necessarie al dispositivo principale per funzionare. Puoi anche distribuire gli strumenti di sviluppo su un dispositivo principale da utilizzare come dispositivo di sviluppo. Ciò consente di fornire meno autorizzazioni al dispositivo quando si esegue il programma di installazione. Per ulteriori informazioni, consulta [Installa AWS IoT Greengrass Software di base con fornitura manuale delle risorse](manual-installation.md).
**Importante**
Prima di scaricare il software AWS IoT Greengrass Core, verifica che il tuo 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**
+ [Configura l'ambiente del dispositivo](#set-up-device-environment)
+ [Fornire AWS credenziali per il dispositivo](#provide-installer-aws-credentials-auto)
+ [Scaricate il AWS IoT Greengrass Software di base](#download-greengrass-core-v2-auto)
+ [Installa il AWS IoT Greengrass Software di base](#run-greengrass-core-v2-installer-auto)
### Configura l'ambiente del dispositivo
Segui i passaggi descritti in 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 ](https://openjdk.java.net/) OpenJDK. È richiesta la versione 8 o successiva. I seguenti comandi mostrano come installare OpenJDK sul tuo dispositivo.
+ Per Debian-based le nostre distribuzioni: Ubuntu-based
```
sudo apt install default-jdk
```
+ Per le Hat-based distribuzioni Red:
```
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 Debian-based distribuzione, 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 esegue 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. Verifica che l'utente che esegue il software AWS IoT Greengrass Core (in genere`root`) disponga dell'autorizzazione per l'esecuzione `sudo` con qualsiasi utente e gruppo.
1. Esegui il comando seguente per aprire il `/etc/sudoers` file.
```
sudo visudo
```
1. Verifica 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), devi abilitare [ cgroups ](https://en.wikipedia.org/wiki/Cgroups) v1 e devi abilitare e montare i cgroup di memoria e dispositivi. * * * * Se non prevedi di eseguire funzioni Lambda containerizzate, puoi saltare questo passaggio.
Per abilitare queste opzioni di cgroups, avviate 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 dispositivo, consultate la documentazione del sistema operativo e del boot loader. Segui le istruzioni per impostare permanentemente 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 Nucleus. ](greengrass-nucleus-component.md)
**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 ](https://openjdk.java.net/) OpenJDK. È richiesta la versione 8 o successiva.
1. Verifica se Java è disponibile nella variabile di [ sistema ](https://en.wikipedia.org/wiki/PATH_(variable)) PATH e aggiungila 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 Start, 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. Sostituisci {{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 una data futura. Per garantire che le 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](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), esegui il comando 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. Utilizza 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 Greengrass Nucleus ed è necessario utilizzare l' PsExec utilità per memorizzare le informazioni utente predefinite nell' LocalSystem account. L'utilizzo dell'applicazione Credential Manager memorizza queste informazioni nell'account Windows dell'utente attualmente connesso, anziché nell'account. LocalSystem
### Fornire AWS credenziali per il dispositivo
Fornisci AWS le tue credenziali al dispositivo in modo che l'installatore possa fornire le risorse necessarie. AWS Per ulteriori informazioni sulle autorizzazioni richieste, consulta [Policy IAM minima per l'installatore per il provisioning delle risorse](provision-minimal-iam-policy.md).
**Fornire AWS credenziali per il dispositivo**
+ 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é memorizza 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 Centro identità AWS IAM
1. Fornisci l'ID della chiave di accesso, la chiave di accesso segreta e il token di sessione dallo IAM Identity Center. Per ulteriori informazioni, consulta Aggiornamento ** manuale delle credenziali ** in [ Ottenere e aggiornare le credenziali temporanee ](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials) nella guida per l'utente di * IAM Identity Center. *
1. Esegui i seguenti comandi per fornire le credenziali al software principale. 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=}}"
```
------
+ Usa le credenziali di sicurezza temporanee di 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 [ Richiedere credenziali di sicurezza temporanee ](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) nella IAM User Guide. * *
1. Esegui i seguenti comandi per fornire le credenziali al software principale. 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=}}"
```
------
+ Usa 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 che successivamente eliminerai. 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 ](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) nella IAM User * Guide. *
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}}
```
------
#### [ 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 eseguire 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*.
### Scaricate il AWS IoT Greengrass Software di base
È possibile scaricare la versione più recente del software AWS IoT Greengrass Core dalla seguente posizione:
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)
**Nota**
È possibile scaricare una versione specifica del software AWS IoT Greengrass Core dalla seguente posizione. Sostituiscila {{version}} con la versione da scaricare.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-{{version}}.zip
```
**Per scaricare il AWS IoT Greengrass Software di base**
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. (Facoltativo) Per verificare la firma del software Greengrass Nucleus
**Nota**
Questa funzionalità è disponibile con Greengrass nucleus versione 2.9.5 e successive.
1. Utilizzate il seguente comando per verificare la firma del vostro 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 JDK installata. Sostituiscilo {{`jdk17.0.6_10`}} 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 JDK installata. Sostituiscilo {{`jdk17.0.6_10`}} 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 avete fornito l'`-certs`opzione Jarsigner insieme alle `-verbose` opzioni `-verify` and, 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) Esegui il comando seguente per visualizzare la versione del software AWS IoT Greengrass Core.
```
java -jar ./{{GreengrassInstaller}}/lib/Greengrass.jar --version
```
**Importante**
Se installate una versione di Greengrass nucleus precedente alla v2.4.0, non rimuovete questa cartella dopo aver installato il software Core. AWS IoT Greengrass Il software AWS IoT Greengrass Core utilizza i file contenuti in questa cartella per l'esecuzione.
Se hai scaricato la versione più recente del software, installi la v2.4.0 o successiva e puoi rimuovere questa cartella dopo aver installato il software AWS IoT Greengrass Core.
### Installa il AWS IoT Greengrass Software di base
Esegui il programma di installazione con argomenti che specificano di fare quanto segue:
+ Crea le AWS risorse necessarie per il funzionamento del dispositivo principale.
+ Specifica di utilizzare l'utente `ggc_user` del sistema per eseguire i componenti software sul dispositivo principale. Sui dispositivi Linux, questo comando specifica anche l'uso del gruppo di `ggc_group` sistema e il programma di installazione crea l'utente e il gruppo di sistema al posto tuo.
+ 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 configurare un dispositivo di sviluppo con strumenti di sviluppo locali, specifica l'`--deploy-dev-tools true`argomento. La distribuzione degli strumenti di sviluppo locali può richiedere fino a un minuto dopo il completamento dell'installazione.
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, puoi impostare le opzioni di 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).
**Per installare AWS IoT Greengrass Software di base**
1. Utilizzate un editor di testo per creare un file di configurazione denominato `config.yaml` da fornire all'installatore.
Ad esempio, su un Linux-based sistema, puoi eseguire il seguente comando per usare GNU nano per creare il file.
```
nano {{GreengrassInstaller}}/config.yaml
```
Copia il seguente contenuto YAML nel file. Questo file di configurazione parziale specifica i parametri di sistema e i parametri del nucleo di Greengrass.
```
---
services:
aws.greengrass.Nucleus:
configuration:
fipsMode: "true"
iotDataEndpoint: "{{data.iot-fips.us-west-2.amazonaws.com}}"
iotCredEndpoint: "{{data.credentials.iot-fips.us-west-2.amazonaws.com}}"
greengrassDataPlaneEndpoint: "iotData"
```
+ Sostituisci {{us-west-2}} con il Regione AWS luogo in cui hai creato le risorse.
+ Sostituiscilo {{iotDataEndpoint}} con il tuo endpoint di AWS IoT dati.
+ Sostituisci l'{{iotCredEndpoint}}endpoint con AWS IoT le tue credenziali.
1. Esegui il programma di installazione AWS IoT Greengrass Core. Sostituisci i valori degli argomenti nel comando come segue.
**Nota**
In Windows esiste un limite di lunghezza del percorso di 260 caratteri. Se utilizzate Windows, utilizzate una cartella principale come `C:\greengrass\v2` o `D:\greengrass\v2` per mantenere i percorsi dei componenti di Greengrass al di sotto del limite di 260 caratteri.
1. `{{/greengrass/v2}}`oppure{{C:\\greengrass\\v2}}: 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 dell' AWS IoT oggetto per il 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 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 ha una distribuzione attiva, il dispositivo principale scarica ed esegue il software specificato dalla distribuzione.
**Nota**
Il nome del gruppo di oggetti non può contenere due punti ()`:`.
1. {{GreengrassV2IoTThingPolicy}}. Il nome della AWS IoT policy che consente ai dispositivi principali di Greengrass di comunicare con AWS IoT e AWS IoT Greengrass. Se la AWS IoT policy non esiste, il programma di installazione crea una AWS IoT policy permissiva con questo nome. Puoi limitare le autorizzazioni di questa policy 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 di Greengrass di ottenere AWS credenziali temporanee. Se il ruolo non esiste, l'installatore lo crea e crea e allega una policy denominata. `{{GreengrassV2TokenExchangeRole}}Access` 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 di 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 \
--init-config ./GreengrassInstaller/config.yaml \
--setup-system-service 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
```
------
#### [ 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
```
------
**Importante**
Sui dispositivi Windows Core, è necessario specificare `--setup-system-service true` di configurare il software AWS IoT Greengrass Core come servizio di sistema.
In caso di esito positivo, il programma di installazione stampa i seguenti messaggi:
+ Se si specifica`--provision`, il programma di installazione stampa `Successfully configured Nucleus with provisioned resource details` se ha configurato correttamente le risorse.
+ Se si specifica`--deploy-dev-tools`, il programma di installazione stampa `Configured Nucleus to deploy aws.greengrass.Cli component` se ha creato la distribuzione con successo.
+ 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.
+ Se non si specifica`--setup-system-service true`, il programma di installazione stampa `Launched Nucleus successfully` se è stato eseguito correttamente e il software è stato eseguito.
1. Salta questo passaggio se hai installato [Nucleo di Greengrass](greengrass-nucleus-component.md) la versione 2.0.4 o successiva. Se hai scaricato la versione più recente del software, hai installato la v2.0.4 o successiva.
Esegui il comando seguente per impostare le autorizzazioni di file richieste per la cartella principale del software AWS IoT Greengrass Core. Sostituiscila `{{/greengrass/v2}}` con la cartella principale specificata nel comando di installazione e sostituiscila {{/greengrass}} con la cartella principale per la cartella principale.
```
sudo chmod 755 {{/greengrass/v2}} && sudo chmod 755 {{/greengrass}}
```
Se hai installato il software AWS IoT Greengrass Core come servizio di sistema, il programma di installazione esegue il software per te. Altrimenti, è necessario eseguire il software manualmente. Per ulteriori informazioni, consulta [Esegui il software AWS IoT Greengrass Core](run-greengrass-core-v2.md).
**Nota**
Per impostazione predefinita, il ruolo IAM creato dall'installatore 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.
Per ulteriori informazioni su come configurare e utilizzare il software e, consulta quanto segue: AWS IoT Greengrass
+ [Configura il AWS IoT Greengrass Software di base](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)
## Componenti proprietari conformi alla normativa FIPS
| | |
| --- | --- |
| aws.greengrass.Nucleus | data.iot-fips.{{us-east-1}}.amazonaws.com |
| | greengrass-fips.{{us-east-1}}.amazonaws.com |
| | data.credentials.iot-fips.{{us-east-1}}.amazonaws.com |
| aws.greengrass.TokenExchangeService | data.credentials.iot-fips.{{us-east-1}}.amazonaws.com |
| aws.greengrass.Cli | |
| aws.greengrass.StreamManager | + `kinesis-fips.{{us-east-1}}.amazonaws.com`
+ `data.iotsitewise-fips.{{us-east-1}}.amazonaws.com `
+ `s3-fips.{{us-east-1}}.amazonaws.com` |
| aws.greengrass.LogManager | logs-fips. {{us-east-1}}.amazonaws.com |
| aws.greengrass.crypto.Pkcs11Provider | |
| aws.greengrass.ShadowManager | |
| aws.greengrass.DockerApplicationManager | ecr-fips. {{us-east-1}}.amazonaws.com |
| aws.greengrass.SecretManager | secretsmanager-fips. {{us-east-1}}.amazonaws.com |
| aws.greengrass.telemetry.NucleusEmitter | |
| aws.greengrass.clientdevices.IPDetector | |
| aws.greengrass.DiskSpooler | |