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 un contenitore Docker
Puoi configurare AWS IoT Greengrass i componenti per eseguire un contenitore [Docker](https://www.docker.com/) da immagini archiviate nelle seguenti posizioni:
+ Archivi di immagini pubblici e privati in Amazon Elastic Container Registry (Amazon ECR)
+ Archivio pubblico di Docker Hub
+ Registro pubblico affidabile di Docker
+ Bucket S3
Nel componente personalizzato, includi l'URI dell'immagine Docker come artefatto per recuperare l'immagine ed eseguirla sul dispositivo principale. Per le immagini di Amazon ECR e Docker Hub, puoi utilizzare il componente [Docker Application Manager](docker-application-manager-component.md) per scaricare le immagini e gestire le credenziali per i repository Amazon ECR privati.
**Topics**
+ [Requisiti](#run-docker-container-requirements)
+ [Esegui un contenitore Docker da un'immagine pubblica in Amazon ECR o Docker Hub](#run-docker-container-public-ecr-dockerhub)
+ [Esegui un contenitore Docker da un'immagine privata in Amazon ECR](#run-docker-container-private-ecr)
+ [Esegui un contenitore Docker da un'immagine in Amazon S3](#run-docker-container-s3)
+ [Usa la comunicazione tra processi nei componenti del contenitore Docker](#docker-container-ipc)
+ [Usa AWS le credenziali nei componenti del contenitore Docker (Linux)](#docker-container-token-exchange-service)
+ [Usa lo stream manager nei componenti del contenitore Docker (Linux)](#docker-container-stream-manager)
## Requisiti
Per eseguire un contenitore Docker in un componente, è necessario quanto segue:
+ Un dispositivo principale Greengrass. Se non lo hai, consultare [Tutorial: Guida introduttiva a AWS IoT Greengrass V2](getting-started.md).
+ [Docker Engine](https://docs.docker.com/engine/) 1.9.1 o versione successiva installato sul dispositivo principale Greengrass. La versione 20.10 è l'ultima versione verificata per funzionare con il software Core. AWS IoT Greengrass È necessario installare Docker direttamente sul dispositivo principale prima di distribuire componenti che eseguono contenitori Docker.
**Suggerimento**
Puoi anche configurare il dispositivo principale per installare Docker Engine quando il componente viene installato. Ad esempio, lo script di installazione seguente installa Docker Engine prima di caricare l'immagine Docker. Questo script di installazione funziona su distribuzioni Linux basate su Debian, come Ubuntu. Se si configura il componente per installare Docker Engine con questo comando, potrebbe essere necessario impostarlo `true` nello script del ciclo di vita `RequiresPrivilege` per eseguire l'installazione e i comandi. `docker` Per ulteriori informazioni, consulta [AWS IoT Greengrass riferimento alla ricetta del componente](component-recipe-reference.md).
```
apt-get install docker-ce docker-ce-cli containerd.io && docker load -i {artifacts:path}/hello-world.tar
```
+ L'utente di sistema che esegue un componente del contenitore Docker deve disporre delle autorizzazioni di root o amministratore oppure è necessario configurare Docker per eseguirlo come utente non root o non amministratore.
+ Sui dispositivi Linux, puoi aggiungere un utente al gruppo senza il quale chiamare i comandi. `docker` `docker` `sudo`
+ Nei dispositivi Windows, è possibile aggiungere un utente al `docker-users` gruppo per richiamare `docker` comandi senza privilegi di amministratore.
------
#### [ Linux or Unix ]
Per aggiungere `ggc_user` al `docker` gruppo l'utente non root che usi per eseguire i componenti del contenitore Docker, esegui il comando seguente.
```
sudo usermod -aG docker ggc_user
```
Per ulteriori informazioni, consulta [Gestire Docker come](https://docs.docker.com/engine/install/linux-postinstall/#manage-docker-as-a-non-root-user) utente non root.
------
#### [ Windows Command Prompt (CMD) ]
Per aggiungere al `docker-users` gruppo`ggc_user`, o l'utente che usi per eseguire i componenti del contenitore Docker, esegui il comando seguente come amministratore.
```
net localgroup docker-users ggc_user /add
```
------
#### [ Windows PowerShell ]
Per aggiungere al `docker-users` gruppo`ggc_user`, o l'utente che usi per eseguire i componenti del contenitore Docker, esegui il comando seguente come amministratore.
```
Add-LocalGroupMember -Group docker-users -Member ggc_user
```
------
+ File a cui accede il componente del contenitore Docker [montato come volume](https://docs.docker.com/storage/volumes/) nel contenitore Docker.
+ Se [configuri il software AWS IoT Greengrass Core per utilizzare un proxy di rete](configure-greengrass-core-v2.md#configure-alpn-network-proxy), devi [configurare Docker per utilizzare lo stesso](https://docs.docker.com/network/proxy/) server proxy.
Oltre a questi requisiti, è necessario soddisfare anche i seguenti requisiti, se applicabili al proprio ambiente:
+ Per utilizzare [Docker Compose](https://docs.docker.com/compose/) per creare e avviare i tuoi contenitori Docker, installa Docker Compose sul tuo dispositivo principale Greengrass e carica il file Docker Compose in un bucket S3. È necessario archiviare il file Compose in un bucket S3 nello stesso ambiente del componente. Account AWS Regione AWS Per un esempio che utilizza il `docker-compose up` comando in un componente personalizzato, vedi. [Esegui un contenitore Docker da un'immagine pubblica in Amazon ECR o Docker Hub](#run-docker-container-public-ecr-dockerhub)
+ [Se utilizzi un AWS IoT Greengrass proxy di rete, configura il demone Docker per utilizzare un server proxy.](https://docs.docker.com/network/proxy/)
+ Se le tue immagini Docker sono archiviate in Amazon ECR o Docker Hub, includi il componente [Docker component manager](docker-application-manager-component.md) come dipendenza nel tuo componente contenitore Docker. È necessario avviare il demone Docker sul dispositivo principale prima di distribuire il componente.
Inoltre, includi l'immagine come artefatti del componente URIs . L'immagine URIs deve essere nel formato `docker:registry/image[:tag|@digest]` illustrato negli esempi seguenti:
+ Immagine Amazon ECR privata: `docker:account-id.dkr.ecr.region.amazonaws.com/repository/image[:tag|@digest]`
+ Immagine pubblica di Amazon ECR: `docker:public.ecr.aws/repository/image[:tag|@digest]`
+ Immagine pubblica di Docker Hub: `docker:name[:tag|@digest]`
Per ulteriori informazioni sull'esecuzione di contenitori Docker da immagini archiviate in archivi pubblici, consulta. [Esegui un contenitore Docker da un'immagine pubblica in Amazon ECR o Docker Hub](#run-docker-container-public-ecr-dockerhub)
+ Se le tue immagini Docker sono archiviate in un repository privato Amazon ECR, devi includere il componente del servizio di scambio di token come dipendenza nel componente contenitore Docker. Inoltre, il [ruolo del dispositivo Greengrass](device-service-role.md) deve consentire le `ecr:GetDownloadUrlForLayer` azioni`ecr:GetAuthorizationToken`, e`ecr:BatchGetImage`, come mostrato nell'esempio seguente di politica IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ecr:GetAuthorizationToken",
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": [
"*"
],
"Effect": "Allow"
}
]
}
```
------
Per informazioni sull'esecuzione di contenitori Docker da immagini archiviate in un repository privato Amazon ECR, consulta. [Esegui un contenitore Docker da un'immagine privata in Amazon ECR](#run-docker-container-private-ecr)
+ Per utilizzare le immagini Docker archiviate in un repository privato Amazon ECR, l'archivio privato deve trovarsi nello Regione AWS stesso dispositivo principale.
+ Se le immagini Docker o i file Compose sono archiviati in un bucket S3, il [ruolo del dispositivo Greengrass](device-service-role.md) deve consentire l'`s3:GetObject`autorizzazione per consentire ai dispositivi principali di scaricare le immagini come artefatti componenti, come mostrato nel seguente esempio di politica IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject"
],
"Resource": [
"*"
],
"Effect": "Allow"
}
]
}
```
------
Per informazioni sull'esecuzione di contenitori Docker da immagini archiviate in Amazon S3, consulta. [Esegui un contenitore Docker da un'immagine in Amazon S3](#run-docker-container-s3)
+ Per utilizzare la comunicazione tra processi (IPC), AWS le credenziali o lo stream manager nel componente del contenitore Docker, devi specificare opzioni aggiuntive quando esegui il contenitore Docker. Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Usa la comunicazione tra processi nei componenti del contenitore Docker](#docker-container-ipc)
+ [Usa AWS le credenziali nei componenti del contenitore Docker (Linux)](#docker-container-token-exchange-service)
+ [Usa lo stream manager nei componenti del contenitore Docker (Linux)](#docker-container-stream-manager)
## Esegui un contenitore Docker da un'immagine pubblica in Amazon ECR o Docker Hub
Questa sezione descrive come creare un componente personalizzato che utilizza Docker Compose per eseguire un contenitore Docker da immagini Docker archiviate in Amazon ECR e Docker Hub.
**Per eseguire un contenitore Docker utilizzando Docker Compose**
1. Crea e carica un file Docker Compose in un bucket Amazon S3. Assicurati che il [ruolo del dispositivo Greengrass](device-service-role.md) consenta l'`s3:GetObject`autorizzazione per consentire al dispositivo di accedere al file Compose. Il file Compose di esempio mostrato nell'esempio seguente include l'immagine Amazon CloudWatch Agent di Amazon ECR e l'immagine MySQL di Docker Hub.
```
version: "3"
services:
cloudwatchagent:
image: "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
mysql:
image: "mysql:8.0"
```
1. [Crea un componente personalizzato](create-components.md) sul tuo dispositivo principale. AWS IoT Greengrass La ricetta di esempio mostrata nell'esempio seguente ha le seguenti proprietà:
+ Il componente Docker Application Manager come dipendenza. Questo componente consente di AWS IoT Greengrass scaricare immagini dai repository pubblici di Amazon ECR e Docker Hub.
+ Un elemento componente che specifica un'immagine Docker in un repository Amazon ECR pubblico.
+ Un elemento componente che specifica un'immagine Docker in un repository pubblico di Docker Hub.
+ Un elemento componente che specifica il file Docker Compose che include i contenitori per le immagini Docker che si desidera eseguire.
+ Uno script di esecuzione del ciclo di vita che utilizza [docker-compose up](https://docs.docker.com/compose/reference/up/) per creare e avviare un contenitore dalle immagini specificate.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyDockerComposeComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.DockerApplicationManager": {
"VersionRequirement": "~2.0.0"
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Lifecycle": {
"Run": "docker-compose -f {artifacts:path}/docker-compose.yaml up"
},
"Artifacts": [
{
"URI": "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
},
{
"URI": "docker:mysql:8.0"
},
{
"URI": "s3://amzn-s3-demo-bucket/folder/docker-compose.yaml"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyDockerComposeComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.'
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.DockerApplicationManager:
VersionRequirement: ~2.0.0
Manifests:
- Platform:
os: all
Lifecycle:
Run: docker-compose -f {artifacts:path}/docker-compose.yaml up
Artifacts:
- URI: "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
- URI: "docker:mysql:8.0"
- URI: "s3://amzn-s3-demo-bucket/folder/docker-compose.yaml"
```
------
**Nota**
Per utilizzare la comunicazione tra processi (IPC), AWS le credenziali o lo stream manager nel componente del contenitore Docker, devi specificare opzioni aggiuntive quando esegui il contenitore Docker. Per ulteriori informazioni, consulta gli argomenti seguenti:
[Usa la comunicazione tra processi nei componenti del contenitore Docker](#docker-container-ipc)
[Usa AWS le credenziali nei componenti del contenitore Docker (Linux)](#docker-container-token-exchange-service)
[Usa lo stream manager nei componenti del contenitore Docker (Linux)](#docker-container-stream-manager)
1. [Testa il componente](test-components.md) per verificare che funzioni come previsto.
**Importante**
È necessario installare e avviare il demone Docker prima di distribuire il componente.
Dopo aver distribuito il componente localmente, puoi eseguire il comando [docker container](https://docs.docker.com/engine/reference/commandline/container_ls/) ls per verificare che il contenitore funzioni.
```
docker container ls
```
1. Quando il componente è pronto, caricalo su per AWS IoT Greengrass distribuirlo su altri dispositivi principali. Per ulteriori informazioni, consulta [Pubblica componenti da distribuire sui tuoi dispositivi principali](publish-components.md).
## Esegui un contenitore Docker da un'immagine privata in Amazon ECR
Questa sezione descrive come creare un componente personalizzato che esegue un contenitore Docker da un'immagine Docker archiviata in un repository privato in Amazon ECR.
**Per eseguire un contenitore Docker**
1. [Crea un componente personalizzato](create-components.md) sul tuo dispositivo AWS IoT Greengrass principale. Usa la seguente ricetta di esempio, che ha le seguenti proprietà:
+ Il componente Docker Application Manager come dipendenza. Questo componente consente di AWS IoT Greengrass gestire le credenziali per scaricare immagini da archivi privati.
+ Il componente del servizio di scambio di token come dipendenza. Questo componente consente di AWS IoT Greengrass recuperare AWS le credenziali per interagire con Amazon ECR.
+ Un elemento componente che specifica un'immagine Docker in un repository Amazon ECR privato.
+ Uno script di esecuzione del ciclo di vita che utilizza [docker run](https://docs.docker.com/engine/reference/commandline/run/) per creare e avviare un contenitore dall'immagine.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyPrivateDockerComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that runs a Docker container from a private Amazon ECR image.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.DockerApplicationManager": {
"VersionRequirement": "~2.0.0"
},
"aws.greengrass.TokenExchangeService": {
"VersionRequirement": "~2.0.0"
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Lifecycle": {
"Run": "docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
},
"Artifacts": [
{
"URI": "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyPrivateDockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from a private Amazon ECR image.'
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.DockerApplicationManager:
VersionRequirement: ~2.0.0
aws.greengrass.TokenExchangeService:
VersionRequirement: ~2.0.0
Manifests:
- Platform:
os: all
Lifecycle:
Run: docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]
Artifacts:
- URI: "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
```
------
**Nota**
Per utilizzare la comunicazione tra processi (IPC), AWS le credenziali o lo stream manager nel componente del contenitore Docker, devi specificare opzioni aggiuntive quando esegui il contenitore Docker. Per ulteriori informazioni, consulta gli argomenti seguenti:
[Usa la comunicazione tra processi nei componenti del contenitore Docker](#docker-container-ipc)
[Usa AWS le credenziali nei componenti del contenitore Docker (Linux)](#docker-container-token-exchange-service)
[Usa lo stream manager nei componenti del contenitore Docker (Linux)](#docker-container-stream-manager)
1. [Testa il componente](test-components.md) per verificare che funzioni come previsto.
**Importante**
È necessario installare e avviare il demone Docker prima di distribuire il componente.
Dopo aver distribuito il componente localmente, puoi eseguire il comando [docker container](https://docs.docker.com/engine/reference/commandline/container_ls/) ls per verificare che il contenitore funzioni.
```
docker container ls
```
1. Carica il componente su per AWS IoT Greengrass distribuirlo su altri dispositivi principali. Per ulteriori informazioni, consulta [Pubblica componenti da distribuire sui tuoi dispositivi principali](publish-components.md).
## Esegui un contenitore Docker da un'immagine in Amazon S3
Questa sezione descrive come eseguire un contenitore Docker in un componente da un'immagine Docker archiviata in Amazon S3.
**Per eseguire un contenitore Docker in un componente da un'immagine in Amazon S3**
1. Esegui il comando [docker save](https://docs.docker.com/engine/reference/commandline/save/) per creare un backup di un contenitore Docker. Fornisci questo backup come elemento componente su cui eseguire il contenitore. AWS IoT Greengrass Sostituisci *hello-world* con il nome dell'immagine e sostituisci *hello-world.tar* con il nome del file di archivio da creare.
```
docker save hello-world > artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar
```
1. [Crea un componente personalizzato](create-components.md) sul tuo dispositivo AWS IoT Greengrass principale. Usa la seguente ricetta di esempio, che ha le seguenti proprietà:
+ Uno script di installazione del ciclo di vita che utilizza [docker load](https://docs.docker.com/engine/reference/commandline/load/) per caricare un'immagine Docker da un archivio.
+ Uno script di esecuzione del ciclo di vita che utilizza [docker run](https://docs.docker.com/engine/reference/commandline/run/) per creare e avviare un contenitore dall'immagine. L'`--rm`opzione pulisce il contenitore quando esce.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyS3DockerComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
"ComponentPublisher": "Amazon",
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": {
"Script": "docker load -i {artifacts:path}/hello-world.tar"
},
"Run": {
"Script": "docker run --rm hello-world"
}
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
- Platform:
os: linux
Lifecycle:
install:
Script: docker load -i {artifacts:path}/hello-world.tar
Run:
Script: docker run --rm hello-world
```
------
**Nota**
Per utilizzare la comunicazione tra processi (IPC), AWS le credenziali o lo stream manager nel componente del contenitore Docker, devi specificare opzioni aggiuntive quando esegui il contenitore Docker. Per ulteriori informazioni, consulta gli argomenti seguenti:
[Usa la comunicazione tra processi nei componenti del contenitore Docker](#docker-container-ipc)
[Usa AWS le credenziali nei componenti del contenitore Docker (Linux)](#docker-container-token-exchange-service)
[Usa lo stream manager nei componenti del contenitore Docker (Linux)](#docker-container-stream-manager)
1. [Testa il componente](test-components.md) per verificare che funzioni come previsto.
Dopo aver distribuito il componente localmente, puoi eseguire il comando [docker container](https://docs.docker.com/engine/reference/commandline/container_ls/) ls per verificare che il contenitore funzioni.
```
docker container ls
```
1. Quando il componente è pronto, carica l'archivio di immagini Docker in un bucket S3 e aggiungi il relativo URI alla ricetta del componente. Quindi, puoi caricare il componente su per AWS IoT Greengrass distribuirlo su altri dispositivi principali. Per ulteriori informazioni, consulta [Pubblica componenti da distribuire sui tuoi dispositivi principali](publish-components.md).
Al termine, la ricetta del componente dovrebbe essere simile all'esempio seguente.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyS3DockerComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
"ComponentPublisher": "Amazon",
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": {
"Script": "docker load -i {artifacts:path}/hello-world.tar"
},
"Run": {
"Script": "docker run --rm hello-world"
}
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
- Platform:
os: linux
Lifecycle:
install:
Script: docker load -i {artifacts:path}/hello-world.tar
Run:
Script: docker run --rm hello-world
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar
```
------
## Usa la comunicazione tra processi nei componenti del contenitore Docker
È possibile utilizzare la libreria di comunicazione interprocesso (IPC) di Greengrass SDK per dispositivi AWS IoT per comunicare con il nucleo Greengrass, altri componenti Greengrass e. AWS IoT Core Per ulteriori informazioni, consulta [Usa il SDK per dispositivi AWS IoT per comunicare con il nucleo Greengrass, altri componenti e AWS IoT CoreComunica con il nucleo Greengrass, altri componenti e AWS IoT Core](interprocess-communication.md).
Per utilizzare IPC in un componente del contenitore Docker, è necessario eseguire il contenitore Docker con i seguenti parametri:
+ Montate il socket IPC nel contenitore. Il nucleo Greengrass fornisce il percorso del file socket IPC nella variabile di ambiente. `AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT`
+ Imposta le variabili `SVCUID` e di `AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT` ambiente sui valori che il nucleo Greengrass fornisce ai componenti. Il componente utilizza queste variabili di ambiente per autenticare le connessioni al nucleo Greengrass.
**Example Ricetta di esempio: pubblica un messaggio MQTT su AWS IoT Core (Python)**
La seguente ricetta definisce un componente contenitore Docker di esempio su cui pubblica un messaggio MQTT. AWS IoT Core La ricetta ha le seguenti proprietà:
+ Una politica di autorizzazione (`accessControl`) che consente al componente di pubblicare messaggi MQTT su tutti gli AWS IoT Core argomenti. Per ulteriori informazioni, vedere [Autorizza i componenti a eseguire operazioni IPC](interprocess-communication.md#ipc-authorization-policies) Autorizzazione [IPC AWS IoT Core MQTT](ipc-iot-core-mqtt.md#ipc-iot-core-mqtt-authorization).
+ Un elemento componente che specifica un'immagine Docker come archivio TAR in Amazon S3.
+ Uno script di installazione del ciclo di vita che carica l'immagine Docker dall'archivio TAR.
+ Uno script di esecuzione del ciclo di vita che esegue un contenitore Docker dall'immagine. Il comando [Docker run](https://docs.docker.com/engine/reference/run/) ha i seguenti argomenti:
+ L'`-v`argomento monta il socket IPC Greengrass nel contenitore.
+ I primi due `-e` argomenti impostano le variabili di ambiente richieste nel contenitore Docker.
+ `-e`Gli argomenti aggiuntivi impostano le variabili di ambiente utilizzate in questo esempio.
+ L'`--rm`argomento pulisce il contenitore quando esce.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.python.docker.PublishToIoTCore",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Uses interprocess communication to publish an MQTT message to IoT Core.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"topic": "test/topic/java",
"message": "Hello, World!",
"qos": "1",
"accessControl": {
"aws.greengrass.ipc.mqttproxy": {
"com.example.python.docker.PublishToIoTCore:pubsub:1": {
"policyDescription": "Allows access to publish to IoT Core on all topics.",
"operations": [
"aws.greengrass#PublishToIoTCore"
],
"resources": [
"*"
]
}
}
}
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Lifecycle": {
"install": "docker load -i {artifacts:path}/publish-to-iot-core.tar",
"Run": "docker run -v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e SVCUID -e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e MQTT_TOPIC=\"{configuration:/topic}\" -e MQTT_MESSAGE=\"{configuration:/message}\" -e MQTT_QOS=\"{configuration:/qos}\" --rm publish-to-iot-core"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar"
}
]
}
]
}
```
```
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.PublishToIoTCore
ComponentVersion: 1.0.0
ComponentDescription: Uses interprocess communication to publish an MQTT message to IoT Core.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
topic: 'test/topic/java'
message: 'Hello, World!'
qos: '1'
accessControl:
aws.greengrass.ipc.mqttproxy:
'com.example.python.docker.PublishToIoTCore:pubsub:1':
policyDescription: Allows access to publish to IoT Core on all topics.
operations:
- 'aws.greengrass#PublishToIoTCore'
resources:
- '*'
Manifests:
- Platform:
os: all
Lifecycle:
install: 'docker load -i {artifacts:path}/publish-to-iot-core.tar'
Run: |
docker run \
-v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \
-e SVCUID \
-e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \
-e MQTT_TOPIC="{configuration:/topic}" \
-e MQTT_MESSAGE="{configuration:/message}" \
-e MQTT_QOS="{configuration:/qos}" \
--rm publish-to-iot-core
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar
```
## Usa AWS le credenziali nei componenti del contenitore Docker (Linux)
È possibile utilizzare il [componente del servizio di scambio di token](token-exchange-service-component.md) per interagire con AWS i servizi nei componenti Greengrass. Questo componente fornisce AWS le credenziali derivanti dal [ruolo di scambio di token](device-service-role.md) del dispositivo principale utilizzando un server container locale. Per ulteriori informazioni, consulta [Interagisci con AWS i servizi](interact-with-aws-services.md).
**Nota**
L'esempio in questa sezione funziona solo su dispositivi core Linux.
Per utilizzare AWS le credenziali del servizio di scambio di token in un componente del contenitore Docker, è necessario eseguire il contenitore Docker con i seguenti parametri:
+ Fornisci l'accesso alla rete host utilizzando l'argomento. `--network=host` Questa opzione consente al contenitore Docker di connettersi al servizio di scambio di token locale per recuperare AWS le credenziali. Questo argomento funziona solo su Docker per Linux.
**avvertimento**
Questa opzione consente al contenitore di accedere a tutte le interfacce di rete locale sull'host, quindi è meno sicura rispetto all'esecuzione di contenitori Docker senza questo accesso alla rete host. Considera questo aspetto quando sviluppi ed esegui componenti del contenitore Docker che utilizzano questa opzione. Per ulteriori informazioni, consulta [Network: host](https://docs.docker.com/engine/reference/run/#network-host) nella *documentazione Docker*.
+ Imposta le variabili `AWS_CONTAINER_CREDENTIALS_FULL_URI` e di `AWS_CONTAINER_AUTHORIZATION_TOKEN` ambiente sui valori che il nucleo Greengrass fornisce ai componenti. AWS SDKs utilizzate queste variabili di ambiente per recuperare AWS le credenziali.
**Example Ricetta di esempio: elenca i bucket S3 in un componente contenitore Docker (Python)**
La seguente ricetta definisce un esempio di componente del contenitore Docker che elenca i bucket S3 presenti nel tuo. Account AWS La ricetta ha le seguenti proprietà:
+ Il componente del servizio di scambio di token come dipendenza. Questa dipendenza consente al componente di recuperare le AWS credenziali per interagire con altri servizi. AWS
+ Un elemento componente che specifica un'immagine Docker come archivio tar in Amazon S3.
+ Uno script di installazione del ciclo di vita che carica l'immagine Docker dall'archivio TAR.
+ Uno script di esecuzione del ciclo di vita che esegue un contenitore Docker dall'immagine. Il comando [Docker run](https://docs.docker.com/engine/reference/run/) ha i seguenti argomenti:
+ L'`--network=host`argomento fornisce al contenitore l'accesso alla rete host, in modo che il contenitore possa connettersi al servizio di scambio di token.
+ L'`-e`argomento imposta le variabili di ambiente richieste nel contenitore Docker.
+ L'`--rm`argomento pulisce il contenitore quando esce.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.python.docker.ListS3Buckets",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Uses the token exchange service to lists your S3 buckets.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.TokenExchangeService": {
"VersionRequirement": "^2.0.0",
"DependencyType": "HARD"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": "docker load -i {artifacts:path}/list-s3-buckets.tar",
"Run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e AWS_CONTAINER_CREDENTIALS_FULL_URI --rm list-s3-buckets"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar"
}
]
}
]
}
```
```
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.ListS3Buckets
ComponentVersion: 1.0.0
ComponentDescription: Uses the token exchange service to lists your S3 buckets.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.TokenExchangeService:
VersionRequirement: ^2.0.0
DependencyType: HARD
Manifests:
- Platform:
os: linux
Lifecycle:
install: 'docker load -i {artifacts:path}/list-s3-buckets.tar'
Run: |
docker run \
--network=host \
-e AWS_CONTAINER_AUTHORIZATION_TOKEN \
-e AWS_CONTAINER_CREDENTIALS_FULL_URI \
--rm list-s3-buckets
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar
```
## Usa lo stream manager nei componenti del contenitore Docker (Linux)
È possibile utilizzare il [componente stream manager](stream-manager-component.md) per gestire i flussi di dati nei componenti Greengrass. Questo componente consente di elaborare flussi di dati e trasferire dati IoT ad alto volume a. Cloud AWS AWS IoT Greengrass fornisce un SDK per la gestione dello stream che puoi utilizzare per interagire con il componente stream manager. Per ulteriori informazioni, consulta [Gestisci i flussi di dati sui dispositivi core Greengrass](manage-data-streams.md).
**Nota**
L'esempio in questa sezione funziona solo su dispositivi core Linux.
Per utilizzare lo stream manager SDK in un componente del contenitore Docker, devi eseguire il contenitore Docker con i seguenti parametri:
+ Fornisci l'accesso alla rete host utilizzando l'argomento. `--network=host` Questa opzione consente al contenitore Docker di interagire con il componente stream manager tramite una connessione TLS locale. Questo argomento funziona solo su Docker per Linux
**avvertimento**
Questa opzione consente al contenitore di accedere a tutte le interfacce di rete locale sull'host, quindi è meno sicura rispetto all'esecuzione di contenitori Docker senza questo accesso alla rete host. Considera questo aspetto quando sviluppi ed esegui componenti del contenitore Docker che utilizzano questa opzione. Per ulteriori informazioni, consulta [Network: host](https://docs.docker.com/engine/reference/run/#network-host) nella *documentazione Docker*.
+ Se configurate il componente stream manager per richiedere l'autenticazione, che è il comportamento predefinito, impostate la variabile di `AWS_CONTAINER_CREDENTIALS_FULL_URI` ambiente sul valore che il nucleo Greengrass fornisce ai componenti. Per ulteriori informazioni, consulta la configurazione dello [stream manager](stream-manager-component.md#stream-manager-component-configuration).
+ Se configuri il componente stream manager per utilizzare una porta non predefinita, usa la [comunicazione tra processi (IPC)](interprocess-communication.md) per ottenere la porta dalla configurazione del componente stream manager. È necessario eseguire il contenitore Docker con opzioni aggiuntive per utilizzare IPC. Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Connect allo stream manager nel codice dell'applicazione](use-stream-manager-in-custom-components.md#connect-to-stream-manager)
+ [Usa la comunicazione tra processi nei componenti del contenitore Docker](#docker-container-ipc)
**Example Ricetta di esempio: trasmetti un file a un bucket S3 in un componente contenitore Docker (Python)**
La seguente ricetta definisce un esempio di componente contenitore Docker che crea un file e lo trasmette a un bucket S3. La ricetta ha le seguenti proprietà:
+ Il componente stream manager come dipendenza. Questa dipendenza consente al componente di utilizzare lo stream manager SDK per interagire con il componente stream manager.
+ Un elemento componente che specifica un'immagine Docker come archivio TAR in Amazon S3.
+ Uno script di installazione del ciclo di vita che carica l'immagine Docker dall'archivio TAR.
+ Uno script di esecuzione del ciclo di vita che esegue un contenitore Docker dall'immagine. Il comando [Docker run](https://docs.docker.com/engine/reference/run/) ha i seguenti argomenti:
+ L'`--network=host`argomento fornisce al contenitore l'accesso alla rete host, in modo che il contenitore possa connettersi al componente stream manager.
+ Il primo `-e` argomento imposta la variabile di `AWS_CONTAINER_AUTHORIZATION_TOKEN` ambiente richiesta nel contenitore Docker.
+ `-e`Gli argomenti aggiuntivi impostano le variabili di ambiente utilizzate in questo esempio.
+ L'`-v`argomento monta la [cartella di lavoro](component-recipe-reference.md#component-recipe-work-path) del componente nel contenitore. Questo esempio crea un file nella cartella di lavoro per caricare quel file su Amazon S3 utilizzando stream manager.
+ L'`--rm`argomento pulisce il contenitore quando esce.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.python.docker.StreamFileToS3",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Creates a text file and uses stream manager to stream the file to S3.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.StreamManager": {
"VersionRequirement": "^2.0.0",
"DependencyType": "HARD"
}
},
"ComponentConfiguration": {
"DefaultConfiguration": {
"bucketName": ""
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": "docker load -i {artifacts:path}/stream-file-to-s3.tar",
"Run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e BUCKET_NAME=\"{configuration:/bucketName}\" -e WORK_PATH=\"{work:path}\" -v {work:path}:{work:path} --rm stream-file-to-s3"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar"
}
]
}
]
}
```
```
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.StreamFileToS3
ComponentVersion: 1.0.0
ComponentDescription: Creates a text file and uses stream manager to stream the file to S3.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.StreamManager:
VersionRequirement: ^2.0.0
DependencyType: HARD
ComponentConfiguration:
DefaultConfiguration:
bucketName: ''
Manifests:
- Platform:
os: linux
Lifecycle:
install: 'docker load -i {artifacts:path}/stream-file-to-s3.tar'
Run: |
docker run \
--network=host \
-e AWS_CONTAINER_AUTHORIZATION_TOKEN \
-e BUCKET_NAME="{configuration:/bucketName}" \
-e WORK_PATH="{work:path}" \
-v {work:path}:{work:path} \
--rm stream-file-to-s3
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar
```