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.
# Implemente AWS IoT Greengrass grupos en un AWS IoT Greengrass núcleo
Utilice AWS IoT Greengrass grupos para organizar las entidades de su entorno perimetral. También puede utilizar los grupos para controlar cómo interactúan las entidades del grupo entre sí y con la Nube de AWS. Por ejemplo, solo las funciones de Lambda del grupo se implementan para ejecutarse de manera local y solo los dispositivos del grupo pueden comunicarse mediante el servidor MQTT local.
Un grupo debe incluir un [núcleo](gg-core.md), que es un AWS IoT dispositivo que ejecuta el software AWS IoT Greengrass Core. El núcleo actúa como una puerta de enlace perimetral y proporciona AWS IoT Core capacidades en el entorno perimetral. En función de las necesidades de su negocio, también puede añadir a un grupo las siguientes entidades:
+ **Dispositivos cliente**. Se representan como objetos en el registro de AWS IoT . Estos dispositivos deben ejecutar [FreeRTOS](https://docs.aws.amazon.com/freertos/latest/userguide/freertos-lib-gg-connectivity.html) o deben utilizar el [SDK de dispositivos de AWS IoT](what-is-gg.md#iot-device-sdk) o la [API de detección de AWS IoT Greengrass](gg-discover-api.md) para obtener la información de conexión del núcleo. Solo los dispositivos cliente que son miembros del grupo pueden conectarse al núcleo.
+ **Funciones de Lambda** Son aplicaciones definidas por los usuarios sin servidor que ejecutan código en el núcleo. Las funciones Lambda se crean AWS Lambda y se hace referencia a ellas desde un grupo de Greengrass. Para obtener más información, consulte [Ejecute funciones Lambda en el núcleo AWS IoT Greengrass](lambda-functions.md).
+ **Conectores**. Son aplicaciones predefinidas sin servidor que ejecutan código en el núcleo. Los conectores pueden proporcionar una integración integrada con la infraestructura local, los protocolos de los dispositivos y otros servicios en la nube. AWS Para obtener más información, consulte [Integración con servicios y protocolos mediante conectores de Greengrass](connectors.md).
+ **Suscripciones**. Definen los publicadores, los suscriptores y los temas (o asuntos) de MQTT que están autorizados para la comunicación con MQTT.
+ **Recursos**. Referencias a [dispositivos y volúmenes](access-local-resources.md) locales, [modelos de machine learning](ml-inference.md) y [secretos](secrets.md), que se utilizan para controlar el acceso por parte de Greengrass en funciones y conectores de Lambda.
+ **Registros**. Registrar las configuraciones de los componentes AWS IoT Greengrass del sistema y las funciones Lambda. Para obtener más información, consulte [Supervisión con AWS IoT Greengrass registros](greengrass-logs-overview.md).
Administra su grupo de Greengrass en Nube de AWS y, a continuación, lo despliega en un núcleo. La implementación copia la configuración del grupo en el archivo `group.json` del dispositivo del núcleo. Este archivo se encuentra en `greengrass-root/ggc/deployments/group`.
![\[Definición en la nube del grupo de Greengrass implementado en un dispositivo del núcleo.\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/group-deploy.png)
**nota**
Durante una implementación, el proceso del demonio de Greengrass del dispositivo del núcleo se detiene y después se reinicia.
## Despliegue de grupos desde la consola AWS IoT
Puede implementar un grupo y administrar sus despliegues desde la página de configuración del grupo en la AWS IoT consola.
**nota**
Para abrir esta página en la consola, seleccione **Dispositivos Greengrass**, luego **Grupos (V1)** y, a continuación, en **Grupos de Greengrass**, seleccione su grupo.
**Para implementar la versión actual del grupo**
+ Desde la página de configuración de grupo, elija **Implementaciones**.
**Para ver el historial de implementaciones del grupo**
El historial de implementaciones de un grupo incluye la fecha y la hora, la versión del grupo y el estado de cada intento de implementación.
1. Desde la página de configuración de grupo, elija la pestaña **Implementaciones**.
1. Para ver más información sobre una implementación, incluidos los mensajes de error, selecciona **Implementaciones** en la AWS IoT consola, en Dispositivos **Greengrass**.
**Para volver a implementar una implementación de grupo**
Es posible que desee repetir una implementación si se produce un error en la implementación actual o si quiere volver a otra versión del grupo.
1. En la AWS IoT consola, selecciona **dispositivos Greengrass** y, a continuación, selecciona **Grupos (V1)**.
1. Elija la pestaña **Implementaciones**.
1. Elija la implementación que desea volver a implementar y elija **Reimplementar.**
**Para restablecer las implementaciones de grupo**
Es posible que desee restablecer las implementaciones de grupo para mover o eliminar un grupo o para eliminar la información de implementación. Para obtener más información, consulte [Restablecimiento de implementaciones](reset-deployments-scenario.md).
1. En la AWS IoT consola, selecciona **dispositivos Greengrass** y, a continuación, selecciona **Grupos (V1)**.
1. Elija la pestaña **Implementaciones**.
1. Elija la implementación que desea restablecer y elija **Restablecer implementaciones**.
## Desplegar grupos con la API AWS IoT Greengrass
La AWS IoT Greengrass API proporciona las siguientes acciones para implementar AWS IoT Greengrass grupos y administrar las implementaciones grupales. Puede llamar a estas acciones desde la AWS CLI AWS IoT Greengrass API o el AWS SDK.
| Acción | Descripción |
| --- | --- |
| [CreateDeployment](https://docs.aws.amazon.com/greengrass/v1/apireference/createdeployment-post.html) | Crea una implementación `Redeployment` o `NewDeployment`. Es posible que desee repetir una implementación si se produce un error en la implementación actual. O es posible que desee repetirla para revertir a otra versión del grupo. |
| [GetDeploymentStatus](https://docs.aws.amazon.com/greengrass/v1/apireference/getdeploymentstatus-get.html) | Devuelve el estado de una implementación: `Building`, `InProgress`, `Success` o `Failure`. Puedes configurar EventBridge los eventos de Amazon para recibir notificaciones de despliegue. Para obtener más información, consulte [Obtención de notificaciones de implementación](deployment-notifications.md). |
| [ListDeployments](https://docs.aws.amazon.com/greengrass/v1/apireference/listdeployments-get.html) | Devuelve el historial de implementaciones del grupo. |
| [ResetDeployments](https://docs.aws.amazon.com/greengrass/v1/apireference/resetdeployments-post.html) | Restablece las implementaciones del grupo. Es posible que desee restablecer las implementaciones de grupo para mover o eliminar un grupo o para eliminar la información de implementación. Para obtener más información, consulte [Restablecimiento de implementaciones](reset-deployments-scenario.md). |
**nota**
Para obtener información acerca de las operaciones de implementación por lotes, consulte [Creación de implementaciones de grupos por lotes](bulk-deploy-cli.md).
### Obtener el ID del grupo
El ID del grupo se usa comúnmente en acciones de la API. Puede utilizar la [ListGroups](https://docs.aws.amazon.com/greengrass/v1/apireference/listgroups-get.html)acción para buscar el ID del grupo objetivo en su lista de grupos. Por ejemplo, en AWS CLI, usa el `list-groups` comando.
```
aws greengrass list-groups
```
También puede incluir la opción `query` para filtrar los resultados. Por ejemplo:
+ Para obtener el grupo creado más recientemente:
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
+ Para obtener un grupo por nombre:
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
No es necesario que los nombres de grupo sean únicos, por lo que podrían devolverse varios grupos.
A continuación se muestra un ejemplo de respuesta de `list-groups`. La información de cada grupo incluye el ID del grupo (en la propiedad `Id`) y el ID de la versión de grupo más reciente (en la propiedad `LatestVersion`). Para obtener otra versión IDs para un grupo, usa el ID de grupo con [ListGroupVersions](https://docs.aws.amazon.com/greengrass/v1/apireference/listgroupversions-get.html).
**nota**
También puedes encontrar estos valores en la AWS IoT consola. El ID de grupo se muestra en la página **Settings (Configuración)** del grupo. La versión del grupo IDs se muestra en la pestaña **Implementaciones** del grupo.
```
{
"Groups": [
{
"LatestVersionArn": "arn:aws:us-west-2:123456789012:/greengrass/groups/00dedaaa-ac16-484d-ad77-c3eedEXAMPLE/versions/4cbc3f07-fc5e-48c4-a50e-7d356EXAMPLE",
"Name": "MyFirstGroup",
"LastUpdatedTimestamp": "2019-11-11T05:47:31.435Z",
"LatestVersion": "4cbc3f07-fc5e-48c4-a50e-7d356EXAMPLE",
"CreationTimestamp": "2019-11-11T05:47:31.435Z",
"Id": "00dedaaa-ac16-484d-ad77-c3eedEXAMPLE",
"Arn": "arn:aws:us-west-2:123456789012:/greengrass/groups/00dedaaa-ac16-484d-ad77-c3eedEXAMPLE"
},
{
"LatestVersionArn": "arn:aws:us-west-2:123456789012:/greengrass/groups/036ceaf9-9319-4716-ba2a-237f9EXAMPLE/versions/8fe9e8ec-64d1-4647-b0b0-01dc8EXAMPLE",
"Name": "GreenhouseSensors",
"LastUpdatedTimestamp": "2020-01-07T19:58:36.774Z",
"LatestVersion": "8fe9e8ec-64d1-4647-b0b0-01dc8EXAMPLE",
"CreationTimestamp": "2020-01-07T19:58:36.774Z",
"Id": "036ceaf9-9319-4716-ba2a-237f9EXAMPLE",
"Arn": "arn:aws:us-west-2:123456789012:/greengrass/groups/036ceaf9-9319-4716-ba2a-237f9EXAMPLE"
},
...
]
}
```
Si no especificas ninguna Región de AWS, AWS CLI los comandos utilizan la región predeterminada de tu perfil. Para devolver grupos de una región diferente, incluye la *region* opción. Por ejemplo:
```
aws greengrass list-groups --region us-east-1
```
## Descripción general del modelo de objetos AWS IoT Greengrass grupales
Al programar con la AWS IoT Greengrass API, es útil entender el modelo de objetos grupales de Greengrass.
### Grupos
En la AWS IoT Greengrass API, el `Group` objeto de nivel superior consta de metadatos y una lista de `GroupVersion` objetos. `GroupVersion`los objetos están asociados a un `Group` por ID.
![\[Diagrama de un grupo, que se compone de metadatos y una lista de versiones de grupo.\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/om-group.png)
### Versiones del grupo
Los objetos `GroupVersion` definen la pertenencia a los grupos. Cada `GroupVersion` hace referencia a un objeto `CoreDefinitionVersion` y a otras versiones de componentes a través de su ARN. Estas referencias determinan qué entidades se van a incluir en el grupo.
![\[Diagrama de una versión del grupo que hace referencia a otros tipos de versiones a través de su ARN.\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/om-groupversion.png)
Por ejemplo, para incluir tres funciones de Lambda, un dispositivo y dos suscripciones en el grupo, `GroupVersion` hace referencia a:
+ El `CoreDefinitionVersion` que contiene el núcleo requerido.
+ `FunctionDefinitionVersion` que contiene las tres funciones.
+ La `DeviceDefinitionVersion` que contiene el dispositivo de cliente.
+ `SubscriptionDefinitionVersion` que contiene las dos suscripciones.
El objeto `GroupVersion` implementado en un dispositivo de núcleo determina las entidades que están disponibles en el entorno local y cómo pueden interactuar.
### Componentes del grupo
Los componentes que añada a los grupos tienen una jerarquía de tres niveles:
+ Una *definición* que hace referencia a una lista de *DefinitionVersion*objetos de un tipo determinado. Por ejemplo, un objeto `DeviceDefinition` hace referencia a una lista de objetos `DeviceDefinitionVersion`.
+ A *DefinitionVersion*que contiene un conjunto de entidades de un tipo determinado. Por ejemplo, un objeto `DeviceDefinitionVersion` contiene una lista de objetos `Device`.
+ Entidades individuales que definen sus propiedades y su comportamiento. Por ejemplo, a `Device` define el ARN del dispositivo cliente correspondiente en el AWS IoT registro, el ARN de su certificado de dispositivo y si su sombra local se sincroniza automáticamente con la nube.
Puede añadir los siguientes tipos de entidades a un grupo:
+ [Kinesis - S3](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-connector.html)
+ [Core](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-core.html)
+ [Dispositivo](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-device.html)
+ [Función](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-function.html)
+ [Logger](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-logger.html)
+ [Resource](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-resource.html)
+ [Suscripción](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-subscription.html)
En el siguiente ejemplo, `DeviceDefinition` hace referencia a tres objetos `DeviceDefinitionVersion`, cada uno de los cuales contiene varios objetos `Device`. En los grupos, solo se utiliza un `DeviceDefinitionVersion` cada vez.
![\[Un diagrama de una jerarquía de dispositivos, que consta de DeviceDefinition DeviceDefinitionVersion, y objetos de dispositivo.\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/om-devicedefinition.png)
### Actualización de grupos
En la AWS IoT Greengrass API, se utilizan las versiones para actualizar la configuración de un grupo. Las versiones son inmutables, por lo que para añadir, eliminar o cambiar los componentes del grupo, debe crear *DefinitionVersion*objetos que contengan entidades nuevas o actualizadas.
Puede asociar *DefinitionVersions*objetos nuevos a objetos de *definición* nuevos o existentes. Por ejemplo, puede utilizar la acción `CreateFunctionDefinition` para crear un objeto `FunctionDefinition` que incluya el objeto `FunctionDefinitionVersion` como versión inicial, o puede utilizar la acción `CreateFunctionDefinitionVersion` y hacer referencia a un objeto `FunctionDefinition` existente.
Tras crear los componentes del grupo, se crea uno `GroupVersion` que contenga todos los *DefinitionVersion*objetos que se desean incluir en el grupo. A continuación, debe implementar `GroupVersion`.
Para implementar un objeto `GroupVersion`, debe hacer referencia a un objeto `CoreDefinitionVersion` que contenga exactamente un objeto `Core`. Todas las entidades a las que se haga referencia deben ser miembros del grupo. Además, un [rol de servicio de Greengrass](service-role.md) debe estar asociado a usted Cuenta de AWS en el Región de AWS lugar donde vaya a implementar el. `GroupVersion`
**nota**
Las acciones `Update` de la API se utilizan para cambiar el nombre de un objeto `Group` o *Definition* del componente.
**Actualizar las entidades que hacen referencia a los recursos AWS **
Las funciones Lambda y los [recursos secretos de Greengrass definen las propiedades específicas de Greengrass y también hacen referencia a los recursos](secrets.md) correspondientes. AWS Para actualizar estas entidades, puede realizar cambios en el AWS recurso correspondiente en lugar de en sus objetos de Greengrass. Por ejemplo, las funciones de Lambda hacen referencia a una función en el grupo Greengrass AWS Lambda y también definen el ciclo de vida y otras propiedades que son específicas del grupo Greengrass.
+ Para actualizar el código de la función de Lambda o las dependencias empaquetadas, realice los cambios en AWS Lambda. Durante la siguiente implementación grupal, estos cambios se recuperan del entorno local AWS Lambda y se copian en él.
+ Para actualizar las [propiedades específicas de Greengrass](lambda-group-config.md), debe crear un objeto `FunctionDefinitionVersion` que contenga las propiedades `Function` actualizadas.
**nota**
Las funciones de Lambda de Greengrass pueden hacer referencia a una función de Lambda por el ARN del alias o el ARN de versión. Si hace referencia al ARN del alias (recomendado), no es necesario actualizar `FunctionDefinitionVersion` (ni `SubscriptionDefinitionVersion`) al publicar una nueva versión de la función en AWS Lambda. Para obtener más información, consulte [Referencia a funciones de Lambda por alias o versión](lambda-functions.md#lambda-versions-aliases).
## Véase también
+ [Obtención de notificaciones de implementación](deployment-notifications.md)
+ [Restablecimiento de implementaciones](reset-deployments-scenario.md)
+ [Creación de implementaciones de grupos por lotes](bulk-deploy-cli.md)
+ [Solución de problemas de implementación](gg-troubleshooting.md#gg-troubleshooting-deploymentissues)
+ [AWS IoT Greengrass Version 1 Referencia de la API](https://docs.aws.amazon.com/greengrass/v1/apireference/)
+ [AWS IoT Greengrass comandos](https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html) de la *Referencia de AWS CLI comandos*
# Obtención de notificaciones de implementación
Las reglas de EventBridge eventos de Amazon le proporcionan notificaciones sobre los cambios de estado de sus despliegues grupales de Greengrass. EventBridge ofrece un flujo casi en tiempo real de los eventos del sistema que describe los cambios en AWS los recursos. AWS IoT Greengrass envía estos eventos EventBridge al *menos una vez*. Esto significa que AWS IoT Greengrass puede enviar varias copias de un evento determinado para garantizar la entrega. Además, los agentes de escucha de eventos podrían no recibir los eventos en el orden en el que los eventos han ocurrido.
**nota**
Amazon EventBridge es un servicio de bus de eventos que puede utilizar para conectar sus aplicaciones con datos de diversas fuentes, como los [dispositivos principales de Greengrass](telemetry.md) y las notificaciones de implementación. Para obtener más información, consulta [¿Qué es Amazon EventBridge?](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html) en la *Guía del EventBridge usuario de Amazon*.
AWS IoT Greengrass emite un evento cuando las implementaciones grupales cambian de estado. Puede crear una EventBridge regla que se aplique a todas las transiciones de estado o a los estados que especifique. Cuando una implementación entra en un estado que inicia una regla, EventBridge invoca las acciones objetivo definidas en la regla. Esto le permite enviar notificaciones, capturar información sobre el evento, tomar medidas correctivas o iniciar otros eventos en respuesta a un cambio de estado. Por ejemplo, puede crear reglas para los siguientes casos de uso:
+ Iniciar operaciones posteriores a la implementación, como descargar recursos y enviar notificaciones al personal.
+ Envíe notificaciones en caso de una implementación correcta o con error.
+ Publicar métricas personalizadas sobre los eventos de implementación.
AWS IoT Greengrass emite un evento cuando una implementación entra en los siguientes estados:`Building`,`InProgress`, `Success` y. `Failure`
**nota**
Actualmente, no se puede monitorizar el estado de una operación de [implementación por lotes](bulk-deploy-cli.md) . Sin embargo, AWS IoT Greengrass emite eventos de cambio de estado para las implementaciones de grupos individuales que forman parte de una implementación masiva.
## Evento de cambio de estado de una implementación de grupo
El [evento](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html) de un cambio de estado de la implementación tiene el siguiente formato:
```
{
"version":"0",
"id":" cd4d811e-ab12-322b-8255-EXAMPLEb1bc8",
"detail-type":"Greengrass Deployment Status Change",
"source":"aws.greengrass",
"account":"123456789012",
"time":"2018-03-22T00:38:11Z",
"region":"us-west-2",
"resources":[],
"detail":{
"group-id": "284dcd4e-24bc-4c8c-a770-EXAMPLEf03b8",
"deployment-id": "4f38f1a7-3dd0-42a1-af48-EXAMPLE09681",
"deployment-type": "NewDeployment|Redeployment|ResetDeployment|ForceResetDeployment",
"status": "Building|InProgress|Success|Failure"
}
}
```
Puede crear reglas que se apliquen a uno o varios grupos. Puede filtrar reglas por uno o varios de los siguientes tipos de implementaciones y estados de implementación:
**Tipos de implementación**
+ `NewDeployment`. Primera implementación de la versión de un grupo.
+ `ReDeployment`. Nueva implementación de la versión de un grupo.
+ `ResetDeployment`. Elimina la información de despliegue almacenada en el AWS IoT Greengrass núcleo Nube de AWS y en él. Para obtener más información, consulte [Restablecimiento de implementaciones](reset-deployments-scenario.md).
+ `ForceResetDeployment`. Elimina la información de la implementación almacenada en la Nube de AWS y notifica el éxito sin esperar a que el núcleo responda. También elimina la información de la implementación almacenada en el núcleo si este está conectado. De lo contrario, la información se eliminará la próxima vez que se conecte el núcleo.
**Estados de implementación**
+ `Building`. AWS IoT Greengrass está validando la configuración del grupo y creando artefactos de despliegue.
+ `InProgress`. El despliegue está en curso en el AWS IoT Greengrass núcleo.
+ `Success`. La implementación se ha realizado correctamente.
+ `Failure`. La implementación no se ha realizado correctamente
Es posible que los eventos se dupliquen o estén desordenados. Para determinar el orden de los eventos, utilice la propiedad `time`.
**nota**
AWS IoT Greengrass no usa la `resources` propiedad, por lo que siempre está vacía.
## Requisitos previos para crear reglas EventBridge
Antes de crear una EventBridge regla para AWS IoT Greengrass, haga lo siguiente:
+ Familiarícese con los eventos, las reglas y los objetivos de EventBridge.
+ Cree y configure los objetivos invocados por sus EventBridge reglas. Las reglas pueden invocar muchos tipos de destinos, entre los que se incluyen:
+ Amazon Simple Notification Service (Amazon SNS)
+ AWS Lambda funciones
+ Amazon Kinesis Video Streams
+ Colas de Amazon Simple Queue Service (Amazon SQS)
Para obtener más información, consulta [¿Qué es Amazon EventBridge?](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html) y [Primeros pasos con Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-getting-set-up.html) en la *Guía del EventBridge usuario de Amazon*.
## Configuración de las notificaciones de implementación (consola)
Siga los siguientes pasos para crear una EventBridge regla que publique un tema de Amazon SNS cuando cambie el estado de despliegue de un grupo. De este modo, los servidores web, las direcciones de correo electrónico y otros suscriptores del tema podrán responder al evento. Para obtener más información, consulta [Crear una EventBridge regla que se active en un evento desde un AWS recurso](https://docs.aws.amazon.com/eventbridge/latest/userguide/create-eventbridge-rule.html) en la *Guía del EventBridge usuario de Amazon*.
1. Abre la [ EventBridgeconsola de Amazon](https://console.aws.amazon.com/events/).
1. En el panel de navegación, seleccione **Reglas**.
1. Elija **Creación de regla**.
1. Escriba un nombre y una descripción para la regla.
Una regla no puede tener el mismo nombre que otra regla de la misma región y del mismo bus de eventos.
1. En **Bus de eventos**, seleccione el bus de eventos que desea asociar a esta regla. Si desea que esta regla coincida con eventos procedentes de su cuenta, seleccione **Bus de eventos predeterminado de AWS **. Cuando un AWS servicio de tu cuenta emite un evento, siempre va al bus de eventos predeterminado de tu cuenta.
1. En **Tipo de regla**, elija **Regla con un patrón de evento**.
1. Seleccione **Siguiente**.
1. En **Origen de evento**, seleccione **Servicios de AWS **.
1. En **Patrón de eventos**, seleccione **servicios AWS **.
1. En **Servicio de AWS **, elija Greengrass.
1. En **Event type (Tipo de evento)**, elija **Greengrass Deployment Status Change (Cambio de estado de implementación de Greengrass)**.
**nota**
El tipo **AWS de llamada a la API mediante CloudTrail** evento se basa en la AWS IoT Greengrass integración con AWS CloudTrail. Puede usar esta opción para crear reglas que se inicien mediante llamadas de lectura o escritura a la AWS IoT Greengrass API. Para obtener más información, consulte [Registrar llamadas a la AWS IoT Greengrass API con AWS CloudTrail](logging-using-cloudtrail.md).
1. Elija los estados de implementación que inicia una notificación.
+ Para recibir notificaciones de todos los eventos de cambio de estado, seleccione **Any state (Cualquier estado)**.
+ Para recibir notificaciones solo para algunos eventos de cambio de estado, elija **Specific state(s) (Estados específicos)** y, a continuación, elija los estados de destino.
1. Elija los tipos de implementación que inicia una notificación.
+ Para recibir notificaciones de todos los tipos de implementación, elija **Any state (Cualquier estado)**.
+ Para recibir notificaciones solo para algunos tipos de implementación, elija **Specific state(s) (Estados específicos)** y, a continuación, elija los tipos de implementación de destino.
1. Elija **Siguiente**.
1. En **Tipos de destino** (Tipos de destino), elija **AWS service**.
1. En **Seleccionar destinos**, configure su destino. En este ejemplo se utiliza un tema de Amazon SNS, pero se pueden configurar otros tipos de destino para enviar notificaciones.
1. En **Destino**, elija **Tema de SNS**.
1. En **Topic (Tema)**, elija el tema de destino.
1. Elija **Siguiente**.
1. En **Etiquetas**, defina etiquetas para la regla o deje los campos vacíos.
1. Elija **Siguiente**.
1. Revise los detalles de la regla y seleccione **Creación de regla**.
## Configuración de notificaciones de implementación (CLI)
Siga los siguientes pasos para crear una EventBridge regla que publique un tema de Amazon SNS cuando cambie el estado de despliegue de un grupo. De este modo, los servidores web, las direcciones de correo electrónico y otros suscriptores del tema podrán responder al evento.
1. Crear la regla.
+ *group-id*Sustitúyalo por el ID de su AWS IoT Greengrass grupo.
```
aws events put-rule \
--name TestRule \
--event-pattern "{\"source\": [\"aws.greengrass\"], \"detail\": {\"group-id\": [\"group-id\"]}}"
```
Las propiedades que se omiten en el patrón no se tienen en cuenta.
1. Agregue el tema como destino de la regla.
+ *topic-arn*Sustitúyalo por el ARN de su tema de Amazon SNS.
```
aws events put-targets \
--rule TestRule \
--targets "Id"="1","Arn"="topic-arn"
```
**nota**
Para permitir que Amazon llame EventBridge a tu tema objetivo, debes añadir a tu tema una política basada en recursos. Para obtener más información, consulte los [permisos de Amazon SNS](https://docs.aws.amazon.com/eventbridge/latest/userguide/resource-based-policies-eventbridge.html#sns-permissions) en la Guía * EventBridge del usuario de Amazon*.
Para obtener más información, consulta [Eventos y patrones de eventos EventBridge en](https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-and-event-patterns.html) la *Guía del EventBridge usuario de Amazon*.
## Configuración de notificaciones de implementación (CloudFormation)
Utilice CloudFormation plantillas para crear EventBridge reglas que envíen notificaciones sobre los cambios de estado para las implementaciones de su grupo de Greengrass. Para obtener más información, consulta la [referencia de tipos de EventBridge recursos de Amazon](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_Events.html) en la *Guía del AWS CloudFormation usuario*.
## Véase también
+ [Implemente AWS IoT Greengrass grupos en un AWS IoT Greengrass núcleo](deployments.md)
+ [¿Qué es Amazon EventBridge?](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html) en la *Guía del EventBridge usuario de Amazon*
# Restablecimiento de implementaciones
Esta función está disponible para AWS IoT Greengrass Core v1.1 y versiones posteriores.
Es posible que desee restablecer las implementaciones de un grupo para:
+ Elimine el grupo, por ejemplo, cuando desee mover el núcleo del grupo a otro grupo o cuando se haya rediseñado el núcleo del grupo. Antes de eliminar un grupo, debe restablecer las implementaciones del grupo para usar el núcleo con otro grupo de Greengrass.
+ Mover el núcleo del grupo a otro grupo
+ Revertir el grupo al estado que tenía antes de la implementación.
+ Eliminar la configuración de la implementación del dispositivo del núcleo
+ Eliminar datos confidenciales del dispositivo del núcleo o de la nube
+ Implementar una nueva configuración del grupo en un núcleo sin tener que reemplazar el núcleo por otro del grupo actual
**nota**
La funcionalidad de restablecimiento de implementaciones no está disponible en AWS IoT Greengrass Core Software v1.0.0. No puede eliminar los grupos implementados con la versión 1.0.0.
La operación de restablecimiento primero limpia toda la información que hay en la nube sobre la implementación de un determinado grupo. A continuación, ordena al dispositivo del núcleo del grupo que borre toda la información relacionada con la implementación (funciones de Lambda, registros de usuario, base de datos de instantáneas y certificado del servidor, aunque no el archivo `config.json` definido por el usuario ni los certificados del núcleo de Greengrass). No se puede iniciar el restablecimiento de la implementación de un grupo si actualmente dicho grupo tiene una implementación con el estado `In Progress` o `Building`.
## Restablezca las implementaciones desde la consola AWS IoT
Puede restablecer las implementaciones de grupo desde la página de configuración de grupos de la AWS IoT consola.
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 pestaña **Implementaciones**, elija **Reiniciar implementación**.
1. En el cuadro de diálogo **Restablecer implementaciones para este grupo de Greengrass**, escriba **confirm** para aceptar y seleccione **Restablecer implementación**.
## Restablezca las implementaciones con la API AWS IoT Greengrass
Puede usar la `ResetDeployments` acción de la AWS CLI AWS IoT Greengrass API o el AWS SDK para restablecer las implementaciones. En los ejemplos de este tema, se utiliza la CLI.
```
aws greengrass reset-deployments --group-id GroupId [--force]
```Argumentos del comando de la CLI `reset-deployments`:
`--group-id`
El ID del grupo. Utilice el comando `list-groups` para obtener este valor.
`--force`
Opcional. Utilice este parámetro si el dispositivo del núcleo del grupo se ha perdido, robado o destruido. Esta opción hace que el proceso de restablecimiento de la implementación notifique que se ha realizado correctamente una vez que se ha borrado toda la información de implementación de la nube, sin tener que esperar a que responda el dispositivo del núcleo. Sin embargo, si el dispositivo del núcleo está activo o se activa, también realiza operaciones de limpieza.
El resultado del comando `reset-deployments` de la CLI es similar al siguiente:
```
{
"DeploymentId": "4db95ef8-9309-4774-95a4-eea580b6ceef",
"DeploymentArn": "arn:aws:greengrass:us-west-2:106511594199:/greengrass/groups/b744ed45-a7df-4227-860a-8d4492caa412/deployments/4db95ef8-9309-4774-95a4-eea580b6ceef"
}
```
Puede comprobar el estado del restablecimiento de la implementación con el comando de la CLI `get-deployment-status`:
```
aws greengrass get-deployment-status --deployment-id DeploymentId --group-id GroupId
```Argumentos del comando de la CLI `get-deployment-status`:
`--deployment-id`
El ID de implementación.
`--group-id`
El ID del grupo.
El resultado del comando `get-deployment-status` de la CLI es similar al siguiente:
```
{
"DeploymentStatus": "Success",
"UpdatedAt": "2017-04-04T00:00:00.000Z"
}
```
El estado de `DeploymentStatus` se establece en `Building` cuando se está preparando el restablecimiento de la implementación. Cuando la implementación restablecida esté lista pero el AWS IoT Greengrass núcleo no haya retomado la implementación restablecida, estará lista. `DeploymentStatus` `InProgress`
Si la operación de restablecimiento da un error, se devuelve la información del error en la solicitud.
## Véase también
+ [Implemente AWS IoT Greengrass grupos en un AWS IoT Greengrass núcleo](deployments.md)
+ [ResetDeployments ](https://docs.aws.amazon.com/greengrass/v1/apireference/resetdeployments-post.html)en la *referencia AWS IoT Greengrass Version 1 de la API*
+ [GetDeploymentStatus](https://docs.aws.amazon.com/greengrass/v1/apireference/getdeploymentstatus-get.html)en la *referencia AWS IoT Greengrass Version 1 de la API*
# Creación de implementaciones de grupos por lotes
Puede utilizar llamadas a la API simples para implementar un gran número de grupos de Greengrass a la vez. Estas implementaciones se activan con una velocidad flexible que tiene un límite superior fijo.
En este tutorial se describe cómo utilizar el AWS CLI para crear y supervisar un despliegue grupal masivo en AWS IoT Greengrass. El ejemplo de implementación por lotes de este tutorial contiene varios grupos. Puede utilizar el ejemplo en su implementación para añadir tantos grupos como necesite.
El tutorial contiene los siguientes pasos generales:
1. [Crear y cargar el archivo de entrada de la implementación por lotes](#bulk-deploy-cli-create-input-file)
1. [Cree y configure un rol de ejecución IAM para implementaciones masivas](#bulk-deploy-cli-create-role)
1. [Permitir que el rol de ejecución acceda al bucket de S3](#bulk-deploy-cli-modify-bucket)
1. [Implementar los grupos](#bulk-deploy-cli-start-bulk-deployments)
1. [Cómo probar la implementación](#bulk-deploy-cli-test)
## Requisitos previos
Para completar este tutorial, se necesita lo siguiente:
+ Uno o varios grupos de Greengrass implementables. Para obtener más información acerca de la creación de núcleos y grupos de AWS IoT Greengrass , consulte [Empezar con AWS IoT Greengrass](gg-gs.md).
+ El AWS CLI instalado y configurado en su máquina. Para obtener más información, consulte [Guía del usuario de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).
+ Un bucket de S3 creado en el mismo sitio Región de AWS que AWS IoT Greengrass. Para obtener más información, consulte [Creación y configuración de un bucket de S3](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-configure-bucket.html) en la *Guía del usuario de Amazon Simple Storage Service*.
**nota**
Actualmente, los buckets habilitados para SSE KMS no son compatibles.
## Paso 1: Crear y cargar el archivo de entrada de la implementación por lotes
En este paso, creará un archivo de entrada de implementación y lo cargará en el bucket de Amazon S3. Este archivo es un archivo JSON serializado y delimitado por líneas que contiene información sobre cada grupo de la implementación masiva. AWS IoT Greengrass utiliza esta información para implementar cada grupo en su nombre al inicializar la implementación de un grupo masivo.
1. Ejecute el siguiente comando con el fin de obtener el parámetro `groupId` para cada grupo que desea implementar. Escriba el parámetro `groupId` en el archivo de entrada de implementación por lotes, de modo que AWS IoT Greengrass pueda identificar cada grupo que se va a implementar.
**nota**
También puede encontrar estos valores en la AWS IoT consola. El ID de grupo se muestra en la página **Settings (Configuración)** del grupo. La versión del grupo IDs se muestra en la pestaña **Implementaciones** del grupo.
```
aws greengrass list-groups
```
La respuesta contiene información sobre cada grupo de tu AWS IoT Greengrass cuenta:
```
{
"Groups": [
{
"Name": "string",
"Id": "string",
"Arn": "string",
"LastUpdatedTimestamp": "string",
"CreationTimestamp": "string",
"LatestVersion": "string",
"LatestVersionArn": "string"
}
],
"NextToken": "string"
}
```
Ejecute el siguiente comando con el fin de obtener el parámetro `groupVersionId` de cada grupo que desea implementar.
```
list-group-versions --group-id groupId
```
La respuesta contiene información acerca de todas las versiones de grupo. Anote el valor de la `Version` del grupo que desee utilizar.
```
{
"Versions": [
{
"Arn": "string",
"Id": "string",
"Version": "string",
"CreationTimestamp": "string"
}
],
"NextToken": "string"
}
```
1. En el terminal de su ordenador o en el editor que prefiera*MyBulkDeploymentInputFile*, cree un archivo a partir del siguiente ejemplo. Este archivo contiene información sobre cada AWS IoT Greengrass grupo que se incluirá en una implementación masiva. Aunque este ejemplo define varios grupos, para este tutorial, el archivo puede contener solo uno.
**nota**
El tamaño de este archivo debe ser inferior a 100 MB.
```
{"GroupId":"groupId1", "GroupVersionId":"groupVersionId1", "DeploymentType":"NewDeployment"}
{"GroupId":"groupId2", "GroupVersionId":"groupVersionId2", "DeploymentType":"NewDeployment"}
{"GroupId":"groupId3", "GroupVersionId":"groupVersionId3", "DeploymentType":"NewDeployment"}
...
```
Cada registro (o línea) contiene un objeto de grupo. Cada objeto de grupo contiene su correspondiente `GroupId` y `GroupVersionId`, y un parámetro `DeploymentType`. Actualmente, solo AWS IoT Greengrass admite los tipos de despliegue `NewDeployment` masivo.
Guarde y cierre el archivo. Anote la ubicación del archivo.
1. Utilice el siguiente comando en el terminal para cargar el archivo de entrada en el bucket de Amazon S3. Sustituya la ruta del archivo por la ubicación y el nombre del archivo. Para obtener información, consulte [Cargar un objeto en un bucket](https://docs.aws.amazon.com/AmazonS3/latest/gsg/PuttingAnObjectInABucket.html).
```
aws s3 cp path/MyBulkDeploymentInputFile s3://amzn-s3-demo-bucket/
```
## Paso 2: Crear y configurar un rol de ejecución de IAM
En este paso, utilizará la consola de IAM para crear un rol de ejecución independiente. A continuación, debe establecer una relación de confianza entre el rol AWS IoT Greengrass y asegurarse de que su usuario de IAM tenga `PassRole` privilegios para su rol de ejecución. Esto le AWS IoT Greengrass permite asumir su función de ejecución y crear las implementaciones en su nombre.
1. Utilice la siguiente política para crear un rol de ejecución. Este documento de política permite a AWS IoT Greengrass acceder al archivo de entrada de implementación por lotes al crear cada implementación en su nombre.
Para obtener más información acerca de cómo crear un rol de IAM y delegar permisos, consulte [Creación de roles de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "greengrass:CreateDeployment",
"Resource": [
"arn:aws:greengrass:us-east-1:123456789012:/greengrass/groups/groupId1",
"arn:aws:greengrass:us-east-1:123456789012:/greengrass/groups/groupId2",
"arn:aws:greengrass:us-east-1:123456789012:/greengrass/groups/groupId3"
]
}
]
}
```
------
**nota**
Esta política debe tener un recurso para cada grupo o versión de grupo en el archivo de entrada de implementación por lotes que va a implementar AWS IoT Greengrass. Para permitir el acceso a todos los grupos, en `Resource`, especifique un asterisco:
```
"Resource": ["*"]
```
1. Modifique la relación de confianza para que el rol de ejecución incluya AWS IoT Greengrass. Esto permite a AWS IoT Greengrass utilizar el rol de ejecución y los permisos asociados a él. Para obtener más información, consulte [Edición de la relación de confianza para un rol existente](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html).
Le recomendamos que incluya también las claves de contexto de condición global `aws:SourceArn` y `aws:SourceAccount` en su política de confianza para ayudar a prevenir el problema de seguridad del *suplente confuso*. Las claves de contexto de condición restringen el acceso para permitir solo las solicitudes que provienen de la cuenta especificada y del espacio de trabajo de Greengrass. Para obtener más información sobre el problema del suplente confuso, consulte [Prevención de la sustitución confusa entre servicios](cross-service-confused-deputy-prevention.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "greengrass.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "123456789012"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:greengrass:us-east-1:123456789012:*"
}
}
}
]
}
```
------
1. Conceda a IAM los permisos `PassRole` del rol de ejecución del usuario de IAM. Este usuario de IAM es el que se utiliza para iniciar la implementación por lotes. Los permisos `PassRole` permiten su usuario de IAM transferir el rol de ejecución para que AWS IoT Greengrass lo use. Para obtener más información, consulte [Otorgar permisos a un usuario para transferir un rol a un AWS servicio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html).
Utilice el siguiente ejemplo para actualizar la política de IAM adjunta a su rol de ejecución. Modifique este ejemplo según sea necesario.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Stmt1508193814000",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::123456789012:user/executionRoleArn"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "greengrass.amazonaws.com"
}
}
}
]
}
```
------
## Paso 3: Permitir que el rol de ejecución acceda al bucket de S3
Para iniciar la implementación por lotes, el rol de ejecución debe poder leer el archivo de entrada de implementación por lotes desde el bucket de Amazon S3. Asocie la siguiente política de ejemplo a su bucket de Amazon S3, para que el rol de ejecución puede acceder a los permisos `GetObject`.
Para obtener más información, consulte [¿Cómo agrego una política de bucket en S3?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-bucket-policy.html)
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "examplePolicy",
"Statement": [
{
"Sid": "Stmt1535408982966",
"Effect": "Allow",
"Principal": {
"AWS": [
"executionRoleArn"
]
},
"Action": "s3:GetObject",
"Resource":
"arn:aws:s3:::amzn-s3-demo-bucket/objectKey"
}
]
}
```
------
Puede utilizar el siguiente comando en el terminal para comprobar la política del bucket.
```
aws s3api get-bucket-policy --bucket amzn-s3-demo-bucket
```
**nota**
Puede modificar directamente el rol de ejecución para concederle el permiso `GetObject` al bucket de Amazon S3. Para hacerlo, asocie la siguiente política de ejemplo al rol de ejecución.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/objectKey"
}
]
}
```
## Paso 4: Implementar los grupos
En este paso, iniciará una operación de implementación por lotes para todas las versiones de grupo configuradas en el archivo de entrada de implementación por lotes. La acción de implementación de cada una de las versiones de grupo es del tipo `NewDeploymentType`.
**nota**
No puede llamar a **StartBulkDeployment** si hay otra implementación por lotes de la misma cuenta ejecutándose. La solicitud se rechaza.
1. Utilice el siguiente comando para iniciar la implementación por lotes.
Le recomendamos que incluya un token `X-Amzn-Client-Token` en cada solicitud **StartBulkDeployment**. Estas solicitudes son idempotentes en relación con el token y los parámetros de solicitud. Este token puede ser cualquier cadena única que distingue entre mayúsculas y minúsculas de hasta 64 caracteres ASCII.
```
aws greengrass start-bulk-deployment --cli-input-json "{
"InputFileUri":"URI of file in S3 bucket",
"ExecutionRoleArn":"ARN of execution role",
"AmznClientToken":"your Amazon client token"
}"
```
El comando debe generar un código de estado correcto de `200`, junto con la siguiente respuesta:
```
{
"bulkDeploymentId": UUID
}
```
Anote el ID de la implementación por lotes. Se puede utilizar para comprobar el estado de la implementación por lotes.
**nota**
Aunque actualmente no se admiten las operaciones de despliegue masivo, puedes crear reglas de EventBridge eventos de Amazon para recibir notificaciones sobre los cambios en el estado del despliegue para grupos individuales. Para obtener más información, consulte [Obtención de notificaciones de implementación](deployment-notifications.md).
1. Use el siguiente comando para comprobar el estado de la implementación por lotes.
```
aws greengrass get-bulk-deployment-status --bulk-deployment-id 1234567
```
El comando debe devolver un código de estado de`200`, además de una carga JSON de información:
```
{
"BulkDeploymentStatus": Running,
"Statistics": {
"RecordsProcessed": integer,
"InvalidInputRecords": integer,
"RetryAttempts": integer
},
"CreatedAt": "string",
"ErrorMessage": "string",
"ErrorDetails": [
{
"DetailedErrorCode": "string",
"DetailedErrorMessage": "string"
}
]
}
```
`BulkDeploymentStatus` contiene el estado actual de la ejecución por lotes. La ejecución puede tener uno de seis estados diferentes:
+ `Initializing`. La solicitud de implementación por lotes se ha recibido y la ejecución se está preparando para iniciarse.
+ `Running`. La ejecución de la implementación por lotes se ha iniciado.
+ `Completed`. La ejecución de la implementación por lotes ha terminado de procesar todos los registros.
+ `Stopping`. La ejecución de la implementación por lotes ha recibido un comando para detenerse y terminará en breve. No se puede iniciar una nueva implementación por lotes si hay una anterior con el estado `Stopping`.
+ `Stopped`. La ejecución de la implementación por lotes se ha detenido manualmente.
+ `Failed`. La ejecución de la implementación por lotes ha encontrado un error y ha terminado. Puede ver los detalles del error en el campo `ErrorDetails`.
La carga JSON también incluye información estadística acerca del progreso de la implementación por lotes. Puede utilizar esta información para determinar la cantidad de grupos que se han procesado y cuántos han obtenido un error. La información estadística incluye los siguientes datos:
+ `RecordsProcessed`: el número de registros de grupo que se intentaron.
+ `InvalidInputRecords`: el número total de registros que han devuelto un error que no se puede reintentar. Por ejemplo, esto puede ocurrir si un registro de grupo del archivo de entrada utiliza un formato no válido o especifica una versión de grupo que no existe, o bien si la ejecución no concede permiso para implementar un grupo o una versión de grupo.
+ `RetryAttempts`: el número de intentos de implementación que han devuelto un error que se puede reintentar. Por ejemplo, un reintento se activa si el intento para implementar un grupo devuelve un error de limitación controlada. Una implementación de grupo puede reintentarse hasta cinco veces.
En el caso de que se produzca un error de una ejecución de implementación por lotes, esta carga también incluye una sección `ErrorDetails` que se puede utilizar para la resolución de problemas. Contiene información acerca de la causa del error de ejecución.
Puede comprobar periódicamente el estado de la implementación por lotes para confirmar que está avanzando según lo previsto. Una vez finalizada la implementación, `RecordsProcessed` debe ser igual que el número de grupos de implementación del archivo de entrada de implementación por lotes. Esto indica que cada registro se ha procesado.
## Paso 5: Probar la implementación
Utilice el comando **ListBulkDeployments** para encontrar el ID de la implementación por lotes.
```
aws greengrass list-bulk-deployments
```
Este comando devuelve una lista de todas las implementaciones por lote de la más reciente a la que menos, incluido el parámetro `BulkDeploymentId`.
```
{
"BulkDeployments": [
{
"BulkDeploymentId": 1234567,
"BulkDeploymentArn": "string",
"CreatedAt": "string"
}
],
"NextToken": "string"
}
```
Ahora llame al comando **ListBulkDeploymentDetailedReports** para recopilar información detallada acerca de cada implementación.
```
aws greengrass list-bulk-deployment-detailed-reports --bulk-deployment-id 1234567
```
El comando debe devolver un código de estado de`200`, además de una carga JSON de información:
```
{
"BulkDeploymentResults": [
{
"DeploymentId": "string",
"GroupVersionedArn": "string",
"CreatedAt": "string",
"DeploymentStatus": "string",
"ErrorMessage": "string",
"ErrorDetails": [
{
"DetailedErrorCode": "string",
"DetailedErrorMessage": "string"
}
]
}
],
"NextToken": "string"
}
```
Esta carga normalmente contiene una lista paginada de cada implementación con su estado de la más reciente a la que menos. También contiene más información en caso de que se produzca un error de ejecución de implementación por lotes. Una vez más, el número total de las implementaciones disponibles debe ser igual que el número de grupos que haya identificado en el archivo de entrada de implementación por lotes.
La información que se devuelve puede cambiar hasta que las implementaciones se encuentran en un estado terminal (éxito o error). Puede llamar a este comando periódicamente hasta entonces.
## Solución de problemas de las implementaciones por lotes
Si la implementación por lotes no se realiza correctamente, puede seguir estos pasos de solución de problemas. Ejecute el comando en el terminal.
### Solución de problemas del archivo de entrada
La implementación por lotes puede obtener un error en caso de que se produzca errores de sintaxis en el archivo de entrada de implementación por lotes. Esto devuelve un estado de implementación por lotes de `Failed` con un mensaje de error en el que se indica el número de línea del primer error de validación. Existen cuatro posibles errores:
+
```
InvalidInputFile: Missing GroupId at line number: line number
```
Este error indica que la línea del archivo de entrada determinada no puede registrar el parámetro especificado. Los posibles parámetros que faltan son `GroupId` y `GroupVersionId`.
+
```
InvalidInputFile: Invalid deployment type at line number : line number. Only valid type is 'NewDeployment'.
```
Este error indica que la línea del archivo de entrada determinada muestra un tipo de implementación no válido. En este momento, el único tipo de implementación admitido es `NewDeployment`.
+
```
Line %s is too long in S3 File. Valid line is less than 256 chars.
```
Este error indica que la línea del archivo de entrada determinada es demasiado largo y debe acortarse.
+
```
Failed to parse input file at line number: line number
```
Este error indica que la línea del archivo de entrada determinada no se considera un JSON válido.
### Comprobación de si hay implementaciones por lotes simultáneas
No puede iniciar una nueva implementación por lotes si hay otra ejecutándose o con un estado no terminal. Esto puede generar un error `Concurrent Deployment Error`. Puede utilizar el comando **ListBulkDeployments** para verificar que actualmente no hay ninguna implementación por lotes. Este comando muestra las implementaciones por lotes de la más reciente a la que menos.
```
{
"BulkDeployments": [
{
"BulkDeploymentId": BulkDeploymentId,
"BulkDeploymentArn": "string",
"CreatedAt": "string"
}
],
"NextToken": "string"
}
```
Utilice el parámetro `BulkDeploymentId` de la primera implementación por lotes enumerada para ejecutar el comando **GetBulkDeploymentStatus**. Si la implementación por lotes más reciente se encuentra en un estado de ejecución (`Initializing` o `Running`), utilice el siguiente comando para detener la implementación por lotes.
```
aws greengrass stop-bulk-deployment --bulk-deployment-id BulkDeploymentId
```
Esta acción genera un estado de `Stopping` hasta que la implementación obtiene el estado de `Stopped`. Después de que la implementación haya alcanzado el estado de `Stopped`, puede iniciar una nueva implementación por lotes.
### Compruebe ErrorDetails
Ejecute el comando `GetBulkDeploymentStatus` para devolver una carga JSON con información detallada sobre cualquier error de ejecución de la implementación por lotes.
```
"Message": "string",
"ErrorDetails": [
{
"DetailedErrorCode": "string",
"DetailedErrorMessage": "string"
}
]
```
Al salir con un error, la carga JSON `ErrorDetails` que devuelve esta llamada contiene obtener más información acerca del error de ejecución de implementación por lotes. Un código de estado de error de la serie `400`, por ejemplo, indica un error de entrada, ya sea en los parámetros de entrada o en las dependencias del intermediario.
### Compruebe el registro AWS IoT Greengrass principal
Puede solucionar problemas consultando los registros AWS IoT Greengrass principales. Use los siguientes comandos para ver `runtime.log`:
```
cd /greengrass/ggc/var/log
sudo cat system/runtime.log | more
```
Para obtener más información sobre el AWS IoT Greengrass registro, consulte[Supervisión con AWS IoT Greengrass registros](greengrass-logs-overview.md).
## Véase también
Para obtener más información, consulte los siguientes recursos:
+ [Implemente AWS IoT Greengrass grupos en un AWS IoT Greengrass núcleo](deployments.md)
+ [Los comandos de la API S3 de Amazon](https://docs.aws.amazon.com/cli/latest/reference/s3api) en la *Referencia de comandos de la AWS CLI *
+ [AWS IoT Greengrass comandos](https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html) de la *Referencia de AWS CLI comandos*