Aviso de fim do suporte: em 7 de outubro de 2026, AWS o suporte para o. AWS IoT Greengrass Version 1 Depois de 7 de outubro de 2026, você não poderá mais acessar os AWS IoT Greengrass V1 recursos. Para obter mais informações, visite [Migrar de AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html). 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á. # Conector de implantação de aplicativo do Docker O conector de implantação do aplicativo Greengrass Docker facilita a execução de suas imagens do Docker em um núcleo. AWS IoT Greengrass O conector usa o Compose do Docker para iniciar um aplicativo Docker de vários contêineres de um arquivo `docker-compose.yml`. Especificamente, o conector executa comandos `docker-compose` para gerenciar contêineres do Docker em um dispositivo de núcleo único. Para obter mais informações, consulte [Visão geral do Compose do Docker](https://docs.docker.com/compose/) na documentação do Docker. O conector pode acessar imagens do Docker armazenadas em registros de contêiner do Docker, como o Amazon Elastic Container Registry (Amazon ECR), Hub do Docker e registros confiáveis privados do Docker. Depois de implantar o grupo do Greengrass, o conector extrai as imagens mais recentes e inicia os contêineres do Docker. Ele executa o `docker-compose pull` e o comando `docker-compose up`. Depois, o conector publica o status do comando no [tópico MQTT de saída](#docker-app-connector-data-output). Ele também registra informações de status sobre a execução de contêineres do Docker. Isso possibilita que você monitore seus registros de aplicativos na Amazon CloudWatch. Para obter mais informações, consulte [Monitoramento com AWS IoT Greengrass registros](greengrass-logs-overview.md). O conector também inicia contêineres do Docker sempre que o daemon do Greengrass é reiniciado. O número de contêineres do Docker que podem ser executados no núcleo depende do seu hardware. Os contêineres do Docker são executados fora do domínio Greengrass no dispositivo de núcleo, portanto não podem acessar a IPC (Comunicação entre processos) do núcleo. No entanto, você pode configurar alguns canais de comunicação com componentes do Greengrass, como funções locais do Lambda. Para obter mais informações, consulte [Comunicar-se com os contêineres do Docker](#docker-app-connector-communicating). Você pode usar o conector para cenários como hospedagem de um servidor web ou servidor MySQL em seu dispositivo de núcleo. Os serviços locais em seus aplicativos Docker podem se comunicar entre si, com outros processos no ambiente local e com serviços em nuvem. Por exemplo, você pode executar um servidor Web no núcleo que envia solicitações de funções do Lambda para um serviço da Web na nuvem. Este conector é executado no modo de isolamento [Sem contêiner](lambda-group-config.md#no-container-mode) para que você possa implantá-lo em um grupo do Greengrass que é executado sem a conteinerização do Greengrass. Esse conector tem as seguintes versões. | Versão | ARN | | --- | --- | | 7 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/7` | | 6 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/6` | | 5 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/5` | | 4 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/4` | | 3 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/3` | | 2 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/2` | | 1 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/1` | Para obter informações sobre alterações de versão, consulte o [Changelog](#docker-app-connector-changelog). ## Requisitos Esse conector tem os seguintes requisitos: + AWS IoT Greengrass Software principal v1.10 ou posterior. **nota** Esse conector não é suportado em OpenWrt distribuições. + [Python](https://www.python.org/), versão 3.7 ou 3.8, instalado no dispositivo de núcleo e adicionado à variável de ambiente PATH. **nota** Para usar o Python 3.8, execute o comando a seguir para criar um symblink da pasta de instalação padrão do Python 3.7 para os binários instalados do Python 3.8. ``` sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7 ``` Isso configura seu dispositivo para atender ao requisito Python para AWS IoT Greengrass. + O mínimo de 36 MB de RAM no núcleo do Greengrass para que o conector monitore contêineres do Docker em execução. O requisito total de memória depende do número de contêineres do Docker executados no núcleo. + [Docker Engine](https://docs.docker.com/install/) 1.9.1 ou versão posterior instalado no núcleo do Greengrass. A versão 19.0.3 é a versão mais recente verificada para trabalhar com o conector. O executável `docker` deve estar no diretório `/usr/bin` ou `/usr/local/bin`. **Importante** Recomendamos que você instale um armazenamento de credenciais para proteger as cópias locais das suas credenciais do Docker. Para obter mais informações, consulte [Observações de segurança](#docker-app-connector-security). Para obter informações sobre como instalar o Docker nas distribuições do Amazon Linux, consulte [Noções básicas do Docker para o Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/docker-basics.html) no *Guia do desenvolvedor do Elastic Container da Amazon Service*. + [Compose do Docker](https://docs.docker.com/compose/install/) instalado no núcleo do Greengrass. O executável `docker-compose` deve estar no diretório `/usr/bin` ou `/usr/local/bin`. As versões a seguir do Docker Compose são verificadas para trabalhar com o conector. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/docker-app-connector.html) + Um único arquivo do Docker Compose (por exemplo, `docker-compose.yml`), armazenado no Amazon Simple Storage Service (Amazon S3). O formato deve ser compatível com a versão do Compose do Docker instalada no núcleo. Você deve testar o arquivo antes de usá-lo no núcleo. Se você editar o arquivo depois de implantar o grupo do Greengrass, será necessário reimplantar o grupo para atualizar sua cópia local no núcleo. + Um usuário Linux com permissão para chamar o daemon do Docker local e gravar no diretório que armazena a cópia local do arquivo Compose. Para obter mais informações, consulte [Configurar o usuário do Docker no núcleo](#docker-app-connector-linux-user). + A [função de grupo do Greengrass](group-role.md) configurada para permitir a ação `s3:GetObject` no bucket do S3 que contém o arquivo Compose. Essa permissão é exibida no exemplo de política do IAM a seguir. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowAccessToComposeFileS3Bucket", "Action": [ "s3:GetObject", "s3:GetObjectVersion" ], "Effect": "Allow", "Resource": "arn:aws:s3:::bucket-name/*" } ] } ``` ------ **nota** Se o bucket do S3 estiver habilitado para versionamento, a função deve ser configurada para permitir a ação `s3:GetObjectVersion` também. Para obter mais informações, consulte [Usando versionamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) no *Guia do usuário do Amazon Simple Storage Service*. Para o requisito de função de grupo, você deve configurar a função para conceder as permissões necessárias e certificar-se de que a função tenha sido adicionada ao grupo. Para acessar mais informações, consulte [Gerenciar a função de grupo do Greengrass (console)](group-role.md#manage-group-role-console) ou [Gerenciar a função de grupo do Greengrass (CLI)](group-role.md#manage-group-role-cli). + Se o arquivo Docker Compose fizer referência a uma imagem do Docker armazenada no Amazon ECR, a [função de grupo do Greengrass](group-role.md) deverá estar configurada para permitir o seguinte: + As ações `ecr:GetDownloadUrlForLayer` e `ecr:BatchGetImage` em seus repositórios do Amazon ECR que contêm as imagens do Docker. + A ação `ecr:GetAuthorizationToken` em seus recursos. Os repositórios devem estar no mesmo conector Conta da AWS e no Região da AWS mesmo. **Importante** As permissões na função de grupo podem ser assumidas por todos os conectores e funções do Lambda no grupo do Greengrass. Para obter mais informações, consulte [Observações de segurança](#docker-app-connector-security). Essas permissões são exibidas na política de exemplo a seguir. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowGetEcrRepositories", "Effect": "Allow", "Action": [ "ecr:GetDownloadUrlForLayer", "ecr:BatchGetImage" ], "Resource": [ "arn:aws:ecr:us-east-1:123456789012:repository/repository-name" ] }, { "Sid": "AllowGetEcrAuthToken", "Effect": "Allow", "Action": "ecr:GetAuthorizationToken", "Resource": "*" } ] } ``` ------ Para obter mais informações, consulte [Exemplos de políticas do repositório do Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/RepositoryPolicyExamples.html) no *Guia do usuário do Amazon ECR*. Para o requisito de função de grupo, você deve configurar a função para conceder as permissões necessárias e certificar-se de que a função tenha sido adicionada ao grupo. Para acessar mais informações, consulte [Gerenciar a função de grupo do Greengrass (console)](group-role.md#manage-group-role-console) ou [Gerenciar a função de grupo do Greengrass (CLI)](group-role.md#manage-group-role-cli). + Se o arquivo Compose do Docker fizer referência a uma imagem do Docker do [AWS Marketplace](https://aws.amazon.com/marketplace), o conector também terá os seguintes requisitos: + Você deve estar inscrito em produtos de AWS Marketplace contêiner. Para obter mais informações, consulte [Encontrar e assinar produtos de contêiner](https://docs.aws.amazon.com/marketplace/latest/buyerguide/buyer-finding-and-subscribing-to-container-products.html) no *Guia de assinantes do AWS Marketplace *. + AWS IoT Greengrass deve ser configurado para oferecer suporte a segredos locais, conforme descrito em [Requisitos de segredos](secrets.md#secrets-reqs). O conector usa esse recurso apenas para recuperar seus segredos AWS Secrets Manager, não para armazená-los. + Você deve criar um segredo no Secrets Manager para cada AWS Marketplace registro que armazena uma imagem do Docker referenciada em seu arquivo Compose. Para obter mais informações, consulte [Acessar imagens do Docker de repositórios privados](#access-private-repositories). + Se o arquivo Compose do Docker fizer referência a uma imagem do Docker de repositórios privados em registros que não sejam o Amazon ECR, como o Hub do Docker, o conector também terá os seguintes requisitos: + AWS IoT Greengrass deve ser configurado para oferecer suporte a segredos locais, conforme descrito em [Requisitos de segredos](secrets.md#secrets-reqs). O conector usa esse recurso apenas para recuperar seus segredos AWS Secrets Manager, não para armazená-los. + Você deve criar um segredo no Secrets Manager para cada repositório privado que armazena uma imagem do Docker referenciada no arquivo Compose. Para obter mais informações, consulte [Acessar imagens do Docker de repositórios privados](#access-private-repositories). + O daemon do Docker deve estar em execução quando você implantar um grupo do Greengrass que contenha esse conector. ### Acessar imagens do Docker de repositórios privados Se você usar credenciais para acessar suas imagens do Docker, será necessário permitir que o conector as acesse. A maneira de fazer isso dependerá de onde a imagem do Docker estiver localizada. Para imagens do Docker armazenadas no Amazon ECR, você concede permissão para obter seu token de autorização na função de grupo do Greengrass. Para obter mais informações, consulte [Requisitos](#docker-app-connector-req). Para imagens do Docker armazenadas em outros repositórios ou registros privados, você deve criar um segredo AWS Secrets Manager para armazenar suas informações de login. Isso inclui imagens do Docker nas quais você se inscreveu. AWS Marketplace Crie um segredo para cada repositório. Ao atualizar seus segredos no Secrets Manager, as alterações serão propagadas para o núcleo da próxima vez que você implantar o grupo. **nota** O Secrets Manager é um serviço que você pode usar para armazenar e gerenciar com segurança suas credenciais, chaves e outros segredos na Nuvem AWS. Para obter mais informações, consulte [O que é AWS Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) no *Guia do AWS Secrets Manager usuário*. Cada segredo deve conter as seguintes chaves: | Chave | Valor | | --- | --- | | `username` | O nome de usuário usado para acessar o repositório ou registro. | | `password` | A senha usada para acessar o repositório ou registro. | | `registryUrl` | O endpoint do registro. Isso deve corresponder ao URL de registro correspondente no arquivo Compose. | **nota** AWS IoT Greengrass Para permitir o acesso a um segredo por padrão, o nome do segredo deve começar com *greengrass-*. Caso contrário, sua função de serviço do Greengrass deverá conceder acesso. Para obter mais informações, consulte [AWS IoT Greengrass Permitir obter valores secretos](secrets.md#secrets-config-service-role). **Para obter informações de login para imagens do Docker no AWS Marketplace** 1. Obtenha sua senha para imagens do Docker AWS Marketplace usando o `aws ecr get-login-password` comando. Para obter mais informações, consulte [get-login-password](https://docs.aws.amazon.com/cli/latest/reference/ecr/get-login.html) na *Referência de comandos da AWS CLI *. ``` aws ecr get-login-password ``` 1. Recupere o URL do registro para a imagem do Docker. Abra o site do AWS Marketplace e abra a página de lançamento do produto em contêiner. Em **Imagens do contêiner**, selecione **Exibir detalhes da imagem do contêiner** para localizar o nome do usuário e o URL do registro. Use o nome de usuário, a senha e o URL do registro recuperados para criar um segredo para cada AWS Marketplace registro que armazena imagens do Docker referenciadas em seu arquivo Compose. **Como criar segredos (console)** No AWS Secrets Manager console, escolha **Outro tipo de segredos**. Em **Specify the key/value pairs to be stored for this secret (Especificar os pares de chave/valor a serem armazenados para este segredo)**, adicione as linhas para `username`, `password` e `registryUrl`: Para obter mais informações, consulte [Criar um segredo básico](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) no *Guia do usuário do AWS Secrets Manager *. ![\[Criar um segredo com nome de usuário, senha e chaves registryUrl.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/connectors/secret-docker-trusted-registry.png) **Como criar segredos (CLI)** No AWS CLI, use o `create-secret` comando Secrets Manager, conforme mostrado no exemplo a seguir. Para obter mais informações, consulte [create-secret](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/create-secret.html) na *AWS CLI Command Reference*. ``` aws secretsmanager create-secret --name greengrass-MySecret --secret-string [{"username":"Mary_Major"},{"password":"abc123xyz456"},{"registryUrl":"https://docker.io"}] ``` **Importante** Você é responsável por proteger o diretório `DockerComposeFileDestinationPath` que armazena seu arquivo Compose do Docker e as credenciais para suas imagens do Docker de repositórios privados. Para obter mais informações, consulte [Observações de segurança](#docker-app-connector-security). ## Parâmetros Esse conector oferece os seguintes parâmetros: ------ #### [ Version 7 ] `DockerComposeFileS3Bucket` O nome do bucket do S3 que contém o arquivo Compose do Docker. Ao criar o bucket, certifique-se de seguir as [regras para nomes de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritas no *Guia do usuário do Amazon Simple Storage Service*. Nome de exibição no AWS IoT console: **arquivo Docker Compose** no S3 No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `true` Digite: `string` Padrão válido `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` A chave de objeto do arquivo do Docker Compose no Amazon S3. Para obter mais informações, incluindo diretrizes de nomenclatura das chaves de objeto, consulte [Metadados e chaves de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) no *Guia do usuário do Amazon Simple Storage Service*. No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `true` Digite: `string` Padrão válido `.+` `DockerComposeFileS3Version` A versão de objeto do arquivo do Docker Compose no Amazon S3. Para obter mais informações, incluindo diretrizes de nomenclatura das chaves de objeto, consulte [Uso do versionamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) no *Guia do usuário do Amazon Simple Storage Service*. No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `false` Digite: `string` Padrão válido `.+` `DockerComposeFileDestinationPath` O caminho absoluto do diretório local usado para armazenar uma cópia do arquivo Compose do Docker. Esse deve ser um diretório existente. O usuário especificado para `DockerUserId` deve ter permissão para criar um arquivo neste diretório. Para obter mais informações, consulte [Configurando o usuário Docker no núcleo AWS IoT Greengrass](#docker-app-connector-linux-user). Este diretório armazena seu arquivo Compose do Docker e as credenciais para suas imagens do Docker de repositórios privados. Você é responsável por proteger este diretório. Para obter mais informações, consulte [Observações de segurança](#docker-app-connector-security). Nome de exibição no AWS IoT console: **caminho do diretório para o arquivo Compose local** Obrigatório: `true` Digite: `string` Padrão válido `\/.*\/?` Exemplo: `/home/username/myCompose` `DockerUserId` O UID do usuário Linux com o qual o conector é executado. Esse usuário deve pertencer ao grupo Linux `docker` no dispositivo de núcleo e ter permissões de gravação no diretório `DockerComposeFileDestinationPath`. Para obter mais informações, consulte [Configurar o usuário do Docker no núcleo](#docker-app-connector-linux-user). Convém evitar a execução como raiz, a menos que isso seja absolutamente necessário. Se você especificar o usuário raiz, é necessário permitir que as funções do Lambda sejam executadas como raiz no núcleo AWS IoT Greengrass . Para obter mais informações, consulte [Executar uma função do Lambda como raiz](lambda-group-config.md#lambda-running-as-root). Nome de exibição no AWS IoT console: ID de **usuário do Docker** Obrigatório: `false` Digite: `string` Padrão válido: `^[0-9]{1,5}$` `AWSSecretsArnList` Os nomes de recursos da Amazon (ARNs) dos segredos AWS Secrets Manager que contêm as informações de login usadas para acessar suas imagens do Docker em repositórios privados. Para obter mais informações, consulte [Acessar imagens do Docker de repositórios privados](#access-private-repositories). Nome de exibição no AWS IoT console: **Credenciais para repositórios privados** Obrigatório:`false`. Esse parâmetro é necessário para acessar imagens do Docker armazenadas em repositórios privados. Tipo: `array` de `string` Padrão válido: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` A frequência (em segundos) na qual o conector registra informações de status sobre os contêineres do Docker em execução no núcleo. O padrão é 300 segundos (5 minutos). Nome de exibição no AWS IoT console: **Frequência de registro** Obrigatório: `false` Digite: `string` Padrão válido: `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Indica se é preciso forçar a implantação do Docker em caso de falha devido à limpeza inadequada da última implantação. O valor padrão é `False`. Nome de exibição no AWS IoT console: **Forçar implantação** Obrigatório: `false` Digite: `string` Padrão válido: `^(true|false)$` `DockerPullBeforeUp` Indica se o implantador deve ser executado `docker-compose pull` antes `docker-compose up` de executar um pull-down-up comportamento. O valor padrão é `True`. Nome de exibição no AWS IoT console: **Docker Pull Before** Up Obrigatório: `false` Digite: `string` Padrão válido: `^(true|false)$` `StopContainersOnNewDeployment` Indica se o conector deve interromper os contêineres docker gerenciados pelo Docker Deployer quando o GGC é interrompido (o GGC para quando um novo grupo é implantado ou quando o kernel é desligado). O valor padrão é `True`. Nome de exibição no AWS IoT console: **parada do Docker na nova implantação** Recomendamos manter esse parâmetro definido com seu valor `True`padrão. O parâmetro para fazer `False` com que seu contêiner Docker continue em execução mesmo depois de encerrar o AWS IoT Greengrass núcleo ou iniciar uma nova implantação. Se você definir esse parâmetro como `False`, você deverá garantir que seus contêineres do Docker sejam mantidos conforme necessário no caso de uma alteração ou adição do nome do serviço `docker-compose`. Para obter mais informações, consulte a documentação dos arquivos do `docker-compose` Compose. Obrigatório: `false` Digite: `string` Padrão válido: `^(true|false)$` `DockerOfflineMode` Indica se é preciso usar o arquivo do Docker Compose existente quando o AWS IoT Greengrass iniciar offline. O valor padrão é `False`. Obrigatório: `false` Digite: `string` Padrão válido: `^(true|false)$` ------ #### [ Version 6 ] `DockerComposeFileS3Bucket` O nome do bucket do S3 que contém o arquivo Compose do Docker. Ao criar o bucket, certifique-se de seguir as [regras para nomes de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritas no *Guia do usuário do Amazon Simple Storage Service*. Nome de exibição no AWS IoT console: **arquivo Docker Compose** no S3 No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `true` Digite: `string` Padrão válido `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` A chave de objeto do arquivo do Docker Compose no Amazon S3. Para obter mais informações, incluindo diretrizes de nomenclatura das chaves de objeto, consulte [Metadados e chaves de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) no *Guia do usuário do Amazon Simple Storage Service*. No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `true` Digite: `string` Padrão válido `.+` `DockerComposeFileS3Version` A versão de objeto do arquivo do Docker Compose no Amazon S3. Para obter mais informações, incluindo diretrizes de nomenclatura das chaves de objeto, consulte [Uso do versionamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) no *Guia do usuário do Amazon Simple Storage Service*. No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `false` Digite: `string` Padrão válido `.+` `DockerComposeFileDestinationPath` O caminho absoluto do diretório local usado para armazenar uma cópia do arquivo Compose do Docker. Esse deve ser um diretório existente. O usuário especificado para `DockerUserId` deve ter permissão para criar um arquivo neste diretório. Para obter mais informações, consulte [Configurando o usuário Docker no núcleo AWS IoT Greengrass](#docker-app-connector-linux-user). Este diretório armazena seu arquivo Compose do Docker e as credenciais para suas imagens do Docker de repositórios privados. Você é responsável por proteger este diretório. Para obter mais informações, consulte [Observações de segurança](#docker-app-connector-security). Nome de exibição no AWS IoT console: **caminho do diretório para o arquivo Compose local** Obrigatório: `true` Digite: `string` Padrão válido `\/.*\/?` Exemplo: `/home/username/myCompose` `DockerUserId` O UID do usuário Linux com o qual o conector é executado. Esse usuário deve pertencer ao grupo Linux `docker` no dispositivo de núcleo e ter permissões de gravação no diretório `DockerComposeFileDestinationPath`. Para obter mais informações, consulte [Configurar o usuário do Docker no núcleo](#docker-app-connector-linux-user). Convém evitar a execução como raiz, a menos que isso seja absolutamente necessário. Se você especificar o usuário raiz, é necessário permitir que as funções do Lambda sejam executadas como raiz no núcleo AWS IoT Greengrass . Para obter mais informações, consulte [Executar uma função do Lambda como raiz](lambda-group-config.md#lambda-running-as-root). Nome de exibição no AWS IoT console: ID de **usuário do Docker** Obrigatório: `false` Digite: `string` Padrão válido: `^[0-9]{1,5}$` `AWSSecretsArnList` Os nomes de recursos da Amazon (ARNs) dos segredos AWS Secrets Manager que contêm as informações de login usadas para acessar suas imagens do Docker em repositórios privados. Para obter mais informações, consulte [Acessar imagens do Docker de repositórios privados](#access-private-repositories). Nome de exibição no AWS IoT console: **Credenciais para repositórios privados** Obrigatório:`false`. Esse parâmetro é necessário para acessar imagens do Docker armazenadas em repositórios privados. Tipo: `array` de `string` Padrão válido: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` A frequência (em segundos) na qual o conector registra informações de status sobre os contêineres do Docker em execução no núcleo. O padrão é 300 segundos (5 minutos). Nome de exibição no AWS IoT console: **Frequência de registro** Obrigatório: `false` Digite: `string` Padrão válido: `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Indica se é preciso forçar a implantação do Docker em caso de falha devido à limpeza inadequada da última implantação. O valor padrão é `False`. Nome de exibição no AWS IoT console: **Forçar implantação** Obrigatório: `false` Digite: `string` Padrão válido: `^(true|false)$` `DockerPullBeforeUp` Indica se o implantador deve ser executado `docker-compose pull` antes `docker-compose up` de executar um pull-down-up comportamento. O valor padrão é `True`. Nome de exibição no AWS IoT console: **Docker Pull Before** Up Obrigatório: `false` Digite: `string` Padrão válido: `^(true|false)$` `StopContainersOnNewDeployment` Indica se o conector deve interromper os contêineres docker gerenciados pelo Docker Deployer quando o GGC é interrompido (quando uma nova implantação em grupo é feita ou quando o kernel é desligado). O valor padrão é `True`. Nome de exibição no AWS IoT console: **parada do Docker na nova implantação** Recomendamos manter esse parâmetro definido com seu valor `True`padrão. O parâmetro para fazer `False` com que seu contêiner Docker continue em execução mesmo depois de encerrar o AWS IoT Greengrass núcleo ou iniciar uma nova implantação. Se você definir esse parâmetro como `False`, você deverá garantir que seus contêineres do Docker sejam mantidos conforme necessário no caso de uma alteração ou adição do nome do serviço `docker-compose`. Para obter mais informações, consulte a documentação dos arquivos do `docker-compose` Compose. Obrigatório: `false` Digite: `string` Padrão válido: `^(true|false)$` ------ #### [ Version 5 ] `DockerComposeFileS3Bucket` O nome do bucket do S3 que contém o arquivo Compose do Docker. Ao criar o bucket, certifique-se de seguir as [regras para nomes de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritas no *Guia do usuário do Amazon Simple Storage Service*. Nome de exibição no AWS IoT console: **arquivo Docker Compose** no S3 No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `true` Digite: `string` Padrão válido `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` A chave de objeto do arquivo do Docker Compose no Amazon S3. Para obter mais informações, incluindo diretrizes de nomenclatura das chaves de objeto, consulte [Metadados e chaves de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) no *Guia do usuário do Amazon Simple Storage Service*. No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `true` Digite: `string` Padrão válido `.+` `DockerComposeFileS3Version` A versão de objeto do arquivo do Docker Compose no Amazon S3. Para obter mais informações, incluindo diretrizes de nomenclatura das chaves de objeto, consulte [Uso do versionamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) no *Guia do usuário do Amazon Simple Storage Service*. No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `false` Digite: `string` Padrão válido `.+` `DockerComposeFileDestinationPath` O caminho absoluto do diretório local usado para armazenar uma cópia do arquivo Compose do Docker. Esse deve ser um diretório existente. O usuário especificado para `DockerUserId` deve ter permissão para criar um arquivo neste diretório. Para obter mais informações, consulte [Configurando o usuário Docker no núcleo AWS IoT Greengrass](#docker-app-connector-linux-user). Este diretório armazena seu arquivo Compose do Docker e as credenciais para suas imagens do Docker de repositórios privados. Você é responsável por proteger este diretório. Para obter mais informações, consulte [Observações de segurança](#docker-app-connector-security). Nome de exibição no AWS IoT console: **caminho do diretório para o arquivo Compose local** Obrigatório: `true` Digite: `string` Padrão válido `\/.*\/?` Exemplo: `/home/username/myCompose` `DockerUserId` O UID do usuário Linux com o qual o conector é executado. Esse usuário deve pertencer ao grupo Linux `docker` no dispositivo de núcleo e ter permissões de gravação no diretório `DockerComposeFileDestinationPath`. Para obter mais informações, consulte [Configurar o usuário do Docker no núcleo](#docker-app-connector-linux-user). Convém evitar a execução como raiz, a menos que isso seja absolutamente necessário. Se você especificar o usuário raiz, é necessário permitir que as funções do Lambda sejam executadas como raiz no núcleo AWS IoT Greengrass . Para obter mais informações, consulte [Executar uma função do Lambda como raiz](lambda-group-config.md#lambda-running-as-root). Nome de exibição no AWS IoT console: ID de **usuário do Docker** Obrigatório: `false` Digite: `string` Padrão válido: `^[0-9]{1,5}$` `AWSSecretsArnList` Os nomes de recursos da Amazon (ARNs) dos segredos AWS Secrets Manager que contêm as informações de login usadas para acessar suas imagens do Docker em repositórios privados. Para obter mais informações, consulte [Acessar imagens do Docker de repositórios privados](#access-private-repositories). Nome de exibição no AWS IoT console: **Credenciais para repositórios privados** Obrigatório:`false`. Esse parâmetro é necessário para acessar imagens do Docker armazenadas em repositórios privados. Tipo: `array` de `string` Padrão válido: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` A frequência (em segundos) na qual o conector registra informações de status sobre os contêineres do Docker em execução no núcleo. O padrão é 300 segundos (5 minutos). Nome de exibição no AWS IoT console: **Frequência de registro** Obrigatório: `false` Digite: `string` Padrão válido: `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Indica se é preciso forçar a implantação do Docker em caso de falha devido à limpeza inadequada da última implantação. O valor padrão é `False`. Nome de exibição no AWS IoT console: **Forçar implantação** Obrigatório: `false` Digite: `string` Padrão válido: `^(true|false)$` `DockerPullBeforeUp` Indica se o implantador deve ser executado `docker-compose pull` antes `docker-compose up` de executar um pull-down-up comportamento. O valor padrão é `True`. Nome de exibição no AWS IoT console: **Docker Pull Before** Up Obrigatório: `false` Digite: `string` Padrão válido: `^(true|false)$` ------ #### [ Versions 2 - 4 ] `DockerComposeFileS3Bucket` O nome do bucket do S3 que contém o arquivo Compose do Docker. Ao criar o bucket, certifique-se de seguir as [regras para nomes de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritas no *Guia do usuário do Amazon Simple Storage Service*. Nome de exibição no AWS IoT console: **arquivo Docker Compose** no S3 No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `true` Digite: `string` Padrão válido `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` A chave de objeto do arquivo do Docker Compose no Amazon S3. Para obter mais informações, incluindo diretrizes de nomenclatura das chaves de objeto, consulte [Metadados e chaves de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) no *Guia do usuário do Amazon Simple Storage Service*. No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `true` Digite: `string` Padrão válido `.+` `DockerComposeFileS3Version` A versão de objeto do arquivo do Docker Compose no Amazon S3. Para obter mais informações, incluindo diretrizes de nomenclatura das chaves de objeto, consulte [Uso do versionamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) no *Guia do usuário do Amazon Simple Storage Service*. No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `false` Digite: `string` Padrão válido `.+` `DockerComposeFileDestinationPath` O caminho absoluto do diretório local usado para armazenar uma cópia do arquivo Compose do Docker. Esse deve ser um diretório existente. O usuário especificado para `DockerUserId` deve ter permissão para criar um arquivo neste diretório. Para obter mais informações, consulte [Configurando o usuário Docker no núcleo AWS IoT Greengrass](#docker-app-connector-linux-user). Este diretório armazena seu arquivo Compose do Docker e as credenciais para suas imagens do Docker de repositórios privados. Você é responsável por proteger este diretório. Para obter mais informações, consulte [Observações de segurança](#docker-app-connector-security). Nome de exibição no AWS IoT console: **caminho do diretório para o arquivo Compose local** Obrigatório: `true` Digite: `string` Padrão válido `\/.*\/?` Exemplo: `/home/username/myCompose` `DockerUserId` O UID do usuário Linux com o qual o conector é executado. Esse usuário deve pertencer ao grupo Linux `docker` no dispositivo de núcleo e ter permissões de gravação no diretório `DockerComposeFileDestinationPath`. Para obter mais informações, consulte [Configurar o usuário do Docker no núcleo](#docker-app-connector-linux-user). Convém evitar a execução como raiz, a menos que isso seja absolutamente necessário. Se você especificar o usuário raiz, é necessário permitir que as funções do Lambda sejam executadas como raiz no núcleo AWS IoT Greengrass . Para obter mais informações, consulte [Executar uma função do Lambda como raiz](lambda-group-config.md#lambda-running-as-root). Nome de exibição no AWS IoT console: ID de **usuário do Docker** Obrigatório: `false` Digite: `string` Padrão válido: `^[0-9]{1,5}$` `AWSSecretsArnList` Os nomes de recursos da Amazon (ARNs) dos segredos AWS Secrets Manager que contêm as informações de login usadas para acessar suas imagens do Docker em repositórios privados. Para obter mais informações, consulte [Acessar imagens do Docker de repositórios privados](#access-private-repositories). Nome de exibição no AWS IoT console: **Credenciais para repositórios privados** Obrigatório:`false`. Esse parâmetro é necessário para acessar imagens do Docker armazenadas em repositórios privados. Tipo: `array` de `string` Padrão válido: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` A frequência (em segundos) na qual o conector registra informações de status sobre os contêineres do Docker em execução no núcleo. O padrão é 300 segundos (5 minutos). Nome de exibição no AWS IoT console: **Frequência de registro** Obrigatório: `false` Digite: `string` Padrão válido: `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Indica se é preciso forçar a implantação do Docker em caso de falha devido à limpeza inadequada da última implantação. O valor padrão é `False`. Nome de exibição no AWS IoT console: **Forçar implantação** Obrigatório: `false` Digite: `string` Padrão válido: `^(true|false)$` ------ #### [ Version 1 ] `DockerComposeFileS3Bucket` O nome do bucket do S3 que contém o arquivo Compose do Docker. Ao criar o bucket, certifique-se de seguir as [regras para nomes de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritas no *Guia do usuário do Amazon Simple Storage Service*. Nome de exibição no AWS IoT console: **arquivo Docker Compose** no S3 No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `true` Digite: `string` Padrão válido `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` A chave de objeto do arquivo do Docker Compose no Amazon S3. Para obter mais informações, incluindo diretrizes de nomenclatura das chaves de objeto, consulte [Metadados e chaves de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) no *Guia do usuário do Amazon Simple Storage Service*. No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `true` Digite: `string` Padrão válido `.+` `DockerComposeFileS3Version` A versão de objeto do arquivo do Docker Compose no Amazon S3. Para obter mais informações, incluindo diretrizes de nomenclatura das chaves de objeto, consulte [Uso do versionamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) no *Guia do usuário do Amazon Simple Storage Service*. No console, a propriedade **Docker Compose file in S3 (Arquivo Compose do Docker no S3)** combina os parâmetros `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` e `DockerComposeFileS3Version`. Obrigatório: `false` Digite: `string` Padrão válido `.+` `DockerComposeFileDestinationPath` O caminho absoluto do diretório local usado para armazenar uma cópia do arquivo Compose do Docker. Esse deve ser um diretório existente. O usuário especificado para `DockerUserId` deve ter permissão para criar um arquivo neste diretório. Para obter mais informações, consulte [Configurando o usuário Docker no núcleo AWS IoT Greengrass](#docker-app-connector-linux-user). Este diretório armazena seu arquivo Compose do Docker e as credenciais para suas imagens do Docker de repositórios privados. Você é responsável por proteger este diretório. Para obter mais informações, consulte [Observações de segurança](#docker-app-connector-security). Nome de exibição no AWS IoT console: **caminho do diretório para o arquivo Compose local** Obrigatório: `true` Digite: `string` Padrão válido `\/.*\/?` Exemplo: `/home/username/myCompose` `DockerUserId` O UID do usuário Linux com o qual o conector é executado. Esse usuário deve pertencer ao grupo Linux `docker` no dispositivo de núcleo e ter permissões de gravação no diretório `DockerComposeFileDestinationPath`. Para obter mais informações, consulte [Configurar o usuário do Docker no núcleo](#docker-app-connector-linux-user). Convém evitar a execução como raiz, a menos que isso seja absolutamente necessário. Se você especificar o usuário raiz, é necessário permitir que as funções do Lambda sejam executadas como raiz no núcleo AWS IoT Greengrass . Para obter mais informações, consulte [Executar uma função do Lambda como raiz](lambda-group-config.md#lambda-running-as-root). Nome de exibição no AWS IoT console: ID de **usuário do Docker** Obrigatório: `false` Digite: `string` Padrão válido: `^[0-9]{1,5}$` `AWSSecretsArnList` Os nomes de recursos da Amazon (ARNs) dos segredos AWS Secrets Manager que contêm as informações de login usadas para acessar suas imagens do Docker em repositórios privados. Para obter mais informações, consulte [Acessar imagens do Docker de repositórios privados](#access-private-repositories). Nome de exibição no AWS IoT console: **Credenciais para repositórios privados** Obrigatório:`false`. Esse parâmetro é necessário para acessar imagens do Docker armazenadas em repositórios privados. Tipo: `array` de `string` Padrão válido: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` A frequência (em segundos) na qual o conector registra informações de status sobre os contêineres do Docker em execução no núcleo. O padrão é 300 segundos (5 minutos). Nome de exibição no AWS IoT console: **Frequência de registro** Obrigatório: `false` Digite: `string` Padrão válido: `^[1-9]{1}[0-9]{0,3}$` ------ ### Exemplo de criação de conector (AWS CLI) O seguinte comando da CLI cria um `ConnectorDefinition` com uma versão inicial que contém o conector de implantação do aplicativo do Docker do Greengrass. ``` aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyDockerAppplicationDeploymentConnector", "ConnectorArn": "arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/5", "Parameters": { "DockerComposeFileS3Bucket": "amzn-s3-demo-bucket", "DockerComposeFileS3Key": "production-docker-compose.yml", "DockerComposeFileS3Version": "123", "DockerComposeFileDestinationPath": "/home/username/myCompose", "DockerUserId": "1000", "AWSSecretsArnList": "[\"arn:aws:secretsmanager:region:account-id:secret:greengrass-secret1-hash\",\"arn:aws:secretsmanager:region:account-id:secret:greengrass-secret2-hash\"]", "DockerContainerStatusLogFrequency": "30", "ForceDeploy": "True", "DockerPullBeforeUp": "True" } } ] }' ``` **nota** A função do Lambda nesse conector tem um ciclo de vida [longo](lambda-functions.md#lambda-lifecycle). ## Dados de entrada Este conector não requer nem aceita dados de entrada. ## Dados de saída Este conector publica o status do comando `docker-compose up` como dados de saída. **Filtro de tópico na assinatura** `dockerapplicationdeploymentconnector/message/status` **Exemplo de resultado: sucesso** ``` { "status":"success", "GreengrassDockerApplicationDeploymentStatus":"Successfully triggered docker-compose up", "S3Bucket":"amzn-s3-demo-bucket", "ComposeFileName":"production-docker-compose.yml", "ComposeFileVersion":"123" } ``` **Exemplo de resultado: falha** ``` { "status":"fail", "error_message":"description of error", "error":"InvalidParameter" } ``` O tipo de erro pode ser `InvalidParameter` ou `InternalError`. ## Configurando o usuário Docker no núcleo AWS IoT Greengrass O conector de implantação do aplicativo do Docker do Greengrass é executado como o usuário especificado para o parâmetro `DockerUserId`. Se você não especificar um valor, o conector será executado como `ggc_user`, que é a identidade de acesso padrão do Greengrass. Para permitir que o conector interaja com o daemon do Docker, o usuário do Docker deve pertencer ao grupo Linux do `docker` no núcleo. O usuário do Docker também deve ter permissões de gravação no diretório `DockerComposeFileDestinationPath`. Esse é o local em que o conector armazena o arquivo local `docker-compose.yml` e as credenciais do Docker. **nota** Recomendamos que você crie um usuário Linux em vez de usar o padrão `ggc_user`. Caso contrário, qualquer função do Lambda no grupo do Greengrass poderá acessar o arquivo Compose e as credenciais do Docker. Convém evitar a execução como raiz, a menos que isso seja absolutamente necessário. Se você especificar o usuário raiz, é necessário permitir que as funções do Lambda sejam executadas como raiz no núcleo AWS IoT Greengrass . Para obter mais informações, consulte [Executar uma função do Lambda como raiz](lambda-group-config.md#lambda-running-as-root). 1. Crie o usuário. Você pode executar o comando `useradd` e incluir a opção `-u` opcional para atribuir um UID. Por exemplo: ``` sudo useradd -u 1234 user-name ``` 1. Adicione o usuário ao grupo `docker` no núcleo. Por exemplo: ``` sudo usermod -aG docker user-name ``` Para obter mais informações, incluindo como criar o grupo `docker`, consulte [Gerenciar Docker como usuário não raiz](https://docs.docker.com/install/linux/linux-postinstall/#manage-docker-as-a-non-root-user) na documentação do Docker. 1. Conceda ao usuário permissão para gravação no diretório especificado para o parâmetro `DockerComposeFileDestinationPath`. Por exemplo: 1. Para definir o usuário como proprietário do diretório. Este exemplo usa o UID da etapa 1. ``` chown 1234 docker-compose-file-destination-path ``` 1. Conceda permissões de leitura e gravação ao proprietário. ``` chmod 700 docker-compose-file-destination-path ``` Para obter mais informações, consulte [Como gerenciar permissões para arquivos e pastas no Linux](https://www.linux.com/tutorials/how-manage-file-and-folder-permissions-linux/) na documentação do Linux Foundation. 1. Caso você não tenha atribuído um UID ao criar o usuário, ou ainda, caso tenha usado um usuário existente, execute o comando `id` para pesquisar o UID. ``` id -u user-name ``` Use o UID para configurar o parâmetro `DockerUserId` para o conector. ## Informações de uso Ao usar o conector de implantação do aplicativo do Docker do Greengrass, você deve estar ciente das seguintes informações de uso específicas da implementação. + **Prefixo fixo para nomes de projeto.** O conector prepõe o prefixo `greengrassdockerapplicationdeployment` para os nomes dos contêineres do Docker que inicia. O conector usa esse prefixo como o nome do projeto nos comandos `docker-compose` que executa. + **Comportamento de log.** O conector grava informações de status e de solução de problemas em um arquivo de log. Você pode configurar AWS IoT Greengrass para enviar registros para o CloudWatch Logs e gravar registros localmente. Para obter mais informações, consulte [Registro em log para conectores](connectors.md#connectors-logging). Este é o caminho para o log local do conector: ``` /greengrass-root/ggc/var/log/user/region/aws/DockerApplicationDeployment.log ``` Você deve ter permissões root para acessar logs locais. + **Atualizando as imagens do Docker.** O Docker armazena imagens em cache no dispositivo de núcleo. Se você atualizar uma imagem do Docker e quiser propagar a alteração para o dispositivo de núcleo, certifique-se de alterar a tag da imagem no arquivo Compose. As alterações entram em vigor após a implantação do grupo do Greengrass. + **Tempo limite de 10 minutos para operações de limpeza.** Quando o daemon do Greengrass é interrompido durante uma reinicialização, o comando `docker-compose down` é iniciado. Todos os contêineres do Docker têm duração máxima de 10 minutos após o `docker-compose down` ser iniciado para executar uma operação de limpeza. Se a limpeza não for concluída em 10 minutos, você deverá limpar os contêineres restantes manualmente. Para obter mais informações, consulte [docker rm](https://docs.docker.com/engine/reference/commandline/rm/) na documentação da CLI do Docker. + **Executando comandos do Docker.** Para solucionar problemas, você pode executar comandos do Docker em uma janela de terminal no dispositivo de núcleo. Por exemplo, execute o seguinte comando para visualizar os contêineres do Docker que foram iniciados pelo conector: ``` docker ps --filter name="greengrassdockerapplicationdeployment" ``` + **ID de recurso reservado.** O conector usa o ID `DOCKER_DEPLOYER_SECRET_RESOURCE_RESERVED_ID_index` para os recursos do Greengrass criados por ele no grupo do Greengrass. O recurso IDs deve ser exclusivo no grupo, portanto, não atribua uma ID de recurso que possa entrar em conflito com essa ID de recurso reservada. + **Modo off-line.** Quando você define o parâmetro de configuração `DockerOfflineMode` como `True`, o conector do Docker pode operar no *modo offline*. Isso pode acontecer quando a implantação de um grupo do Greengrass é reiniciada enquanto o dispositivo principal está off-line e o conector não consegue estabelecer uma conexão com o Amazon S3 nem com o Amazon ECR para recuperar o arquivo do Docker Compose. Com o modo off-line ativado, o conector tenta baixar seu arquivo do Compose e executar comandos `docker login` como faria em uma reinicialização normal. Se essas tentativas falharem, o conector procurará um arquivo do Compose armazenado localmente na pasta especificada usando o parâmetro `DockerComposeFileDestinationPath`. Se existir um arquivo do Compose local, o conector seguirá a sequência normal de comandos `docker-compose` e extrairá as imagens locais. Se o arquivo do Compose ou as imagens locais não estiverem presentes, o conector falhará. O comportamento dos parâmetros `ForceDeploy` e `StopContainersOnNewDeployment` permanece o mesmo no modo off-line. ## Comunicar-se com os contêineres do Docker AWS IoT Greengrass suporta os seguintes canais de comunicação entre os componentes do Greengrass e os contêineres Docker: + As funções Lambda do Greengrass podem usar REST APIs para se comunicar com processos em contêineres Docker. Você pode configurar um servidor em um contêiner do Docker que abre uma porta. As funções do Lambda podem se comunicar com o contêiner nessa porta. + Os processos em contêineres do Docker podem trocar mensagens MQTT por meio do atendente de mensagens local do Greengrass. Você pode configurar o contêiner Docker como um dispositivo cliente no grupo Greengrass e, em seguida, criar assinaturas para permitir que o contêiner se comunique com as funções do Greengrass Lambda, dispositivos cliente e outros conectores no grupo, ou com o serviço paralelo local. AWS IoT Para obter mais informações, consulte [Configurar a comunicação MQTT com contêineres do Docker](#docker-app-connector-mqtt-communication). + As funções do Lambda do Greengrass podem atualizar um arquivo compartilhado para passar informações para contêineres do Docker. Você pode usar o arquivo Compose para a vinculação-montagem do caminho do arquivo compartilhado para um contêiner do Docker. ### Configurar a comunicação MQTT com contêineres do Docker Você pode configurar um contêiner do Docker como dispositivo cliente do Greengrass e adicioná-lo a um grupo do Greengrass. Em seguida, você pode criar assinaturas que permitem a comunicação MQTT entre o contêiner do Docker e os componentes do Greengrass ou a AWS IoT. No procedimento a seguir, você cria uma assinatura que permite que o dispositivo de contêiner do Docker receba mensagens de atualização de shadow do serviço de shadow local. Você pode seguir esse padrão para criar outras assinaturas. **nota** Esse procedimento supõe que você já criou um grupo do Greengrass e um núcleo do Greengrass (v1.10 ou posterior). Para obter informações sobre a criação de em grupo e de núcleos do Greengrass, consulte [Começando com AWS IoT Greengrass](gg-gs.md). **Para configurar um contêiner do Docker como dispositivo cliente do Greengrass e adicioná-lo a um grupo do Greengrass** 1. Crie uma pasta no dispositivo de núcleo para armazenar os certificados e chaves usados para autenticar o dispositivo do Greengrass. O caminho do arquivo deve ser montado no contêiner do Docker que você deseja iniciar. O snippet a seguir mostra como montar um caminho de arquivo no arquivo Compose. Neste exemplo, *path-to-device-certs* representa a pasta que você criou nesta etapa. ``` version: '3.3' services: myService: image: user-name/repo:image-tag volumes: - /path-to-device-certs/:/path-accessible-in-container ``` 1. No painel de navegação do AWS IoT console, em **Gerenciar**, expanda dispositivos **Greengrass** e **escolha Grupos (**V1). 1. Selecione o grupo de destino. 1. Na página de configuração do grupo, selecione **Dispositivos cliente** e, em seguida, selecione **Associar**. 1. No modal **Associar um dispositivo cliente a este grupo**, escolha **Criar AWS IoT coisa nova**. A página **Criar coisas** é aberta em uma nova guia. 1. Na página **Criar coisas**, selecione **Criar uma única coisa**, em seguida, selecione **Avançar**. 1. Na página **Especificar propriedades da coisa**, insira um nome para o dispositivo e, em seguida, selecione **Avançar**. 1. Na página **Configurar certificado do dispositivo**, selecione **Avançar**. 1. Na página **Anexar políticas ao certificado**, execute uma das seguintes ações: + Selecione uma política existente que conceda as permissões exigidas pelos dispositivos cliente e, em seguida, selecione **Criar coisa**. Um modal é aberto, onde você pode baixar os certificados e as chaves que o dispositivo usa para se conectar ao Nuvem AWS núcleo. + Crie e anexe uma nova política que conceda permissões ao dispositivo cliente. Faça o seguinte: 1. Selecione **Create policy** (Criar política). A página **Create policy (Criar política)** é aberta em uma nova guia. 1. Na página **Create policy (Criar política)** faça o seguinte: 1. Em **Nome da política**, insira um nome que descreva a política, como **GreengrassV1ClientDevicePolicy**. 1. Na guia **Instruções da política**, em **Documento da política**, selecione **JSON**. 1. Insira o seguinte documento de política. Essa política permite que o dispositivo cliente descubra os núcleos do Greengrass e se comunique sobre todos os tópicos do MQTT. Para obter informações sobre como restringir o acesso a essa política, consulte [Autenticação e autorização de dispositivos para AWS IoT Greengrass](device-auth.md). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iot:Publish", "iot:Subscribe", "iot:Connect", "iot:Receive" ], "Resource": [ "*" ] }, { "Effect": "Allow", "Action": [ "greengrass:*" ], "Resource": [ "*" ] } ] } ``` ------ 1. Selecione **Create** (Criar) para criar a política. 1. Volte para a guia do navegador com a página **Anexar políticas ao certificado** aberta. Faça o seguinte: 1. Na lista **Políticas**, selecione a política que você criou, como **GreengrassV1ClientDevicePolicy**. Se a política não for exibida, selecione o botão de atualização. 1. Selecione **Criar coisa**. Um modal é aberto, onde você pode baixar os certificados e as chaves que o dispositivo usa para se conectar ao Nuvem AWS núcleo. 1. No modal **Baixar certificados e chaves**, baixe os certificados do dispositivo. **Importante** Antes de selecionar **Concluído**, faça download dos recursos de segurança. Faça o seguinte: 1. Em **Certificado do dispositivo**, selecione **Download** para baixar o certificado do dispositivo. 1. Em **Arquivo de chave pública**, selecione **Download** para baixar a chave pública do certificado. 1. Em **Arquivo de chave privada**, selecione **Download** para baixar o arquivo de chave privada para o certificado. 1. Revise [Autenticação do servidor](https://docs.aws.amazon.com/iot/latest/developerguide/server-authentication.html) no *Guia do desenvolvedor da AWS IoT * e, em seguida selecione o certificado de CA raiz apropriado. Recomendamos que você use endpoints do Amazon Trust Services (ATS) e certificados raiz da CA do ATS. Em **Certificados CA raiz**, selecione **Download** para obter um certificado de CA raiz. 1. Selecione **Done** (Concluído). Anote a ID do certificado, que é comum nos nomes dos arquivos do certificado e das chaves do dispositivo. Você precisará disso mais tarde. 1. Copie os certificados e as chaves na pasta criada na etapa 1. Em seguida, crie uma assinatura no grupo. Neste exemplo, você cria uma assinatura que permite que o dispositivo de contêiner do Docker receba mensagens MQTT do serviço de shadow local. **nota** O tamanho máximo de um documento do shadow é 8 KB. Para obter mais informações, consulte [Cotas do AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/limits-iot.html) no *Guia do desenvolvedor do AWS IoT *. **Para criar uma assinatura que permita que o dispositivo de contêiner do Docker receba mensagens MQTT do serviço de shadow local** 1. Na página de configuração do grupo, selecione a guia **Assinaturas** e, em seguida, **Adicionar assinatura**. 1. Na página **Select your source and target**, configure a origem e o destino, da seguinte forma: 1. Para **Select a source (Selecione uma origem)**, selecione **Serviços** e **Serviço de sombra local**. 1. Em **Selecionar um destino**, selecione **Devices (Dispositivos)** e o seu dispositivo. 1. Selecione **Next** (Próximo). 1. Na página **Filtrar seus dados com um tópico**, em **Filtro de tópico**, selecione **\$1aws/things/*MyDockerDevice*/shadow/update/accepted** e, em seguida selecione **Avançar**. *MyDockerDevice*Substitua pelo nome do dispositivo que você criou anteriormente. 1. Selecione **Finish**. Inclua o snippet de código a seguir na imagem do Docker a qual você faz referência no arquivo Compose. Esse é o código de dispositivo do Greengrass. Além disso, adicione o código ao contêiner do Docker que inicia o dispositivo do Greengrass dentro do contêiner. Ele pode ser executado como processo separado na imagem, ou em um thread separado. ``` import os import sys import time import uuid from AWSIoTPythonSDK.core.greengrass.discovery.providers import DiscoveryInfoProvider from AWSIoTPythonSDK.exception.AWSIoTExceptions import DiscoveryInvalidRequestException from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient # Replace thingName with the name you registered for the Docker device. thingName = "MyDockerDevice" clientId = thingName # Replace host with the IoT endpoint for your &AWS-account;. host = "myPrefix.iot.region.amazonaws.com" # Replace topic with the topic where the Docker container subscribes. topic = "$aws/things/MyDockerDevice/shadow/update/accepted" # Replace these paths based on the download location of the certificates for the Docker container. rootCAPath = "/path-accessible-in-container/AmazonRootCA1.pem" certificatePath = "/path-accessible-in-container/certId-certificate.pem.crt" privateKeyPath = "/path-accessible-in-container/certId-private.pem.key" # Discover Greengrass cores. discoveryInfoProvider = DiscoveryInfoProvider() discoveryInfoProvider.configureEndpoint(host) discoveryInfoProvider.configureCredentials(rootCAPath, certificatePath, privateKeyPath) discoveryInfoProvider.configureTimeout(10) # 10 seconds. GROUP_CA_PATH = "./groupCA/" MQTT_QOS = 1 discovered = False groupCA = None coreInfo = None try: # Get discovery info from AWS IoT. discoveryInfo = discoveryInfoProvider.discover(thingName) caList = discoveryInfo.getAllCas() coreList = discoveryInfo.getAllCores() # Use first discovery result. groupId, ca = caList[0] coreInfo = coreList[0] # Save the group CA to a local file. groupCA = GROUP_CA_PATH + groupId + "_CA_" + str(uuid.uuid4()) + ".crt" if not os.path.exists(GROUP_CA_PATH): os.makedirs(GROUP_CA_PATH) groupCAFile = open(groupCA, "w") groupCAFile.write(ca) groupCAFile.close() discovered = True except DiscoveryInvalidRequestException as e: print("Invalid discovery request detected!") print("Type: %s" % str(type(e))) print("Error message: %s" % str(e)) print("Stopping...") except BaseException as e: print("Error in discovery!") print("Type: %s" % str(type(e))) print("Error message: %s" % str(e)) print("Stopping...") myAWSIoTMQTTClient = AWSIoTMQTTClient(clientId) myAWSIoTMQTTClient.configureCredentials(groupCA, privateKeyPath, certificatePath) # Try to connect to the Greengrass core. connected = False for connectivityInfo in coreInfo.connectivityInfoList: currentHost = connectivityInfo.host currentPort = connectivityInfo.port myAWSIoTMQTTClient.configureEndpoint(currentHost, currentPort) try: myAWSIoTMQTTClient.connect() connected = True except BaseException as e: print("Error in connect!") print("Type: %s" % str(type(e))) print("Error message: %s" % str(e)) if connected: break if not connected: print("Cannot connect to core %s. Exiting..." % coreInfo.coreThingArn) sys.exit(-2) # Handle the MQTT message received from GGShadowService. def customCallback(client, userdata, message): print("Received an MQTT message") print(message) # Subscribe to the MQTT topic. myAWSIoTMQTTClient.subscribe(topic, MQTT_QOS, customCallback) # Keep the process alive to listen for messages. while True: time.sleep(1) ``` ## Observações de segurança Ao usar o conector de implantação do aplicativo do Docker do Greengrass, esteja ciente das seguintes considerações de segurança. **Armazenamento local do arquivo Compose do Docker** O conector armazena uma cópia do arquivo Compose no diretório especificado para o parâmetro `DockerComposeFileDestinationPath`. Você é responsável por proteger esse diretório. Você deve usar permissões do sistema de arquivos para restringir o acesso ao diretório. **Armazenamento local das credenciais do Docker** Se as imagens do Docker estiverem armazenadas em repositórios privados, o conector armazenará suas credenciais do Docker no diretório especificado para o parâmetro `DockerComposeFileDestinationPath`. Você é responsável por proteger essas credenciais. Por exemplo, use [credential-helper](https://docs.docker.com/engine/reference/commandline/login/#credentials-store) no dispositivo de núcleo ao instalar o Docker Engine. **Instalar o Docker Engine de uma fonte confiável** Você é responsável por instalar o Docker Engine de uma fonte confiável. Esse conector usa o daemon do Docker no dispositivo de núcleo para acessar seus ativos do Docker e gerenciar contêineres do Docker. **Escopo das permissões de função de grupo do Greengrass** As permissões adicionadas à função de grupo do Greengrass podem ser assumidas por todos os conectores e funções do Lambda no grupo do Greengrass. Esse conector requer acesso ao arquivo Compose do Docker armazenado em um bucket do S3. Ele também requer acesso ao seu token de autorização do Amazon ECR se suas imagens do Docker estiverem armazenadas em um repositório privado no Amazon ECR. ## Licenças O conector de implantação do aplicativo do Docker do Greengrass inclui o seguinte licenciamento/software de terceiros: + [AWS SDK para Python (Boto3)](https://pypi.org/project/boto3/)/Licença Apache 2.0 + [botocore](https://pypi.org/project/botocore/)/Licença Apache 2.0 + [dateutil](https://pypi.org/project/python-dateutil/1.4/)/Licença PSF + [docutils](https://pypi.org/project/docutils/)/Licença BSD, GNU Licença pública geral (GPL), Licença Python Software Foundation, Domínio público + [jmespath](https://pypi.org/project/jmespath/)/Licença MIT + [s3transfer](https://pypi.org/project/s3transfer/)/Licença Apache 2.0 + [urllib3](https://pypi.org/project/urllib3/)/Licença MIT Esse conector é liberado de acordo com o [Contrato de licença de software do Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf). ## Changelog A tabela a seguir descreve as alterações em cada versão do conector. | Versão | Alterações | | --- | --- | | 7 | Adicionado `DockerOfflineMode` para usar um arquivo Docker Compose existente quando AWS IoT Greengrass inicia offline. Novas tentativas implementadas para o comando `docker login`. Support para 32 bits. UIDs | | 6 | Adicionado `StopContainersOnNewDeployment` para substituir a limpeza do contêiner quando uma nova implantação é feita ou quando o GGC é interrompido. Mecanismos mais seguros de desligamento e inicialização. Correção de erro de validação YAML. | | 5 | As imagens são extraídas antes da execução `docker-compose down`. | | 4 | pull-before-upComportamento adicionado para atualizar imagens do Docker. | | 3 | Correção de um problema com a localização de variáveis de ambiente. | | 2 | Adição do parâmetro `ForceDeploy`. | | 1 | Versão inicial. | Um grupo do Greengrass só pode conter uma versão do conector por vez. Para obter informações sobre como fazer upgrade de uma versão do conector, consulte [Atualizar a versões do conector](connectors.md#upgrade-connector-versions). ## Consulte também + [Integrar a serviços e protocolos usando conectores do Greengrass](connectors.md) + [Conceitos básicos de conectores do Greengrass (console)](connectors-console.md) + [Conceitos básicos de conectores do Greengrass (CLI)](connectors-cli.md)