Ejecute un contenedor Docker - AWS IoT Greengrass
RequisitosEjecute un contenedor Docker desde una imagen pública en Amazon ECR o Docker HubEjecute un contenedor de Docker desde una imagen privada en Amazon ECREjecute un contenedor Docker a partir de una imagen en Amazon S3Utilice la comunicación entre procesos en los componentes del contenedor de DockerUtilice AWS las credenciales en los componentes del contenedor de Docker (Linux)Utilice el administrador de flujos en los componentes del contenedor de Docker (Linux)

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Ejecute un contenedor Docker

Puede configurar AWS IoT Greengrass los componentes para que ejecuten un contenedor Docker a partir de imágenes almacenadas en las siguientes ubicaciones:

  • Repositorios de imágenes públicos y privados en Amazon Elastic Container Registry (Amazon ECR)

  • Repositorio público de Docker Hub

  • Registro público de confianza de Docker

  • Bucket de S3

En su componente personalizado, incluya el URI de la imagen de Docker como un artefacto para recuperar la imagen y ejecutarla en el dispositivo principal. En el caso de las imágenes de Amazon ECR y Docker Hub, puede utilizar el componente gestor de aplicaciones de Docker para descargar las imágenes y gestionar las credenciales de los repositorios privados de Amazon ECR.

Requisitos

Para ejecutar un contenedor de Docker en un componente, necesita lo siguiente:

  • Un dispositivo central de Greengrass. Si no dispone de una, consulte Tutorial: Introducción a AWS IoT Greengrass V2.

  • Docker Engine 1.9.1 o posterior instalado en el dispositivo principal de Greengrass. Se ha comprobado que la versión 20.10 es la última versión que funciona con el software Core. AWS IoT Greengrass Debe instalar Docker directamente en el dispositivo principal antes de implementar los componentes que ejecutan contenedores de Docker.

    sugerencia

    También puede configurar el dispositivo principal para instalar Docker Engine cuando se instale el componente. Por ejemplo, el siguiente script de instalación instala Docker Engine antes de cargar la imagen de Docker. Este script de instalación funciona en distribuciones de Linux basadas en Debian, como Ubuntu. Si configura el componente para instalar Docker Engine con este comando, puede que tenga que configurarlo true en el script del ciclo de vida RequiresPrivilege para ejecutar la instalación y los comandos. docker Para obtener más información, consulte AWS IoT Greengrassreferencia de recetas de componentes.

    apt-get install docker-ce docker-ce-cli containerd.io && docker load -i {artifacts:path}/hello-world.tar

  • El usuario del sistema que ejecute un componente contenedor de Docker debe tener permisos de raíz o administrador, o bien debe configurar Docker para que se ejecute como un usuario no de raíz o no administrador.

    • En los dispositivos Linux, puede añadir un usuario al docker grupo sin necesidad sudo de invocar docker comandos.

    • En los dispositivos Windows, puede añadir un usuario al docker-users grupo para que invoque docker comandos sin privilegios de administrador.

    Linux or Unix

    Para añadir ggc_user al docker grupo el usuario no root que utiliza para ejecutar los componentes del contenedor de Docker, ejecute el siguiente comando.

    sudo usermod -aG docker ggc_user

    Para obtener más información, consulta Administrar Docker como usuario no root.

    Windows Command Prompt (CMD)

    Para añadir ggc_user al docker-users grupo o el usuario que utiliza para ejecutar los componentes del contenedor de Docker, ejecute el siguiente comando como administrador.

    net localgroup docker-users ggc_user /add
    Windows PowerShell

    Para añadir ggc_user al docker-users grupo o al usuario que utiliza para ejecutar los componentes del contenedor de Docker, ejecute el siguiente comando como administrador.

    Add-LocalGroupMember -Group docker-users -Member ggc_user

  • Los archivos a los que accede el componente contenedor de Docker están montados como un volumen en el contenedor de Docker.

  • Si configura el software AWS IoT Greengrass Core para usar un proxy de red, debe configurar Docker para que use el mismo servidor proxy.

Además de estos requisitos, también debe cumplir los siguientes requisitos si se aplican a su entorno:

  • Para usar Docker Compose para crear e iniciar sus contenedores de Docker, instale Docker Compose en su dispositivo principal de Greengrass y cargue el archivo de Docker Compose en un bucket de S3. Debe almacenar el archivo de Compose en un depósito de S3 en el mismo Cuenta de AWS componente y como él. Región de AWS Para ver un ejemplo en el que se usa el docker-compose up comando en un componente personalizado, consulteEjecute un contenedor Docker desde una imagen pública en Amazon ECR o Docker Hub.

  • Si utiliza un proxy AWS IoT Greengrass de red, configure el daemon de Docker para que utilice un servidor proxy.

  • Si sus imágenes de Docker están almacenadas en Amazon ECR o Docker Hub, incluya el componente administrador de componentes de Docker como una dependencia en su componente de contenedor de Docker. Debe iniciar el daemon de Docker en el dispositivo principal antes de implementar el componente.

    Además, incluya los URI de la imagen como artefactos de los componentes. Los URI de imagen deben tener el formato que docker:registry/image[:tag|@digest] se muestra en los siguientes ejemplos:

    • Imagen privada de Amazon ECR: docker:account-id.dkr.ecr.region.amazonaws.com/repository/image[:tag|@digest]

    • Imagen pública de Amazon ECR: docker:public.ecr.aws/repository/image[:tag|@digest]

    • Imagen pública de Docker Hub: docker:name[:tag|@digest]

    Para obtener más información sobre cómo ejecutar contenedores Docker a partir de imágenes almacenadas en repositorios públicos, consulte. Ejecute un contenedor Docker desde una imagen pública en Amazon ECR o Docker Hub

  • Si sus imágenes de Docker están almacenadas en un repositorio privado de Amazon ECR, debe incluir el componente del servicio de intercambio de tokens como una dependencia en el componente de contenedor de Docker. Además, el rol de dispositivo de Greengrass debe permitir las ecr:GetDownloadUrlForLayer acciones, y ecr:GetAuthorizationTokenecr:BatchGetImage, como se muestra en el siguiente ejemplo de política de IAM. 

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [
        "ecr:GetAuthorizationToken",
        "ecr:BatchGetImage",
        "ecr:GetDownloadUrlForLayer"
      ],
      "Resource": [
        "*"
      ],
      "Effect": "Allow"
    }
  ]
}

    Para obtener información sobre la ejecución de contenedores Docker a partir de imágenes almacenadas en un repositorio privado de Amazon ECR, consulte. Ejecute un contenedor de Docker desde una imagen privada en Amazon ECR

  • Para usar imágenes de Docker almacenadas en un repositorio privado de Amazon ECR, el repositorio privado debe estar en el Región de AWS mismo lugar que el dispositivo principal.

  • Si las imágenes de Docker o los archivos de Compose se almacenan en un bucket de S3, el rol de dispositivo de Greengrass debe conceder s3:GetObject el permiso para que los dispositivos principales descarguen las imágenes como artefactos componentes, como se muestra en el siguiente ejemplo de política de IAM. 

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [
        "s3:GetObject"
      ],
      "Resource": [
        "*"
      ],
      "Effect": "Allow"
    }
  ]
}

    Para obtener información sobre la ejecución de contenedores Docker a partir de imágenes almacenadas en Amazon S3, consulteEjecute un contenedor Docker a partir de una imagen en Amazon S3.

  • Para usar la comunicación entre procesos (IPC), AWS las credenciales o el administrador de transmisiones en el componente de contenedor de Docker, debe especificar opciones adicionales al ejecutar el contenedor de Docker. Para obtener más información, consulte los siguientes temas:

Ejecute un contenedor Docker desde una imagen pública en Amazon ECR o Docker Hub

En esta sección, se describe cómo crear un componente personalizado que utilice Docker Compose para ejecutar un contenedor de Docker a partir de imágenes de Docker almacenadas en Amazon ECR y Docker Hub.

Para ejecutar un contenedor de Docker mediante Docker Compose

  1. Cree y cargue un archivo de Docker Compose en un bucket de Amazon S3. Asegúrese de que el rol de dispositivo de Greengrass otorgue el s3:GetObject permiso para permitir que el dispositivo acceda al archivo de composición. El archivo Compose de ejemplo que se muestra en el siguiente ejemplo incluye la imagen de Amazon CloudWatch Agent de Amazon ECR y la imagen de MySQL de Docker Hub.

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

  2. Cree un componente personalizado en su dispositivo AWS IoT Greengrass principal. La receta de ejemplo que se muestra en el siguiente ejemplo tiene las siguientes propiedades:

    • El componente del administrador de aplicaciones de Docker como dependencia. Este componente permite AWS IoT Greengrass descargar imágenes de los repositorios públicos de Amazon ECR y Docker Hub.

    • Un artefacto componente que especifica una imagen de Docker en un repositorio público de Amazon ECR.

    • Un artefacto componente que especifica una imagen de Docker en un repositorio público de Docker Hub.

    • Un artefacto componente que especifica el archivo de Docker Compose que incluye los contenedores para las imágenes de Docker que quieres ejecutar.

    • Un script de ejecución de ciclo de vida que usa docker-compose up para crear e iniciar un contenedor a partir de las imágenes 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 la comunicación entre procesos (IPC), AWS las credenciales o el administrador de flujos en el componente de contenedor de Docker, debe especificar opciones adicionales al ejecutar el contenedor de Docker. Para obtener más información, consulte los siguientes temas:

  3. Pruebe el componente para comprobar que funciona según lo esperado.

    importante

    Debe instalar e iniciar el daemon de Docker antes de implementar el componente.

    Tras implementar el componente localmente, puede ejecutar el comando docker container ls para comprobar que el contenedor se ejecuta.

    docker container ls

  4. Cuando el componente esté listo, cárguelo para AWS IoT Greengrass implementarlo en otros dispositivos principales. Para obtener más información, consulte Publique componentes para desplegarlos en sus dispositivos principales.

Ejecute un contenedor de Docker desde una imagen privada en Amazon ECR

En esta sección se describe cómo puede crear un componente personalizado que ejecute un contenedor de Docker a partir de una imagen de Docker almacenada en un repositorio privado de Amazon ECR.

Para ejecutar un contenedor de Docker

  1. Cree un componente personalizado en su dispositivo AWS IoT Greengrass principal. Utilice la siguiente receta de ejemplo, que tiene las siguientes propiedades:

    • El componente del administrador de aplicaciones de Docker como dependencia. Este componente permite AWS IoT Greengrass administrar las credenciales para descargar imágenes de repositorios privados.

    • El componente del servicio de intercambio de fichas como dependencia. Este componente permite AWS IoT Greengrass recuperar AWS credenciales para interactuar con Amazon ECR.

    • Un artefacto componente que especifica una imagen de Docker en un repositorio privado de Amazon ECR.

    • Un script de ejecución del ciclo de vida que usa docker run para crear e iniciar un contenedor a partir de la imagen.

    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 la comunicación entre procesos (IPC), AWS las credenciales o el administrador de flujos en el componente de contenedor de Docker, debe especificar opciones adicionales al ejecutar el contenedor de Docker. Para obtener más información, consulte los siguientes temas:

  2. Pruebe el componente para comprobar que funciona según lo esperado.

    importante

    Debe instalar e iniciar el daemon de Docker antes de implementar el componente.

    Tras implementar el componente localmente, puede ejecutar el comando docker container ls para comprobar que el contenedor se ejecuta.

    docker container ls

  3. Cargue el componente AWS IoT Greengrass para implementarlo en otros dispositivos principales. Para obtener más información, consulte Publique componentes para desplegarlos en sus dispositivos principales.

Ejecute un contenedor Docker a partir de una imagen en Amazon S3

En esta sección, se describe cómo ejecutar un contenedor de Docker en un componente desde una imagen de Docker almacenada en Amazon S3.

Para ejecutar un contenedor de Docker en un componente desde una imagen en Amazon S3

  1. Ejecute el comando docker save para crear una copia de seguridad de un contenedor Docker. Esta copia de seguridad se proporciona como un artefacto componente en el que ejecutar el contenedor. AWS IoT Greengrass Sustituya hello-world por el nombre de la imagen y sustituya hello-world.tar por el nombre del archivo comprimido que desee crear.

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

  2. Cree un componente personalizado en su dispositivo AWS IoT Greengrass principal. Utilice la siguiente receta de ejemplo, que tiene las siguientes propiedades:

    • Un script de instalación del ciclo de vida que usa Docker Load para cargar una imagen de Docker desde un archivo.

    • Un script de ejecución del ciclo de vida que usa docker run para crear e iniciar un contenedor a partir de la imagen. La --rm opción limpia el contenedor al salir.

    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 la comunicación entre procesos (IPC), AWS las credenciales o el administrador de flujos en el componente de contenedor de Docker, debe especificar opciones adicionales al ejecutar el contenedor de Docker. Para obtener más información, consulte los siguientes temas:

  3. Pruebe el componente para comprobar que funciona según lo esperado.

    Tras implementar el componente localmente, puede ejecutar el comando docker container ls para comprobar que el contenedor se ejecuta.

    docker container ls

  4. Cuando el componente esté listo, sube el archivo de imágenes de Docker a un bucket de S3 y añade su URI a la receta del componente. A continuación, puede cargar el componente para AWS IoT Greengrass implementarlo en otros dispositivos principales. Para obtener más información, consulte Publique componentes para desplegarlos en sus dispositivos principales.

    Cuando termines, la receta del componente debería tener el aspecto que se muestra en el siguiente ejemplo.

    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

Utilice la comunicación entre procesos en los componentes del contenedor de Docker

Puede utilizar la biblioteca de comunicación entre procesos (IPC) de Greengrass SDK para dispositivos con AWS IoT para comunicarse con el núcleo de Greengrass, otros componentes de Greengrass y. AWS IoT Core Para obtener más información, consulte Úselo SDK para dispositivos con AWS IoT para comunicarse con el núcleo de Greengrass, otros componentes y AWS IoT Core.

Para usar el IPC en un componente de contenedor de Docker, debe ejecutar el contenedor de Docker con los siguientes parámetros:

  • Monte el socket IPC en el contenedor. El núcleo de Greengrass proporciona la ruta del archivo del socket IPC en la AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT variable de entorno.

  • Establezca las variables SVCUID y de AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT entorno en los valores que el núcleo de Greengrass proporciona a los componentes. Su componente utiliza estas variables de entorno para autenticar las conexiones al núcleo de Greengrass.

ejemplo Receta de ejemplo: publicar un mensaje MQTT en AWS IoT Core (Python)

La siguiente receta define un ejemplo de componente contenedor de Docker en el que se publica un mensaje MQTT. AWS IoT Core Esta receta tiene las siguientes propiedades:

  • Una política de autorización (accessControl) que permite al componente publicar mensajes MQTT AWS IoT Core sobre todos los temas. Para obtener más información, consulte Autorización de Autorice a los componentes a realizar operaciones de IPC IPC en AWS IoT Core MQTT.

  • Un artefacto componente que especifica una imagen de Docker como un archivo TAR en Amazon S3.

  • Un script de instalación del ciclo de vida que carga la imagen de Docker desde el archivo TAR.

  • Un script de ejecución del ciclo de vida que ejecuta un contenedor Docker desde la imagen. El comando Docker run tiene los siguientes argumentos:

    • El -v argumento monta el conector IPC de Greengrass en el contenedor.

    • Los dos primeros -e argumentos establecen las variables de entorno necesarias en el contenedor Docker.

    • Los -e argumentos adicionales establecen las variables de entorno utilizadas en este ejemplo.

    • El --rm argumento limpia el contenedor al salir.

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

Utilice AWS las credenciales en los componentes del contenedor de Docker (Linux)

Puede usar el componente del servicio de intercambio de fichas para interactuar con AWS los servicios de los componentes de Greengrass. Este componente proporciona AWS las credenciales de la función de intercambio de fichas del dispositivo principal mediante un servidor contenedor local. Para obtener más información, consulte Interactúa con AWS los servicios.

nota

El ejemplo de esta sección solo funciona en los dispositivos principales de Linux.

Para usar AWS las credenciales del servicio de intercambio de fichas en un componente de contenedor de Docker, debe ejecutar el contenedor de Docker con los siguientes parámetros:

  • Proporcione acceso a la red host mediante el --network=host argumento. Esta opción permite que el contenedor de Docker se conecte al servicio de intercambio de tokens local para recuperar AWS las credenciales. Este argumento solo funciona en Docker para Linux.

    aviso

    Esta opción proporciona al contenedor acceso a todas las interfaces de red locales del host, por lo que es menos segura que si se ejecutan contenedores de Docker sin este acceso a la red del host. Tenga esto en cuenta al desarrollar y ejecutar componentes de contenedores de Docker que utilizan esta opción. Para obtener más información, consulte Network: host en la documentación de Docker.

  • Establezca las variables AWS_CONTAINER_CREDENTIALS_FULL_URI y de AWS_CONTAINER_AUTHORIZATION_TOKEN entorno en los valores que el núcleo de Greengrass proporciona a los componentes. AWS Los SDK utilizan estas variables de entorno para recuperar las AWS credenciales.

ejemplo Receta de ejemplo: Listar buckets de S3 en un componente contenedor de Docker (Python)

La siguiente receta define un ejemplo de componente de contenedor de Docker que muestra los buckets de S3 del suyo. Cuenta de AWS Esta receta tiene las siguientes propiedades:

  • El componente del servicio de intercambio de fichas como dependencia. Esta dependencia permite que el componente recupere AWS credenciales para interactuar con otros AWS servicios.

  • Un artefacto componente que especifica una imagen de Docker como un archivo tar en Amazon S3.

  • Un script de instalación del ciclo de vida que carga la imagen de Docker desde el archivo TAR.

  • Un script de ejecución del ciclo de vida que ejecuta un contenedor Docker desde la imagen. El comando Docker run tiene los siguientes argumentos:

    • El --network=host argumento proporciona al contenedor acceso a la red host, de modo que el contenedor puede conectarse al servicio de intercambio de fichas.

    • El -e argumento establece las variables de entorno necesarias en el contenedor de Docker.

    • El --rm argumento limpia el contenedor al salir.

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

Utilice el administrador de flujos en los componentes del contenedor de Docker (Linux)

Puede usar el componente administrador de flujos para administrar flujos de datos en los componentes de Greengrass. Este componente le permite procesar flujos de datos y transferir datos de IoT de gran volumen alNube de AWS. AWS IoT Greengrassproporciona un SDK de administrador de transmisiones que se utiliza para interactuar con el componente de administrador de transmisiones. Para obtener más información, consulte Gestione los flujos de datos en los dispositivos principales de Greengrass.

nota

El ejemplo de esta sección solo funciona en los dispositivos principales de Linux.

Para usar el SDK del administrador de transmisiones en un componente de contenedor de Docker, debe ejecutar el contenedor de Docker con los siguientes parámetros:

  • Proporcione acceso a la red host mediante el --network=host argumento. Esta opción permite que el contenedor Docker interactúe con el componente del administrador de transmisiones a través de una conexión TLS local. Este argumento solo funciona en Docker para Linux

    aviso

    Esta opción proporciona al contenedor acceso a todas las interfaces de red locales del host, por lo que es menos segura que si se ejecutan contenedores de Docker sin este acceso a la red del host. Tenga esto en cuenta al desarrollar y ejecutar componentes de contenedores de Docker que utilizan esta opción. Para obtener más información, consulte Network: host en la documentación de Docker.

  • Si configura el componente del administrador de transmisiones para que requiera autenticación, que es el comportamiento predeterminado, establezca la variable de AWS_CONTAINER_CREDENTIALS_FULL_URI entorno en el valor que el núcleo de Greengrass proporciona a los componentes. Para obtener más información, consulte la configuración del administrador de transmisiones.

  • Si configura el componente del administrador de flujos para que utilice un puerto que no sea el predeterminado, utilice la comunicación entre procesos (IPC) para obtener el puerto desde la configuración del componente del administrador de flujos. Debe ejecutar el contenedor Docker con opciones adicionales para usar el IPC. Para obtener más información, consulte los siguientes temas:

ejemplo Receta de ejemplo: Transmita un archivo a un bucket de S3 en un componente contenedor de Docker (Python)

La siguiente receta define un ejemplo de componente contenedor de Docker que crea un archivo y lo transmite a un bucket de S3. Esta receta tiene las siguientes propiedades:

  • El componente del administrador de flujos como dependencia. Esta dependencia permite que el componente utilice el SDK del administrador de transmisiones para interactuar con el componente de administrador de transmisiones.

  • Un artefacto componente que especifica una imagen de Docker como un archivo TAR en Amazon S3.

  • Un script de instalación del ciclo de vida que carga la imagen de Docker desde el archivo TAR.

  • Un script de ejecución del ciclo de vida que ejecuta un contenedor Docker desde la imagen. El comando Docker run tiene los siguientes argumentos:

    • El --network=host argumento proporciona al contenedor acceso a la red host, de modo que el contenedor puede conectarse al componente del administrador de flujos.

    • El primer -e argumento establece la variable de AWS_CONTAINER_AUTHORIZATION_TOKEN entorno requerida en el contenedor de Docker.

    • Los -e argumentos adicionales establecen las variables de entorno utilizadas en este ejemplo.

    • El -v argumento monta la carpeta de trabajo del componente en el contenedor. En este ejemplo, se crea un archivo en la carpeta de trabajo para subirlo a Amazon S3 mediante el administrador de transmisiones.

    • El --rm argumento limpia el contenedor al salir.

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