Execute um contêiner Docker - AWS IoT Greengrass
RequisitosExecute um contêiner Docker a partir de uma imagem pública no Amazon ECR ou no Docker HubExecute um contêiner Docker a partir de uma imagem privada no Amazon ECRExecute um contêiner Docker a partir de uma imagem no Amazon S3Use a comunicação entre processos nos componentes do contêiner DockerUse AWS credenciais em componentes de contêiner do Docker (Linux)Use o gerenciador de fluxo em componentes de contêiner Docker (Linux)

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á.

Execute um contêiner Docker

Você pode configurar AWS IoT Greengrass componentes para executar um contêiner Docker a partir de imagens armazenadas nos seguintes locais:

  • Repositórios de imagens públicos e privados no Amazon Elastic Container Registry (Amazon ECR)

  • Repositório público do Docker Hub

  • Registro confiável do Public Docker

  • Bucket do S3

Em seu componente personalizado, inclua o URI da imagem do Docker como um artefato para recuperar a imagem e executá-la no dispositivo principal. Para imagens do Amazon ECR e do Docker Hub, você pode usar o componente Docker Application Manager para baixar as imagens e gerenciar credenciais para repositórios privados do Amazon ECR.

Requisitos

Para executar um contêiner Docker em um componente, você precisa do seguinte:

  • Um dispositivo principal do Greengrass. Se você não tiver uma, consulte Tutorial: Conceitos básicos do AWS IoT Greengrass V2.

  • Docker Engine 1.9.1 ou 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. Você deve instalar o Docker diretamente no dispositivo principal antes de implantar componentes que executam contêineres do Docker.

    dica

    Você também pode 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 RequiresPrivilege configurá-lo true no script do ciclo de vida para executar a instalação e os comandos. docker Para ter 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 Linux, você pode adicionar um usuário ao docker grupo para chamar docker comandos semsudo.

    • Em dispositivos Windows, você pode adicionar um usuário ao docker-users grupo para chamar docker comandos sem privilégios de administrador.

    Linux or Unix

    Para adicionar ggc_user ou o usuário não root que você usa para executar componentes de contêiner do Docker ao docker grupo, execute o comando a seguir.

    sudo usermod -aG docker ggc_user

    Para obter mais informações, consulte Gerenciar o Docker como usuário não root.

    Windows Command Prompt (CMD)

    Para adicionar ggc_user ou o usuário que você usa para executar componentes de contêiner do Docker ao docker-users grupo, execute o comando a seguir como administrador.

    net localgroup docker-users ggc_user /add
    Windows PowerShell

    Para adicionar ggc_user ou o usuário que você usa para executar componentes de contêiner do Docker ao docker-users grupo, execute o comando a seguir como administrador.

    Add-LocalGroupMember -Group docker-users -Member ggc_user

  • Arquivos acessados pelo componente de contêiner Docker montado como um volume no contêiner 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:

Execute um contêiner Docker a partir de uma imagem pública no 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 no Amazon ECR e no Docker Hub.

Para executar um contêiner Docker usando o Docker Compose

  1. Crie e faça upload de um arquivo Docker Compose para um bucket do Amazon S3. Certifique-se de que a função de dispositivo do Greengrass permita que o s3:GetObject dispositivo acesse o arquivo Compose. O exemplo de arquivo Compose mostrado no exemplo a seguir inclui a imagem do Amazon CloudWatch Agent do Amazon ECR e a imagem do MySQL do Docker Hub.

    version: "3"
services:
  cloudwatchagent:
    image: "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
  mysql:
    image: "mysql:8.0"

  2. Crie um componente personalizado em seu dispositivo AWS IoT Greengrass principal. A receita de exemplo mostrada no exemplo a seguir tem as seguintes propriedades:

    • O componente do gerenciador de aplicativos Docker como uma dependência. Esse componente permite AWS IoT Greengrass baixar imagens dos repositórios públicos do Amazon ECR e do Docker Hub.

    • Um artefato de componente que especifica uma imagem do Docker em um repositório público do Amazon ECR.

    • Um artefato de componente que especifica uma imagem do Docker em um repositório público do Docker Hub.

    • Um artefato de componente que especifica o arquivo 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.

    JSON
    {
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.MyDockerComposeComponent",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.",
  "ComponentPublisher": "Amazon",
  "ComponentDependencies": {
    "aws.greengrass.DockerApplicationManager": {
      "VersionRequirement": "~2.0.0"
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "all"
      },
      "Lifecycle": {
        "run": "docker-compose -f {artifacts:path}/docker-compose.yaml up"
      },
      "Artifacts": [
        {
          "URI": "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
        },
        {
          "URI": "docker:mysql:8.0"
        },
        {
          "URI": "s3://DOC-EXAMPLE-BUCKET/folder/docker-compose.yaml"
        }
      ]
    }
  ]
}
    YAML
    ---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyDockerComposeComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.'
ComponentPublisher: Amazon
ComponentDependencies:
  aws.greengrass.DockerApplicationManager:
    VersionRequirement: ~2.0.0
Manifests:
  - Platform:
      os: all
    Lifecycle:
        run: docker-compose -f {artifacts:path}/docker-compose.yaml up
    Artifacts:
      - URI: "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
      - URI: "docker:mysql:8.0"
      - URI: "s3://DOC-EXAMPLE-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 mais informações, consulte:

  3. Teste o componente para verificar se ele funciona conforme o esperado.

    Importante

    Você deve 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

  4. Quando o componente estiver pronto, faça o upload do componente AWS IoT Greengrass para implantá-lo em outros dispositivos principais. Para ter mais informações, consulte Publish components to deploy to your core devices.

Execute um contêiner Docker a partir de uma imagem privada no 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 no Amazon ECR.

Para executar um contêiner Docker

  1. Crie um componente personalizado em seu dispositivo AWS IoT Greengrass principal. Use o exemplo de receita a seguir, que tem as seguintes propriedades:

    • O componente do gerenciador de aplicativos Docker como uma dependência. Esse componente permite AWS IoT Greengrass gerenciar credenciais para baixar imagens de repositórios privados.

    • O componente do serviço de troca de tokens como uma dependência. Esse componente permite recuperar AWS credenciais AWS IoT Greengrass para interagir com o Amazon ECR.

    • Um artefato de componente que especifica uma imagem do Docker em um repositório privado do Amazon ECR.

    • Um script de execução do ciclo de vida que usa docker run para criar e iniciar um contêiner a partir da imagem.

    JSON
    {
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.MyPrivateDockerComponent",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that runs a Docker container from a private Amazon ECR image.",
  "ComponentPublisher": "Amazon",
  "ComponentDependencies": {
    "aws.greengrass.DockerApplicationManager": {
      "VersionRequirement": "~2.0.0"
    },
    "aws.greengrass.TokenExchangeService": {
      "VersionRequirement": "~2.0.0"
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "all"
      },
      "Lifecycle": {
        "run": "docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
      },
      "Artifacts": [
        {
          "URI": "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
        }
      ]
    }
  ]
}
    YAML
    ---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyPrivateDockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from a private Amazon ECR image.'
ComponentPublisher: Amazon
ComponentDependencies:
  aws.greengrass.DockerApplicationManager:
    VersionRequirement: ~2.0.0
  aws.greengrass.TokenExchangeService:
    VersionRequirement: ~2.0.0
Manifests:
  - Platform:
      os: all
    Lifecycle:
        run: docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]
    Artifacts:
      - URI: "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
    nota

    Para usar comunicação entre processos (IPC), 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 mais informações, consulte:

  2. Teste o componente para verificar se ele funciona conforme o esperado.

    Importante

    Você deve 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

  3. Faça o upload do componente AWS IoT Greengrass para implantá-lo em outros dispositivos principais. Para ter mais informações, consulte Publish components to deploy to your core devices.

Execute um contêiner Docker a partir de uma imagem no Amazon S3

Esta seção descreve como você pode executar um contêiner do Docker em um componente a partir de uma imagem do Docker armazenada no Amazon S3.

Para executar um contêiner Docker em um componente a partir de uma imagem no Amazon S3

  1. Execute o comando docker save para criar um backup de um contêiner Docker. Você fornece esse backup como um artefato de componente para executar o contêiner. AWS IoT Greengrass Substitua hello-world pelo nome da imagem e substitua hello-world.tar pelo nome do arquivo a ser criado.

    docker save hello-world > artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar

  2. Crie um componente personalizado em seu dispositivo AWS IoT Greengrass principal. Use o exemplo de receita 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 --rm opção limpa o contêiner quando ele sai.

    JSON
    {
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.MyS3DockerComponent",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
  "ComponentPublisher": "Amazon",
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": {
          "Script": "docker load -i {artifacts:path}/hello-world.tar"
        },
        "run": {
          "Script": "docker run --rm hello-world"
        }
      }
    }
  ]
}
    YAML
    ---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install:
        Script: docker load -i {artifacts:path}/hello-world.tar
      run:
        Script: docker run --rm hello-world
    nota

    Para usar comunicação entre processos (IPC), 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 mais informações, consulte:

  3. 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

  4. Quando o componente estiver pronto, faça o upload do arquivo de imagens do Docker em um bucket do S3 e adicione seu URI à receita do componente. Em seguida, você pode carregar o componente AWS IoT Greengrass para implantá-lo em outros dispositivos principais. Para ter mais informações, consulte Publish components to deploy to your core devices.

    Quando terminar, a receita do componente deve ter a aparência do exemplo a seguir.

    JSON
    {
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.MyS3DockerComponent",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
  "ComponentPublisher": "Amazon",
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": {
          "Script": "docker load -i {artifacts:path}/hello-world.tar"
        },
        "run": {
          "Script": "docker run --rm hello-world"
        }
      },
      "Artifacts": [
        {
          "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar"
        }
      ]
    }
  ]
}
    YAML
    ---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install:
        Script: docker load -i {artifacts:path}/hello-world.tar
      run:
        Script: docker run --rm hello-world
    Artifacts:
      - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar

Use a comunicação entre processos nos componentes do contêiner Docker

Você pode usar a biblioteca de comunicação entre processos (IPC) do Greengrass no AWS IoT Device SDK para se comunicar com o núcleo do Greengrass, outros componentes do Greengrass e. AWS IoT Core Para ter 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 o IPC em um componente de contêiner do Docker, você deve executar o contêiner do Docker com os seguintes parâmetros:

  • Monte o soquete IPC no contêiner. O núcleo do Greengrass fornece o caminho do arquivo do soquete IPC na variável de ambiente. AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT

  • Defina as variáveis de AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT ambiente SVCUID e 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 mensagem MQTT em AWS IoT Core (Python)

A receita a seguir define um exemplo de componente de contêiner do Docker que publica uma mensagem MQTT no. AWS IoT Core Essa fórmula tem as seguintes propriedades:

  • Uma política de autorização (accessControl) que permite que o componente publique mensagens MQTT AWS IoT Core em todos os tópicos. Para obter mais informações, consulte Autorize componentes a realizar operações de IPC e autorização do AWS IoT Core MQTT IPC.

  • 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 Docker a partir da imagem. O comando de execução do Docker tem os seguintes argumentos:

    • O -v argumento monta o soquete Greengrass IPC no contêiner.

    • Os dois primeiros -e argumentos definem as variáveis de ambiente necessárias no contêiner do Docker.

    • Os -e argumentos adicionais definem as variáveis de ambiente usadas neste exemplo.

    • O --rm argumento limpa o contêiner quando ele sai.

JSON
{
  "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://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar"
        }
      ]
    }
  ]
}
YAML
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://DOC-EXAMPLE-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 AWS credenciais da função de troca de tokens do dispositivo principal usando um servidor de contêiner local. Para ter 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 --network=host argumento. Essa opção permite que o contêiner 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 do 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 ambiente AWS_CONTAINER_CREDENTIALS_FULL_URI e de acordo com os valores que o núcleo do Greengrass fornece aos componentes. AWS Os SDKs usam essas variáveis de ambiente para recuperar credenciais AWS .

exemplo Exemplo de receita: listar buckets do S3 em um componente de contêiner do Docker (Python)

A receita a seguir define um exemplo de componente de contêiner Docker que lista os buckets S3 em seu. 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 Docker a partir da imagem. O comando de execução do Docker tem os seguintes argumentos:

    • O --network=host argumento fornece ao contêiner acesso à rede host, para que o contêiner possa se conectar ao serviço de troca de tokens.

    • O -e argumento define as variáveis de ambiente necessárias no contêiner do Docker.

    • O --rm argumento limpa o contêiner quando ele sai.

JSON
{
  "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://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar"
        }
      ]
    }
  ]
}
YAML
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://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar

Use o gerenciador de fluxo em componentes de contêiner Docker (Linux)

Você pode usar o componente gerenciador de fluxo para gerenciar fluxos de dados nos componentes do Greengrass. Esse componente permite processar fluxos de dados e transferir dados de IoT de alto volume para o. Nuvem AWS AWS IoT Greengrass fornece um SDK do gerenciador de stream que você usa para interagir com o componente do stream manager. Para ter mais informações, consulte Gerencie fluxos de dados nos dispositivos principais do Greengrass.

nota

O exemplo nesta seção funciona somente nos dispositivos principais do Linux.

Para usar o SDK do gerenciador de stream 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 --network=host argumento. Essa opção permite que o contêiner Docker interaja com o componente gerenciador de fluxo por meio de uma conexão TLS local. Esse argumento funciona apenas 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 do 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 fluxo para exigir autenticação, que é o comportamento padrão, defina a variável de AWS_CONTAINER_CREDENTIALS_FULL_URI ambiente com o valor que o núcleo do Greengrass fornece aos componentes. Para obter mais informações, consulte Configuração do gerenciador de stream.

  • 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 usar o IPC. Para mais informações, consulte:

exemplo Exemplo de receita: transmitir um arquivo para um bucket do S3 em um componente de contêiner do Docker (Python)

A receita 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 fluxo como uma dependência. Essa dependência permite que o componente use o SDK do gerenciador de fluxo para interagir com o componente do gerenciador de fluxo.

  • 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 Docker a partir da imagem. O comando de execução do Docker tem os seguintes argumentos:

    • O --network=host argumento fornece ao contêiner acesso à rede host, para que o contêiner possa se conectar ao componente do gerenciador de fluxo.

    • O primeiro -e argumento define a variável de AWS_CONTAINER_AUTHORIZATION_TOKEN ambiente necessária no contêiner do Docker.

    • Os -e argumentos adicionais definem as variáveis de ambiente usadas neste exemplo.

    • O -v argumento monta a pasta de trabalho do componente no contêiner. Este exemplo cria um arquivo na pasta de trabalho para fazer o upload desse arquivo para o Amazon S3 usando o gerenciador de stream.

    • O --rm argumento limpa o contêiner quando ele sai.

JSON
{
  "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://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar"
        }
      ]
    }
  ]
}
YAML
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://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar