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à. # Esegui AWS IoT Greengrass in un contenitore Docker con provisioning manuale delle risorse Questo tutorial mostra come installare ed eseguire il software AWS IoT Greengrass Core in un contenitore Docker con risorse assegnate manualmente. AWS **Topics** + [Prerequisiti](#docker-manual-provisioning-prereqs) + [AWS IoT Recupera gli endpoint](#retrieve-iot-endpoints) + [Crea qualsiasi cosa AWS IoT](#create-iot-thing) + [Crea il certificato dell'oggetto](#create-thing-certificate-mp) + [Crea un ruolo di scambio di token](#create-token-exchange-role) + [Scarica i certificati sul dispositivo](#download-thing-certificates) + [Crea un file di configurazione](#create-docker-install-configuration-file) + [Crea un file di ambiente](#create-env-file-manual-provisioning) + [Esegui il software AWS IoT Greengrass Core in un contenitore](#run-greengrass-image-manual-provisioning) + [Fasi successive](#run-greengrass-docker-next-steps) ## Prerequisiti Per completare questo tutorial, è necessario quanto segue: + Un. Account AWS Se non lo hai, consultare [Configura un Account AWS](setting-up.md#set-up-aws-account). + Un'immagine AWS IoT Greengrass Docker. Puoi [creare un'immagine dal AWS IoT Greengrass Dockerfile](build-greengrass-dockerfile.md). + Il computer host su cui si esegue il contenitore Docker deve soddisfare i seguenti requisiti: + Un sistema operativo basato su Linux con una connessione Internet. + [Docker Engine](https://docs.docker.com/engine/install/) versione 18.09 o successiva. + (Facoltativo) [Docker Compose](https://docs.docker.com/compose/install/) versione 1.22 o successiva. Docker Compose è necessario solo se si desidera utilizzare la CLI Docker Compose per eseguire le immagini Docker. ## AWS IoT Recupera gli endpoint Ottieni gli AWS IoT endpoint per te e salvali per Account AWS utilizzarli in un secondo momento. Il tuo dispositivo utilizza questi endpoint per connettersi a. AWS IoT Esegui questa operazione: 1. Ottieni l'endpoint di AWS IoT dati per il tuo. Account AWS ``` aws iot describe-endpoint --endpoint-type iot:Data-ATS ``` La risposta è simile all'esempio seguente, se la richiesta ha esito positivo. ``` { "endpointAddress": "{{device-data-prefix}}-ats.iot.us-west-2.amazonaws.com" } ``` 1. Ottieni l'endpoint delle AWS IoT credenziali per il tuo. Account AWS ``` aws iot describe-endpoint --endpoint-type iot:CredentialProvider ``` La risposta è simile all'esempio seguente, se la richiesta ha esito positivo. ``` { "endpointAddress": "{{device-credentials-prefix}}.credentials.iot.us-west-2.amazonaws.com" } ``` ## Crea qualsiasi cosa AWS IoT AWS IoT *le cose* rappresentano dispositivi ed entità logiche a cui si connettono AWS IoT. I dispositivi core Greengrass sono AWS IoT cose. Quando registri un dispositivo come AWS IoT oggetto, quel dispositivo può utilizzare un certificato digitale con cui autenticarsi. AWS In questa sezione, crei AWS IoT qualcosa che rappresenta il tuo dispositivo. **Per creare qualsiasi AWS IoT cosa** 1. Crea AWS IoT qualcosa per il tuo dispositivo. Sul tuo computer di sviluppo, esegui il seguente comando. + Sostituisci {{MyGreengrassCore}} con il nome dell'oggetto da usare. Questo nome è anche il nome del dispositivo principale Greengrass. **Nota** Il nome dell'oggetto non può contenere i due punti (`:`). ``` aws iot create-thing --thing-name {{MyGreengrassCore}} ``` La risposta è simile all'esempio seguente, se la richiesta ha esito positivo. ``` { "thingName": "MyGreengrassCore", "thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore", "thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42" } ``` 1. (Facoltativo) Aggiungere l' AWS IoT oggetto a un gruppo di oggetti nuovo o esistente. Utilizzi i gruppi di cose per gestire flotte di dispositivi core Greengrass. Quando distribuisci componenti software sui tuoi dispositivi, puoi scegliere come target singoli dispositivi o gruppi di dispositivi. È possibile aggiungere un dispositivo a un gruppo di cose con una distribuzione Greengrass attiva per distribuire i componenti software di quel gruppo di cose sul dispositivo. Esegui questa operazione: 1. (Facoltativo) Crea un gruppo di AWS IoT cose. + Sostituirlo {{MyGreengrassCoreGroup}} con il nome del gruppo di oggetti da creare. **Nota** Il nome del gruppo di cose non può contenere i due punti (`:`). ``` aws iot create-thing-group --thing-group-name {{MyGreengrassCoreGroup}} ``` La risposta è simile all'esempio seguente, se la richiesta ha esito positivo. ``` { "thingGroupName": "MyGreengrassCoreGroup", "thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup", "thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa" } ``` 1. Aggiungere l' AWS IoT oggetto a un gruppo di oggetti. + Sostituiscilo {{MyGreengrassCore}} con il nome del tuo AWS IoT oggetto. + Sostituisci {{MyGreengrassCoreGroup}} con il nome del gruppo di oggetti. ``` aws iot add-thing-to-thing-group --thing-name {{MyGreengrassCore}} --thing-group-name {{MyGreengrassCoreGroup}} ``` Il comando non produce alcun output se la richiesta ha esito positivo. ## Crea il certificato dell'oggetto Quando si registra un dispositivo come AWS IoT oggetto, quel dispositivo può utilizzare un certificato digitale con AWS cui autenticarsi. Questo certificato consente al dispositivo di comunicare con AWS IoT e AWS IoT Greengrass. In questa sezione, crei e scarichi certificati a cui il tuo dispositivo può connettersi AWS. **Per creare il certificato dell'oggetto** 1. Crea una cartella in cui scaricare i certificati relativi all' AWS IoT oggetto. ``` mkdir greengrass-v2-certs ``` 1. Crea e scarica i certificati relativi all' AWS IoT oggetto. ``` aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key ``` La risposta è simile all'esempio seguente, se la richiesta ha esito positivo. ``` { "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4", "certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4", "certificatePem": "-----BEGIN CERTIFICATE----- MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w 0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5 jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw 3rrszlaEXAMPLE= -----END CERTIFICATE-----", "keyPair": { "PublicKey": "-----BEGIN PUBLIC KEY-----\ MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\ MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\ 59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\ hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\ FQIDAQAB\ -----END PUBLIC KEY-----\ ", "PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\ key omitted for security reasons\ -----END RSA PRIVATE KEY-----\ " } } ``` Salva l'Amazon Resource Name (ARN) del certificato da utilizzare per configurare il certificato in un secondo momento. Quindi, configura il certificato del 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 core Greengrass utilizzano un ruolo di servizio IAM, chiamato *token exchange role*, per autorizzare le chiamate ai servizi. AWS Il dispositivo utilizza il provider di AWS IoT credenziali per ottenere AWS credenziali temporanee per questo ruolo, che consente al dispositivo di interagire AWS IoT, inviare log ad Amazon CloudWatch Logs e scaricare elementi dei componenti personalizzati da Amazon S3. Per ulteriori informazioni, consulta [Autorizza i dispositivi principali a interagire con i servizi AWS](device-service-role.md). Si utilizza un *alias di AWS IoT ruolo* per configurare il ruolo di scambio di token per i dispositivi principali Greengrass. Gli alias di ruolo consentono di modificare il ruolo di scambio di token per un dispositivo ma mantengono invariata la configurazione del dispositivo. Per ulteriori informazioni, consulta [Autorizzazione delle chiamate dirette ai AWS servizi nella Guida per](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html) gli *AWS IoT Core sviluppatori*. In questa sezione, crei un ruolo IAM per lo scambio di token e un alias di AWS IoT ruolo che rimanda al ruolo. Se hai già configurato un dispositivo principale Greengrass, puoi utilizzare il ruolo di scambio di token e l'alias del ruolo invece di crearne di nuovi. Quindi, configuri il dispositivo in modo che utilizzi quel ruolo e quell'alias. AWS IoT **Per creare un ruolo IAM per lo scambio di token** 1. Crea un ruolo IAM che il tuo dispositivo possa utilizzare come ruolo di scambio di token. Esegui questa operazione: 1. Crea un file che contenga il documento sulla politica di fiducia richiesto dal ruolo di scambio di token. Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file. ``` nano device-role-trust-policy.json ``` Copiate il seguente codice JSON nel file. ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "credentials.iot.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` 1. Crea il ruolo di scambio di token con il documento sulla politica di fiducia. + Sostituiscilo {{GreengrassV2TokenExchangeRole}} con il nome del ruolo IAM da creare. ``` aws iam create-role --role-name {{GreengrassV2TokenExchangeRole}} --assume-role-policy-document file://device-role-trust-policy.json ``` La risposta è simile all'esempio seguente, se la richiesta ha esito positivo. ``` { "Role": { "Path": "/", "RoleName": "GreengrassV2TokenExchangeRole", "RoleId": "AROAZ2YMUHYHK5OKM77FB", "Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole", "CreateDate": "2021-02-06T00:13:29+00:00", "AssumeRolePolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "credentials.iot.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } } ``` 1. Crea un file che contenga il documento sulla politica di accesso richiesto dal ruolo di scambio di token. Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file. ``` nano device-role-access-policy.json ``` Copiate il seguente codice JSON nel file. ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents", "logs:DescribeLogStreams", "s3:GetBucketLocation" ], "Resource": "*" } ] } ``` **Nota** Questa politica di accesso non consente l'accesso agli artefatti dei componenti nei bucket S3. Per distribuire componenti personalizzati che definiscono gli artefatti in Amazon S3, devi aggiungere autorizzazioni al ruolo per consentire al dispositivo principale di recuperare gli artefatti dei componenti. Per ulteriori informazioni, consulta [Consenti l'accesso ai bucket S3 per gli artefatti dei componenti](device-service-role.md#device-service-role-access-s3-bucket). Se non disponi ancora di un bucket S3 per gli artefatti dei componenti, puoi aggiungere queste autorizzazioni in un secondo momento dopo aver creato un bucket. 1. Crea la policy IAM dal documento di policy. + Sostituiscila {{GreengrassV2TokenExchangeRoleAccess}} con il nome della policy IAM da creare. ``` aws iam create-policy --policy-name {{GreengrassV2TokenExchangeRoleAccess}} --policy-document file://device-role-access-policy.json ``` La risposta è simile all'esempio seguente, se la richiesta ha esito positivo. ``` { "Policy": { "PolicyName": "GreengrassV2TokenExchangeRoleAccess", "PolicyId": "ANPAZ2YMUHYHACI7C5Z66", "Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess", "Path": "/", "DefaultVersionId": "v1", "AttachmentCount": 0, "PermissionsBoundaryUsageCount": 0, "IsAttachable": true, "CreateDate": "2021-02-06T00:37:17+00:00", "UpdateDate": "2021-02-06T00:37:17+00:00" } } ``` 1. Allega la policy IAM al ruolo di scambio di token. + Sostituisci {{GreengrassV2TokenExchangeRole}} con il nome del ruolo IAM. + Sostituisci l'ARN della policy con l'ARN della policy IAM che hai creato nel passaggio precedente. ``` aws iam attach-role-policy --role-name {{GreengrassV2TokenExchangeRole}} --policy-arn {{arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess}} ``` Il comando non ha alcun output se la richiesta ha esito positivo. 1. Crea un alias di AWS IoT ruolo che punti al ruolo di scambio di token. + Sostituiscilo {{GreengrassCoreTokenExchangeRoleAlias}} con il nome dell'alias del ruolo da creare. + Sostituisci il ruolo ARN con l'ARN del ruolo IAM creato nel passaggio precedente. ``` aws iot create-role-alias --role-alias {{GreengrassCoreTokenExchangeRoleAlias}} --role-arn {{arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole}} ``` La risposta è simile all'esempio seguente, se la richiesta ha esito positivo. ``` { "roleAlias": "GreengrassCoreTokenExchangeRoleAlias", "roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias" } ``` **Nota** Per creare un alias di ruolo, devi disporre dell'autorizzazione a passare il ruolo IAM per lo scambio di token a. AWS IoT Se ricevi un messaggio di errore quando tenti di creare un alias di ruolo, verifica che AWS l'utente disponga di questa autorizzazione. *Per ulteriori informazioni, consulta [Concessione a un utente delle autorizzazioni per il trasferimento di un ruolo a un AWS servizio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html) nella Guida per l'AWS Identity and Access Management utente.* 1. Crea e allega una AWS IoT policy che consenta al tuo dispositivo principale Greengrass di utilizzare l'alias del ruolo per assumere il ruolo di scambio di token. Se hai già configurato un dispositivo principale Greengrass, puoi allegare la sua AWS IoT politica di alias di ruolo invece di crearne uno nuovo. Esegui questa operazione: 1. (Facoltativo) Create un file che contenga il documento di AWS IoT policy richiesto dall'alias di ruolo. Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file. ``` nano greengrass-v2-iot-role-alias-policy.json ``` Copiate il seguente codice JSON nel file. + Sostituisci l'ARN della risorsa con l'ARN del tuo alias di ruolo. ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "iot:AssumeRoleWithCertificate", "Resource": "{{arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias}}" } ] } ``` 1. Crea una AWS IoT politica dal documento di policy. + Sostituisci {{GreengrassCoreTokenExchangeRoleAliasPolicy}} con il nome della AWS IoT politica da creare. ``` aws iot create-policy --policy-name {{GreengrassCoreTokenExchangeRoleAliasPolicy}} --policy-document file://greengrass-v2-iot-role-alias-policy.json ``` La risposta è simile all'esempio seguente, se la richiesta ha esito positivo. ``` { "policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy", "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy", "policyDocument": "{ \\"Version\\":\\"2012-10-17 \\", \\"Statement\\": [ { \\"Effect\\": \\"Allow\\", \\"Action\\": \\"iot:AssumeRoleWithCertificate\\", \\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\" } ] }", "policyVersionId": "1" } ``` 1. Allega la AWS IoT policy al certificato dell' AWS IoT oggetto. + Sostituisci {{GreengrassCoreTokenExchangeRoleAliasPolicy}} con il nome della AWS IoT politica relativa agli alias del ruolo. + Sostituisci l'ARN di destinazione con l'ARN del certificato per il tuo oggetto. AWS IoT ``` aws iot attach-policy --policy-name {{GreengrassCoreTokenExchangeRoleAliasPolicy}} --target {{arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4}} ``` Il comando non ha alcun output se la richiesta ha esito positivo. ## Scarica i certificati sul dispositivo In precedenza, avevi scaricato il certificato del dispositivo sul computer di sviluppo. In questa sezione, scarichi il certificato Amazon Root Certificate Authority (CA). Quindi, se prevedi di eseguire il software AWS IoT Greengrass Core in Docker su un computer diverso da quello di sviluppo, copi i certificati su quel computer host. Il software AWS IoT Greengrass Core utilizza questi certificati per connettersi al servizio AWS IoT cloud. **Per scaricare i certificati sul dispositivo** 1. Sul tuo computer di sviluppo, scarica il certificato Amazon Root Certificate Authority (CA). AWS IoT per impostazione predefinita, i certificati sono associati al certificato CA root di Amazon. ------ #### [ Linux or Unix ] ``` sudo curl -o ./greengrass-v2-certs/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem ``` ------ #### [ Windows Command Prompt (CMD) ] ``` curl -o .\greengrass-v2-certs\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem ``` ------ #### [ PowerShell ] ``` iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile .\greengrass-v2-certs\AmazonRootCA1.pem ``` ------ 1. Se prevedi di eseguire il software AWS IoT Greengrass Core in Docker su un dispositivo diverso dal computer di sviluppo, copia i certificati sul computer host. Se SSH e SCP sono abilitati sul computer di sviluppo e sul computer host, puoi usare il `scp` comando sul tuo computer di sviluppo per trasferire i certificati. {{device-ip-address}}Sostituiscilo con l'indirizzo IP del tuo computer host. ``` scp -r greengrass-v2-certs/ {{device-ip-address}}:~ ``` ## Crea un file di configurazione 1. Sul computer host, crea una cartella in cui inserire il file di configurazione. ``` mkdir ./greengrass-v2-config ``` 1. Utilizzate un editor di testo per creare un file di configurazione denominato `config.yaml` nella `./greengrass-v2-config` cartella. Ad esempio, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il`config.yaml`. ``` nano ./greengrass-v2-config/config.yaml ``` 1. Copiate il seguente contenuto YAML nel file. Questo file di configurazione parziale specifica i parametri di sistema e i parametri del nucleo di Greengrass. ``` --- system: certificateFilePath: "{{/tmp/certs}}/device.pem.crt" privateKeyPath: "{{/tmp/certs}}/private.pem.key" rootCaPath: "{{/tmp/certs}}/AmazonRootCA1.pem" rootpath: "{{/greengrass/v2}}" thingName: "{{MyGreengrassCore}}" services: aws.greengrass.Nucleus: componentType: "NUCLEUS" version: "{{nucleus-version}}" configuration: awsRegion: "{{region}}" iotRoleAlias: "{{GreengrassCoreTokenExchangeRoleAlias}}" iotDataEndpoint: "{{device-data-prefix}}-ats.iot.{{region}}.amazonaws.com" iotCredEndpoint: "{{device-credentials-prefix}}.credentials.{{region}}.amazonaws.com" ``` Quindi, sostituite i seguenti valori: + {{/tmp/certs}}. La directory nel contenitore Docker in cui vengono montati i certificati scaricati all'avvio del contenitore. + `{{/greengrass/v2}}`. La cartella principale di Greengrass che si desidera utilizzare per l'installazione. Utilizzate la variabile di `GGC_ROOT` ambiente per impostare questo valore. + {{MyGreengrassCore}}. Il nome della AWS IoT cosa. + {{nucleus-version}}. La versione del software AWS IoT Greengrass Core da installare. Questo valore deve corrispondere alla versione dell'immagine Docker o del Dockerfile che hai scaricato. Se hai scaricato l'immagine Greengrass Docker con il `latest` tag, usala ****docker inspect {{image-id}}**** per vedere la versione dell'immagine. + {{region}}. Il Regione AWS luogo in cui hai creato AWS IoT le tue risorse. È inoltre necessario specificare lo stesso valore per la variabile di `AWS_REGION` ambiente nel [file di ambiente](#create-env-file-manual-provisioning). + {{GreengrassCoreTokenExchangeRoleAlias}}. L'alias del ruolo di scambio di token. + {{device-data-prefix}}. Il prefisso per il tuo endpoint di AWS IoT dati. + {{device-credentials-prefix}}. Il prefisso per l'endpoint AWS IoT delle credenziali. ## Crea un file di ambiente Questo tutorial utilizza un file di ambiente per impostare le variabili di ambiente che verranno passate al programma di installazione del software AWS IoT Greengrass Core all'interno del contenitore Docker. Puoi anche usare [l'`--env`argomento `-e` or](https://docs.docker.com/engine/reference/commandline/run/#env) nel `docker run` comando per impostare le variabili di ambiente nel contenitore Docker oppure puoi impostare le variabili in [un `environment` blocco](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) del file. `docker-compose.yml` 1. Usa un editor di testo per creare un file di ambiente denominato`.env`. Ad esempio, su un sistema basato su Linux, puoi eseguire il seguente comando per usare GNU nano per crearlo `.env` nella directory corrente. ``` nano .env ``` 1. Copiate il seguente contenuto nel file. ``` GGC_ROOT_PATH={{/greengrass/v2}} AWS_REGION={{region}} PROVISION=false COMPONENT_DEFAULT_USER=ggc_user:ggc_group INIT_CONFIG={{/tmp/config/}}config.yaml ``` Quindi, sostituisci i seguenti valori. + `{{/greengrass/v2}}`. Il percorso della cartella principale da utilizzare per installare il software AWS IoT Greengrass Core. + {{region}}. Il Regione AWS luogo in cui hai creato AWS IoT le tue risorse. È necessario specificare lo stesso valore per il parametro `awsRegion` di configurazione nel [file di configurazione](#create-docker-install-configuration-file). + {{/tmp/config/}}. La cartella in cui monti il file di configurazione all'avvio del contenitore Docker. **Nota** È possibile impostare la variabile di `DEPLOY_DEV_TOOLS` ambiente su `true` per distribuire il componente [Greengrass CLI](greengrass-cli-component.md), che consente di sviluppare componenti personalizzati all'interno del contenitore Docker. Si consiglia di utilizzare questo componente solo in ambienti di sviluppo, non in ambienti di produzione. Questo componente fornisce l'accesso a informazioni e operazioni che in genere non sono necessarie in un ambiente di produzione. Segui il principio del privilegio minimo distribuendo questo componente solo sui dispositivi principali dove ne hai bisogno. ## Esegui il software AWS IoT Greengrass Core in un contenitore Questo tutorial mostra come avviare l'immagine Docker che hai creato in un contenitore Docker. Puoi utilizzare la CLI Docker o la CLI Docker Compose per AWS IoT Greengrass eseguire l'immagine del software Core in un contenitore Docker. ------ #### [ Docker ] + Questo tutorial mostra come avviare l'immagine Docker che hai creato in un contenitore Docker. ``` docker run --rm --init -it --name {{docker-image}} \ -v {{path/to/}}greengrass-v2-config:{{/tmp/config/}}:ro \ -v {{path/to/}}greengrass-v2-certs:{{/tmp/certs}}:ro \ --env-file .env \ -p 8883 \ {{your-container-image:version}} ``` Questo comando di esempio utilizza i seguenti argomenti per [docker run](https://docs.docker.com/engine/reference/commandline/run/): + [https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm). Pulisce il contenitore quando esce. + [https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process). Utilizza un processo di inizializzazione nel contenitore. **Nota** L'`--init`argomento è necessario per chiudere il software AWS IoT Greengrass Core quando si arresta il contenitore Docker. + [https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground). (Facoltativo) Esegue il contenitore Docker in primo piano come processo interattivo. Puoi sostituirlo con l'`-d`argomento per eseguire invece il contenitore Docker in modalità distaccata. Per ulteriori informazioni, consulta [Detached vs foreground](https://docs.docker.com/engine/reference/run/#detached-vs-foreground) nella documentazione Docker. + [https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name). Esegue un contenitore denominato `aws-iot-greengrass` + [https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/). Monta un volume nel contenitore Docker per rendere il file di configurazione e i file di certificato disponibili per l' AWS IoT Greengrass esecuzione all'interno del contenitore. + [https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env). (Facoltativo) Specifica il file di ambiente per impostare le variabili di ambiente che verranno passate al programma di installazione del software AWS IoT Greengrass Core all'interno del contenitore Docker. Questo argomento è richiesto solo se è stato creato un [file di ambiente per impostare le variabili](#create-env-file-manual-provisioning) di ambiente. Se non hai creato un file di ambiente, puoi utilizzare `--env` gli argomenti per impostare le variabili di ambiente direttamente nel comando Docker run. + [https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish). (Facoltativo) Pubblica la porta container 8883 sulla macchina host. Questo argomento è necessario se si desidera connettersi e comunicare tramite MQTT perché AWS IoT Greengrass utilizza la porta 8883 per il traffico MQTT. Per aprire altre porte, utilizzate argomenti aggiuntivi. `-p` **Nota** Per eseguire il contenitore Docker con maggiore sicurezza, puoi utilizzare gli `--cap-add` argomenti `--cap-drop` e per abilitare selettivamente le funzionalità Linux per il tuo contenitore. Per ulteriori informazioni, consulta [Privilegi di runtime e funzionalità Linux nella documentazione](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) Docker. ------ #### [ Docker Compose ] 1. Usa un editor di testo per creare un file Docker Compose denominato. `docker-compose.yml` Ad esempio, su un sistema basato su Linux, puoi eseguire il seguente comando per usare GNU nano per crearlo nella directory corrente. `docker-compose.yml` ``` nano docker-compose.yml ``` **Nota** È inoltre possibile scaricare e utilizzare la versione più recente del file Compose fornito AWS da. [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/) 1. Aggiungi il seguente contenuto al file Compose. Il file si presenta in maniera simile al seguente frammento: {{your-container-name:version}}Sostituiscilo con il nome della tua immagine Docker. ``` version: '3.7' services: greengrass: init: true build: context: . container_name: aws-iot-greengrass image: {{your-container-name:version}} volumes: - {{/path/to/}}greengrass-v2-config:{{/tmp/config/}}:ro - {{/path/to/}}greengrass-v2-certs:{{/tmp/certs}}:ro env_file: .env ports: - "8883:8883" ``` I seguenti parametri in questo file Compose di esempio sono facoltativi: + `ports`—Pubblica le porte del contenitore 8883 sul computer host. Questo parametro è necessario se si desidera connettersi e comunicare tramite MQTT perché AWS IoT Greengrass utilizza la porta 8883 per il traffico MQTT. + `env_file`: specifica il file di ambiente per impostare le variabili di ambiente che verranno passate al programma di installazione del software AWS IoT Greengrass Core all'interno del contenitore Docker. Questo parametro è richiesto solo se è stato creato un [file di ambiente per impostare le variabili di ambiente](#create-env-file-manual-provisioning). Se non avete creato un file di ambiente, potete utilizzare il parametro [environment](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) per impostare le variabili direttamente nel file Compose. **Nota** Per eseguire il contenitore Docker con maggiore sicurezza, puoi utilizzare `cap_drop` e `cap_add` nel tuo file Compose per abilitare selettivamente le funzionalità Linux per il tuo contenitore. Per ulteriori informazioni, consulta [Privilegi di runtime e funzionalità Linux](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) nella documentazione Docker. 1. Esegui il comando seguente per avviare il contenitore. ``` docker-compose -f docker-compose.yml up ``` ------ ## Fasi successive AWS IoT Greengrass Il software principale è ora in esecuzione in un contenitore Docker. Esegui il comando seguente per recuperare l'ID del contenitore attualmente in esecuzione. ``` docker ps ``` È quindi possibile eseguire il comando seguente per accedere al contenitore ed esplorare il software AWS IoT Greengrass Core in esecuzione all'interno del contenitore. ``` docker exec -it {{container-id}} /bin/bash ``` Per informazioni sulla creazione di un componente semplice, consulta [Fase 4: Sviluppa e testa un componente sul tuo dispositivo](create-first-component.md) in [Tutorial: Guida introduttiva a AWS IoT Greengrass V2](getting-started.md) **Nota** Quando esegui comandi all'interno del contenitore Docker, tali comandi non vengono registrati nei log Docker. `docker exec` Per registrare i comandi nei log Docker, collega una shell interattiva al contenitore Docker. Per ulteriori informazioni, consulta [Collega una shell interattiva al contenitore Docker](docker-troubleshooting.md#debugging-docker-attach-shell). Il file di registro AWS IoT Greengrass Core viene chiamato `greengrass.log` e si trova in. `{{/greengrass/v2}}/logs` Nella stessa directory si trovano anche i file di registro dei componenti. Per copiare i log di Greengrass in una directory temporanea sull'host, esegui il seguente comando: ``` docker cp {{container-id}}:/greengrass/v2/logs {{/tmp/logs}} ``` Se desideri mantenere i log dopo l'uscita o la rimozione di un contenitore, ti consigliamo di collegare solo la `{{/greengrass/v2}}/logs` directory alla directory dei log temporanei sull'host invece di montare l'intera directory Greengrass. Per ulteriori informazioni, consulta [Mantieni i log Greengrass all'esterno del contenitore Docker](docker-troubleshooting.md#debugging-docker-persist-logs). Per fermare un contenitore Docker in esecuzione, esegui o. AWS IoT Greengrass `docker stop` `docker-compose -f docker-compose.yml stop` Questa azione invia `SIGTERM` al processo Greengrass e chiude tutti i processi associati che sono stati avviati nel contenitore. Il contenitore Docker viene inizializzato con l'`docker-init`eseguibile come processo PID 1, il che aiuta a rimuovere eventuali processi zombie rimanenti. Per ulteriori informazioni, consulta [Specificare un processo di inizializzazione nella documentazione di Docker](https://docs.docker.com/engine/reference/run/#specify-an-init-process). Per informazioni sulla risoluzione dei problemi relativi all'esecuzione AWS IoT Greengrass in un contenitore Docker, consulta. [Risoluzione dei problemi AWS IoT Greengrass in un contenitore Docker](docker-troubleshooting.md)