Aviso de fin de soporte: el 7 de octubre de 2026, AWS suspenderemos el soporte para AWS IoT Greengrass Version 1. Después del 7 de octubre de 2026, ya no podrá acceder a los AWS IoT Greengrass V1 recursos. Para obtener más información, visita [Migrar desde AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html). 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. # Conector de implementación de aplicaciones Docker El conector de despliegue de aplicaciones Docker de Greengrass facilita la ejecución de las imágenes de Docker en un núcleo. AWS IoT Greengrass El conector utiliza Docker Compose para iniciar una aplicación Docker multicontenedor desde un archivo de `docker-compose.yml`. Concretamente, el conector ejecuta comandos de `docker-compose` para administrar los contenedores Docker en un único dispositivo central. Para obtener más información, consulte [Overview of Greengrass group role permissions (Descripción general de Docker Compose](https://docs.docker.com/compose/) en la documentación de Docker. El conector puede acceder a imágenes de Docker almacenadas en registros de un contenedor de Docker, como Amazon Elastic Container Registry (Amazon ECR), Docker Hub y registros privados de confianza de Docker. Después de implementar el grupo de Greengrass, el conector lanza las últimas imágenes e inicia los contenedores de Docker. Ejecuta el `docker-compose pull` comando y `docker-compose up`. El conector publica el estado del comando en un [tema MQTT de salida](#docker-app-connector-data-output). También registra información del estado sobre contenedores Docker en funcionamiento. Esto te permite supervisar los registros de tus aplicaciones en Amazon CloudWatch. Para obtener más información, consulte [Supervisión con AWS IoT Greengrass registros](greengrass-logs-overview.md). El conector también inicia contenedores Docker cada vez que se reinicia el daemon de Greengrass. La cantidad de contenedores Docker que se puede ejecutar en el núcleo depende del hardware que tenga. Los contenedores Docker se ejecutan fuera del dominio de Greengrass en el dispositivo central, de modo que no pueden acceder a la comunicación entre procesos (IPC) del núcleo. Sin embargo, puede configurar algunos canales de comunicación con componentes de Greengrass, como las funciones locales de Lambda. Para obtener más información, consulte [Comunicación con contenedores Docker](#docker-app-connector-communicating). Puede usar el conector para alojar un servidor web o un servidor MySQL en su dispositivo central. Los servicios locales de sus aplicaciones Docker pueden comunicarse entre sí, con otros procesos del entorno local y con servicios en la nube. Por ejemplo, puede ejecutar un servidor web del núcleo que envíe solicitudes desde las funciones de Lambda a un servicio web en la nube. Este conector se ejecuta en modo de aislamiento [Sin contenedor](lambda-group-config.md#no-container-mode), por lo que puede implementarlo en un grupo de Greengrass que se ejecute sin creación de contenedores de Greengrass. Este conector tiene las siguientes versiones. | Versión | 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 obtener información sobre los cambios de versión, consulte el [Registro de cambios](#docker-app-connector-changelog). ## Requisitos Este conector exige los siguientes requisitos: + AWS IoT Greengrass Software básico, versión 1.10 o posterior. **nota** Este conector no es compatible con las distribuciones. OpenWrt + Se necesita tener la versión 3.7 o 3.8 de [Python](https://www.python.org/) instalada en el dispositivo principal y añadido a la variable de entorno PATH. **nota** Para usar Python 3.8, ejecute el siguiente comando para crear un enlace simbólico desde la carpeta de instalación predeterminada de Python 3.7 a los binarios de Python 3.8 instalados. ``` sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7 ``` Esto configura su dispositivo para que cumpla con el requisito de Python para AWS IoT Greengrass. + Un mínimo de 36 MB de RAM en el núcleo de Greengrass para que el conector supervise los contenedores Docker en funcionamiento. El requisito total de memoria depende del número de contenedores Docker que se ejecuten en el núcleo. + [Docker Engine](https://docs.docker.com/install/) versión 1.9.1 o posterior instalado en el núcleo de Greengrass. La versión 19.0.3 es la última versión cuyo funcionamiento con el conector se ha verificado. El ejecutable `docker` debe estar en el directorio `/usr/bin` o `/usr/local/bin`. **importante** Le recomendamos que instale un almacén de credenciales para proteger las copias locales de sus credenciales de Docker. Para obtener más información, consulte [Notas de seguridad](#docker-app-connector-security). Para obtener información sobre la instalación de Docker en distribuciones de Amazon Linux, consulte [Conceptos básicos de Docker para Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/docker-basics.html) en la *Guía para desarrolladores de Amazon Elastic Container Service*. + [Docker Compose](https://docs.docker.com/compose/install/) instalado en el núcleo de Greengrass. El ejecutable `docker-compose` debe estar en el directorio `/usr/bin` o `/usr/local/bin`. Las siguientes versiones de Docker Compose se verifican para que funcionen con el conector. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/docker-app-connector.html) + Un único archivo de Docker Compose (por ejemplo, `docker-compose.yml`), almacenado en Amazon Simple Storage Service (Amazon S3). El formato debe ser compatible con la versión de Docker Compose instalada en el núcleo. Debe probar el archivo antes de usarlo en su núcleo. Si edita el archivo después de implementar el grupo de Greengrass, debe volver a implementar el grupo para actualizar la copia local del núcleo. + Un usuario de Linux con permiso para llamar al daemon local de Docker y escribir en el directorio que almacena la copia local del archivo de Compose. Para obtener más información, consulte [Configuración del usuario de Docker en el núcleo](#docker-app-connector-linux-user). + El [rol de grupo Greengrass](group-role.md) configurado para permitir la acción `s3:GetObject` en el bucket S3 que contiene el archivo de Compose. Este permiso se muestra en el siguiente ejemplo de política de IAM. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowAccessToComposeFileS3Bucket", "Action": [ "s3:GetObject", "s3:GetObjectVersion" ], "Effect": "Allow", "Resource": "arn:aws:s3:::bucket-name/*" } ] } ``` ------ **nota** Si su bucket de S3 está habilitado para el control de versiones, entonces el rol debe estar configurado para permitir también la acción `s3:GetObjectVersion`. Para obtener más información, consulte [Uso del control de versiones](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) en la *Guía del usuario de Amazon Simple Storage Service*. Para el requisito de rol de grupo, debe configurar el rol para conceder los permisos necesarios y asegurarse de que el rol se ha añadido al grupo. Para obtener más información, consulte [Administración del rol de grupo de Greengrass (consola)](group-role.md#manage-group-role-console) o [Administración del rol de grupo de Greengrass (CLI)](group-role.md#manage-group-role-cli). + Si el archivo Docker Compose hace referencia a una imagen de Docker almacenada en Amazon ECR, el [rol de grupo Greengrass](group-role.md) configurado para permitir lo siguiente: + Las acciones de `ecr:GetDownloadUrlForLayer` y `ecr:BatchGetImage` en los repositorios de Amazon ECR que contienen las imágenes de Docker. + La acción de `ecr:GetAuthorizationToken` en sus recursos. Los repositorios deben estar en el mismo conector Cuenta de AWS y al igual Región de AWS que él. **importante** Todos los conectores y las funciones de Lambda del grupo de Greengrass pueden asumir permisos en el rol de grupo. Para obtener más información, consulte [Notas de seguridad](#docker-app-connector-security). Estos permisos se muestran en la siguiente política de ejemplo. ------ #### [ 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 obtener más información, consulte [Ejemplos de políticas de repositorio de Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/RepositoryPolicyExamples.html) en la *Guía del usuario de Amazon ECR*. Para el requisito de rol de grupo, debe configurar el rol para conceder los permisos necesarios y asegurarse de que el rol se ha añadido al grupo. Para obtener más información, consulte [Administración del rol de grupo de Greengrass (consola)](group-role.md#manage-group-role-console) o [Administración del rol de grupo de Greengrass (CLI)](group-role.md#manage-group-role-cli). + Si el archivo de Docker Compose hace referencia a una imagen de Docker de [AWS Marketplace](https://aws.amazon.com/marketplace), el conector también tiene los siguientes requisitos: + Debe estar suscrito a los productos en AWS Marketplace contenedores. Para obtener más información, consulte [Búsqueda y suscripción a productos de contenedor](https://docs.aws.amazon.com/marketplace/latest/buyerguide/buyer-finding-and-subscribing-to-container-products.html) en la *Guía del suscriptor de AWS Marketplace *. + AWS IoT Greengrass debe configurarse para admitir secretos locales, tal y como se describe en [los requisitos](secrets.md#secrets-reqs) de confidencialidad. El conector utiliza esta función únicamente para recuperar sus secretos AWS Secrets Manager, no para almacenarlos. + Debes crear un secreto en Secrets Manager para cada AWS Marketplace registro que almacene una imagen de Docker a la que se haga referencia en tu archivo de Compose. Para obtener más información, consulte [Acceso a imágenes de Docker desde repositorios privados](#access-private-repositories). + Si el archivo de Docker Compose hace referencia a una imagen de Docker de repositorios privados en registros distintos de Amazon ECR, como Docker Hub, el conector también tendrá los siguientes requisitos: + AWS IoT Greengrass debe configurarse para admitir secretos locales, tal y como se describe en [los requisitos](secrets.md#secrets-reqs) de confidencialidad. El conector utiliza esta función únicamente para recuperar sus secretos AWS Secrets Manager, no para almacenarlos. + Debe crear un secreto en Secrets Manager para cada repositorio privado que almacene una imagen de Docker a la que se hace referencia en su archivo de Compose. Para obtener más información, consulte [Acceso a imágenes de Docker desde repositorios privados](#access-private-repositories). + El daemon de Docker debe ejecutarse cuando implemente un grupo de Greengrass que contenga este conector. ### Acceso a imágenes de Docker desde repositorios privados Si utiliza credenciales para acceder a sus imágenes de Docker, debe permitir que el conector tenga acceso a ellas. La forma en que lo haga depende de dónde se encuentre la imagen de Docker. En el caso de las imágenes de Docker almacenadas en Amazon ECR, concede permiso para obtener su token de autorización en el rol del grupo de Greengrass. Para obtener más información, consulte [Requisitos](#docker-app-connector-req). En el caso de las imágenes de Docker almacenadas en otros repositorios o registros privados, debe crear un registro secreto AWS Secrets Manager para almacenar su información de inicio de sesión. Esto incluye las imágenes de Docker a las que te has suscrito. AWS Marketplace Cree un secreto para cada repositorio. Si actualiza sus secretos en Secrets Manager, los cambios se propagarán al núcleo la próxima vez que implemente el grupo. **nota** Secrets Manager es un servicio que puede utilizar para almacenar y administrar de forma segura sus credenciales, claves y otros secretos en la Nube de AWS. Para obtener más información, consulta [¿Qué es? AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) en la *Guía AWS Secrets Manager del usuario*. Cada secreto debe contener las siguientes claves: | Clave | Valor | | --- | --- | | `username` | El nombre de usuario utilizado para acceder al repositorio o al registro. | | `password` | La contraseña utilizada para acceder al repositorio o al registro. | | `registryUrl` | El punto de enlace del registro. Este debe coincidir con la URL de registro correspondiente del archivo de Compose. | **nota** Para permitir AWS IoT Greengrass el acceso a un secreto de forma predeterminada, el nombre del secreto debe empezar por *greengrass-*. De lo contrario, debe conceder el acceso su rol de servicio de Greengrass. Para obtener más información, consulte [Permite obtener valores secretos AWS IoT Greengrass](secrets.md#secrets-config-service-role). **Para obtener información de inicio de sesión para las imágenes de Docker desde AWS Marketplace** 1. Obtenga la contraseña para las imágenes de Docker AWS Marketplace mediante el `aws ecr get-login-password` comando. Para obtener más información, consulte [get-login-password](https://docs.aws.amazon.com/cli/latest/reference/ecr/get-login.html) en la *Referencia de comandos de la AWS CLI *. ``` aws ecr get-login-password ``` 1. Recupere la URL de registro de la imagen de Docker. Abra el sitio web AWS Marketplace y abra la página de lanzamiento del producto contenedor. En **Imágenes del contenedor**, seleccione **Ver detalles de la imagen del contenedor** para buscar el nombre de usuario y la URL del registro. Usa el nombre de usuario, la contraseña y la URL del registro recuperados para crear un secreto para cada AWS Marketplace registro que almacene las imágenes de Docker a las que se hace referencia en tu archivo de Compose. **Para crear secretos (consola)** En la AWS Secrets Manager consola, selecciona **Otro tipo de secretos**. En **Specify the key-value pairs to be stored for this secret (Especificar los pares clave-valor que se van a almacenar para este secreto)**, añada filas para `username`, `password` y `registryUrl`. Para obtener más información, consulte [Creación de un secreto básico](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) en la *Guía del usuario de AWS Secrets Manager *. ![\[Crear un secreto con claves de nombre de usuario, contraseña y registryUrl.\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/connectors/secret-docker-trusted-registry.png) **Para crear secretos (CLI)** En AWS CLI, utilice el `create-secret` comando Secrets Manager, como se muestra en el siguiente ejemplo. Para obtener más información, consulte [create-cluster](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/create-secret.html) en la *Referencia de comandos de la AWS CLI *. ``` aws secretsmanager create-secret --name greengrass-MySecret --secret-string [{"username":"Mary_Major"},{"password":"abc123xyz456"},{"registryUrl":"https://docker.io"}] ``` **importante** Es su responsabilidad proteger el directorio `DockerComposeFileDestinationPath` en el que se guarda el archivo de Docker Compose y las credenciales de las imágenes de Docker de los repositorios privados. Para obtener más información, consulte [Notas de seguridad](#docker-app-connector-security). ## Parameters Este conector proporciona los siguientes parámetros: ------ #### [ Version 7 ] `DockerComposeFileS3Bucket` El nombre del bucket S3 que contiene el archivo de Docker Compose. Cuando cree el bucket, asegúrese de seguir las [reglas para nombres de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritas en la *guía del desarrollador de Amazon Simple Storage Service*. Nombre para mostrar en la AWS IoT consola: **archivo de Docker Compose en S3** En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `true` Tipo: `string` Patrón válido `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` La clave de objeto de su archivo de Docker Compose en Amazon S3. Para obtener más información, incluyendo las directrices de nomenclatura, consulte [Claves y metadatos de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) en la *Guía del desarrollador de Amazon Simple Storage Service*. En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `true` Tipo: `string` Patrón válido `.+` `DockerComposeFileS3Version` La versión de objeto del archivo de Docker Compose en Amazon S3. Para obtener más información, incluidas las pautas de denominación de las claves de objeto, consulte [Uso del control de versiones](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) en la *Guía del usuario de Amazon Simple Storage Service*. En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `false` Tipo: `string` Patrón válido `.+` `DockerComposeFileDestinationPath` La ruta absoluta del directorio local utilizado para almacenar una copia del archivo de Docker Compose. Debe ser un directorio existente. El usuario especificado para `DockerUserId` debe tener permiso para crear un archivo en este directorio. Para obtener más información, consulte [Configuración del usuario de Docker en el núcleo AWS IoT Greengrass](#docker-app-connector-linux-user). Este directorio almacena las credenciales y el archivo de Docker Compose de sus imágenes de Docker de repositorios privados. Es su responsabilidad proteger este directorio. Para obtener más información, consulte [Notas de seguridad](#docker-app-connector-security). Nombre para mostrar en la AWS IoT consola: **ruta del directorio del archivo Compose local** Obligatorio: `true` Tipo: `string` Patrón válido `\/.*\/?` Ejemplo: `/home/username/myCompose` `DockerUserId` El ID del usuario de Linux con el que se ejecuta el conector. Este usuario debe pertenecer al grupo de Linux de `docker` en el dispositivo central y tener permisos de escritura en el directorio de `DockerComposeFileDestinationPath`. Para obtener más información, consulte [Configuración del usuario de Docker en el núcleo](#docker-app-connector-linux-user). Se recomienda evitar la ejecución como raíz a menos que sea absolutamente necesario. Si especifica el usuario raíz, debe permitir que las funciones de Lambda se ejecuten como raíz en el núcleo de AWS IoT Greengrass . Para obtener más información, consulte [Ejecución de una función de Lambda como raíz](lambda-group-config.md#lambda-running-as-root). Nombre para mostrar en la AWS IoT consola: ID de **usuario de Docker** Obligatorio: `false` Tipo: `string` Patrón válido: `^[0-9]{1,5}$` `AWSSecretsArnList` Los nombres de los recursos de Amazon (ARNs) de los secretos AWS Secrets Manager que contienen la información de inicio de sesión utilizada para acceder a las imágenes de Docker en repositorios privados. Para obtener más información, consulte [Acceso a imágenes de Docker desde repositorios privados](#access-private-repositories). Nombre para mostrar en la AWS IoT consola: **Credenciales para repositorios privados** Obligatorio: `false`. Este parámetro es necesario para acceder a las imágenes de Docker almacenadas en repositorios privados. Tipo: `array` de `string` Patrón 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` La frecuencia (en segundos) a la que el conector registra información de estado sobre los contenedores Docker que se ejecutan en el núcleo. El valor predeterminado es 300 segundos (5 minutos). Nombre para mostrar en la AWS IoT consola: frecuencia de **registro** Obligatorio: `false` Tipo: `string` Patrón válido: `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Indica si se aplicará forzosamente la implementación de Docker en caso de que se produzca un error por una limpieza incorrecta de la última implementación. El valor predeterminado es `False`. Nombre para mostrar en la AWS IoT consola: **despliegue forzado** Obligatorio: `false` Tipo: `string` Patrón válido: `^(true|false)$` `DockerPullBeforeUp` Indica si el implementador debe ejecutarse `docker-compose pull` antes de ejecutarse `docker-compose up` para detectar un pull-down-up comportamiento. El valor predeterminado es `True`. Nombre para mostrar en la AWS IoT consola: **Docker Pull Before Up** Obligatorio: `false` Tipo: `string` Patrón válido: `^(true|false)$` `StopContainersOnNewDeployment` Indica si el conector debe detener los contenedores docker gestionados por Docker Deployer cuando se detiene el GGC (el GGC se detiene cuando se despliega un grupo nuevo o se cierra el núcleo). El valor predeterminado es `True`. Nombre para mostrar en la AWS IoT consola: **Docker se detiene en** una nueva implementación Recomendamos mantener este parámetro establecido en su valor `True` predeterminado. El parámetro `False` hace que el contenedor de Docker siga ejecutándose incluso después de terminar el AWS IoT Greengrass núcleo o iniciar una nueva implementación. Si establece este parámetro en `False`, debe asegurarse de que sus contenedores de Docker se mantengan según sea necesario en caso de que se añada o cambie el nombre del servicio `docker-compose`. Para obtener más información, consulte la documentación del archivo de composición de `docker-compose`. Obligatorio: `false` Tipo: `string` Patrón válido: `^(true|false)$` `DockerOfflineMode` Indica si se debe utilizar el archivo Docker Compose existente al iniciar AWS IoT Greengrass sin conexión. El valor predeterminado es `False`. Obligatorio: `false` Tipo: `string` Patrón válido: `^(true|false)$` ------ #### [ Version 6 ] `DockerComposeFileS3Bucket` El nombre del bucket S3 que contiene el archivo de Docker Compose. Cuando cree el bucket, asegúrese de seguir las [reglas para nombres de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritas en la *guía del desarrollador de Amazon Simple Storage Service*. Nombre para mostrar en la AWS IoT consola: archivo de **Docker Compose** en S3 En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `true` Tipo: `string` Patrón válido `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` La clave de objeto de su archivo de Docker Compose en Amazon S3. Para obtener más información, incluyendo las directrices de nomenclatura, consulte [Claves y metadatos de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) en la *Guía del desarrollador de Amazon Simple Storage Service*. En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `true` Tipo: `string` Patrón válido `.+` `DockerComposeFileS3Version` La versión de objeto del archivo de Docker Compose en Amazon S3. Para obtener más información, incluidas las pautas de denominación de las claves de objeto, consulte [Uso del control de versiones](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) en la *Guía del usuario de Amazon Simple Storage Service*. En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `false` Tipo: `string` Patrón válido `.+` `DockerComposeFileDestinationPath` La ruta absoluta del directorio local utilizado para almacenar una copia del archivo de Docker Compose. Debe ser un directorio existente. El usuario especificado para `DockerUserId` debe tener permiso para crear un archivo en este directorio. Para obtener más información, consulte [Configuración del usuario de Docker en el núcleo AWS IoT Greengrass](#docker-app-connector-linux-user). Este directorio almacena las credenciales y el archivo de Docker Compose de sus imágenes de Docker de repositorios privados. Es su responsabilidad proteger este directorio. Para obtener más información, consulte [Notas de seguridad](#docker-app-connector-security). Nombre para mostrar en la AWS IoT consola: **ruta del directorio del archivo Compose local** Obligatorio: `true` Tipo: `string` Patrón válido `\/.*\/?` Ejemplo: `/home/username/myCompose` `DockerUserId` El ID del usuario de Linux con el que se ejecuta el conector. Este usuario debe pertenecer al grupo de Linux de `docker` en el dispositivo central y tener permisos de escritura en el directorio de `DockerComposeFileDestinationPath`. Para obtener más información, consulte [Configuración del usuario de Docker en el núcleo](#docker-app-connector-linux-user). Se recomienda evitar la ejecución como raíz a menos que sea absolutamente necesario. Si especifica el usuario raíz, debe permitir que las funciones de Lambda se ejecuten como raíz en el núcleo de AWS IoT Greengrass . Para obtener más información, consulte [Ejecución de una función de Lambda como raíz](lambda-group-config.md#lambda-running-as-root). Nombre para mostrar en la AWS IoT consola: ID de **usuario de Docker** Obligatorio: `false` Tipo: `string` Patrón válido: `^[0-9]{1,5}$` `AWSSecretsArnList` Los nombres de los recursos de Amazon (ARNs) de los secretos AWS Secrets Manager que contienen la información de inicio de sesión utilizada para acceder a las imágenes de Docker en repositorios privados. Para obtener más información, consulte [Acceso a imágenes de Docker desde repositorios privados](#access-private-repositories). Nombre para mostrar en la AWS IoT consola: **Credenciales para repositorios privados** Obligatorio: `false`. Este parámetro es necesario para acceder a las imágenes de Docker almacenadas en repositorios privados. Tipo: `array` de `string` Patrón 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` La frecuencia (en segundos) a la que el conector registra información de estado sobre los contenedores Docker que se ejecutan en el núcleo. El valor predeterminado es 300 segundos (5 minutos). Nombre para mostrar en la AWS IoT consola: frecuencia de **registro** Obligatorio: `false` Tipo: `string` Patrón válido: `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Indica si se aplicará forzosamente la implementación de Docker en caso de que se produzca un error por una limpieza incorrecta de la última implementación. El valor predeterminado es `False`. Nombre para mostrar en la AWS IoT consola: **despliegue forzado** Obligatorio: `false` Tipo: `string` Patrón válido: `^(true|false)$` `DockerPullBeforeUp` Indica si el implementador debe ejecutarse `docker-compose pull` antes de ejecutarse `docker-compose up` para detectar un pull-down-up comportamiento. El valor predeterminado es `True`. Nombre para mostrar en la AWS IoT consola: **Docker Pull Before Up** Obligatorio: `false` Tipo: `string` Patrón válido: `^(true|false)$` `StopContainersOnNewDeployment` Indica si el conector debe detener los contenedores docker gestionados por Docker Deployer cuando se detiene el GGC (cuando se realiza una implementación de un nuevo grupo o se apaga el núcleo). El valor predeterminado es `True`. Nombre para mostrar en la AWS IoT consola: **Docker se detiene en** una nueva implementación Recomendamos mantener este parámetro establecido en su valor `True` predeterminado. El parámetro `False` hace que el contenedor de Docker siga ejecutándose incluso después de terminar el AWS IoT Greengrass núcleo o iniciar una nueva implementación. Si establece este parámetro en `False`, debe asegurarse de que sus contenedores de Docker se mantengan según sea necesario en caso de que se añada o cambie el nombre del servicio `docker-compose`. Para obtener más información, consulte la documentación del archivo de composición de `docker-compose`. Obligatorio: `false` Tipo: `string` Patrón válido: `^(true|false)$` ------ #### [ Version 5 ] `DockerComposeFileS3Bucket` El nombre del bucket S3 que contiene el archivo de Docker Compose. Cuando cree el bucket, asegúrese de seguir las [reglas para nombres de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritas en la *guía del desarrollador de Amazon Simple Storage Service*. Nombre para mostrar en la AWS IoT consola: archivo de **Docker Compose** en S3 En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `true` Tipo: `string` Patrón válido `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` La clave de objeto de su archivo de Docker Compose en Amazon S3. Para obtener más información, incluyendo las directrices de nomenclatura, consulte [Claves y metadatos de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) en la *Guía del desarrollador de Amazon Simple Storage Service*. En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `true` Tipo: `string` Patrón válido `.+` `DockerComposeFileS3Version` La versión de objeto del archivo de Docker Compose en Amazon S3. Para obtener más información, incluidas las pautas de denominación de las claves de objeto, consulte [Uso del control de versiones](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) en la *Guía del usuario de Amazon Simple Storage Service*. En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `false` Tipo: `string` Patrón válido `.+` `DockerComposeFileDestinationPath` La ruta absoluta del directorio local utilizado para almacenar una copia del archivo de Docker Compose. Debe ser un directorio existente. El usuario especificado para `DockerUserId` debe tener permiso para crear un archivo en este directorio. Para obtener más información, consulte [Configuración del usuario de Docker en el núcleo AWS IoT Greengrass](#docker-app-connector-linux-user). Este directorio almacena las credenciales y el archivo de Docker Compose de sus imágenes de Docker de repositorios privados. Es su responsabilidad proteger este directorio. Para obtener más información, consulte [Notas de seguridad](#docker-app-connector-security). Nombre para mostrar en la AWS IoT consola: **ruta del directorio del archivo Compose local** Obligatorio: `true` Tipo: `string` Patrón válido `\/.*\/?` Ejemplo: `/home/username/myCompose` `DockerUserId` El ID del usuario de Linux con el que se ejecuta el conector. Este usuario debe pertenecer al grupo de Linux de `docker` en el dispositivo central y tener permisos de escritura en el directorio de `DockerComposeFileDestinationPath`. Para obtener más información, consulte [Configuración del usuario de Docker en el núcleo](#docker-app-connector-linux-user). Se recomienda evitar la ejecución como raíz a menos que sea absolutamente necesario. Si especifica el usuario raíz, debe permitir que las funciones de Lambda se ejecuten como raíz en el núcleo de AWS IoT Greengrass . Para obtener más información, consulte [Ejecución de una función de Lambda como raíz](lambda-group-config.md#lambda-running-as-root). Nombre para mostrar en la AWS IoT consola: ID de **usuario de Docker** Obligatorio: `false` Tipo: `string` Patrón válido: `^[0-9]{1,5}$` `AWSSecretsArnList` Los nombres de los recursos de Amazon (ARNs) de los secretos AWS Secrets Manager que contienen la información de inicio de sesión utilizada para acceder a las imágenes de Docker en repositorios privados. Para obtener más información, consulte [Acceso a imágenes de Docker desde repositorios privados](#access-private-repositories). Nombre para mostrar en la AWS IoT consola: **Credenciales para repositorios privados** Obligatorio: `false`. Este parámetro es necesario para acceder a las imágenes de Docker almacenadas en repositorios privados. Tipo: `array` de `string` Patrón 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` La frecuencia (en segundos) a la que el conector registra información de estado sobre los contenedores Docker que se ejecutan en el núcleo. El valor predeterminado es 300 segundos (5 minutos). Nombre para mostrar en la AWS IoT consola: frecuencia de **registro** Obligatorio: `false` Tipo: `string` Patrón válido: `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Indica si se aplicará forzosamente la implementación de Docker en caso de que se produzca un error por una limpieza incorrecta de la última implementación. El valor predeterminado es `False`. Nombre para mostrar en la AWS IoT consola: **despliegue forzado** Obligatorio: `false` Tipo: `string` Patrón válido: `^(true|false)$` `DockerPullBeforeUp` Indica si el implementador debe ejecutarse `docker-compose pull` antes de ejecutarse `docker-compose up` para detectar un pull-down-up comportamiento. El valor predeterminado es `True`. Nombre para mostrar en la AWS IoT consola: **Docker Pull Before Up** Obligatorio: `false` Tipo: `string` Patrón válido: `^(true|false)$` ------ #### [ Versions 2 - 4 ] `DockerComposeFileS3Bucket` El nombre del bucket S3 que contiene el archivo de Docker Compose. Cuando cree el bucket, asegúrese de seguir las [reglas para nombres de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritas en la *guía del desarrollador de Amazon Simple Storage Service*. Nombre para mostrar en la AWS IoT consola: **archivo de Docker Compose** en S3 En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `true` Tipo: `string` Patrón válido `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` La clave de objeto de su archivo de Docker Compose en Amazon S3. Para obtener más información, incluyendo las directrices de nomenclatura, consulte [Claves y metadatos de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) en la *Guía del desarrollador de Amazon Simple Storage Service*. En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `true` Tipo: `string` Patrón válido `.+` `DockerComposeFileS3Version` La versión de objeto del archivo de Docker Compose en Amazon S3. Para obtener más información, incluidas las pautas de denominación de las claves de objeto, consulte [Uso del control de versiones](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) en la *Guía del usuario de Amazon Simple Storage Service*. En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `false` Tipo: `string` Patrón válido `.+` `DockerComposeFileDestinationPath` La ruta absoluta del directorio local utilizado para almacenar una copia del archivo de Docker Compose. Debe ser un directorio existente. El usuario especificado para `DockerUserId` debe tener permiso para crear un archivo en este directorio. Para obtener más información, consulte [Configuración del usuario de Docker en el núcleo AWS IoT Greengrass](#docker-app-connector-linux-user). Este directorio almacena las credenciales y el archivo de Docker Compose de sus imágenes de Docker de repositorios privados. Es su responsabilidad proteger este directorio. Para obtener más información, consulte [Notas de seguridad](#docker-app-connector-security). Nombre para mostrar en la AWS IoT consola: **ruta del directorio del archivo Compose local** Obligatorio: `true` Tipo: `string` Patrón válido `\/.*\/?` Ejemplo: `/home/username/myCompose` `DockerUserId` El ID del usuario de Linux con el que se ejecuta el conector. Este usuario debe pertenecer al grupo de Linux de `docker` en el dispositivo central y tener permisos de escritura en el directorio de `DockerComposeFileDestinationPath`. Para obtener más información, consulte [Configuración del usuario de Docker en el núcleo](#docker-app-connector-linux-user). Se recomienda evitar la ejecución como raíz a menos que sea absolutamente necesario. Si especifica el usuario raíz, debe permitir que las funciones de Lambda se ejecuten como raíz en el núcleo de AWS IoT Greengrass . Para obtener más información, consulte [Ejecución de una función de Lambda como raíz](lambda-group-config.md#lambda-running-as-root). Nombre para mostrar en la AWS IoT consola: ID de **usuario de Docker** Obligatorio: `false` Tipo: `string` Patrón válido: `^[0-9]{1,5}$` `AWSSecretsArnList` Los nombres de los recursos de Amazon (ARNs) de los secretos AWS Secrets Manager que contienen la información de inicio de sesión utilizada para acceder a las imágenes de Docker en repositorios privados. Para obtener más información, consulte [Acceso a imágenes de Docker desde repositorios privados](#access-private-repositories). Nombre para mostrar en la AWS IoT consola: **Credenciales para repositorios privados** Obligatorio: `false`. Este parámetro es necesario para acceder a las imágenes de Docker almacenadas en repositorios privados. Tipo: `array` de `string` Patrón 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` La frecuencia (en segundos) a la que el conector registra información de estado sobre los contenedores Docker que se ejecutan en el núcleo. El valor predeterminado es 300 segundos (5 minutos). Nombre para mostrar en la AWS IoT consola: frecuencia de **registro** Obligatorio: `false` Tipo: `string` Patrón válido: `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Indica si se aplicará forzosamente la implementación de Docker en caso de que se produzca un error por una limpieza incorrecta de la última implementación. El valor predeterminado es `False`. Nombre para mostrar en la AWS IoT consola: **despliegue forzado** Obligatorio: `false` Tipo: `string` Patrón válido: `^(true|false)$` ------ #### [ Version 1 ] `DockerComposeFileS3Bucket` El nombre del bucket S3 que contiene el archivo de Docker Compose. Cuando cree el bucket, asegúrese de seguir las [reglas para nombres de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) descritas en la *guía del desarrollador de Amazon Simple Storage Service*. Nombre para mostrar en la AWS IoT consola: **archivo de Docker Compose en S3** En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `true` Tipo: `string` Patrón válido `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` La clave de objeto de su archivo de Docker Compose en Amazon S3. Para obtener más información, incluyendo las directrices de nomenclatura, consulte [Claves y metadatos de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) en la *Guía del desarrollador de Amazon Simple Storage Service*. En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `true` Tipo: `string` Patrón válido `.+` `DockerComposeFileS3Version` La versión de objeto del archivo de Docker Compose en Amazon S3. Para obtener más información, incluidas las pautas de denominación de las claves de objeto, consulte [Uso del control de versiones](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) en la *Guía del usuario de Amazon Simple Storage Service*. En la consola, el **archivo de Docker Compose en la propiedad S3** combina los parámetros de `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key`, y `DockerComposeFileS3Version`. Obligatorio: `false` Tipo: `string` Patrón válido `.+` `DockerComposeFileDestinationPath` La ruta absoluta del directorio local utilizado para almacenar una copia del archivo de Docker Compose. Debe ser un directorio existente. El usuario especificado para `DockerUserId` debe tener permiso para crear un archivo en este directorio. Para obtener más información, consulte [Configuración del usuario de Docker en el núcleo AWS IoT Greengrass](#docker-app-connector-linux-user). Este directorio almacena las credenciales y el archivo de Docker Compose de sus imágenes de Docker de repositorios privados. Es su responsabilidad proteger este directorio. Para obtener más información, consulte [Notas de seguridad](#docker-app-connector-security). Nombre para mostrar en la AWS IoT consola: **ruta del directorio del archivo Compose local** Obligatorio: `true` Tipo: `string` Patrón válido `\/.*\/?` Ejemplo: `/home/username/myCompose` `DockerUserId` El ID del usuario de Linux con el que se ejecuta el conector. Este usuario debe pertenecer al grupo de Linux de `docker` en el dispositivo central y tener permisos de escritura en el directorio de `DockerComposeFileDestinationPath`. Para obtener más información, consulte [Configuración del usuario de Docker en el núcleo](#docker-app-connector-linux-user). Se recomienda evitar la ejecución como raíz a menos que sea absolutamente necesario. Si especifica el usuario raíz, debe permitir que las funciones de Lambda se ejecuten como raíz en el núcleo de AWS IoT Greengrass . Para obtener más información, consulte [Ejecución de una función de Lambda como raíz](lambda-group-config.md#lambda-running-as-root). Nombre para mostrar en la AWS IoT consola: ID de **usuario de Docker** Obligatorio: `false` Tipo: `string` Patrón válido: `^[0-9]{1,5}$` `AWSSecretsArnList` Los nombres de los recursos de Amazon (ARNs) de los secretos AWS Secrets Manager que contienen la información de inicio de sesión utilizada para acceder a las imágenes de Docker en repositorios privados. Para obtener más información, consulte [Acceso a imágenes de Docker desde repositorios privados](#access-private-repositories). Nombre para mostrar en la AWS IoT consola: **Credenciales para repositorios privados** Obligatorio: `false`. Este parámetro es necesario para acceder a las imágenes de Docker almacenadas en repositorios privados. Tipo: `array` de `string` Patrón 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` La frecuencia (en segundos) a la que el conector registra información de estado sobre los contenedores Docker que se ejecutan en el núcleo. El valor predeterminado es 300 segundos (5 minutos). Nombre para mostrar en la AWS IoT consola: frecuencia de **registro** Obligatorio: `false` Tipo: `string` Patrón válido: `^[1-9]{1}[0-9]{0,3}$` ------ ### Ejemplo de creación de conector (AWS CLI) El siguiente comando de la CLI crea una `ConnectorDefinition` con una versión inicial que contiene el conector de implementación de la aplicación de Greengrass Docker. ``` 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** La función de Lambda de este conector tiene un ciclo de vida [prolongado](lambda-functions.md#lambda-lifecycle). ## Datos de entrada Este conector no requiere ni acepta datos de entrada. ## Datos de salida Este conector publica el estado del comando de `docker-compose up` como datos de salida. **Filtro de temas en la suscripción** `dockerapplicationdeploymentconnector/message/status` **Ejemplo de salida: Correcto** ``` { "status":"success", "GreengrassDockerApplicationDeploymentStatus":"Successfully triggered docker-compose up", "S3Bucket":"amzn-s3-demo-bucket", "ComposeFileName":"production-docker-compose.yml", "ComposeFileVersion":"123" } ``` **Ejemplo de salida: Error** ``` { "status":"fail", "error_message":"description of error", "error":"InvalidParameter" } ``` El tipo de error puede ser `InvalidParameter` o `InternalError`. ## Configuración del usuario de Docker en el núcleo AWS IoT Greengrass El conector de implementación de aplicaciones Docker de Greengrass se ejecuta como el usuario que especifique para el parámetro `DockerUserId`. Si no especifica un valor, el conector se ejecutará como `ggc_user`, que es la identidad de acceso de Greengrass predeterminada. Para permitir que el conector interactúe con el daemon de Docker, el usuario de Docker debe pertenecer al grupo de Linux de `docker` del núcleo. El usuario de Docker también debe tener permisos de escritura en el directorio de `DockerComposeFileDestinationPath`. Aquí es donde el conector almacena el archivo local de `docker-compose.yml` y las credenciales de Docker. **nota** Le recomendamos que cree un usuario de Linux en lugar de utilizar el `ggc_user` predeterminado. De lo contrario, cualquier función de Lambda del grupo de Greengrass podrá acceder al archivo de Compose y a las credenciales de Docker. Se recomienda evitar la ejecución como raíz a menos que sea absolutamente necesario. Si especifica el usuario raíz, debe permitir que las funciones de Lambda se ejecuten como raíz en el núcleo de AWS IoT Greengrass . Para obtener más información, consulte [Ejecución de una función de Lambda como raíz](lambda-group-config.md#lambda-running-as-root). 1. Cree el usuario. Puede ejecutar el comando de `useradd` e incluir la opción de `-u` opcional para asignar un ID de usuario. Por ejemplo: ``` sudo useradd -u 1234 user-name ``` 1. Añada el usuario al grupo de `docker` en el núcleo. Por ejemplo: ``` sudo usermod -aG docker user-name ``` Para obtener más información, como por ejemplo la forma de crear el grupo de `docker`, consulte [Manage Docker as a non-root user (Administrar Docker como usuario no raíz)](https://docs.docker.com/install/linux/linux-postinstall/#manage-docker-as-a-non-root-user) en la documentación de Docker. 1. Otorgue permisos al usuario para que pueda escribir en el directorio especificado para el parámetro de `DockerComposeFileDestinationPath`. Por ejemplo: 1. Para fijar al usuario como propietario del directorio. En este ejemplo se utiliza el ID de usuario del paso 1. ``` chown 1234 docker-compose-file-destination-path ``` 1. Otorgue permisos de lectura y escritura al propietario. ``` chmod 700 docker-compose-file-destination-path ``` Para obtener más información, consulte [How To Manage File And Folder Permissions In Linux (Cómo administrar los permisos de archivos y carpetas en Linux)](https://www.linux.com/tutorials/how-manage-file-and-folder-permissions-linux/) en la documentación de Linux Foundation. 1. Si no asignó un ID de usuario al crear el usuario, o si utilizó un usuario existente, ejecute el comando de `id` para buscar el ID de usuario. ``` id -u user-name ``` Utilice el ID de usuario para configurar el parámetro de `DockerUserId` para el conector. ## Información de uso Cuando utilice el conector de implementación de la aplicación de Greengrass Docker, debe tener en cuenta la siguiente información de uso específica de la implementación. + **Prefijo fijo para nombres de proyectos.** El conector antepone el prefijo de `greengrassdockerapplicationdeployment` a los nombres de los contenedores Docker que inicia. El conector utiliza este prefijo como nombre del proyecto en los comandos de `docker-compose` que ejecuta. + **Comportamiento de registro.** El conector escribe información de estado e información de resolución de problemas en un archivo de registro. Puede configurarlo AWS IoT Greengrass para enviar CloudWatch registros a Logs y escribirlos localmente. Para obtener más información, consulte [Registro de conectores](connectors.md#connectors-logging). Esta es la ruta al registro local para el conector: ``` /greengrass-root/ggc/var/log/user/region/aws/DockerApplicationDeployment.log ``` Debe tener permisos de root para acceder a los registros locales. + **Actualización de imágenes de Docker.** Docker almacena imágenes en la caché en el dispositivo central. Si actualiza una imagen de Docker y desea propagar el cambio al dispositivo central, asegúrese de cambiar la etiqueta de la imagen en el archivo de Compose. Los cambios surten efecto después de que se implemente el grupo de Greengrass. + **Tiempo de espera de 10 minutos para operaciones de limpieza.** Cuando el daemon de Greengrass se detiene durante un reinicio, el comando de `docker-compose down` se activa. Todos los contenedores de Docker tienen un máximo de 10 minutos después de que se active `docker-compose down` para realizar cualquier operación de limpieza. Si la limpieza no se completa en 10 minutos, deberá limpiar manualmente los contenedores restantes. Para obtener más información, consulte [docker rm](https://docs.docker.com/engine/reference/commandline/rm/) en la documentación de la CLI de Docker. + **Ejecución de comandos de Docker.** Para solucionar problemas, puede ejecutar comandos de Docker en una ventana de terminal del dispositivo central. Por ejemplo, ejecute el siguiente comando para ver los contenedores Docker iniciados por el conector: ``` docker ps --filter name="greengrassdockerapplicationdeployment" ``` + **ID de recurso reservado.** El conector utiliza el ID de `DOCKER_DEPLOYER_SECRET_RESOURCE_RESERVED_ID_index` para los recursos de Greengrass que crea en el grupo de Greengrass. El recurso IDs debe ser único en el grupo, así que no asigne un ID de recurso que pueda entrar en conflicto con este ID de recurso reservado. + **Modo sin conexión.** *Si establece el parámetro de configuración `DockerOfflineMode` en `True`, el conector Docker puede funcionar en modo fuera de línea*. Esto puede ocurrir cuando la implementación de un grupo de Greengrass se reinicia mientras el dispositivo principal está fuera de línea y el conector no puede establecer una conexión con Amazon S3 o Amazon ECR para recuperar el archivo de Docker Compose. Con el modo sin conexión activado, el conector intenta descargar el archivo de Compose y ejecutar los comandos `docker login` como lo haría en un reinicio normal. Si estos intentos fallan, el conector busca un archivo de Compose almacenado localmente en la carpeta que se especificó mediante el parámetro `DockerComposeFileDestinationPath`. Si existe un archivo Compose local, el conector sigue la secuencia normal de los comandos `docker-compose` y extrae imágenes locales. Si el archivo de Compose o las imágenes locales no están presentes, se produce un error en el conector. El comportamiento de los parámetros `ForceDeploy` y `StopContainersOnNewDeployment` sigue siendo el mismo en el modo sin conexión. ## Comunicación con contenedores Docker AWS IoT Greengrass admite los siguientes canales de comunicación entre los componentes de Greengrass y los contenedores de Docker: + Las funciones Lambda de Greengrass pueden usar REST APIs para comunicarse con los procesos de los contenedores de Docker. Puede configurar un servidor en un contenedor de Docker que abre un puerto. Las funciones de Lambda se pueden comunicar con el contenedor de este puerto. + Los procesos de los contenedores Docker pueden intercambiar mensajes MQTT a través del bróker de mensajería local de Greengrass. Puede configurar el contenedor Docker como un dispositivo cliente en el grupo Greengrass y, a continuación, crear suscripciones para permitir que el contenedor se comunique con las funciones de Greengrass Lambda, los dispositivos cliente y otros conectores del grupo, AWS IoT o con el servicio paralelo local. Para obtener más información, consulte [Configurar la comunicación MQTT con contenedores Docker](#docker-app-connector-mqtt-communication). + Las funciones de Lambda de Greengrass pueden actualizar un archivo compartido para pasar información a contenedores de Docker. Puede utilizar el archivo de Compose para montar un subconjunto de la ruta del archivo compartido en un contenedor Docker. ### Configurar la comunicación MQTT con contenedores Docker Puede configurar un contenedor de Docker como un dispositivo de cliente y añadirlo a un grupo de Greengrass. A continuación, puede crear suscripciones que permitan la comunicación MQTT entre el contenedor Docker y los componentes Greengrass o AWS IoT. En el siguiente procedimiento, va a crear una suscripción que permite que el dispositivo del contenedor Docker reciba mensajes de actualización de sombra desde el servicio de sombra local. Puede seguir este patrón para crear otras suscripciones. **nota** Suponemos que ya ha creado un grupo de Greengrass y un núcleo de Greengrass (versión 1.10 o posterior) en este procedimiento. Para obtener más información acerca de la creación de núcleos y grupos de Greengrass, consulte [Empezar con AWS IoT Greengrass](gg-gs.md). **Para configurar un contenedor de Docker como un dispositivo de cliente y añadirlo a un grupo de Greengrass** 1. Cree una carpeta en el dispositivo central para almacenar los certificados y claves utilizados para autenticar el dispositivo Greengrass. La ruta del archivo debe montarse en el contenedor Docker que desee iniciar. El siguiente fragmento muestra cómo montar una ruta de archivo en el archivo de Compose. En este ejemplo, *path-to-device-certs* representa la carpeta que creó en este paso. ``` version: '3.3' services: myService: image: user-name/repo:image-tag volumes: - /path-to-device-certs/:/path-accessible-in-container ``` 1. En el panel de navegación de la AWS IoT consola, en **Administrar**, expanda **los dispositivos Greengrass** y, a continuación, elija **Grupos (V1)**. 1. Seleccione el grupo de destino. 1. En la página de configuración del grupo, seleccione **Dispositivos de cliente** y, a continuación, seleccione **Asociar**. 1. En el modal **Asociar un dispositivo cliente a este grupo**, elija **Crear AWS IoT algo nuevo**. La página **Crear objetos** se abre en una pestaña nueva. 1. En la página **Crear objetos**, elija **Crear un solo objeto**, y luego seleccione **Siguiente**. 1. En la página **Especificar las propiedades del objeto**, introduce un nombre para el dispositivo y, a continuación, seleccione **Siguiente**. 1. En la página **Configurar el certificado del dispositivo**, seleccione **Siguiente**. 1. En la página **Adjuntar políticas al certificado**, realice uno de los siguientes procedimientos: + Seleccione una política existente que conceda los permisos que requieren los dispositivos clientes y, a continuación, seleccione **Crear objeto**. Se abre un modal en el que puede descargar los certificados y las claves que el dispositivo utiliza para conectarse al núcleo Nube de AWS y al núcleo. + Cree y adjunte una nueva política que conceda permisos al dispositivo cliente. Haga lo siguiente: 1. Elija **Crear política**. La página **Create policy (Crear política)** se abre en una pestaña nueva. 1. En la página **Create policy (Crear política)**, haga lo siguiente: 1. En **Nombre de la política**, introduzca un nombre que describa la política, como **GreengrassV1ClientDevicePolicy**. 1. En la pestaña **Declaraciones de política**, en **Documento de política**, seleccione **JSON**. 1. Ingrese el siguiente documento de política. Esta política permite que el dispositivo cliente descubra los núcleos de Greengrass y comunique todos los temas MQTT. Para obtener información acerca de cómo restringir el acceso a esta política, consulte [Autenticación y autorización 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. Elija **Create** (Crear) para crear la política. 1. Vuelva a la pestaña del navegador con la página **Adjuntar políticas al certificado** abierta. Haga lo siguiente: 1. En la lista **Políticas**, seleccione la política que ha creado, como **GreengrassV1ClientDevicePolicy**. Si no se puede ver la política, seleccione el botón de actualizar. 1. Elija **Crear objeto**. Se abre un modal en el que puede descargar los certificados y las claves que el dispositivo utiliza para conectarse al núcleo Nube de AWS y al núcleo. 1. En el modal **Descargar certificados y claves**, descargue los certificados del dispositivo. **importante** Descargue los recursos de seguridad antes de elegir **Listo**. Haga lo siguiente: 1. Para el **Certificado del dispositivo**, seleccione **Descargar** para descargar el certificado del dispositivo. 1. En **Archivo de clave pública**, seleccione **Descargar** para descargar la clave pública del certificado. 1. En **Archivo de clave privada**, seleccione **Descargar** para descargar el archivo de clave privada del certificado. 1. Revise la [Autenticación de servidor](https://docs.aws.amazon.com/iot/latest/developerguide/server-authentication.html) en la *Guía del desarrollador de AWS IoT * y seleccione el certificado de CA raíz adecuado. Le recomendamos que utilice los puntos de conexión de Amazon Trust Services (ATS) y los certificados de CA raíz de ATS. En **Certificados de CA raíz**, seleccione **Descargar** para obtener un certificado de CA raíz. 1. Seleccione **Listo**. Tome nota del identificador del certificado que comparten los nombres de archivo del certificado y las claves del dispositivo. Lo necesitará más adelante. 1. Copie los certificados y las claves en la carpeta que ha creado en el paso 1. A continuación, cree una suscripción en el grupo. En este ejemplo, crear una suscripción permite que el dispositivo del contenedor Docker reciba mensajes MQTT del servicio de sombra local. **nota** El tamaño máximo de un documento sombra es de 8 kB. Para obtener más información, consulte [Cuotas de AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/limits-iot.html) en la *Guía para desarrolladores de AWS IoT *. **Para crear una suscripción que permita al dispositivo del contenedor Docker recibir mensajes MQTT del servicio de sombra local** 1. En la página de configuración del grupo, elija la pestaña **Suscripciones** y, a continuación, elija **Añadir suscripción**. 1. En la página **Select your source and target**, configure el origen y el destino, de la siguiente manera: 1. Para **Select a source (Seleccionar un origen)**: elija **Services (Servicios)** y, a continuación, **Local Shadow Service (Servicio de sombra local)**. 1. En **Select a target (Seleccionar un destino)**, seleccione **Devices (Dispositivos)**, y, a continuación, elija su dispositivo. 1. Elija **Siguiente**. 1. En la página **Filtrar los datos por tema**, en el campo **Filtro por tema**, escriba **\$1aws/things/*MyDockerDevice*/shadow/update/accepted** y, a continuación, seleccione **Siguiente**. *MyDockerDevice*Sustitúyalo por el nombre del dispositivo que creaste anteriormente. 1. Seleccione **Finalizar**. Incluya el siguiente fragmento de código en la imagen de Docker a la que haga referencia en su archivo de Compose. Este es el código del dispositivo Greengrass. Además, añada el código en el contenedor Docker que inicia el dispositivo Greengrass dentro del contenedor. Se puede ejecutar como un proceso independiente en la imagen o en una cadena independiente. ``` 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) ``` ## Notas de seguridad Cuando utilice el conector de implementación de la aplicación de Greengrass Docker, tenga en cuenta las siguientes consideraciones de seguridad. **Almacenamiento local del archivo de Docker Compose** El conector guarda una copia del archivo de Compose en el directorio especificado con el parámetro de `DockerComposeFileDestinationPath`. Es su responsabilidad proteger este directorio. Debe utilizar los permisos del sistema de archivos para restringir el acceso al directorio. **Almacenamiento local de las credenciales de Docker** Si las imágenes de Docker se guardan en repositorios privados, el conector almacenará las credenciales de Docker en el directorio especificado con el parámetro `DockerComposeFileDestinationPath`. Es su responsabilidad proteger estas credenciales. Por ejemplo, debe usar [credencial-helper](https://docs.docker.com/engine/reference/commandline/login/#credentials-store) en el dispositivo central cuando instale Docker Engine. **Instalar Docker Engine desde una fuente de confianza** Es su responsabilidad instalar Docker Engine desde una fuente de confianza. Este conector utiliza el daemon de Docker del dispositivo central para acceder a sus recursos de Docker y administrar los contenedores de Docker. **Alcance de los permisos de rol del grupo de Greengrass** Todos los conectores y funciones de Lambda del grupo de Greengrass pueden asumir los permisos que añada en el rol del grupo de Greengrass. Este conector requiere acceso al archivo de Docker Compose almacenado en un bucket S3. También requiere acceso a su token de autorización de Amazon ECR si sus imágenes de Docker se almacenan en un repositorio privado en Amazon ECR. ## Licencias El conector de implementación de Greengrass Docker incluye las siguientes licencias y software de terceros: + [AWS SDK para Python (Boto3)](https://pypi.org/project/boto3/)/Apache License 2.0 + [botocore](https://pypi.org/project/botocore/)/Apache License 2.0 + [dateutil](https://pypi.org/project/python-dateutil/1.4/)/PSF License + [docutils](https://pypi.org/project/docutils/)/BSD License, GNU General Public License (GPL), Python Software Foundation License, Public Domain + [jmespath](https://pypi.org/project/jmespath/)/MIT License + [s3transfer](https://pypi.org/project/s3transfer/)/Apache License 2.0 + [urllib3](https://pypi.org/project/urllib3/)/MIT License Este conector se publica bajo el [contrato de licencia de software de Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf). ## Registros de cambios La siguiente tabla describe los cambios en cada versión del conector. | Versión | Cambios | | --- | --- | | 7 | Se agregó `DockerOfflineMode` para usar un archivo de Docker Compose existente cuando se AWS IoT Greengrass inicia sin conexión. Se implementaron reintentos para el comando `docker login`. Support para 32 bits UIDs. | | 6 | Se agregó `StopContainersOnNewDeployment` para anular la limpieza del contenedor cuando se realiza una nueva implementación o se detiene el GGC. Mecanismos de apagado y puesta en marcha más seguros. Corrección de un error de validación de YAML. | | 5 | Las imágenes se extraen antes de ejecutar `docker-compose down`. | | 4 | Se agregó pull-before-up un comportamiento para actualizar las imágenes de Docker. | | 3 | Se ha corregido un problema con la búsqueda de variables de entorno. | | 2 | Se ha agregado el parámetro `ForceDeploy`. | | 1 | Versión inicial. | Un grupo de Greengrass solo puede contener una versión del conector a la vez. Para obtener información sobre cómo actualizar una versión de conector, consulte [Actualización de versiones de los conectores](connectors.md#upgrade-connector-versions). ## Véase también + [Integración con servicios y protocolos mediante conectores de Greengrass](connectors.md) + [Introducción a los conectores de Greengrass (consola)](connectors-console.md) + [Introducción a los conectores de Greengrass (CLI)](connectors-cli.md)