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.
# Crear una actualización de OTA con AWS CLI
Al utilizar el AWS CLI para crear una actualización de OTA, usted:
1. Firmar digitalmente la imagen de firmware.
1. Crear una secuencia de su imagen de firmware firmada digitalmente.
1. Comenzar un trabajo de actualización OTA.
## Firma digital de la actualización de firmware
Cuando lo utilices AWS CLI para realizar actualizaciones OTA, puedes usar la firma de código para AWS IoT la actualización del firmware o puedes firmarla tú mismo. Para obtener una lista de los algoritmos de firma criptográfica y hash compatibles con Code Signing for AWS IoT, consulte. [ SigningConfigurationOverrides](https://docs.aws.amazon.com/signer/latest/api/API_SigningConfigurationOverrides.html) Si desea utilizar un algoritmo criptográfico que no sea compatible con Code Signing for AWS IoT, debe firmar el binario de firmware antes de cargarlo en Amazon S3.
### Firmar la imagen de firmware con Code Signing para AWS IoT
Para firmar la imagen de firmware mediante Code Signing for AWS IoT, puede utilizar una de las siguientes [AWS SDKs herramientas de línea de comandos](https://aws.amazon.com/tools/). Para obtener más información sobre Code Signing for AWS IoT, consulte [Code Signing for AWS IoT](https://docs.aws.amazon.com/signer/latest/developerguide/Welcome.html).
Tras instalar y configurar las herramientas de firma de código, copie la imagen de firmware sin firmar en su bucket de Amazon S3 e inicie un trabajo de firma de código con los siguientes comandos. AWS CLI El comando **put-signing-profile** crea un perfil reutilizable de firma de código. El comando **start-signing-job** inicia el trabajo de firma.
```
aws signer put-signing-profile \
--profile-name your_profile_name \
--signing-material certificateArn=arn:aws:acm::your-region:your-aws-account-id:certificate/your-certificate-id \
--platform your-hardware-platform \
--signing-parameters certname=your_certificate_path_on_device
```
```
aws signer start-signing-job \
--source 's3={bucketName=your_s3_bucket,key=your_s3_object_key,version=your_s3_object_version_id}' \
--destination 's3={bucketName=your_destination_bucket}' \
--profile-name your_profile_name
```
**nota**
*your-source-bucket-name*y *your-destination-bucket-name* puede ser el mismo bucket de Amazon S3.
Esto son los parámetros de los comandos **put-signing-profile** y **start-signing-job**:
**`source`**
Especifica la ubicación del firmware sin firmar en un bucket de S3.
+ `bucketName`: el nombre del bucket de S3.
+ `key`: la clave (nombre de archivo) del firmware en su bucket de S3.
+ `version`: la versión de S3 del firmware en su bucket de S3. Esto es diferente de la versión de firmware. Para encontrarla, vaya a la consola de Amazon S3, elija su bucket y, en la parte superior de la página, junto a **Versiones**, elija **Mostrar**.
**`destination`**
El destino del dispositivo en el que se copiará el firmware firmado en el bucket de S3. El formato de este parámetro es el mismo que el del parámetro `source`.
**`signing-material`**
El ARN del certificado de firma de código. Este ARN se genera al importar su certificado a ACM.
**`signing-parameters`**
Un mapa de pares de clave-valor para la firma. Puede incluir toda la información que desea utilizar durante la firma.
Este parámetro es necesario cuando se crea un perfil de firma de código para firmar actualizaciones OTA con la firma de código para AWS IoT.
**`platform`**
El `platformId` de la plataforma de hardware en la que se va a distribuir la actualización OTA.
Para obtener una lista de las plataformas disponibles y sus valores de `platformId`, utilice el comando `aws signer list-signing-platforms`.
El trabajo de firma comienza y escribe la imagen de firmware firmada en el bucket de Amazon S3 de destino. El nombre del archivo de la imagen de firmware firmada es un GUID. Necesitará este nombre de archivo para crear una secuencia. Para encontrar el nombre del archivo, vaya a la consola de Amazon S3 y elija su bucket. Si no ve un archivo con un nombre de archivo GUID, actualice el navegador.
El comando muestra un ARN de trabajo y un ID de trabajo. Necesitará estos valores más adelante. Para obtener más información sobre Code Signing for AWS IoT, consulte [Code Signing for AWS IoT](https://docs.aws.amazon.com/signer/latest/developerguide/Welcome.html).
### Firma manual de la imagen de firmware
Firme digitalmente la imagen de firmware y cargue la imagen de firmware firmada en su bucket de Amazon S3.
## Creación de una secuencia de actualización de firmware
Una secuencia es una interfaz abstracta a los datos que puede consumir un dispositivo. Una secuencia puede ocultar la complejidad de obtener acceso a los datos almacenados en diferentes ubicaciones o en diferentes servicios en la nube. El servicio de administrador de actualizaciones OTA le permite utilizar varios datos, almacenados en varias ubicaciones de Amazon S3, para realizar una actualización OTA.
Al crear una actualización AWS IoT OTA, también puedes crear una transmisión que contenga la actualización de firmware firmada. Cree un archivo JSON (`stream.json`) que identifique su imagen de firmware firmada. El archivo JSON debe contener lo siguiente.
```
[
{
"fileId":"your_file_id",
"s3Location":{
"bucket":"your_bucket_name",
"key":"your_s3_object_key"
}
}
]
```
Estos son los atributos del archivo JSON:
**`fileId`**
Un número entero arbitrario entre 0 y 255 que identifica la imagen de firmware.
**`s3Location`**
El bucket y la clave para el firmware que se va a transmitir.
**`bucket`**
El bucket de Amazon S3 donde se almacena la imagen de firmware sin firmar.
**`key`**
El nombre del archivo de la imagen de firmware firmada en el bucket de Amazon S3. Puede encontrar este valor en la consola de Amazon S3. Para ello, debe consultar el contenido de su bucket.
Si utiliza Code Signing for AWS IoT, el nombre del archivo es un GUID generado por Code Signing for AWS IoT.
Utilice el comando **create-stream** AWS CLI para crear un flujo.
```
aws iot create-stream \
--stream-id your_stream_id \
--description your_description \
--files file://stream.json \
--role-arn your_role_arn
```
Estos son los argumentos del **create-stream** AWS CLI comando:
**`stream-id`**
Una cadena arbitraria para identificar la secuencia.
**`description`**
Una descripción opcional de la secuencia.
**`files`**
Una o varias referencias a archivos JSON que contienen datos sobre las imágenes de firmware que se van a transmitir. El archivo JSON contiene los siguientes atributos:
**`fileId`**
Un ID de archivo arbitrario.
**`s3Location`**
El nombre del bucket donde se almacena la imagen de firmware firmada y la clave (nombre del archivo) de la imagen de firmware firmada.
**`bucket`**
El bucket de Amazon S3 donde se almacena la imagen de firmware firmada.
**`key`**
La clave (nombre del archivo) de la imagen de firmware firmada.
Cuando se utiliza la firma de código para AWS IoT, esta clave es un GUID.
A continuación se muestra un ejemplo de un archivo `stream.json`.
```
[
{
"fileId":123,
"s3Location": {
"bucket":"codesign-ota-bucket",
"key":"48c67f3c-63bb-4f92-a98a-4ee0fbc2bef6"
}
}
]
```
**`role-arn`**
El [rol de servicio OTA](create-service-role.md) que también concede acceso al bucket de Amazon S3 donde se almacena la imagen del firmware.
Para encontrar la clave de objeto de Amazon S3 de la imagen de firmware firmada, utilice el **aws signer describe-signing-job --job-id *my-job-id*** comando where `my-job-id` is the job ID que muestra el **create-signing-job** AWS CLI comando. La salida del comando **describe-signing-job** contiene la clave de la imagen de firmware firmada.
```
... text deleted for brevity ...
"signedObject": {
"s3": {
"bucketName": "ota-bucket",
"key": "7309da2c-9111-48ac-8ee4-5a4262af4429"
}
}
... text deleted for brevity ...
```
## Creación de una actualización OTA
Utilice el **create-ota-update** AWS CLI comando para crear un trabajo de actualización de OTA.
**nota**
No utilice información de identificación personal (PII) en el ID de trabajo de su actualización OTA. Los ejemplos de información de identificación personal incluyen:
Nombres.
Direcciones IP.
Direcciones de correo electrónico.
Ubicaciones.
Datos bancarios.
Información médica.
```
aws iot create-ota-update \
--ota-update-id value \
[--description value] \
--targets value \
[--protocols value] \
[--target-selection value] \
[--aws-job-executions-rollout-config value] \
[--aws-job-presigned-url-config value] \
[--aws-job-abort-config value] \
[--aws-job-timeout-config value] \
--files value \
--role-arn value \
[--additional-parameters value] \
[--tags value] \
[--cli-input-json value] \
[--generate-cli-skeleton]
```
Formato `cli-input-json`
```
{
"otaUpdateId": "string",
"description": "string",
"targets": [
"string"
],
"protocols": [
"string"
],
"targetSelection": "string",
"awsJobExecutionsRolloutConfig": {
"maximumPerMinute": "integer",
"exponentialRate": {
"baseRatePerMinute": "integer",
"incrementFactor": "double",
"rateIncreaseCriteria": {
"numberOfNotifiedThings": "integer",
"numberOfSucceededThings": "integer"
}
}
},
"awsJobPresignedUrlConfig": {
"expiresInSec": "long"
},
"awsJobAbortConfig": {
"abortCriteriaList": [
{
"failureType": "string",
"action": "string",
"thresholdPercentage": "double",
"minNumberOfExecutedThings": "integer"
}
]
},
"awsJobTimeoutConfig": {
"inProgressTimeoutInMinutes": "long"
},
"files": [
{
"fileName": "string",
"fileType": "integer",
"fileVersion": "string",
"fileLocation": {
"stream": {
"streamId": "string",
"fileId": "integer"
},
"s3Location": {
"bucket": "string",
"key": "string",
"version": "string"
}
},
"codeSigning": {
"awsSignerJobId": "string",
"startSigningJobParameter": {
"signingProfileParameter": {
"certificateArn": "string",
"platform": "string",
"certificatePathOnDevice": "string"
},
"signingProfileName": "string",
"destination": {
"s3Destination": {
"bucket": "string",
"prefix": "string"
}
}
},
"customCodeSigning": {
"signature": {
"inlineDocument": "blob"
},
"certificateChain": {
"certificateName": "string",
"inlineDocument": "string"
},
"hashAlgorithm": "string",
"signatureAlgorithm": "string"
}
},
"attributes": {
"string": "string"
}
}
],
"roleArn": "string",
"additionalParameters": {
"string": "string"
},
"tags": [
{
"Key": "string",
"Value": "string"
}
]
}
```
**Campos `cli-input-json`**
| Name | Tipo | Description (Descripción) |
| --- | --- | --- |
| `otaUpdateId` | cadena (máximo: 128 mínimo:1) | El ID de la actualización OTA que se va a crear. |
| `description` | cadena (máximo: 2028) | La descripción de la actualización OTA. |
| `targets` | list | Los dispositivos que van a recibir actualizaciones OTA. |
| `protocols` | list | El protocolo utilizado para transferir la imagen de actualización de OTA. Los valores válidos son [HTTP], [MQTT], [HTTP, MQTT]. Cuando se especifican HTTP y MQTT, el dispositivo de destino puede elegir el protocolo. |
| `targetSelection` | cadena | Especifica si la actualización seguirá ejecutándose (CONTINUOUS) o si se completará después de que todos los objetos especificados como destino hayan completado la actualización (SNAPSHOT). Si el estado es CONTINUOUS, es posible también que la actualización solo pueda ejecutarse en un objeto cuando se detecte un cambio en un destino. Por ejemplo, se ejecutará una actualización en un objeto cuando este se añada a un grupo de destino, incluso después de que los objetos originales del grupo completen la actualización. Valores válidos: CONTINUOUS \$1 SNAPSHOT. Enum: CONTINUOUS \$1 SNAPSHOT |
| `awsJobExecutionsRolloutConfig` | | Configuración de la implementación de las actualizaciones OTA. |
| `maximumPerMinute` | entero (máximo: 1000 mínimo:1) | El número máximo de ejecuciones de trabajos de actualización de OTA iniciadas por minuto. |
| `exponentialRate` | | La tasa de aumento para el despliegue de un trabajo. Este parámetro le permite definir un aumento de tasa exponencial para el despliegue de un trabajo. |
| `baseRatePerMinute` | entero (máximo: 1000 mínimo:1) | El número mínimo de objetos del que se notificará de un trabajo pendiente, por minuto, al empezar a desplegar el trabajo. Esta es la tasa inicial del despliegue. |
| `rateIncreaseCriteria` | | Los criterios para iniciar el aumento en la tasa de despliegue de un trabajo. AWS IoT admite hasta un dígito después del decimal (por ejemplo, 1,5, pero no 1,55). |
| `numberOfNotifiedThings` | entero (mínimo:1) | Cuando se haya notificado a esta cantidad de cosas, se iniciará un aumento en la tasa de despliegue. |
| `numberOfSucceededThings` | entero (mínimo:1) | Cuando esta cantidad de cosas hayan tenido éxito en la ejecución de su trabajo, se iniciará un aumento en la tasa de despliegue. |
| `awsJobPresignedUrlConfig` | | Información de configuración para prefirmados URLs. |
| `expiresInSec` | long | Cuánto tiempo (en segundos) son válidos los URLs prefirmados. Los valores válidos oscilan entre 60 y 3600. El valor predeterminado es 1800 segundos. Los URLs prefirmados se generan cuando se recibe una solicitud del documento de trabajo. |
| `awsJobAbortConfig` | | Criterios que determinan cuándo y cómo se produce la detención de un trabajo. |
| `abortCriteriaList` | list | Lista de criterios que determinan cuándo y cómo detener el trabajo. |
| `failureType` | cadena | Tipo de errores de ejecución de trabajos que pueden iniciar una detención del trabajo. enum: FAILED \$1 REJECTED \$1 TIMED\$1OUT \$1 ALL |
| `action` | cadena | Tipo de acción de trabajo que se va a realizar para iniciar la detención del trabajo. enum: CANCEL |
| `minNumberOfExecutedThings` | entero (mínimo:1) | El número mínimo de objetos que deben recibir notificaciones de ejecución de trabajos antes de que el trabajo se pueda detener. |
| `awsJobTimeoutConfig` | | Especifica la cantidad de tiempo que cada dispositivo tiene para finalizar su ejecución del trabajo. Un temporizador se pone en marcha cuando el estado de ejecución del trabajo se establece en `IN_PROGRESS`. Si el estado de ejecución del trabajo no se establece en otro estado terminal antes de que el temporizador agota el plazo, se establecerá automáticamente en `TIMED_OUT`. |
| `inProgressTimeoutInMinutes` | long | Especifica la cantidad de tiempo, en minutos, que tiene este dispositivo para finalizar la ejecución de este trabajo. El intervalo de tiempo de espera puede estar en cualquier momento entre 1 minuto y 7 días (1 a 10 080 minutos). El temporizador en curso no se puede actualizar y se aplicará a todas las ejecuciones de trabajo para el trabajo. Cada vez que un trabajo permanece en el estado de ejecución IN\$1PROGRESS durante un periodo superior a este intervalo, la ejecución del trabajo producirá un error y cambiará al estado terminal `TIMED_OUT`. |
| `files` | list | Los archivos que se transmiten mediante la actualización OTA. |
| `fileName` | cadena | El nombre del archivo . |
| `fileType` | entero Rango máx.: 255; mín.: 0 | Un valor entero que puede incluir en el documento de trabajo para que sus dispositivos puedan identificar el tipo de archivo recibido de la nube. |
| `fileVersion` | cadena | La versión del archivo. |
| `fileLocation` | | La ubicación del firmware actualizado. |
| `stream` | | La secuencia que contiene la actualización OTA. |
| `streamId` | cadena (máximo: 128 mínimo:1) | El ID de transmisión. |
| `fileId` | entero (máximo:255 mínimo:0) | El ID de un archivo asociado con un flujo. |
| `s3Location` | | La ubicación del firmware actualizado en S3. |
| `bucket` | cadena (mínimo:1) | El bucket de S3. |
| `key` | cadena (mínimo:1) | La clave de S3. |
| `version` | cadena | La versión del bucket de S3. |
| `codeSigning` | | El método de firma de código del archivo. |
| `awsSignerJobId` | cadena | El ID del AWSSigner Job que se creó para firmar el archivo. |
| `startSigningJobParameter` | | Describe el trabajo de firma de código. |
| `signingProfileParameter` | | Describe el perfil de firma de código. |
| `certificateArn` | cadena | ARN del certificado. |
| `platform` | cadena | La plataforma de hardware de su dispositivo. |
| `certificatePathOnDevice` | cadena | La ubicación del certificado de firma de código en el dispositivo. |
| `signingProfileName` | cadena | El nombre del perfil de firma de código. |
| `destination` | | La ubicación para escribir el archivo cuyo código se ha firmado. |
| `s3Destination` | | Describe la ubicación del firmware actualizado en S3. |
| `bucket` | cadena (mínimo:1) | El bucket de S3 que contiene el firmware actualizado. |
| `prefix` | cadena | El prefijo S3. |
| `customCodeSigning` | | Un método personalizado para la firma de código de un archivo. |
| `signature` | | La firma del archivo. |
| `inlineDocument` | blob | Una representación binaria con cifrado base64 de la firma usada para firmar el código. |
| `certificateChain` | | La cadena de certificados. |
| `certificateName` | cadena | El nombre del certificado. |
| `inlineDocument` | cadena | Una representación binaria con cifrado base64 de la cadena de certificados de firma de código. |
| `hashAlgorithm` | cadena | El algoritmo hash que se utiliza para la firma de código del archivo. |
| `signatureAlgorithm` | cadena | El algoritmo de firma que se utiliza para la firma de código del archivo. |
| `attributes` | map | Una lista de name/attribute pares. |
| `roleArn` | cadena (máximo: 2048 mínimo:20) | La función de IAM que otorga AWS IoT acceso a Amazon S3, a los AWS IoT trabajos y a los recursos de firma de AWS código para crear un trabajo de actualización de OTA. |
| `additionalParameters` | map | Una lista de parámetros de actualizaciones OTA adicionales que son pares nombre-valor. |
| `tags` | list | Metadatos que se pueden utilizar para administrar actualizaciones. |
| `Key` | cadena (máximo: 128 mínimo:1) | La clave de la etiqueta. |
| `Value` | cadena (máximo: 256 mínimo:1) | El valor de la etiqueta. |
Output
```
{
"otaUpdateId": "string",
"awsIotJobId": "string",
"otaUpdateArn": "string",
"awsIotJobArn": "string",
"otaUpdateStatus": "string"
}
```
**AWS CLI campos de salida**
| Name | Tipo | Description (Descripción) |
| --- | --- | --- |
| `otaUpdateId` | cadena (máximo: 128 mínimo:1) | El ID de la actualización OTA. |
| `awsIotJobId` | cadena | El ID del AWS IoT trabajo asociado a la actualización de la OTA. |
| `otaUpdateArn` | cadena | El ARN de actualización OTA. |
| `awsIotJobArn` | cadena | El AWS IoT ARN del trabajo asociado a la actualización de OTA. |
| `otaUpdateStatus` | cadena | El estado de la actualización OTA. Enum: CREATE\$1PENDING \$1 CREATE\$1IN\$1PROGRESS \$1 CREATE\$1COMPLETE \$1 CREATE\$1FAILED |
A continuación se muestra un ejemplo de un archivo JSON que se pasa al **create-ota-update** comando que usa la firma de código para AWS IoT.
```
[
{
"fileName": "firmware.bin",
"fileType": 1,
"fileLocation": {
"stream": {
"streamId": "004",
"fileId":123
}
},
"codeSigning": {
"awsSignerJobId": "48c67f3c-63bb-4f92-a98a-4ee0fbc2bef6"
}
}
]
```
El siguiente es un ejemplo de un archivo JSON pasado al **create-ota-update** AWS CLI comando que usa un archivo en línea para proporcionar material de firma de código personalizado.
```
[
{
"fileName": "firmware.bin",
"fileType": 1,
"fileLocation": {
"stream": {
"streamId": "004",
"fileId": 123
}
},
"codeSigning": {
"customCodeSigning":{
"signature":{
"inlineDocument":"your_signature"
},
"certificateChain": {
"certificateName": "your_certificate_name",
"inlineDocument":"your_certificate_chain"
},
"hashAlgorithm":"your_hash_algorithm",
"signatureAlgorithm":"your_signature_algorithm"
}
}
}
]
```
El siguiente es un ejemplo de un archivo JSON pasado al **create-ota-update** AWS CLI comando que permite a FreeRTOS OTA iniciar un trabajo de firma de código y crear un perfil y una transmisión de firma de código.
```
[
{
"fileName": "your_firmware_path_on_device",
"fileType": 1,
"fileVersion": "1",
"fileLocation": {
"s3Location": {
"bucket": "your_bucket_name",
"key": "your_object_key",
"version": "your_S3_object_version"
}
},
"codeSigning":{
"startSigningJobParameter":{
"signingProfileName": "myTestProfile",
"signingProfileParameter": {
"certificateArn": "your_certificate_arn",
"platform": "your_platform_id",
"certificatePathOnDevice": "certificate_path"
},
"destination": {
"s3Destination": {
"bucket": "your_destination_bucket"
}
}
}
}
}
]
```
El siguiente es un ejemplo de un archivo JSON pasado al **create-ota-update** AWS CLI comando que crea una actualización de OTA que inicia un trabajo de firma de código con un perfil existente y utiliza la secuencia especificada.
```
[
{
"fileName": "your_firmware_path_on_device",
"fileType": 1,
"fileVersion": "1",
"fileLocation": {
"s3Location": {
"bucket": "your_s3_bucket_name",
"key": "your_object_key",
"version": "your_S3_object_version"
}
},
"codeSigning":{
"startSigningJobParameter":{
"signingProfileName": "your_unique_profile_name",
"destination": {
"s3Destination": {
"bucket": "your_destination_bucket"
}
}
}
}
}
]
```
El siguiente es un ejemplo de un archivo JSON pasado al **create-ota-update** AWS CLI comando que permite a FreeRTOS OTA crear una transmisión con un ID de trabajo de firma de código existente.
```
[
{
"fileName": "your_firmware_path_on_device",
"fileType": 1,
"fileVersion": "1",
"codeSigning":{
"awsSignerJobId": "your_signer_job_id"
}
}
]
```
El siguiente es un ejemplo de un archivo JSON pasado al **create-ota-update** AWS CLI comando que crea una actualización de OTA. La actualización crea una secuencia desde el objeto de S3 especificado y utiliza firma de código personalizada.
```
[
{
"fileName": "your_firmware_path_on_device",
"fileType": 1,
"fileVersion": "1",
"fileLocation": {
"s3Location": {
"bucket": "your_bucket_name",
"key": "your_object_key",
"version": "your_S3_object_version"
}
},
"codeSigning":{
"customCodeSigning": {
"signature":{
"inlineDocument":"your_signature"
},
"certificateChain": {
"inlineDocument":"your_certificate_chain",
"certificateName": "your_certificate_path_on_device"
},
"hashAlgorithm":"your_hash_algorithm",
"signatureAlgorithm":"your_sig_algorithm"
}
}
}
]
```
## Listado de actualizaciones OTA
Puede usar el **list-ota-updates** AWS CLI comando para obtener una lista de todas las actualizaciones de OTA.
```
aws iot list-ota-updates
```
La salida del comando **list-ota-updates** es como se muestra a continuación.
```
{
"otaUpdates": [
{
"otaUpdateId": "my_ota_update2",
"otaUpdateArn": "arn:aws:iot:us-west-2:123456789012:otaupdate/my_ota_update2",
"creationDate": 1522778769.042
},
{
"otaUpdateId": "my_ota_update1",
"otaUpdateArn": "arn:aws:iot:us-west-2:123456789012:otaupdate/my_ota_update1",
"creationDate": 1522775938.956
},
{
"otaUpdateId": "my_ota_update",
"otaUpdateArn": "arn:aws:iot:us-west-2:123456789012:otaupdate/my_ota_update",
"creationDate": 1522775151.031
}
]
}
```
## Obtener información sobre una actualización OTA
Puede usar el **get-ota-update** AWS CLI comando para obtener el estado de creación o eliminación de una actualización de OTA.
```
aws iot get-ota-update --ota-update-id your-ota-update-id
```
El resultado del comando **get-ota-update** tendrá un aspecto similar al siguiente.
```
{
"otaUpdateInfo": {
"otaUpdateId": "ota-update-001",
"otaUpdateArn": "arn:aws:iot:region:123456789012:otaupdate/ota-update-001",
"creationDate": 1575414146.286,
"lastModifiedDate": 1575414149.091,
"targets": [
"arn:aws:iot:region:123456789012:thing/myDevice"
],
"protocols": [ "HTTP" ],
"awsJobExecutionsRolloutConfig": {
"maximumPerMinute": 0
},
"awsJobPresignedUrlConfig": {
"expiresInSec": 1800
},
"targetSelection": "SNAPSHOT",
"otaUpdateFiles": [
{
"fileName": "my_firmware.bin",
"fileType": 1,
"fileLocation": {
"s3Location": {
"bucket": "my-bucket",
"key": "my_firmware.bin",
"version": "AvP3bfJC9gyqnwoxPHuTqM5GWENt4iii"
}
},
"codeSigning": {
"awsSignerJobId": "b7a55a54-fae5-4d3a-b589-97ed103737c2",
"startSigningJobParameter": {
"signingProfileParameter": {},
"signingProfileName": "my-profile-name",
"destination": {
"s3Destination": {
"bucket": "some-ota-bucket",
"prefix": "SignedImages/"
}
}
},
"customCodeSigning": {}
}
}
],
"otaUpdateStatus": "CREATE_COMPLETE",
"awsIotJobId": "AFR_OTA-ota-update-001",
"awsIotJobArn": "arn:aws:iot:region:123456789012:job/AFR_OTA-ota-update-001"
}
}
```
Los valores devueltos para `otaUpdateStatus` incluyen lo siguiente:
**`CREATE_PENDING`**
La creación de una actualización OTA está pendiente.
**`CREATE_IN_PROGRESS`**
Se está creando una actualización OTA.
**`CREATE_COMPLETE`**
Se ha creado una actualización OTA.
**`CREATE_FAILED`**
La creación de una actualización OTA ha fracasado.
**`DELETE_IN_PROGRESS`**
Se está eliminando una actualización OTA.
**`DELETE_FAILED`**
La eliminación de una actualización OTA ha fracasado.
**nota**
Para obtener el estado de ejecución de una actualización OTA después de que se haya creado, debe utilizar el comando **describe-job-execution**. Para obtener más información, consulte [ Descripción de una ejecución de trabajo](https://docs.aws.amazon.com/iot/latest/developerguide/manage-job-cli.html#describe-job-execution).
## Eliminación de datos relacionados con OTA
Actualmente, no puedes usar la AWS IoT consola para eliminar transmisiones o actualizaciones de OTA. Puede utilizarla AWS CLI para eliminar las transmisiones, las actualizaciones de OTA y los AWS IoT trabajos creados durante una actualización de OTA.
### Eliminar una secuencia OTA
Al crear una actualización OTA que utilice MQTT, puede utilizar la línea de comandos o la AWS IoT consola para crear una secuencia que divida el firmware en partes y poder enviarlo a través de MQTT. Puede eliminar esta transmisión con el **delete-stream** AWS CLI comando, como se muestra en el siguiente ejemplo.
```
aws iot delete-stream --stream-id your_stream_id
```
### Eliminar una actualización OTA
Al crear una actualización OTA, se crean los siguientes elementos:
+ Una entrada en la base de datos del trabajo de actualización OTA.
+ Un AWS IoT trabajo para realizar la actualización.
+ Una ejecución de AWS IoT trabajo para cada dispositivo que se esté actualizando.
El comando **delete-ota-update** elimina la entrada en la base de datos del trabajo de actualización OTA únicamente. Debe utilizar el comando **delete-job** para eliminar el trabajo de AWS IoT .
Utilice el comando **delete-ota-update** para eliminar una actualización OTA.
```
aws iot delete-ota-update --ota-update-id your_ota_update_id
```
**`ota-update-id`**
El ID de la actualización OTA que se va a eliminar.
**`delete-stream`**
Elimina la secuencia asociada a la actualización OTA.
**`force-delete-aws-job`**
Elimina el AWS IoT trabajo asociado a la actualización de la OTA. Si no se establece esta marca y el trabajo se encuentra en estado `In_Progress`, el trabajo no se elimina.
### Eliminar un trabajo de IoT creado para una actualización OTA
Freertos crea un AWS IoT trabajo al crear una actualización de OTA. También se crea una ejecución de trabajo para cada dispositivo que procesa el trabajo. Puede usar el **delete-job** AWS CLI comando para eliminar un trabajo y sus ejecuciones de trabajo asociadas.
```
aws iot delete-job --job-id your-job-id --no-force
```
El parámetro `no-force` especifica que solo se pueden eliminar los trabajos que están en estado terminal (COMPLETED o CANCELLED). Puede eliminar un trabajo que se encuentra en un estado no terminal pasando el parámetro `force`. Para obtener más información, consulte [API de DeleteJob ](https://docs.aws.amazon.com/iot/latest/apireference/API_DeleteJob.html).
**nota**
Eliminar un trabajo con un estado IN\$1PROGRESS interrumpe todas las ejecuciones de trabajo que están IN\$1PROGRESS en sus dispositivos y puede dar lugar a que un dispositivo quede en un estado no determinista. Asegúrese de que todos los dispositivos que ejecutan un trabajo que se ha eliminado pueden recuperarse a un estado conocido.
Según el número de ejecuciones de trabajo creadas para el trabajo y otros factores, se podría tardar unos minutos en borrar un trabajo. Mientras el trabajo se está eliminando, su estado es DELETION\$1IN\$1PROGRESS. Al intentar eliminar o cancelar un trabajo cuyo estado ya es DELETION\$1IN\$1PROGRESS, se producirá un error.
Puede utilizar **delete-job-execution** para eliminar una ejecución de trabajo. Es posible que desee eliminar una ejecución de trabajo cuando un pequeño número de dispositivos no sea capaz de procesar un trabajo. Este elimina la ejecución de trabajo para un único dispositivo, como se muestra en el siguiente ejemplo.
```
aws iot delete-job-execution --job-id your-job-id --thing-name
your-thing-name --execution-number your-job-execution-number --no-force
```
Al igual que con el **delete-job** AWS CLI comando, puede pasar el `--force` parámetro a la **delete-job-execution** para forzar la eliminación de la ejecución de una tarea. Para obtener más información, consulte [DeleteJobExecutionAPI](https://docs.aws.amazon.com/iot/latest/apireference/API_DeleteJobExecution.html).
**nota**
Eliminar una ejecución de trabajo con un estado IN\$1PROGRESS interrumpe todas las ejecuciones de trabajo que están IN\$1PROGRESS en sus dispositivos y puede dar lugar a que un dispositivo quede en un estado no determinista. Asegúrese de que todos los dispositivos que ejecutan un trabajo que se ha eliminado pueden recuperarse a un estado conocido.
Para obtener más información sobre el uso de la aplicación de demostración de actualizaciones OTA, consulte [Over-the-air actualiza la aplicación de demostración](ota-demo.md).