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à.
# Distribuisci applicazioni containerizzate in AWS IoT Greengrass V2 esecuzione come contenitore Docker
*Salih Bakir, Giuseppe Di Bella e Gustav Svalander, Amazon Web Services*
## Riepilogo
AWS IoT Greengrass Version 2, se distribuito come contenitore Docker, non supporta nativamente l'esecuzione di contenitori di applicazioni Docker. Questo modello mostra come creare un'immagine del contenitore personalizzata basata sull'ultima versione AWS IoT Greengrass V2 che abilita la funzionalità Docker-in-Docker (DiND). Con DiND, puoi eseguire applicazioni containerizzate all'interno dell'ambiente. AWS IoT Greengrass V2
Puoi implementare questo modello come soluzione autonoma o integrarlo con piattaforme di orchestrazione dei container come Amazon ECS Anywhere. In entrambi i modelli di implementazione, mantieni la piena AWS IoT Greengrass V2 funzionalità, comprese le funzionalità di elaborazione AWS IoT SiteWise Edge, abilitando al contempo implementazioni scalabili basate su contenitori.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo. Account AWS
+ Per i AWS IoT Greengrass Version 2 prerequisiti generali, vedere [Prerequisiti](https://docs.aws.amazon.com/greengrass/v2/developerguide/getting-started-prerequisites.html) nella AWS IoT Greengrass Version 2 documentazione.
+ Docker Engine, installato e configurato su Linux, macOS o Windows.
+ Docker Compose (se utilizzi l'interfaccia a riga di comando (CLI) di Docker Compose per eseguire immagini Docker).
+ Un sistema operativo Linux.
+ Un hypervisor con un server host che supporta la virtualizzazione.
+ Requisiti di sistema:
+ 2 GB di RAM (minimo)
+ 5 GB di spazio disponibile su disco (minimo)
+ Per AWS IoT SiteWise Edge, una CPU quad-core x86\_64 con 16 GB di RAM e 50 GB di spazio disponibile su disco. Per ulteriori informazioni sull'elaborazione AWS IoT SiteWise dei dati, consulta Requisiti del [pacchetto di elaborazione dati](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/configure-gateway-ggv2.html#w2aac17c19c13b7) nella documentazione. AWS IoT SiteWise
**Versioni del prodotto**
+ AWS IoT Greengrass Version 2 versione 2.5.3 o successiva
+ Docker-in-Docker versione 1.0.0 o successiva
+ Docker Compose versione 1.22 o successiva
+ Docker Engine versione 20.10.12 o successiva
**Limitazioni**
+ Alcuni Servizi AWS non sono disponibili in tutti. Regioni AWS Per la disponibilità regionale, vedi [AWS Servizi per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio.
## Architecture
**Stack tecnologico Target**
+ **Fonti di dati**: dispositivi IoT, sensori o apparecchiature industriali che generano dati per l'elaborazione
+ **AWS IoT Greengrass V2**— Funzionamento come contenitore Docker con D-in-D funzionalità, distribuito su infrastrutture periferiche
+ Applicazioni **containerizzate: applicazioni** personalizzate eseguite all'interno dell'ambiente come contenitori Docker annidati AWS IoT Greengrass V2
+ **(Facoltativo) Amazon ECS** Anywhere: orchestrazione dei container che gestisce la distribuzione dei container AWS IoT Greengrass V2
+ **Altro Servizi AWS** — AWS IoT Core e altro Servizi AWS per AWS IoT SiteWise l'elaborazione e la gestione dei dati
**Architettura Target**
Il diagramma seguente mostra un esempio di architettura di distribuzione di destinazione che utilizza Amazon ECS Anywhere, uno strumento di gestione dei container.
Il diagramma mostra il flusso di lavoro seguente:
**1: Archiviazione delle immagini dei container:** Amazon ECR archivia le immagini dei AWS IoT Greengrass container e tutti i contenitori di applicazioni personalizzati necessari per l'elaborazione edge.
**2** e **3: Implementazione dei container:** Amazon ECS Anywhere distribuisce AWS IoT Greengrass l'immagine del contenitore da Amazon ECR all'edge location, gestendo il ciclo di vita del contenitore e il processo di distribuzione.
**4: Distribuzione dei componenti:** il AWS IoT Greengrass core distribuito distribuisce automaticamente i componenti pertinenti in base alla configurazione. I componenti includono AWS IoT SiteWise Edge e altri componenti necessari per l'elaborazione dei bordi all'interno dell'ambiente containerizzato.
**5: Inserimento dei dati:** dopo la configurazione completa, AWS IoT Greengrass inizia a importare dati di telemetria e sensori da varie fonti di dati IoT presso l'edge location.
**6: Elaborazione dei dati e integrazione nel cloud**: il AWS IoT Greengrass core containerizzato elabora i dati localmente utilizzando i componenti implementati (incluso Edge per i dati industriali). AWS IoT SiteWise Quindi, invia i dati elaborati ai Cloud AWS servizi per ulteriori analisi e archiviazione.
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch-type-external.html) Anywhere ti aiuta a distribuire, utilizzare e gestire attività e servizi Amazon ECS sulla tua infrastruttura.
+ [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) fornisce capacità di calcolo scalabile nel Cloud AWS. Puoi avviare tutti i server virtuali di cui hai bisogno e dimensionarli rapidamente.
+ [Amazon Elastic Container Registry (Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)) è un servizio di registro di immagini di container gestito sicuro, scalabile e affidabile.
+ [AWS IoT Greengrass](https://docs.aws.amazon.com/greengrass/v2/developerguide/what-is-iot-greengrass.html)è un servizio cloud e runtime edge open source per l'Internet of Things (IoT) che ti aiuta a creare, implementare e gestire applicazioni IoT sui tuoi dispositivi.
+ [AWS IoT SiteWise](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html)ti aiuta a raccogliere, modellare, analizzare e visualizzare i dati delle apparecchiature industriali su larga scala.
**Altri strumenti**
+ [Docker](https://www.docker.com/) è un insieme di prodotti Platform as a Service (PaaS) che utilizzano la virtualizzazione a livello di sistema operativo per fornire software in container.
+ [Docker Compose è uno strumento per definire ed eseguire](https://docs.docker.com/compose/) applicazioni multi-contenitore.
+ [Docker Engine](https://docs.docker.com/engine/) è una tecnologia di containerizzazione open source per la creazione e la containerizzazione di applicazioni.
**Archivio di codice**
Il codice per questo pattern è disponibile nel repository GitHub [AWS IoT Greengrass v2 Docker-in-Docker](https://github.com/aws-samples/aws-iot-greengrass-docker-in-docker).
## Epiche
### Costruisci l'immagine AWS IoT Greengrass V2 Docker-in-Docker
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clona e accedi al repository. | Per clonare il repository, usa il seguente comando:
`git clone https://github.com/aws-samples/aws-iot-greengrass-docker-in-docker.git`
Per accedere alla `docker` directory, utilizzate il seguente comando:
`cd aws-iot-greengrass-docker-in-docker/docker` | DevOps ingegnere, AWS DevOps |
| Creazione dell'immagine Docker. | Per creare l'immagine Docker con la versione predefinita (più recente), esegui il seguente comando:
`docker build -t x86_64/aws-iot-greengrass:latest .`
Oppure, per creare l'immagine Docker con una versione specifica, esegui il seguente comando:
`docker build --build-arg GREENGRASS_RELEASE_VERSION=2.12.0 -t x86_64/aws-iot-greengrass:2.12.0 .`
Per verificare la build, esegui il comando seguente:
`docker images \| grep aws-iot-greengrass`
| AWS DevOps, DevOps ingegnere, sviluppatore di app |
| (Facoltativo) Invia ad Amazon ECR. | 1. Per creare il repository, esegui il seguente comando:
`aws ecr create-repository --repository-name aws-iot-greengrass-dind --region us-east-1`
2. Per autenticarti, esegui il seguente comando:
`aws ecr get-login-password --region us-east-1 \| docker login --username AWS --password-stdin .dkr.ecr.us-east-1.amazonaws.com`
3. Per taggare e inviare push, esegui i seguenti comandi:
`docker tag x86_64/aws-iot-greengrass:latest .dkr.ecr.us-east-1.amazonaws.com/aws-iot-greengrass-dind:latest`
`docker push .dkr.ecr.us-east-1.amazonaws.com/aws-iot-greengrass-dind:latest` | Sviluppatore di app, AWS DevOps, DevOps ingegnere |
### Configura le AWS credenziali
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Seleziona il metodo di autenticazione. | Scegli una delle seguenti opzioni:+ **Opzione 1 (consigliata)**: ruoli IAM: da utilizzare se in esecuzione su Amazon EC2, Amazon ECS o Amazon EKS con ruoli IAM appropriati. Non è necessaria alcuna configurazione aggiuntiva.
+ **Opzione 2**: variabili di ambiente: per test e sviluppo.
+ **Opzione 3**: file di credenziali: non consigliato per la produzione.
+ **Opzione 4**: `env.cfg` file legacy. | Amministratore AWS |
| Configura il metodo di autenticazione. | Per il metodo di autenticazione selezionato, utilizza la seguente guida alla configurazione:+ **Opzione 2 (variabili di ambiente)**: preparazione `AWS_ACCESS_KEY_ID` e facoltativamente`AWS_SESSION_TOKEN`. `AWS_SECRET_ACCESS_KEY`
+ **Opzione 3 (file delle credenziali)**: crea la directory e il file delle credenziali:(a) Eseguite il seguente comando:
`mkdir -p ~/greengrass-v2-credentials`(b) Crea il seguente file su`~/greengrass-v2-credentials/credentials`:
`[default]`
`aws_access_key_id=YourAccessKey`
`aws_secret_access_key=YourSecretKey`(c) Proteggi il file come segue:
`chmod 600 ~/greengrass-v2-credentials/credentials`
+ **Opzione 4 (`env.cfg`****)** — Crea il `env.cfg` file nella `docker` directory come segue:
`GGC_ROOT_PATH=/greengrass/v2`
`AWS_REGION=us-east-1`
`PROVISION=true`
`THING_NAME=MyGreengrassCore`
`THING_GROUP_NAME=MyGreengrassCoreGroup`
`TES_ROLE_NAME=GreengrassV2TokenExchangeRole`
`TES_ROLE_ALIAS_NAME=GreengrassCoreTokenExchangeRoleAlias`
`COMPONENT_DEFAULT_USER=ggc_user:ggc_group` | Amministratore AWS |
### Esegui con Docker Compose
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Configurare `docker-compose.yml`. | Aggiorna il `docker-compose.yml` file con le variabili di ambiente come segue:+ Variabili chiave: `PROVISION,` `AWS_REGION``THING_NAME`,`THING_GROUP_NAME`,`TES_ROLE_NAME`, `TES_ROLE_ALIAS_NAME`
+ Per le credenziali tramite variabili di ambiente, decommenta quanto segue:
`environment:`
` - AWS_ACCESS_KEY_ID=YourKey`
` - AWS_SECRET_ACCESS_KEY=YourSecret`+ Per il file delle credenziali, decommenta quanto segue:
`volumes:`
` - ~/greengrass-v2-credentials:/root/.aws/:ro`+ Per la persistenza dei log, aggiungete quanto segue:
`volumes:`
` - ./logs:/greengrass/v2/logs` | DevOps ingegnere |
| Avvia e verifica il contenitore. | Per iniziare in primo piano, esegui il seguente comando:
`docker-compose up --build`
Oppure, per iniziare in background, esegui il seguente comando:
`docker-compose up --build -d`
Per verificare lo stato, esegui il comando seguente:
`docker-compose ps`
Per monitorare i log, esegui il comando seguente:
`docker-compose logs -f` | DevOps ingegnere |
### Esegui con Docker CLI
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Esegui il contenitore con la CLI Docker. | + Per avviare un'esecuzione di base senza provisioning, esegui il comando seguente:
`docker run --init --privileged -it --name aws-iot-greengrass x86_64/aws-iot-greengrass:latest`+ Per avviare un'esecuzione con variabili di ambiente, esegui il comando seguente:
`docker run --init --privileged -it --name aws-iot-greengrass -e PROVISION=true -e AWS_REGION=us-east-1 -e AWS_ACCESS_KEY_ID=YourKey -e AWS_SECRET_ACCESS_KEY=YourSecret -e THING_NAME=MyGreengrassCore -e THING_GROUP_NAME=MyGreengrassCoreGroup -p 8883:8883 x86_64/aws-iot-greengrass:latest`+ Per avviare un'esecuzione con un file di credenziali, esegui il comando seguente:
`docker run --init --privileged -it --name aws-iot-greengrass -v ~/greengrass-v2-credentials:/root/.aws:ro -e PROVISION=true -e AWS_REGION=us-east-1 -e THING_NAME=MyGreengrassCore -p 8883:8883 x86_64/aws-iot-greengrass:latest`+ Per avviare un'esecuzione con un `env.cfg` file, esegui il comando seguente:
`docker run --init --privileged -it --name aws-iot-greengrass -v ~/greengrass-v2-credentials:/root/.aws:ro --env-file env.cfg -p 8883:8883 x86_64/aws-iot-greengrass:latest`+ Per avviare un'esecuzione con log persistenti, esegui il comando seguente:
`docker run --init --privileged -it --name aws-iot-greengrass -v \$(pwd)/logs:/greengrass/v2/logs x86_64/aws-iot-greengrass:latest` | DevOps ingegnere |
| Verifica il contenitore. | + Per verificare lo stato del contenitore, esegui il seguente comando:
`docker ps \| grep aws-iot-greengrass`+ Per monitorare i log, esegui il seguente comando:
`docker logs -f aws-iot-greengrass` | DevOps ingegnere |
### Gestisci applicazioni containerizzate
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Distribuisci applicazioni. | + Per distribuire il contenitore dell'applicazione, esegui il comando seguente:
`docker run -d --name my-app nginx:alpine`+ Per verificare la distribuzione, esegui il comando seguente:
`docker ps`+ Per accedere ai log, esegui il comando seguente:
`cd /greengrass/v2/logs && cat greengrass.log` | Sviluppatore di app |
| Accesso e test Docker-in-Docker. | 1. Per aprire una shell nel contenitore, esegui il seguente comando:
`docker exec -it aws-iot-greengrass sh`
2. Per verificare Docker, esegui i seguenti comandi:
`docker --version`
`docker ps`
3. Per eseguire il test Docker-in-Docker, esegui il comando seguente:
`docker run --rm hello-world` | DevOps ingegnere |
### (Opzionale) Integrazione con Amazon ECS Anywhere
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Configura il cluster Amazon ECS. | + Per creare un cluster Amazon ECS, esegui il seguente comando:
`aws ecs create-cluster --cluster-name greengrass-cluster --region us-east-1`+ Per creare l'attivazione SSM, esegui il seguente comando:
`aws ssm create-activation --default-instance-name greengrass-edge --iam-role GreengrassECSAnywhereRole --registration-limit 10 --region us-east-1`+ Per installare SSM Agent su un dispositivo edge, esegui il seguente comando:
`curl -o install.sh https://s3.amazonaws.com/aws-ssm-downloads/latest/linux_amd64/install.sh`
`chmod +x install.sh`
`./install.sh activation-code activation-id us-east-1` | Amministratore AWS |
| Implementa attività Amazon ECS. | + Crea `greengrass-task-definition.json` con una configurazione delle attività che include `containerDefinitions` with`privileged:true`, variabili di ambiente e montaggi di volume per `/var/lib/docker` ogni attività. `/greengrass/v2.Register` Esegui il comando seguente:
`aws ecs register-task-definition --cli-input-json file://greengrass-task-definition.json`+ Per creare il servizio, esegui il comando seguente:
`aws ecs create-service --cluster greengrass-cluster --service-name greengrass-service --task-definition greengrass-dind --desired-count 1 --launch-type EXTERNAL --region us-east-1`+ Per verificare la distribuzione, esegui il comando seguente:
`aws ecs describe-services --cluster greengrass-cluster --services greengrass-service --region us-east-1` | Amministratore AWS |
### Interrompi e pulisci
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Fermare il contenitore. | + Per fermare il contenitore utilizzando Docker Compose, esegui i seguenti comandi:
`docker-compose stop`
`docker-compose down`
`docker-compose down -v`+ Per arrestare il contenitore (rimuove i volumi) utilizzando la CLI Docker, esegui i seguenti comandi:
`docker stop aws-iot-greengrass`
`docker rm aws-iot-greengrass`+ Per fermare il contenitore usando force remove, esegui il seguente comando:
`docker rm -f aws-iot-greengrass` | DevOps ingegnere |
## Risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| Il contenitore non si avvia con errori di autorizzazione. | 1. Per assicurarti che il contenitore funzioni con il `--privileged` flag richiesto per Docker-in-Docker, esegui il comando seguente:
`docker run --init --privileged -it --name aws-iot-greengrass x86_64/aws-iot-greengrass:latest`
2. Nel `docker-compose.yml` file, imposta quanto segue:
`privileged: true``--privileged`concede privilegi estesi al contenitore. |
| Il provisioning fallisce a causa di errori nelle credenziali. | Per verificare che le credenziali siano configurate correttamente, attenersi alla seguente procedura:1. Controlla il ruolo IAM:
`aws sts get-caller-identity`
2. Verifica le variabili di ambiente:
`docker exec -it aws-iot-greengrass sh -c 'echo \$AWS_ACCESS_KEY_ID'`
3. Controlla il file delle credenziali:
`docker exec -it aws-iot-greengrass sh -c 'cat /root/.aws/credentials'`
Assicurati che le autorizzazioni IAM includano`iot:CreateThing`,`iot:CreatePolicy`, `iot:AttachPolicy``iam:CreateRole`, e. `iam:AttachRolePolicy` |
| Impossibile connettersi al demone Docker all'interno del contenitore. | 1. Controlla lo stato del demone Docker:
`docker exec -it aws-iot-greengrass sh -c 'ps aux \| grep dockerd'`
2. Verifica che il socket Docker esista:
`docker exec -it aws-iot-greengrass sh -c 'ls -la /var/run/docker.sock'`
3. Avvia manualmente se necessario:
`docker exec -it aws-iot-greengrass sh -c 'dockerd > /var/log/docker.log 2>&1 &'` |
| Il contenitore esaurisce lo spazio su disco. | 1. Controlla lo spazio su disco:
`df -h`
2. Pulisci le risorse Docker:
`docker system prune -a --volumes`
3. Rimuovi i vecchi artefatti Greengrass:
`docker exec -it aws-iot-greengrass sh -c 'rm -rf /greengrass/v2/work/*`'Garantire uno spazio minimo su disco: 5 GB per le operazioni di base e 50 GB per Edge AWS IoT SiteWise |
| Crea problemi. | 1. Assicurati di essere nella `docker` directory:
`cd docker && pwd`
2. Verifica che `Dockerfile` esista:
`ls -la Dockerfile`
3. Verifica che Docker sia installato e funzionante:
`docker --version && docker ps` |
| Problemi di connettività di rete. | 1. Verifica la risoluzione DNS:
`docker exec -it aws-iot-greengrass sh -c 'nslookup google.com'`
2. Test di AWS connettività:
`docker exec -it aws-iot-greengrass sh -c 'curl https://iot.us-east-1.amazonaws.com'`Verificate che il firewall consenta il traffico HTTPS (443) e MQTT (8883) in uscita. |
| I componenti Greengrass non vengono distribuiti. | 1. Controlla i registri di Greengrass:
`docker exec -it aws-iot-greengrass sh -c 'cat /greengrass/v2/logs/greengrass.log'`
2. Verifica la configurazione del ruolo TES:
`aws iot describe-role-alias --role-alias TES_ROLE_ALIAS_NAME`Controlla i log specifici dei componenti nella directory. `/greengrass/v2/logs/` |
| Il contenitore esce immediatamente dopo l'avvio. | 1. Verifica la presenza di errori nei log del contenitore:
`docker logs aws-iot-greengrass`
2. Esegui con una shell interattiva per il debug:
`docker run --init --privileged -it --entrypoint sh x86_64/aws-iot-greengrass:latest`Verifica che tutte le variabili di ambiente richieste siano impostate correttamente se. `PROVISION=true` Assicurati che il `--init` flag sia usato all'avvio del contenitore. |
## Risorse correlate
**AWS resources**
+ [Amazon Elastic Container Service](https://aws.amazon.com/ecs/)
+ [Configura l'elaborazione dei dati edge per AWS IoT SiteWise modelli e asset](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/edge-processing.html)
+ [Che cos'è AWS IoT Greengrass](https://docs.aws.amazon.com/greengrass/v2/developerguide/what-is-iot-greengrass.html)
**Altre risorse**
+ [Documentazione Docker](https://docs.docker.com/)
## Informazioni aggiuntive
+ Per l'elaborazione dei dati AWS IoT SiteWise Edge, Docker deve essere disponibile all'interno dell' AWS IoT Greengrass ambiente.
+ Per eseguire un contenitore annidato, è necessario eseguire il AWS IoT Greengrass contenitore con credenziali di amministratore.