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.
# 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*