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á.
Você pode configurar AWS IoT Greengrass componentes para executar um contêiner Docker
-
Repositórios de imagens públicos e privados no Amazon Elastic Container Registry (AmazonECR)
-
Repositório público do Docker Hub
-
Registro confiável e público do Docker
-
Bucket do S3
Em seu componente personalizado, inclua a imagem do Docker URI como um artefato para recuperar a imagem e executá-la no dispositivo principal. Para imagens da Amazon ECR e do Docker Hub, você pode usar o componente Docker Application Manager para baixar as imagens e gerenciar credenciais para repositórios privados da Amazon. ECR
Tópicos
- Requisitos
- Execute um contêiner Docker a partir de uma imagem pública na Amazon ECR ou no Docker Hub
- Execute um contêiner Docker a partir de uma imagem privada na Amazon ECR
- Executar um contêiner do Docker a partir de uma imagem no Amazon S3
- Usar comunicação entre processos nos componentes do contêiner do Docker
- Use AWS credenciais em componentes de contêiner do Docker (Linux)
- Usar o gerenciador de fluxos em componentes de contêiner do Docker (Linux)
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: Começando com AWS IoT Greengrass V2.
-
Docker 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
comotrue
no script do ciclo de vida para executar a instalação e os comandosdocker
. Para obter mais informações, consulte AWS IoT Greengrass referência da receita do componente.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 você deve configurar o Docker para executá-lo como usuário não raiz ou não administrador.
-
Em dispositivos do Linux, é possível adicionar um usuário ao grupo do
docker
para chamar os comandos dodocker
semsudo
. -
Em dispositivos Windows, é possível adicionar um usuário ao grupo
docker-users
para chamar comandos dodocker
sem privilégios de administrador.
Para adicionar o
ggc_user
, ou o usuário não raiz que você usa para executar componentes de contêiner do Docker ao grupo dodocker
, 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
. -
-
Arquivos acessados pelo componente de contêiner do Docker montado como um volume
no contêiner do Docker. -
Se você configurar o software AWS IoT Greengrass Core para usar um proxy de rede, deverá configurar o Docker para usar o mesmo servidor 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
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 Docker a partir de uma imagem pública na Amazon ECR ou no Docker Hub. -
Se suas imagens do Docker estiverem armazenadas na Amazon ECR ou no Docker Hub, inclua o componente gerenciador de componentes do Docker 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:
mostrado nos exemplos a seguir:registry
/image
[:tag|@digest
]-
ECRImagem privada da Amazon:
docker:
account-id
.dkr.ecr.region
.amazonaws.com/repository
/image
[:tag|@digest
] -
ECRImagem pública da Amazon:
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 Docker a partir de uma imagem pública na Amazon ECR ou no Docker Hub.
-
-
Se suas imagens do Docker estiverem armazenadas em um repositório ECR privado da Amazon, você deverá incluir o componente do serviço de troca de tokens como uma dependência no componente de contêiner do Docker. Além disso, a função de dispositivo do Greengrass deve permitir as
ecr:GetDownloadUrlForLayer
açõesecr:GetAuthorizationToken
,ecr:BatchGetImage
, e, conforme mostrado no exemplo IAM de política a seguir.{ "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 ECR privado da Amazon, consulte. Execute um contêiner Docker a partir de uma imagem privada na Amazon ECR
-
Para usar imagens do Docker armazenadas em um repositório ECR privado da Amazon, o repositório privado deve estar no mesmo que o dispositivo Região da AWS principal.
-
Se suas imagens do Docker ou arquivos do Compose estiverem armazenados em um bucket do S3, a função de dispositivo do Greengrass deve permitir que os
s3:GetObject
dispositivos principais baixem as imagens como artefatos de componentes, conforme mostrado no exemplo de política a seguir. IAM{ "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.
-
Para usar comunicação entre processos (IPC), AWS credenciais ou gerenciador de fluxo em seu componente de contêiner do Docker, você deve especificar opções adicionais ao executar o contêiner do Docker. Para obter mais informações, consulte:
Execute um contêiner Docker a partir de uma imagem pública na Amazon ECR ou no Docker Hub
Esta seção descreve como você pode criar um componente personalizado que usa o Docker Compose para executar um contêiner Docker a partir de imagens do Docker armazenadas na Amazon ECR e no Docker Hub.
Para executar um contêiner do Docker usando o Docker Compose
-
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 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 da Amazon ECR e a SQL imagem My do Docker Hub.version: "3" services: cloudwatchagent: image: "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest" mysql: image: "mysql:8.0"
-
Crie um componente personalizado 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 AWS IoT Greengrass baixar imagens dos repositórios públicos da Amazon ECR e do Docker Hub.
-
Um artefato de componente que especifica uma imagem do Docker em um repositório público da 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
para criar e iniciar um contêiner a partir das imagens especificadas.
{ "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), AWS credenciais ou gerenciador de fluxo em seu componente de contêiner do Docker, você deve especificar opções adicionais ao executar o contêiner do Docker. Para obter mais informações, consulte:
-
-
Teste o componente 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
para verificar se o contêiner está sendo executado. docker container ls
-
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.
Execute um contêiner Docker a partir de uma imagem privada na Amazon ECR
Esta seção descreve como você pode criar um componente personalizado que executa um contêiner do Docker a partir de uma imagem do Docker armazenada em um repositório privado na Amazon. ECR
Para executar um contêiner do Docker
-
Crie um componente personalizado 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 AWS IoT Greengrass recuperar AWS credenciais para interagir com a Amazon. ECR
-
Um artefato de componente que especifica uma imagem do Docker em um repositório privado da Amazon. ECR
-
Um script de execução do ciclo de vida que usa docker run
para criar e iniciar um contêiner a partir da imagem.
{ "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), AWS credenciais ou gerenciador de fluxo em seu componente de contêiner do Docker, você deve especificar opções adicionais ao executar o contêiner do Docker. Para obter mais informações, consulte:
-
-
Teste o componente 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
para verificar se o contêiner está sendo executado. docker container ls
-
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.
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
-
Execute o comando docker 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 ehello-world.tar
substitua pelo nome do arquivo a ser criado.docker save
hello-world
>artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar
-
Crie um componente personalizado 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
carregar uma imagem do Docker de um arquivo. -
Um script de execução do ciclo de vida que usa docker run
para criar e iniciar um contêiner a partir da imagem. A opção --rm
limpa o contêiner quando ele sair.
{ "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 --rmhello-world
" } } } ] }nota
Para usar comunicação entre processos (IPC), AWS credenciais ou gerenciador de fluxo em seu componente de contêiner do Docker, você deve especificar opções adicionais ao executar o contêiner do Docker. Para obter mais informações, consulte:
-
-
Teste o componente para verificar se ele funciona conforme o esperado.
Depois de implantar o componente localmente, você pode executar o comando docker container ls
para verificar se o contêiner está sendo executado. docker container ls
-
Quando o componente estiver pronto, faça o upload do arquivo de imagens do Docker em um bucket do S3 e adicione-o URI à receita 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.
Quando você terminar, a fórmula do componente deve ser semelhante ao seguinte exemplo.
{ "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 --rmhello-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 do Greengrass (IPC) 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 Core.
Para usar IPC em um componente de contêiner do Docker, você deve executar o contêiner do Docker com os seguintes parâmetros:
-
Monte o IPC soquete no contêiner. O núcleo do Greengrass fornece o caminho do arquivo de IPC soquete na variável de ambiente.
AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT
-
Defina as variáveis de ambiente
SVCUID
eAWS_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.
exemplo Exemplo de receita: publicar uma MQTT mensagem em AWS IoT Core (Python)
A receita a seguir define um exemplo de componente de contêiner do Docker que publica uma MQTT mensagem no. AWS IoT Core Essa fórmula tem as seguintes propriedades:
-
Uma política de autorização (
accessControl
) que permite que o componente publique MQTT mensagens AWS IoT Core em todos os tópicos. Para obter mais informações, consulte Autorizar componentes a realizar operações IPC e AWS IoT Core MQTTIPCautorização. -
Um artefato de componente que especifica uma imagem do Docker como um TAR arquivo 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
tem os seguintes argumentos: -
O
-v
argumento monta o soquete IPC 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"
}
]
}
]
}
Use AWS credenciais em componentes de contêiner do Docker (Linux)
Você pode usar o componente de serviço de troca de tokens 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 do dispositivo principal usando um servidor de contêiner local. Para obter mais informações, consulte Interaja com AWS os serviços.
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
na documentação do Docker. -
Defina as variáveis de
AWS_CONTAINER_AUTHORIZATION_TOKEN
ambienteAWS_CONTAINER_CREDENTIALS_FULL_URI
e de acordo com os valores que o núcleo do Greengrass fornece aos componentes. AWS SDKsuse essas variáveis de ambiente para recuperar as AWS credenciais.
exemplo 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
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"
}
]
}
]
}
Usar o gerenciador de fluxos em componentes de contêiner do Docker (Linux)
Você pode usar o componente gerenciador de fluxos 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 gerenciador de fluxo SDK que você usa para interagir com o componente gerenciador de fluxo. Para obter mais informações, consulte Gerenciar fluxos de dados no nos dispositivos principais do Greengrass.
nota
O exemplo nesta seção funciona somente nos dispositivos principais do Linux.
Para usar o gerenciador de stream SDK 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 do gerenciador de fluxo por meio de uma TLS conexão local. Esse argumento funciona somente no Docker para LinuxAtençã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
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. -
Se você configurar o componente do gerenciador de fluxo para usar uma porta não padrão, use a comunicação entre processos (IPC) para obter a porta da configuração do componente do gerenciador de fluxo. Você deve executar o contêiner Docker com opções adicionais para usarIPC. Para obter mais informações, consulte:
exemplo 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 gerenciador de fluxo SDK para interagir com o componente gerenciador de fluxo.
-
Um artefato de componente que especifica uma imagem do Docker como um TAR arquivo 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
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 ambienteAWS_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 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"
}
]
}
]
}