As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Executar um contêiner do Docker
Você pode configurar AWS IoT Greengrass componentes para executar um contêiner [Docker](https://www.docker.com/) a partir de imagens armazenadas nos seguintes locais:
+ Repositórios de imagem públicos e privados no Amazon Elastic Container Registry (Amazon ECR)
+ Repositório público do Docker Hub
+ Registro confiável e público do Docker
+ Bucket do S3
Em seu componente personalizado, inclua o URI da imagem do Docker como um artefato para recuperar a imagem e executá-la no dispositivo principal. Para imagens do Amazon ECR e do Docker Hub, você pode usar o componente [gerenciador de aplicativos do Docker](docker-application-manager-component.md) para baixar as imagens e gerenciar credenciais para repositórios privados do Amazon ECR.
**Topics**
+ [Requisitos](#run-docker-container-requirements)
+ [Execute um contêiner do Docker a partir de uma imagem pública no Amazon ECR ou Docker Hub](#run-docker-container-public-ecr-dockerhub)
+ [Executar um contêiner do Docker a partir de uma imagem privada no Amazon ECR](#run-docker-container-private-ecr)
+ [Executar um contêiner do Docker a partir de uma imagem no Amazon S3](#run-docker-container-s3)
+ [Usar comunicação entre processos nos componentes do contêiner do Docker](#docker-container-ipc)
+ [Use AWS credenciais em componentes de contêiner do Docker (Linux)](#docker-container-token-exchange-service)
+ [Usar o gerenciador de fluxos em componentes de contêiner do Docker (Linux)](#docker-container-stream-manager)
## Requisitos
Para executar um contêiner do Docker em um componente, você precisa:
+ Um dispositivo principal do Greengrass. Se você não tiver uma, consulte [Tutorial: Conceitos básicos do AWS IoT Greengrass V2](getting-started.md).
+ [Docker Engine](https://docs.docker.com/engine/) 1.9.1 ou versão posterior instalado no dispositivo principal do Greengrass. A versão 20.10 é a versão mais recente verificada para funcionar com o software AWS IoT Greengrass Core. É preciso instalar o Docker diretamente no dispositivo principal antes de implantar componentes que executam contêineres do Docker.
**dica**
Também é possível configurar o dispositivo principal para instalar o Docker Engine quando o componente for instalado. Por exemplo, o script de instalação a seguir instala o Docker Engine antes de carregar a imagem do Docker. Esse script de instalação funciona em distribuições Linux baseadas no Debian, como o Ubuntu. Se você configurar o componente para instalar o Docker Engine com esse comando, talvez seja necessário configurar o `RequiresPrivilege` como `true` no script do ciclo de vida para executar a instalação e os comandos `docker`. Para obter mais informações, consulte [AWS IoT Greengrass referência da receita do componente](component-recipe-reference.md).
```
apt-get install docker-ce docker-ce-cli containerd.io && docker load -i {artifacts:path}/hello-world.tar
```
+ O usuário do sistema que executa um componente de contêiner do Docker deve ter permissões de raiz ou administrador, ou é necessário configurar o Docker para executá-lo como usuário não raiz ou não administrador.
+ Em dispositivos Linux, você pode adicionar um usuário ao grupo `docker` para chamar os comandos `docker` sem `sudo`.
+ Em dispositivos Windows, é possível adicionar um usuário ao grupo `docker-users` para chamar comandos do `docker` sem privilégios de administrador.
------
#### [ Linux or Unix ]
Para adicionar `ggc_user` ou o usuário não raiz que você usa para executar componentes de contêiner do Docker ao grupo de `docker`, execute o seguinte comando.
```
sudo usermod -aG docker ggc_user
```
Para obter mais informações, consulte [Gerenciar o Docker como um usuário não raiz](https://docs.docker.com/engine/install/linux-postinstall/#manage-docker-as-a-non-root-user).
------
#### [ Windows Command Prompt (CMD) ]
Para adicionar `ggc_user` ou o usuário que você usa para executar componentes de contêiner do Docker ao grupo de `docker-users`, execute o seguinte comando como administrador.
```
net localgroup docker-users ggc_user /add
```
------
#### [ Windows PowerShell ]
Para adicionar `ggc_user` ou o usuário que você usa para executar componentes de contêiner do Docker ao grupo de `docker-users`, execute o seguinte comando como administrador.
```
Add-LocalGroupMember -Group docker-users -Member ggc_user
```
------
+ Arquivos acessados pelo componente de contêiner do Docker [montado como um volume](https://docs.docker.com/storage/volumes/) no contêiner do Docker.
+ Se você [configurar o software AWS IoT Greengrass Core para usar um proxy de rede](configure-greengrass-core-v2.md#configure-alpn-network-proxy), deverá [configurar o Docker para usar o mesmo servidor proxy](https://docs.docker.com/network/proxy/).
Além desses requisitos, você também deve atender aos seguintes requisitos se eles se aplicarem ao seu ambiente:
+ Para usar o [Docker Compose](https://docs.docker.com/compose/) para criar e iniciar seus contêineres do Docker, instale o Docker Compose em seu dispositivo principal do Greengrass e carregue seu arquivo do Docker Compose em um bucket do S3. Você deve armazenar seu arquivo Compose em um bucket do S3 no mesmo componente Conta da AWS e no Região da AWS mesmo. Para ver um exemplo que usa o comando `docker-compose up` em um componente personalizado, consulte [Execute um contêiner do Docker a partir de uma imagem pública no Amazon ECR ou Docker Hub](#run-docker-container-public-ecr-dockerhub).
+ [Se você estiver executando AWS IoT Greengrass por trás de um proxy de rede, configure o daemon do Docker para usar um servidor proxy.](https://docs.docker.com/network/proxy/)
+ Se suas imagens do Docker estiverem armazenadas no Amazon ECR ou no Docker Hub, inclua o componente [gerenciador de componentes do Docker](docker-application-manager-component.md) como uma dependência em seu componente de contêiner do Docker. Inicie o daemon do Docker no dispositivo principal antes de implantar o componente.
Além disso, inclua a imagem URIs como artefatos componentes. A imagem URIs deve estar no formato `docker:registry/image[:tag|@digest]` mostrado nos exemplos a seguir:
+ Imagem privada do Amazon ECR: `docker:account-id.dkr.ecr.region.amazonaws.com/repository/image[:tag|@digest]`
+ Imagem pública do Amazon ECR: `docker:public.ecr.aws/repository/image[:tag|@digest]`
+ Imagem pública do Docker Hub: `docker:name[:tag|@digest]`
Para obter mais informações sobre como executar contêineres do Docker a partir de imagens armazenadas em repositórios públicos, consulte [Execute um contêiner do Docker a partir de uma imagem pública no Amazon ECR ou Docker Hub](#run-docker-container-public-ecr-dockerhub).
+ Se suas imagens do Docker estiverem armazenadas em um repositório privado do Amazon ECR, será preciso incluir o componente do serviço de troca de tokens como uma dependência no componente do contêiner do Docker. Além disso, o [perfil de dispositivo do Greengrass](device-service-role.md) precisa permitir as ações `ecr:GetAuthorizationToken`, `ecr:BatchGetImage` e `ecr:GetDownloadUrlForLayer`, conforme mostrado no seguinte exemplo de política do IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ecr:GetAuthorizationToken",
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": [
"*"
],
"Effect": "Allow"
}
]
}
```
------
Para obter informações sobre como executar contêineres do Docker a partir de imagens armazenadas em um repositório privado do Amazon ECR, consulte [Executar um contêiner do Docker a partir de uma imagem privada no Amazon ECR](#run-docker-container-private-ecr).
+ Para usar imagens do Docker armazenadas em um repositório privado do Amazon ECR, o repositório privado deve estar no mesmo que o dispositivo principal Região da AWS .
+ Se suas imagens do Docker ou arquivos do Compose estiverem armazenados em um bucket do S3, o [perfil de dispositivo do Greengrass](device-service-role.md) deve oferecer a permissão `s3:GetObject` para permitir que os dispositivos principais baixem as imagens como artefatos de componentes, conforme mostrado no exemplo de política do IAM a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject"
],
"Resource": [
"*"
],
"Effect": "Allow"
}
]
}
```
------
Para obter informações sobre como executar contêineres do Docker a partir de imagens armazenadas no Amazon S3, consulte [Executar um contêiner do Docker a partir de uma imagem no Amazon S3](#run-docker-container-s3).
+ Para usar comunicação entre processos (IPC), credenciais da AWS ou gerenciador de fluxos em seu componente de contêiner do Docker, você deve especificar opções adicionais ao executar o contêiner do Docker. Para saber mais, consulte:
+ [Usar comunicação entre processos nos componentes do contêiner do Docker](#docker-container-ipc)
+ [Use AWS credenciais em componentes de contêiner do Docker (Linux)](#docker-container-token-exchange-service)
+ [Usar o gerenciador de fluxos em componentes de contêiner do Docker (Linux)](#docker-container-stream-manager)
## Execute um contêiner do Docker a partir de uma imagem pública no Amazon ECR ou Docker Hub
Esta seção descreve como você pode criar um componente personalizado que usa o Docker Compose para executar um contêiner do Docker a partir de imagens do Docker armazenadas no Amazon ECR e no Docker Hub.
**Para executar um contêiner do Docker usando o Docker Compose**
1. Crie e faça upload de um arquivo Docker Compose para um bucket do Amazon S3. Certifique-se de que o [perfil de dispositivo do Greengrass](device-service-role.md) conceda a permissão `s3:GetObject` para que o dispositivo acesse o arquivo do Compose. O exemplo de arquivo Compose mostrado no exemplo a seguir inclui a imagem do Amazon CloudWatch Agent do Amazon ECR e a imagem do MySQL do Docker Hub.
```
version: "3"
services:
cloudwatchagent:
image: "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
mysql:
image: "mysql:8.0"
```
1. [Crie um componente personalizado](create-components.md) em seu dispositivo AWS IoT Greengrass principal. A fórmula de exemplo mostrada no exemplo a seguir tem as seguintes propriedades:
+ O componente do gerenciador de aplicações Docker como uma dependência. Esse componente permite que o AWS IoT Greengrass baixe imagens dos repositórios públicos do Amazon ECR e do Docker Hub.
+ Um artefato de componente que especifica uma imagem do Docker em um repositório público do Amazon ECR.
+ Um artefato de componente que especifica uma imagem do Docker em um repositório público do Docker Hub.
+ Um artefato de componente que especifica o arquivo do Docker Compose que inclui contêineres para as imagens do Docker que você deseja executar.
+ Um script de execução do ciclo de vida que usa [docker-compose up](https://docs.docker.com/compose/reference/up/) para criar e iniciar um contêiner a partir das imagens especificadas.
------
#### [ 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**
Para usar comunicação entre processos (IPC), credenciais da AWS ou gerenciador de fluxos em seu componente de contêiner do Docker, você deve especificar opções adicionais ao executar o contêiner do Docker. Para saber mais, consulte:
[Usar comunicação entre processos nos componentes do contêiner do Docker](#docker-container-ipc)
[Use AWS credenciais em componentes de contêiner do Docker (Linux)](#docker-container-token-exchange-service)
[Usar o gerenciador de fluxos em componentes de contêiner do Docker (Linux)](#docker-container-stream-manager)
1. [Teste o componente](test-components.md) para verificar se ele funciona conforme o esperado.
**Importante**
É necessário instalar e iniciar o daemon do Docker antes de implantar o componente.
Depois de implantar o componente localmente, você pode executar o comando [docker container ls](https://docs.docker.com/engine/reference/commandline/container_ls/) para verificar se o contêiner está sendo executado.
```
docker container ls
```
1. Quando o componente estiver pronto, faça o upload do componente AWS IoT Greengrass para implantá-lo em outros dispositivos principais. Para obter mais informações, consulte [Publish components to deploy to your core devices](publish-components.md).
## Executar um contêiner do Docker a partir de uma imagem privada no Amazon ECR
Esta seção descreve como criar um componente personalizado que executa um contêiner do Docker a partir de uma imagem do Docker armazenada em um repositório privado no Amazon ECR.
**Para executar um contêiner do Docker**
1. [Crie um componente personalizado](create-components.md) em seu dispositivo AWS IoT Greengrass principal. Use a fórmula de exemplo a seguir, que tem as seguintes propriedades:
+ O componente do gerenciador de aplicações Docker como uma dependência. Esse componente permite que o AWS IoT Greengrass gerencie credenciais para baixar imagens de repositórios privados.
+ O componente do serviço de troca de tokens como uma dependência. Esse componente permite recuperar AWS credenciais AWS IoT Greengrass para interagir com o Amazon ECR.
+ Um artefato de componente que especifica uma imagem do Docker em um repositório privado do Amazon ECR.
+ Um script de execução do ciclo de vida que usa [docker run](https://docs.docker.com/engine/reference/commandline/run/) para criar e iniciar um contêiner a partir da imagem.
------
#### [ 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**
Para usar comunicação entre processos (IPC), credenciais da AWS ou gerenciador de fluxos em seu componente de contêiner do Docker, você deve especificar opções adicionais ao executar o contêiner do Docker. Para saber mais, consulte:
[Usar comunicação entre processos nos componentes do contêiner do Docker](#docker-container-ipc)
[Use AWS credenciais em componentes de contêiner do Docker (Linux)](#docker-container-token-exchange-service)
[Usar o gerenciador de fluxos em componentes de contêiner do Docker (Linux)](#docker-container-stream-manager)
1. [Teste o componente](test-components.md) para verificar se ele funciona conforme o esperado.
**Importante**
É necessário instalar e iniciar o daemon do Docker antes de implantar o componente.
Depois de implantar o componente localmente, você pode executar o comando [docker container ls](https://docs.docker.com/engine/reference/commandline/container_ls/) para verificar se o contêiner está sendo executado.
```
docker container ls
```
1. Faça o upload do componente AWS IoT Greengrass para implantá-lo em outros dispositivos principais. Para obter mais informações, consulte [Publish components to deploy to your core devices](publish-components.md).
## Executar um contêiner do Docker a partir de uma imagem no Amazon S3
Esta seção descreve como executar um contêiner do Docker em um compentne de uma imagem do Docker armazenada no Amazon S3.
**Para executar um contêiner do Docker em um componente de uma imagem no Amazon S3**
1. Execute o comando [docker save](https://docs.docker.com/engine/reference/commandline/save/) para criar um backup de um contêiner do Docker. Você fornece esse backup como um artefato de componente para executar o contêiner no AWS IoT Greengrass. *hello-world*Substitua pelo nome da imagem e *hello-world.tar* substitua pelo nome do arquivo a ser criado.
```
docker save hello-world > artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar
```
1. [Crie um componente personalizado](create-components.md) em seu dispositivo AWS IoT Greengrass principal. Use a fórmula de exemplo a seguir, que tem as seguintes propriedades:
+ Um script de instalação do ciclo de vida que usa [docker load para](https://docs.docker.com/engine/reference/commandline/load/) carregar uma imagem do Docker de um arquivo.
+ Um script de execução do ciclo de vida que usa [docker run](https://docs.docker.com/engine/reference/commandline/run/) para criar e iniciar um contêiner a partir da imagem. A opção `--rm` limpa o contêiner quando ele sair.
------
#### [ 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**
Para usar comunicação entre processos (IPC), credenciais da AWS ou gerenciador de fluxos em seu componente de contêiner do Docker, você deve especificar opções adicionais ao executar o contêiner do Docker. Para saber mais, consulte:
[Usar comunicação entre processos nos componentes do contêiner do Docker](#docker-container-ipc)
[Use AWS credenciais em componentes de contêiner do Docker (Linux)](#docker-container-token-exchange-service)
[Usar o gerenciador de fluxos em componentes de contêiner do Docker (Linux)](#docker-container-stream-manager)
1. [Teste o componente](test-components.md) para verificar se ele funciona conforme o esperado.
Depois de implantar o componente localmente, você pode executar o comando [docker container ls](https://docs.docker.com/engine/reference/commandline/container_ls/) para verificar se o contêiner está sendo executado.
```
docker container ls
```
1. Quando o componente estiver pronto, faça o upload do arquivo de imagens do Docker em um bucket do S3 e adicione seu URI à fórmula do componente. Em seguida, você pode carregar o componente AWS IoT Greengrass para implantá-lo em outros dispositivos principais. Para obter mais informações, consulte [Publish components to deploy to your core devices](publish-components.md).
Quando você terminar, a fórmula do componente deve ser semelhante ao seguinte exemplo.
------
#### [ 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
```
------
## Usar comunicação entre processos nos componentes do contêiner do Docker
Você pode usar a biblioteca de comunicação entre processos (IPC) do Greengrass no AWS IoT Device SDK para se comunicar com o núcleo do Greengrass, outros componentes do Greengrass e. AWS IoT Core Para obter mais informações, consulte [Use o AWS IoT Device SDK para se comunicar com o núcleo do Greengrass, outros componentes e AWS IoT CoreComunique-se com o núcleo do Greengrass, outros componentes e AWS IoT Core](interprocess-communication.md).
Para usar o IPC em um componente de contêiner do Docker, você deve executar o contêiner do Docker com os seguintes parâmetros:
+ Monte o soquete IPC no contêiner. O núcleo do Greengrass fornece o caminho do arquivo do soquete IPC na variável de ambiente `AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT`.
+ Defina as variáveis de ambiente `SVCUID` e `AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT` de acordo com os valores que o núcleo do Greengrass fornece aos componentes. Seu componente usa essas variáveis de ambiente para autenticar conexões com o núcleo do Greengrass.
**Example Exemplo de receita: publicar uma mensagem MQTT em AWS IoT Core (Python)**
A receita a seguir define um exemplo de componente de contêiner do Docker que publica uma mensagem MQTT no. AWS IoT Core Essa fórmula tem as seguintes propriedades:
+ Uma política de autorização (`accessControl`) que permite que o componente publique mensagens MQTT AWS IoT Core em todos os tópicos. Para obter mais informações, consulte [Autorizar componentes a realizar operações de IPC](interprocess-communication.md#ipc-authorization-policies) e [autorização de IPC do MQTT do AWS IoT Core](ipc-iot-core-mqtt.md#ipc-iot-core-mqtt-authorization).
+ Um artefato de componente que especifica uma imagem do Docker como um arquivo TAR no Amazon S3.
+ Um script de instalação do ciclo de vida que carrega a imagem do Docker do arquivo TAR.
+ Um script de execução do ciclo de vida que executa um contêiner do Docker a partir da imagem. O comando [Docker run](https://docs.docker.com/engine/reference/run/) tem os seguintes argumentos:
+ O argumento `-v` monta o soquete IPC do Greengrass no contêiner.
+ Os dois primeiros argumentos `-e` definem as variáveis de ambiente necessárias no contêiner do Docker.
+ Os argumentos adicionais `-e` definem as variáveis de ambiente usadas neste exemplo.
+ O argumento `--rm` limpa o contêiner quando ele sair.
```
{
"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
```
## Use AWS credenciais em componentes de contêiner do Docker (Linux)
Você pode usar o [componente de serviço de troca de tokens](token-exchange-service-component.md) para interagir com AWS os serviços nos componentes do Greengrass. Esse componente fornece credenciais da AWS obtidas da [função de troca de tokens](device-service-role.md) do dispositivo principal usando um servidor de contêiner local. Para obter mais informações, consulte [Interaja com AWS os serviços](interact-with-aws-services.md).
**nota**
O exemplo nesta seção funciona somente nos dispositivos principais do Linux.
Para usar AWS as credenciais do serviço de troca de tokens em um componente de contêiner do Docker, você deve executar o contêiner do Docker com os seguintes parâmetros:
+ Forneça acesso à rede host usando o argumento `--network=host`. Essa opção permite que o contêiner do Docker se conecte ao serviço local de troca de tokens para recuperar AWS as credenciais. Esse argumento funciona somente no Docker para Linux.
**Atenção**
Essa opção dá ao contêiner acesso a todas as interfaces de rede local no host, portanto, essa opção é menos segura do que se você executasse contêineres do Docker sem esse acesso à rede host. Considere isso ao desenvolver e executar componentes de contêiner do Docker que usam essa opção. Para obter mais informações, consulte [Rede: host](https://docs.docker.com/engine/reference/run/#network-host) na *documentação do Docker*.
+ Defina as variáveis de `AWS_CONTAINER_AUTHORIZATION_TOKEN` ambiente `AWS_CONTAINER_CREDENTIALS_FULL_URI` e de acordo com os valores que o núcleo do Greengrass fornece aos componentes. AWS SDKs use essas variáveis de ambiente para recuperar as AWS credenciais.
**Example Exemplo de fórmula: listar buckets S3 em um componente de contêiner do Docker (Python)**
A fórmula a seguir define um exemplo de componente de contêiner do Docker que lista os buckets S3 em sua Conta da AWS. Essa fórmula tem as seguintes propriedades:
+ O componente do serviço de troca de tokens como uma dependência. Essa dependência permite que o componente recupere AWS credenciais para interagir com outros serviços. AWS
+ Um artefato de componente que especifica uma imagem do Docker como um arquivo TAR no Amazon S3.
+ Um script de instalação do ciclo de vida que carrega a imagem do Docker do arquivo TAR.
+ Um script de execução do ciclo de vida que executa um contêiner do Docker a partir da imagem. O comando [Docker run](https://docs.docker.com/engine/reference/run/) tem os seguintes argumentos:
+ O argumento `--network=host` fornece ao contêiner acesso à rede host, para que o contêiner possa se conectar ao serviço de troca de tokens.
+ O argumento `-e` define as variáveis de ambiente necessárias no contêiner do Docker.
+ O argumento `--rm` limpa o contêiner quando ele sair.
```
{
"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
```
## Usar o gerenciador de fluxos em componentes de contêiner do Docker (Linux)
Você pode usar o [componente gerenciador de fluxos](stream-manager-component.md) para gerenciar fluxos de dados nos componentes do Greengrass. Esse componente permite que você processe fluxos de dados e transfira dados de IoT de alto volume para o. Nuvem AWS AWS IoT Greengrass fornece um SDK do gerenciador de stream que você usa para interagir com o componente do gerenciador de stream. Para obter mais informações, consulte [Gerenciar fluxos de dados no nos dispositivos principais do Greengrass](manage-data-streams.md).
**nota**
O exemplo nesta seção funciona somente nos dispositivos principais do Linux.
Para usar o SDK do gerenciador de fluxos em um componente de contêiner do Docker, você deve executar o contêiner do Docker com os seguintes parâmetros:
+ Forneça acesso à rede host usando o argumento `--network=host`. Essa opção permite que o contêiner do Docker interaja com o componente gerenciador de fluxos por meio de uma conexão TLS local. Esse argumento funciona somente no Docker para Linux
**Atenção**
Essa opção dá ao contêiner acesso a todas as interfaces de rede local no host, portanto, essa opção é menos segura do que se você executasse contêineres do Docker sem esse acesso à rede host. Considere isso ao desenvolver e executar componentes de contêiner do Docker que usam essa opção. Para obter mais informações, consulte [Rede: host](https://docs.docker.com/engine/reference/run/#network-host) na *documentação do Docker*.
+ Se você configurar o componente do gerenciador de fluxos para exigir autenticação, que é o comportamento padrão, defina a variável de ambiente `AWS_CONTAINER_CREDENTIALS_FULL_URI` com o valor que o núcleo do Greengrass fornece aos componentes. Para obter mais informações, consulte a [configuração do gerenciador de fluxos](stream-manager-component.md#stream-manager-component-configuration).
+ Se você configurar o componente do gerenciador de fluxos com uma porta diferente do padrão, deverá usar a [comunicação entre processos (IPC)](interprocess-communication.md) para recuperar a porta da configuração do gerenciador de fluxos. Execute o contêiner do Docker com opções adicionais para usar a IPC. Para saber mais, consulte:
+ [Conectar-se ao gerenciador de fluxos no código da aplicação](use-stream-manager-in-custom-components.md#connect-to-stream-manager)
+ [Usar comunicação entre processos nos componentes do contêiner do Docker](#docker-container-ipc)
**Example Exemplo de fórmula: transmitir um arquivo para um bucket do S3 em um componente de contêiner do Docker (Python)**
A fórmula a seguir define um exemplo de componente de contêiner do Docker que cria um arquivo e o transmite para um bucket do S3. Essa fórmula tem as seguintes propriedades:
+ O componente do gerenciador de fluxos como uma dependência. Essa dependência permite que o componente use o SDK do gerenciador de fluxos para interagir com o componente do gerenciador de fluxos.
+ Um artefato de componente que especifica uma imagem do Docker como um arquivo TAR no Amazon S3.
+ Um script de instalação do ciclo de vida que carrega a imagem do Docker do arquivo TAR.
+ Um script de execução do ciclo de vida que executa um contêiner do Docker a partir da imagem. O comando [Docker run](https://docs.docker.com/engine/reference/run/) tem os seguintes argumentos:
+ O argumento `--network=host` fornece ao contêiner acesso à rede host, para que o contêiner possa se conectar ao componente do gerenciador de fluxos.
+ O primeiro argumento `-e` define a variável de ambiente `AWS_CONTAINER_AUTHORIZATION_TOKEN` necessária no contêiner do Docker.
+ Os argumentos adicionais `-e` definem as variáveis de ambiente usadas neste exemplo.
+ O argumento `-v` monta a [pasta de trabalho](component-recipe-reference.md#component-recipe-work-path) do componente no contêiner. Esse exemplo cria um arquivo na pasta de trabalho para fazer o upload desse arquivo para o Amazon S3 usando o gerenciador de fluxos.
+ O argumento `--rm` limpa o contêiner quando ele sair.
```
{
"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
```