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.
# AWS IoT Device Management comandos
**importante**
En esta documentación se describe cómo puede utilizar la [característica de comandos en AWS IoT Device Management](https://docs.aws.amazon.com/iot/latest/developerguide/iot-remote-command-concepts.html#command-iot-namespace). Para obtener más información sobre cómo usar esta característica para AWS IoT FleetWise, consulte [Comandos remotos](https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/remote-commands.html).
Usted es el único responsable de implementar los comandos de forma segura y que cumpla con las normativas aplicables. Para obtener más información sobre sus responsabilidades, consulte los [términos de servicio de AWS para los servicios de AWS IoT](https://aws.amazon.com/service-terms/).
Usa AWS IoT Device Management los comandos para enviar una instrucción desde la nube a un dispositivo al que esté conectado AWS IoT. Los comandos se dirigen a un dispositivo a la vez y se pueden usar para aplicaciones de baja latencia y alto rendimiento, como recuperar registros del dispositivo o iniciar un cambio de estado del dispositivo.
El *comando es un recurso reutilizable* que se administra mediante. AWS IoT Device Management Contiene configuraciones que se aplican antes de publicarse en el dispositivo. Puede predefinir un conjunto de comandos para casos de uso específicos, como encender una bombilla o abrir la puerta de un vehículo.
La función de AWS IoT comandos le permite:
+ Cree plantillas de comandos reutilizables con cargas útiles estáticas o dinámicas y ejecútelas en dispositivos específicos.
+ Diríjase a dispositivos registrados como AWS IoT cosas o clientes MQTT no registrados.
+ Ejecute varios comandos simultáneamente en el mismo dispositivo.
+ Habilite las notificaciones de eventos y realice un seguimiento del estado de ejecución a medida que los dispositivos procesan los comandos.
En los temas siguientes se muestra cómo crear comandos, enviarlos al dispositivo y recuperar el estado notificado por el dispositivo.
**Topics**
+ [Inicio rápido](iot-commands-quickstart.md)
+ [Estado y conceptos de los comandos](iot-remote-command-concepts.md)
+ [Flujo de trabajo de comandos de](iot-remote-command-workflow.md)
+ [Creación y administración de comandos](iot-remote-command-create-manage.md)
+ [Inicio y supervisión de las ejecuciones de comandos](iot-remote-command-execution-start-monitor.md)
+ [Obsolescencia de un recurso de comandos](iot-remote-command-deprecate.md)
# Inicio rápido
Complete estos pasos para enviar su primer comando:
1. **Requisitos previos**: asegúrese de estar incorporado a IoT Core, un dispositivo conectado a IoT Core, tener permisos de IAM para las operaciones de la API de comandos y tener una biblioteca de clientes MQTT instalada en su dispositivo.
1. **Crear un comando**: defina un comando con una carga útil estática o una plantilla de carga útil que especifique las acciones del dispositivo. Consulte [Creación de un recurso de comandos](iot-remote-command-create-manage.md#iot-remote-command-create).
1. **Identifique su dispositivo**: registre su dispositivo como un elemento de IoT o anote su ID de cliente MQTT. Consulte [Consideraciones sobre los dispositivos de destino](iot-remote-command-execution-start-monitor.md#iot-command-execution-target).
1. **Configure los permisos**: configure las políticas de IAM que permitan a su dispositivo recibir comandos y publicar respuestas.
1. **Suscríbase a los temas**: configure su dispositivo para suscribirse a los temas de solicitud y respuesta de comandos. Consulte [Selección del dispositivo de destino para los comandos y suscripción a los temas de MQTT](iot-remote-command-workflow.md#command-choose-target).
1. **Ejecute el comando**: inicie la ejecución del comando en el dispositivo de destino. Consulte [Inicio de la ejecución de un comandoInicio de la ejecución de un comando (consola)Inicio de la ejecución de un comando (AWS CLI)](iot-remote-command-execution-start-monitor.md#iot-remote-command-execution-start).
**Casos de uso comunes:**
+ *Diagnóstico remoto*: recupere registros, ejecute diagnósticos y compruebe el estado del dispositivo
+ *Actualizaciones de configuración*: cambie la configuración, actualice los parámetros y cambie las funciones
+ *Control del dispositivo*: Lock/unlock, power on/off cambios de modo
# Estado y conceptos de los comandos
Utilice AWS IoT los comandos para enviar instrucciones desde la nube a los dispositivos conectados. Para usar esta característica:
1. Cree un comando con una carga útil que contenga las configuraciones necesarias para ejecutarse en el dispositivo.
1. Especifique el dispositivo de destino que recibirá la carga útil y realizará las acciones.
1. Ejecute el comando en el dispositivo de destino y recupere la información de estado. Para solucionar problemas, consulte los CloudWatch registros.
Para obtener más información acerca de este flujo de trabajo, consulte [Flujo de trabajo de comandos de](iot-remote-command-workflow.md).
**Topics**
+ [Conceptos clave de los comandos](#iot-command-concepts)
+ [Estados de comando](#iot-command-states)
+ [Estado de la ejecución del comando](#iot-command-execution-status)
## Conceptos clave de los comandos
Los siguientes conceptos clave le ayudan a entender la función de comandos. Los términos se utilizan de forma coherente en toda esta documentación:
+ *Comando*: plantilla reutilizable que define las instrucciones del dispositivo
+ *Ejecución*: instancia de un comando que se ejecuta en un dispositivo
+ *Nombre de la cosa*: identificador de dispositivos registrados en el registro de IoT
+ *ID de cliente*: identificador MQTT para dispositivos no registrados
+ *Carga útil*: los datos de instrucciones que se envían a los dispositivos
+ *Tema*: Canal MQTT para la comunicación de comandos
**Comandos**
Los comandos son instrucciones que se envían desde la nube a sus dispositivos de IoT como mensajes MQTT. Tras recibir la carga útil, los dispositivos procesan las instrucciones y toman las medidas correspondientes, como modificar los ajustes de configuración, transmitir las lecturas de los sensores o cargar los registros. Luego, los dispositivos devuelven los resultados a la nube, lo que permite la supervisión y el control remotos.
**Namespace**
Al crear un comando, especifique su espacio de nombres. Para AWS IoT Device Management los comandos, utilice el espacio de `AWS-IoT` nombres predeterminado y proporcione una carga útil o una plantilla de carga útil. Para los AWS IoT FleetWise comandos, usa el espacio de nombres. `AWS-IoT-FleetWise` Para obtener más información, consulte [Comandos remotos](https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/remote-commands.html) en la Guía para *AWS IoT FleetWise desarrolladores*.
**Carga útil**
Al crear un comando, proporcione una carga estática que defina las acciones que debe realizar el dispositivo. La carga útil puede utilizar cualquier formato compatible. Para garantizar que los dispositivos interpreten correctamente la carga útil, recomendamos especificar el tipo de formato de la carga útil. Los dispositivos que utilizan el MQTT5 protocolo pueden seguir el estándar MQTT para identificar el formato. Los indicadores de formato para JSON o CBOR están disponibles en el tema de solicitud de comandos.
**Plantilla de carga útil**
Una plantilla de carga útil define una carga útil de comandos con marcadores de posición que generan diferentes cargas útiles en tiempo de ejecución en función de los valores de los parámetros que proporciones. Por ejemplo, en lugar de crear cargas útiles independientes para diferentes valores de temperatura, crea una plantilla con un marcador de temperatura y especifica el valor durante la ejecución. Esto elimina el mantenimiento de varias cargas útiles similares.
**Dispositivo de destino**
Para ejecutar un comando, especifique un dispositivo de destino utilizando su nombre (en el caso de los dispositivos registrados AWS IoT) o el ID de cliente MQTT (en el caso de los dispositivos no registrados). El ID de cliente es un identificador único definido en el [MQTT](mqtt.md) protocolo utilizado para conectar los dispositivos. AWS IoT Para obtener más información, consulte [Consideraciones sobre los dispositivos de destino](iot-remote-command-execution-start-monitor.md#iot-command-execution-target).
**Temas de comandos**
Antes de ejecutar un comando, los dispositivos deben suscribirse al tema de solicitud de comandos. Al ejecutar un comando, la carga útil se envía al dispositivo relacionado con este tema. Tras la ejecución, los dispositivos publican los resultados y el estado en el tema de respuesta al comando. Para obtener más información, consulte [Temas de comandos](reserved-topics.md#reserved-topics-commands).
**Ejecución de comandos**
Una ejecución es una instancia de un comando que se ejecuta en un dispositivo de destino. Al iniciar una ejecución, la carga útil se entrega al dispositivo y se genera un identificador de ejecución único. El dispositivo ejecuta el comando e informa al respecto del progreso. AWS IoT La lógica del dispositivo determina el comportamiento de ejecución y los informes sobre el estado de los temas reservados.
### Condiciones de valor de los parámetros
Al crear comandos con plantillas de carga útil, defina las condiciones de valor para validar los valores de los parámetros antes de la ejecución. Las condiciones de valor garantizan que los parámetros cumplan los requisitos, lo que evita las ejecuciones no válidas.
**Operadores compatibles por [CommandParameterValue](https://docs.aws.amazon.com//iot/latest/apireference/API_CommandParameterValue.html)tipo**
**Tipos numéricos (INTEGER, LONG, DOUBLE, UNSIGNEDLONG)**
+ `EQUALS`- El valor debe ser igual al número especificado
+ `NOT_EQUALS`- El valor no debe ser igual al número especificado
+ `GREATER_THAN`- El valor debe ser mayor que el número especificado
+ `GREATER_THAN_EQUALS`- El valor debe ser mayor o igual al número especificado
+ `LESS_THAN`- El valor debe ser inferior al número especificado
+ `LESS_THAN_EQUALS`- El valor debe ser menor o igual al número especificado
+ `IN_RANGE`- El valor debe estar dentro del rango especificado (incluido)
+ `NOT_IN_RANGE`- El valor debe estar fuera del rango especificado (incluido)
+ `IN_SET`- El valor debe coincidir con uno de los números especificados
+ `NOT_IN_SET`- El valor no debe coincidir con ninguno de los números especificados
**Tipo de cadena (STRING)**
+ `EQUALS`- El valor debe ser igual a la cadena especificada
+ `NOT_EQUALS`- El valor no debe ser igual a la cadena especificada
+ `IN_SET`- El valor debe coincidir con una de las cadenas especificadas
+ `NOT_IN_SET`- El valor no debe coincidir con ninguna de las cadenas especificadas
**Tipo booleano**
+ No se admiten condiciones de valores
**Tipo binario**
+ No se admiten condiciones de valor
**Ejemplo: comando de control de temperatura**
```
{
"commandId": "SetTemperature",
"namespace": "AWS-IoT",
"payloadTemplate": "{\"temperature\": \"${aws:iot:commandexecution::parameter:temperature}\"}",
"parameters": [
{
"name": "temperature",
"type": "INTEGER",
"valueConditions": [
{
"comparisonOperator": "IN_RANGE",
"operand": {
"numberRange": {
"min": "60",
"max": "80"
}
}
}
]
}
]
}
```
En este ejemplo, el `temperature` parámetro debe estar entre 60 y 80 (ambos incluidos). Las solicitudes de ejecución con valores fuera de este rango no se validan.
**nota**
Las condiciones de los valores se evalúan al invocar la [StartCommandExecution API](https://docs.aws.amazon.com//iot/latest/apireference/API_iot-jobs-data_StartCommandExecution.html). Las validaciones fallidas devuelven un error e impiden la creación de la ejecución.
### Prioridad y evaluación del valor del parámetro
Al iniciar la ejecución de comandos con plantillas de carga útil, los valores de los parámetros se resuelven con la siguiente prioridad:
1. **Parámetros de la solicitud de ejecución**: los valores proporcionados en la `StartCommandExecution` solicitud tienen la máxima prioridad
1. **Valores predeterminados del comando**: si no se proporciona un parámetro en la solicitud de ejecución, `defaultValue` se utiliza el parámetro
1. **Sin valor**: si no se proporciona ninguno, se produce un error en la ejecución, ya que es el parámetro necesario para generar la solicitud de ejecución
Las condiciones de valor se evalúan en función del valor final del parámetro obtenido anteriormente en función de la prioridad y antes de la creación de la ejecución. Si la validación falla, la solicitud de ejecución devuelve un error.
**Ejemplo: SetTemperature comando con `defaultValue`**
```
{
"parameters": [
{
"name": "temperature",
"type": "INTEGER",
"defaultValue": {"I": 72},
"valueConditions": [
{
"comparisonOperator": "IN_RANGE",
"operand": {"numberRange": {"min": "60", "max": "80"}}
}
]
}
]
}
```
Al iniciar la ejecución:
+ Si proporciona `"temperature": {"I": 75}` la solicitud, se utiliza 75
+ Si omite el parámetro de temperatura, se utilizará el valor predeterminado 72
+ Ambos valores se validan con respecto a la condición de rango [60,80]
## Estados de comando
Los comandos de su Cuenta de AWS ordenador pueden estar en uno de estos tres estados: *disponibles*, *obsoletos* o *pendientes* de eliminación.
**Disponible**
Una vez creado correctamente, un comando pasa al estado Disponible y se puede ejecutar en los dispositivos.
**Obsoleto**
Marque los comandos como obsoletos cuando ya no sean necesarios. Los comandos obsoletos no pueden iniciar nuevas ejecuciones, pero las ejecuciones pendientes siguen completándose. Para habilitar nuevas ejecuciones, restaure el comando al estado Disponible.
**Eliminación pendiente**
Al marcar un comando para su eliminación, se elimina automáticamente si está obsoleto durante más tiempo que el tiempo de espera máximo (predeterminado: 12 horas). Esta acción es permanente. Si no está en desuso o ha pasado un tiempo inferior al tiempo de espera, el comando pasa al estado de eliminación pendiente y se elimina una vez transcurrido el tiempo de espera.
## Estado de la ejecución del comando
Al iniciar una ejecución en un dispositivo de destino, entra en `CREATED` estado y puede pasar a otros estados en función de los informes del dispositivo. Puede recuperar la información de estado y realizar un seguimiento de las ejecuciones.
**nota**
Puede ejecutar varios comandos simultáneamente en un dispositivo. Utilice el control de simultaneidad para limitar las ejecuciones por dispositivo y evitar la sobrecarga. Para ver el número máximo de ejecuciones simultáneas por dispositivo, consulta las cuotas de [AWS IoT Device Management comandos](https://docs.aws.amazon.com/general/latest/gr/iot_device_management.html#commands-limits).
La siguiente tabla muestra los estados de ejecución y sus transiciones en función del progreso de la ejecución.
**Estado y origen de la ejecución de los comandos**
| Estado de la ejecución del comando | ¿Iniciado por un dispositivo o la nube? | ¿Ejecución final? | Transiciones de estado permitidas |
| --- | --- | --- | --- |
| CREATED | Cloud | No | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/iot-remote-command-concepts.html) |
| IN\$1PROGRESS | Dispositivo | No | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/iot-remote-command-concepts.html) |
| TIMED\$1OUT | Dispositivo y nube | No | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/iot-remote-command-concepts.html) |
| SUCCEEDED | Dispositivo | Sí | No aplicable |
| FAILED | Dispositivo | Sí | No aplicable |
| REJECTED | Dispositivo | Sí | No aplicable |
Los dispositivos pueden publicar actualizaciones de estado y resultados en cualquier momento mediante comandos reservados a los temas de MQTT. Para proporcionar un contexto adicional, los dispositivos pueden usar `reasonCode` `reasonDescription` campos en el `statusReason` objeto.
El siguiente diagrama muestra las transiciones del estado de ejecución.
![\[Imagen que muestra cómo el estado de ejecución de un comando pasa de un estado a otro\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/images/command-execution-status-transitions.png)
**nota**
Cuando no AWS IoT detecta ninguna respuesta del dispositivo dentro del período de tiempo de espera, se establece `TIMED_OUT` como un estado temporal que permite reintentos y cambios de estado. Si el dispositivo informa de forma explícita`TIMED_OUT`, se convierte en un estado terminal sin más transiciones. Para obtener más información, consulte [Ejecuciones de comandos no finales](#iot-command-execution-status-nonterminal).
En las siguientes secciones se describen las ejecuciones terminales y no terminales y sus estados.
**Topics**
+ [Ejecuciones de comandos no finales](#iot-command-execution-status-nonterminal)
+ [Ejecuciones de comandos finales](#iot-command-execution-status-terminal)
### Ejecuciones de comandos no finales
Una ejecución no es terminal si puede aceptar actualizaciones de dispositivos. *Las ejecuciones que no son terminales se consideran activas.* Los siguientes estados no son terminales:
+
**CREATED**
Cuando inicias una ejecución desde la AWS IoT consola o utilizas la `StartCommandExecution` API, las solicitudes correctas cambian el estado a. `CREATED` A partir de este estado, las ejecuciones pueden pasar a cualquier otro estado terminal o no terminal.
+
**IN\$1PROGRESS**
Tras recibir la carga útil, los dispositivos pueden empezar a ejecutar instrucciones y realizar acciones específicas. Durante la ejecución, los dispositivos pueden publicar las respuestas al tema de respuesta de los comandos y actualizar el estado a`IN_PROGRESS`. Desde`IN_PROGRESS`, las ejecuciones pueden pasar a cualquier estado terminal o no terminal, excepto`CREATED`.
**nota**
La `UpdateCommandExecution` API se puede invocar varias veces con el `IN_PROGRESS` estado. Especifique detalles de ejecución adicionales mediante el `statusReason` objeto.
+
**TIMED\$1OUT**
Tanto la nube como el dispositivo pueden activar este estado. Las ejecuciones en `CREATED` nuestro `IN_PROGRESS` estado pueden cambiar a `TIMED_OUT` uno por los siguientes motivos:
+ Tras enviar el comando, se inicia un temporizador. Si el dispositivo no responde dentro del tiempo especificado, la nube cambia de estado a`TIMED_OUT`. En este caso, la ejecución no es terminal.
+ El dispositivo puede cambiar el estado a cualquier estado de terminal o informar de un tiempo de espera y establecer el estado en. `TIMED_OUT` En este caso, el estado permanece`TIMED_OUT`, pero los campos del `StatusReason` objeto cambian en función de la información del dispositivo. La ejecución pasa a ser terminal.
Para obtener más información, consulte [Valor de tiempo de espera y estado de ejecución de `TIMED_OUT`](iot-remote-command-execution-start-monitor.md#iot-command-execution-timeout-status).
### Ejecuciones de comandos finales
Una ejecución se convierte en terminal cuando ya no acepta actualizaciones de los dispositivos. Los siguientes estados son finales. Las ejecuciones pueden pasar a estados de terminal desde cualquier estado no terminal:`CREATED`,`IN_PROGRESS`, o. `TIMED_OUT`
+
**SUCCEEDED**
Si el dispositivo completa la ejecución correctamente, puede publicar una respuesta en el tema de respuesta del comando y actualizar el estado a. `SUCCEEDED`
+
**ERROR**
Cuando un dispositivo no completa la ejecución, puede publicar una respuesta en el tema de respuesta al comando y actualizar el estado a`FAILED`. Utilice los `reasonDescription` campos `reasonCode` y del `statusReason` objeto, o CloudWatch los registros, para solucionar errores.
+
**REJECTED**
Cuando un dispositivo recibe una solicitud no válida o incompatible, puede invocar la `UpdateCommandExecution` API con el estado. `REJECTED` Usa los `reasonDescription` campos `reasonCode` y del `statusReason` objeto, o CloudWatch los registros, para solucionar problemas.
# Flujo de trabajo de comandos de
Este flujo de trabajo muestra cómo los dispositivos interactúan con AWS IoT Device Management los comandos. Todas las solicitudes de la API HTTP utilizan [credenciales Sigv4](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) para firmar.
![\[Descripción general del flujo de trabajo de alto nivel de los comandos del AWS IoT Device Management dispositivo.\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/images/device-command-workflow.png)
**Topics**
+ [Creación y administración de comandos](#command-create-command)
+ [Selección del dispositivo de destino para los comandos y suscripción a los temas de MQTT](#command-choose-target)
+ [Inicio y supervisión de las ejecuciones de comandos en el dispositivo de destino](#command-command-executions)
+ [(Opcional) Habilitación de las notificaciones para los eventos de comandos](#iot-remote-command-commands-notifications)
## Creación y administración de comandos
Para crear y administrar comandos para los dispositivos, siga los pasos que se indican a continuación.
1.
**Creación de un recurso de comandos**
Cree un comando desde el [centro de comandos](https://console.aws.amazon.com/iot/home#/commandHub) o mediante la [https://docs.aws.amazon.com/iot/latest/apireference/API_CreateCommand.html](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateCommand.html)API.
1.
**Especificación de la carga útil**
Proporcione una carga útil en cualquier formato. Especifique el tipo de contenido para garantizar una interpretación correcta del dispositivo.
En el caso de los comandos dinámicos con plantillas de carga útil, la carga útil final se genera en tiempo de ejecución con los parámetros proporcionados. Las plantillas solo admiten el formato JSON, pero la carga útil generada se puede enviar como JSON o CBOR.
1.
**(Opcional) Administración de los comandos creados**
Actualice el nombre para mostrar y la descripción después de la creación. Marque los comandos como obsoletos cuando ya no sean necesarios o elimínelos permanentemente. Para modificar la información de carga útil, crea un comando nuevo.
## Selección del dispositivo de destino para los comandos y suscripción a los temas de MQTT
Elija su dispositivo de destino y configure los temas de MQTT para recibir comandos y publicar respuestas.
1.
**Selección del dispositivo de destino para el comando**
Elija un dispositivo de destino para recibir y ejecutar el comando. Utilice un nombre de cosa para los dispositivos registrados o un ID de cliente para los dispositivos no registrados. Para obtener más información, consulte [Consideraciones sobre los dispositivos de destino](iot-remote-command-execution-start-monitor.md#iot-command-execution-target).
1.
**Configure la política de AWS IoT dispositivos**
Configure una política de IAM que conceda permisos para recibir ejecuciones y publicar actualizaciones. Consulte [Ejemplo de política de IAM](iot-remote-command-execution-start-monitor.md#iot-remote-command-execution-update-policy) para ver ejemplos de políticas.
1.
**Establecimiento de una conexión con MQTT**
Conecte los dispositivos al agente de mensajes y suscríbase a los temas de solicitud y respuesta. Los dispositivos necesitan `iot:Connect` permiso. Busque el punto final de su plano de datos mediante el comando `DescribeEndpoint` API o `describe-endpoint` CLI:
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Al ejecutar este comando, se devolverá el punto de conexión del plano de datos específico de la cuenta, tal como se muestra a continuación.
```
account-specific-prefix.iot.region.amazonaws.com
```
1.
**Suscríbase a los temas de comandos**
Suscríbase al tema de solicitud de comandos. Al iniciar una ejecución, el agente de mensajes publica la carga útil de este tema. El dispositivo recibe y procesa el comando.
(Opcional) Suscríbase a los temas de respuesta (`accepted`o`rejected`) para recibir confirmación de si el servicio en la nube ha aceptado o rechazado la respuesta del dispositivo.
En este ejemplo, sustituya:
+ *``* con `thing` o `client` en función de si el dispositivo al que se dirige se ha registrado como un objeto de IoT o se ha especificado como un cliente de MQTT.
+ *``* con el identificador único del dispositivo de destino. Este ID puede ser el ID único de cliente de MQTT o el nombre de un objeto.
**nota**
Si el tipo de carga útil no es JSON o CBOR, es posible que el ** campo no esté presente en el tema de solicitud de comandos. Para obtener el formato de carga útil, le recomendamos que lo utilice MQTT5 para obtener la información del formato de los encabezados de los mensajes de MQTT. Para obtener más información, consulte [Temas de comandos](reserved-topics.md#reserved-topics-commands).
```
$aws/commands///executions/+/request/
$aws/commands///executions/+/response/accepted/
$aws/commands///executions/+/response/rejected/
```
## Inicio y supervisión de las ejecuciones de comandos en el dispositivo de destino
Una vez creados los comandos y especificado los destinos del comando, puede iniciar la ejecución en el dispositivo de destino realizando los siguientes pasos.
1.
**Inicio de la ejecución de comandos en el dispositivo de destino**
Inicie la ejecución desde el [centro de comandos](https://console.aws.amazon.com/iot/home#/commandHub) o utilice la `StartCommandExecution` API con el punto final específico de su cuenta. Úselo `iot:Data-ATS` para doble pila (IPv4/IPv6) o `iot:Jobs` solo para. IPv4
La API publica la carga útil en el tema de solicitud de comandos.
**nota**
Si el dispositivo está desconectado y utiliza sesiones persistentes de MQTT, el comando espera en el intermediario de mensajes. Cuando el dispositivo se vuelva a conectar antes de que se agote el tiempo de espera, puede procesar el comando y publicar los resultados. Si se agota el tiempo de espera, se agota el tiempo de espera de la ejecución y se descarta la carga útil.
1.
**Actualización del resultado de la ejecución de comandos**
El dispositivo recibe la carga útil, procesa el comando, realiza las acciones especificadas y publica los resultados en el tema de respuesta a los comandos mediante una API basada en `UpdateCommandExecution` MQTT. Si se ha suscrito a los temas aceptados y rechazados, el dispositivo recibe la confirmación de si el servicio en la nube ha aceptado o rechazado la respuesta.
Según lo que haya especificado en el tema de la solicitud, ** pueden ser cosas o clientes, y ** puede ser su nombre o el AWS IoT ID de cliente de MQTT.
**nota**
Solo ** puede ser JSON o CBOR en el tema de respuesta a los comandos.
```
$aws/commands///executions//response/
```
1.
**(Opcional) Recuperación del resultado de la ejecución de comandos**
Recupere los resultados de la ejecución desde la AWS IoT consola o mediante`GetCommandExecution`. El dispositivo debe publicar los resultados en el tema de respuesta a los comandos para obtener la información más reciente. Vea detalles adicionales, incluida la hora de la última actualización, el resultado y la hora de finalización.
## (Opcional) Habilitación de las notificaciones para los eventos de comandos
Suscríbase a los eventos de Commands para recibir notificaciones cuando cambie el estado de ejecución. Para obtener información detallada sobre los eventos de ejecución de comandos, incluidos el formato del mensaje del evento y los atributos de carga útil, consulte[Eventos de ejecución de comandos](command-events.md).
1.
**Creación de una regla del tema**
Suscríbase al tema de eventos de comandos para ver las notificaciones de cambios de estado. Cree una regla temática para enrutar los datos del dispositivo a otros AWS IoT servicios AWS Lambda, como Amazon SQS y AWS Step Functions, mediante la AWS IoT consola o. [Crear una AWS IoT regla](iot-create-rule.md)
En este ejemplo, sustituya `` por el identificador del comando del que desea recibir notificaciones y `` por el estado de la ejecución del comando.
```
$aws/events/commandExecution//
```
**nota**
Para recibir notificaciones de todos los comandos y estados de ejecución de los comandos, puede utilizar caracteres comodín y suscribirse al tema siguiente.
```
$aws/events/commandExecution/+/#
```
1.
**Recepción y procesamiento de los eventos de comandos**
Administre los comandos, envíe notificaciones y cree aplicaciones utilizando los eventos suscritos.
En el siguiente código se muestra un ejemplo de carga útil para las notificaciones de eventos de comandos que recibirá.
```
{
"executionId": "2bd65c51-4cfd-49e4-9310-d5cbfdbc8554",
"status":"FAILED",
"statusReason": {
"reasonCode": "DEVICE_TOO_BUSY",
"reasonDescription": ""
},
"eventType": "COMMAND_EXECUTION",
"commandArn":"arn:aws:iot:us-east-1:123456789012:command/0b9d9ddf-e873-43a9-8e2c-9fe004a90086",
"targetArn":"arn:aws:iot:us-east-1:123456789012:thing/5006c3fc-de96-4def-8427-7eee36c6f2bd",
"timestamp":1717708862107
}
```
# Creación y administración de comandos
Utilice AWS IoT Device Management los comandos para configurar acciones remotas reutilizables o enviar instrucciones inmediatas a los dispositivos. Cree y gestione comandos desde la AWS IoT consola o mediante el AWS CLI.
**Topics**
+ [Creación de un recurso de comandos](#iot-remote-command-create)
+ [Recuperación de información sobre un comando](#iot-remote-command-get)
+ [Enumere los comandos de su Cuenta de AWS](#iot-remote-command-list)
+ [Actualización de un recurso de comandos](#iot-remote-command-update)
+ [Obsolescencia o restauración de un recurso de comandos](#iot-remote-command-deprecatecmd)
+ [Eliminación de un recurso de comandos](#iot-remote-command-delete)
## Creación de un recurso de comandos
Proporcione la siguiente información al crear un comando:
+
**Información general**
Proporcione un identificador de comando único para identificar el comando cuando lo ejecute en los dispositivos de destino. Si lo desea, especifique un nombre para mostrar, una descripción y etiquetas para la administración.
+ **Carga útil**
En el caso de los comandos estáticos, proporciona una carga útil que defina las acciones del dispositivo. Especifique el tipo de formato de carga útil para una interpretación correcta del dispositivo.
Para ver los comandos dinámicos, consulte el atributo de plantilla Payload.
+ **Plantilla de carga útil**
Para los comandos dinámicos, proporciona una plantilla de carga útil con marcadores de posición y parámetros. Si lo desea, proporcione una condición`defaultValue`. AWS IoT Device Management Los comandos sustituyen a los marcadores de posición en tiempo de ejecución. Los parámetros que faltan utilizan su DefaultValue. Todos los valores deben cumplir las condiciones definidas.
Se admiten los siguientes tipos de marcadores de posición que distinguen mayúsculas de minúsculas:
+ `${aws:iot:commandexecution::parameter:parameter1}`— Un marcador de posición para el valor de un parámetro con el nombre. `parameter1`
+ `${aws:iot:commandexecution::executionTimeoutSec}`— Un marcador de posición para el parámetro de tiempo de espera de ejecución del comando que se proporciona en tiempo de ejecución.
### Temas de comandos y carga útil
Comandos reservados Los temas utilizan un formato basado en el tipo de formato de carga útil.
+ Para nuestros `application/json` tipos de `application/cbor` contenido, utilice este tema de solicitud:
```
$aws/commands///executions/+/request/
```
+ Para otros tipos de contenido o formatos no especificados, utilice este tema de solicitud. El formato de carga útil aparece en el encabezado del mensaje MQTT.
```
$aws/commands///executions/+/request
```
El tema de respuesta a los comandos utiliza `json` o `cbor` formatea independientemente del tipo de carga útil. **debe ser `json` o`cbor`:
```
$aws/commands///executions//response/
```
### Creación de un recurso de comandos (consola)
En las siguientes secciones se describen las consideraciones sobre el formato de carga útil y la creación de comandos desde la consola.
**Topics**
+ [Formato de carga útil de comandos estáticos](#iot-commands-payload-format)
+ [Formato de carga útil de comandos dinámicos](#iot-commands-dynamic-payload-format)
+ [Cómo crear un comando (consola)](#iot-commands-console-how)
#### Formato de carga útil de comandos estáticos
La carga útil admite cualquier formato de hasta 32 KB. Especifique el tipo de formato de carga útil para una interpretación segura y correcta del dispositivo.
Especifique el tipo de formato de carga útil mediante el `type/subtype` formato (p. ej., `application/json` o`application/cbor`). Predeterminado: `application/octet-stream`. Consulta los [tipos MIME más comunes para ver los](https://developer.mozilla.org/en-US/docs/Web/HTTP/MIME_types/Common_types) formatos compatibles.
#### Formato de carga útil de comandos dinámicos
La plantilla de carga útil debe ser un archivo JSON válido con al menos un marcador de posición (32 KB como máximo).
En el caso `AwsJsonSubstitution` del preprocesador, AWS IoT Device Management Commands envía las notificaciones en formato JSON o CBOR en función de la configuración del preprocesador.
#### Cómo crear un comando (consola)
Para crear un comando desde la consola, vaya al [Centro de comandos](https://console.aws.amazon.com/iot/home#/commandHub) y siga estos pasos:
1. Seleccione **Crear comando**.
1. Especifique un ID de comando único.
1. (Opcional) Especifique el nombre para mostrar, la descripción y las etiquetas.
1. Cargue el archivo de carga útil que contiene las acciones del dispositivo. Especifique el tipo de formato de carga útil para una interpretación correcta del dispositivo.
1. (Opcional) En el caso de las plantillas de carga útil JSON con marcadores de posición, los parámetros se rellenan previamente en la tabla integrada para su edición.
1. (Opcional) Configure el tipo de valor del parámetro (obligatorio), el valor predeterminado y las condiciones.
1. Seleccione **Crear comando**.
### Creación de un recurso de comandos (CLI)
Utilice el comando [https://docs.aws.amazon.com/iot/latest/apireference/API_CreateCommand.html](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateCommand.html)API o [https://docs.aws.amazon.com/cli/latest/reference/iot/create-command.html](https://docs.aws.amazon.com/cli/latest/reference/iot/create-command.html)CLI para crear un comando.
**Topics**
+ [Carga útil de comandos](#iot-commands-payload)
+ [Ejemplo de política de IAM](#iot-remote-command-create-iam)
+ [Ejemplo de creación de comandos estáticos](#iot-remote-command-create-example)
+ [Ejemplo de creación dinámica de comandos](#iot-remote-dynamic-command-create-example)
#### Carga útil de comandos
Proporcione una carga útil estática o una plantilla de carga útil. Las cargas útiles estáticas están codificadas en base64. En el caso de las plantillas de carga útil, la carga útil final se genera en tiempo de ejecución mediante valores de parámetros. Los dispositivos procesan la carga útil y realizan acciones específicas. Especifique el tipo de contenido de la carga útil para una correcta recepción del dispositivo.
**nota**
Las cargas útiles no se pueden modificar después de la creación del comando. Crea un comando nuevo para modificar la carga útil.
#### Ejemplo de política de IAM
Antes de usar esta operación de la API, asegúrese de que la política de IAM le autorice a realizar esta acción en el dispositivo. A continuación, se muestra un ejemplo de una política de IAM que permite a un usuario realizar la acción `CreateCommand`.
En este ejemplo, sustituya:
+ `region` con la Región de AWS, como, por ejemplo, `us-east-1`.
+ `account-id` con el número de la Cuenta de AWS , como, por ejemplo `123456789012`.
+ `command-id`con un identificador único para su ID de AWS IoT comando, como`LockDoor`. Si desea enviar más de un comando, puede especificarlos en la sección *Recursos* de la política de IAM.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:CreateCommand",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/command-id"
}
}
```
#### Ejemplo de creación de comandos estáticos
El siguiente ejemplo muestra cómo se puede crear un comando estático. En función de la aplicación, sustituya:
+ *``* por un identificador único para el comando. Por ejemplo, para bloquear la puerta de su casa, puede especificarlo*`LockDoor`*. Le recomendamos que utilice UUID. También puede utilizar caracteres alfanuméricos, “-” y “\$1”.
+ (Opcional) *``* y *``*, que son campos opcionales que puede usar para proporcionar un nombre descriptivo y una descripción significativa para el comando, como, por ejemplo *`Lock the doors of my home`*.
+ `namespace`, que puede utilizar para especificar el espacio de nombres del comando. Debe ser `AWS-IoT`. Para obtener información sobre el uso de esta función AWS IoT FleetWise, consulte [Comandos remotos](https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/remote-commands.html)
+ `payload` incluye información sobre la carga útil que desea utilizar al ejecutar el comando y su tipo de contenido.
```
aws iot create-command \
--command-id \
--display-name \
--description \
--namespace AWS-IoT \
--payload '{"content":"eyAibWVzc2FnZSI6ICJIZWxsbyBJb1QiIH0=","contentType":"application/json"}'
```
La ejecución de este comando genera una respuesta que incluye el ID y el ARN (nombre de recurso de Amazon) del comando. Por ejemplo, si ha especificado el comando `LockDoor` durante la creación, a continuación se muestra un ejemplo del resultado de la ejecución del comando.
```
{
"commandId": "LockDoor",
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/LockDoor"
}
```
#### Ejemplo de creación dinámica de comandos
El siguiente ejemplo muestra cómo se puede crear un comando dinámico. En función de la aplicación, sustituya:
+ *``* por un identificador único para el comando. Por ejemplo, para establecer el estado de alimentación de la luz, puede especificarlo*`Light_Power_Status`*. Le recomendamos que utilice UUID. También puede utilizar caracteres alfanuméricos, “-” y “\$1”.
+ (Opcional) *``* y *``*, que son campos opcionales que puede usar para proporcionar un nombre descriptivo y una descripción significativa para el comando, como, por ejemplo *`Turn a light ON or OFF`*.
+ `namespace`, que puede utilizar para especificar el espacio de nombres del comando. Debe ser `AWS-IoT`. Para obtener información sobre el uso de esta función AWS IoT FleetWise, consulte [Comandos remotos](https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/remote-commands.html)
+ `payloadTemplate`contiene la plantilla de carga de reproducción en formato JSON con marcadores de posición.
+ `preprocessor`contiene la configuración del preprocesador que determina cómo se debe procesar la plantilla de carga útil.
+ `mandatoryParameter`contiene los parámetros correspondientes a los marcadores de posición de la plantilla de carga útil, su tipo, los valores predeterminados y las condiciones.
```
aws iot create-command \
--command-id Light_Power_Status \
--description "Turn a light ON or OFF" \
--namespace AWS-IoT \
--payload-template '{"powerStatus":"${aws:iot:commandexecution::parameter:powerStatus}"}' \
--preprocessor awsJsonSubstitution={outputFormat=JSON} \
--mandatory-parameters "name=powerStatus, defaultValue={S=OFF}, valueConditions=[{comparisonOperator=IN_SET, operand={strings=['ON','OFF']}}]"
```
La ejecución de este comando genera una respuesta que incluye el ID y el ARN (nombre de recurso de Amazon) del comando. Por ejemplo, si ha especificado el comando `Light_Power_Status` durante la creación, a continuación se muestra un ejemplo del resultado de la ejecución del comando.
```
{
"commandId": "Light_Power_Status",
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/Light_Power_Status"
}
```
## Recuperación de información sobre un comando
Tras crear un comando, puede recuperar información sobre este desde la consola de AWS IoT y mediante la AWS CLI. Puede obtener la siguiente información.
+ El ID del comando, el nombre de recurso de Amazon (ARN) y cualquier nombre y descripción visibles que haya especificado para el comando.
+ El estado del comando que indica si un comando está disponible para ejecutarse en el dispositivo de destino o si se va a quedar obsoleto o se va a eliminar.
+ La carga útil o la plantilla de carga útil que has proporcionado.
+ El preprocesador que ha proporcionado.
+ Los parámetros obligatorios que ha proporcionado.
+ El momento en que se creó el comando y se actualizó por última vez.
### Recuperación de un recurso de comandos (consola)
Para recuperar un comando de la consola, vaya al [centro de comandos](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT consola y, a continuación, elija el comando que creó para ver sus detalles.
Además de los detalles del comando, puede ver el historial de comandos, que proporciona información sobre las ejecuciones del comando en el dispositivo de destino. Tras ejecutar este comando en el dispositivo, encontrará información sobre las ejecuciones en esta pestaña.
### Recuperación de un recurso de comandos (CLI)
Usa la operación de la API del plano de control [https://docs.aws.amazon.com/iot/latest/apireference/API_GetCommand.html](https://docs.aws.amazon.com/iot/latest/apireference/API_GetCommand.html)HTTP o el [https://docs.aws.amazon.com/cli/latest/reference/get-command.html](https://docs.aws.amazon.com/cli/latest/reference/get-command.html) AWS CLI comando para recuperar información sobre un recurso de comando. Debe haber creado ya el comando mediante la solicitud de la API `CreateCommand` o de la CLI `create-command`.
#### Ejemplo de política de IAM
Antes de usar esta operación de la API, asegúrese de que la política de IAM le autorice a realizar esta acción en el dispositivo. A continuación, se muestra un ejemplo de una política de IAM que permite a un usuario realizar la acción `GetCommand`.
En este ejemplo, sustituya:
+ `region` con la Región de AWS, como, por ejemplo, `us-east-1`.
+ `account-id` con el número de la Cuenta de AWS , como, por ejemplo `123456789023`.
+ `command-id`con su identificador de comando AWS IoT único, como `LockDoor` o`Light_Power_Status`. Si desea recuperar más de un comando, puede especificarlos en la sección *Recursos* de la política de IAM.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:GetCommand",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/command-id"
}
}
```
#### Ejemplo de recuperación de un comando (AWS CLI)
En el siguiente ejemplo, se muestra cómo recuperar información sobre un comando mediante `get-command` AWS CLI. En función de la aplicación, sustituya *``* por el identificador del comando para el que desea recuperar la información. Puede obtener esta información de la respuesta de la CLI `create-command`.
```
aws iot get-command --command-id
```
Al ejecutar este comando, se genera una respuesta que incluye información sobre el comando, la carga útil y el momento de creación y de la última actualización. También proporciona información que indica si un comando ha quedado obsoleto o se va a eliminar.
En el siguiente código se muestra una respuesta de ejemplo.
```
{
"commandId": "LockDoor",
"commandArn": "arn:aws:iot:::command/LockDoor",
"namespace": "AWS-IoT",
"payload":{
"content": "eyAibWVzc2FnZSI6ICJIZWxsbyBJb1QiIH0=",
"contentType": "application/json"
},
"createdAt": "2024-03-23T00:50:10.095000-07:00",
"lastUpdatedAt": "2024-03-23T00:50:10.095000-07:00",
"deprecated": false,
"pendingDeletion": false
}
```
## Enumere los comandos de su Cuenta de AWS
Una vez que haya creado los comandos, podrá ver los comandos que ha creado en la cuenta. En la lista, puede encontrar información sobre:
+ El ID del comando y cualquier nombre para mostrar que haya especificado para los comandos.
+ El nombre de recurso de Amazon (ARN) de los comandos.
+ El estado del comando que indica si los comandos están disponibles para ejecutarse en el dispositivo de destino o si se van a quedar obsoletos.
**nota**
En la lista no se muestran los comandos que se van a eliminar de la cuenta. Si los comandos están pendientes de eliminación, aún puede ver los detalles de estos comandos mediante el ID de comando.
+ El momento en que se crearon los comandos y su última actualización.
### Enumeración de los comandos de la cuenta (consola)
En la AWS IoT consola, puedes encontrar la lista de comandos que has creado y sus detalles en el [Centro de Comandos](https://console.aws.amazon.com/iot/home#/commandHub).
### Enumeración de los comandos de la cuenta (CLI)
Para enumerar los comandos que ha creado, utilice la operación de la API [https://docs.aws.amazon.com/iot/latest/apireference/API_ListCommands.html](https://docs.aws.amazon.com/iot/latest/apireference/API_ListCommands.html) o la CLI [https://docs.aws.amazon.com/cli/latest/reference/iot/list-commands.html](https://docs.aws.amazon.com/cli/latest/reference/iot/list-commands.html).
#### Ejemplo de política de IAM
Antes de usar esta operación de la API, asegúrese de que la política de IAM le autorice a realizar esta acción en el dispositivo. A continuación, se muestra un ejemplo de una política de IAM que permite a un usuario realizar la acción `ListCommands`.
En este ejemplo, sustituya:
+ `region` con la Región de AWS, como, por ejemplo, `us-east-1`.
+ `account-id` con el número de la Cuenta de AWS , como, por ejemplo `123456789012`.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:ListCommands",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/*"
}
}
```
#### Ejemplo de enumeración de los comandos de la cuenta
En el siguiente comando se muestra cómo enumerar los comandos de la cuenta.
```
aws iot list-commands --namespace "AWS-IoT"
```
Al ejecutar este comando, se genera una respuesta que incluye una lista de los comandos que ha creado, el momento de creación de los comandos y su última actualización. También proporciona información sobre el estado del comando, que indica si un comando ha quedado obsoleto o si está disponible para ejecutarse en el dispositivo de destino. Para obtener más información sobre los distintos estados y el motivo del estado, consulte [Estado de la ejecución del comando](iot-remote-command-concepts.md#iot-command-execution-status).
## Actualización de un recurso de comandos
Una vez creado un comando, puede actualizar el nombre para mostrar y la descripción del comando.
**nota**
No se puede actualizar la carga útil del comando. Para actualizar esta información o usar una carga útil modificada, tendrá que crear un comando nuevo.
### Actualización de un recurso de comandos (consola)
Para actualizar un comando desde la consola, vaya al [centro de comandos](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT consola y lleve a cabo los siguientes pasos.
1. Para actualizar un recurso de comandos existente, elija el comando que desee actualizar y, a continuación, en **Acciones**, seleccione **Editar**.
1. Especifique un nombre para mostrar, una descripción y cualquier par de nombre y valor como etiquetas para el comando.
1. Seleccione **Editar** para guardar el comando con la nueva configuración.
### Actualización de un recurso de comandos (CLI)
Utilice la operación API del plano de [https://docs.aws.amazon.com/iot/latest/apireference/API_UpdateCommand.html](https://docs.aws.amazon.com/iot/latest/apireference/API_UpdateCommand.html)control o la [https://docs.aws.amazon.com/cli/latest/reference/iot/update-command.html](https://docs.aws.amazon.com/cli/latest/reference/iot/update-command.html) AWS CLI para actualizar un recurso de comandos. Con esta API, podrá:
+ Editar el nombre para mostrar y la descripción de un comando que haya creado.
+ Dar de baja un recurso de comandos o restaurar un comando que ya haya quedado obsoleto.
#### Ejemplo de política de IAM
Antes de usar esta operación de la API, asegúrese de que la política de IAM le autorice a realizar esta acción en el dispositivo. A continuación, se muestra un ejemplo de una política de IAM que permite a un usuario realizar la acción `UpdateCommand`.
En este ejemplo, sustituya:
+ `region` con la Región de AWS, como, por ejemplo, `us-east-1`.
+ `account-id` con el número de la Cuenta de AWS , como, por ejemplo `123456789012`.
+ `command-id` con el identificador único del comando de AWS IoT , como, por ejemplo, `LockDoor`. Si desea recuperar más de un comando, puede especificarlos en la sección *Recursos* de la política de IAM.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:UpdateCommand",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/command-id"
}
}
```
#### Ejemplos de actualización de la información sobre un comando (AWS CLI)
El siguiente ejemplo muestra cómo actualizar la información sobre un comando mediante el `update-command` AWS CLI comando. Para obtener más información sobre cómo usar esta API para dar de baja o restaurar un recurso de comandos, consulte [Actualización de un recurso de comandos (CLI)](iot-remote-command-deprecate.md#iot-remote-command-deprecate-cli).
En el ejemplo se muestra cómo se puede actualizar el nombre para mostrar y la descripción de un comando. En función de la aplicación, sustituya *``* por el identificador del comando para el que desea recuperar la información.
```
aws iot update-command \
--command-id
--displayname \
--description
```
Al ejecutar este comando, se genera una respuesta que incluye información sobre el comando y el momento de su última actualización. En el siguiente código se muestra un ejemplo de solicitud y respuesta para actualizar el nombre para mostrar y la descripción de un comando que desactiva la CA.
```
aws iot update-command \
--command-id \
--displayname \
--description
```
La ejecución de este comando genera la siguiente respuesta.
```
{
"commandId": "LockDoor",
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/LockDoor",
"displayName": "Secondary lock door",
"description": "Locks doors to my home",
"lastUpdatedAt": "2024-05-09T23:15:53.899000-07:00"
}
```
## Obsolescencia o restauración de un recurso de comandos
Una vez creado un comando, si ya no desea seguir utilizándolo, puede marcarlo como obsoleto. Al marcar como obsoleto un comando, todas las ejecuciones de comandos pendientes seguirán ejecutándose en el dispositivo de destino hasta que alcancen el estado final. Una vez que un comando haya quedado obsoleto, si quiere usarlo, por ejemplo, para enviar una nueva ejecución de comando al dispositivo de destino, debe restaurarlo.
**nota**
No puede editar un comando obsoleto ni ejecutarlo. Para ejecutar nuevos comandos en el dispositivo, debe restaurarlo para que el estado del comando cambie a *Disponible*.
Para obtener información adicional sobre la obsolescencia y la restauración de un comando, así como otros aspectos que hay que tener en cuenta, consulte [Obsolescencia de un recurso de comandos](iot-remote-command-deprecate.md).
## Eliminación de un recurso de comandos
Si ya no quiere usar un comando, puede eliminarlo permanentemente de la cuenta. Si la acción de eliminación se realiza correctamente:
+ Si el comando ha quedado obsoleto durante un periodo superior al tiempo de espera máximo de 12 horas, se eliminará inmediatamente.
+ Si el comando no ha quedado obsoleto o ha dejado de utilizarse durante un periodo inferior al tiempo de espera máximo, el comando pasará al estado `pending deletion`. Se eliminará automáticamente de la cuenta una vez transcurrido el tiempo de espera máximo de 12 horas.
**nota**
Es posible que el comando se elimine incluso si hay alguna ejecución pendiente de ejecución. El comando estará en un estado pendiente de eliminación y se eliminará automáticamente de la cuenta.
### Eliminación de un recurso de comandos (consola)
Para eliminar un comando de la consola, vaya al [centro de comandos](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT consola y lleve a cabo los siguientes pasos.
1. Elija el comando que desea eliminar y, a continuación, en **Acciones** y elija **Eliminar**.
1. Confirme que desea eliminar el comando y, a continuación, seleccione **Eliminar**.
El comando se marcará para su eliminación y se eliminará permanentemente de la cuenta después de 12 horas.
### Eliminación de un recurso de comandos (CLI)
Utilice la operación API del plano de control `DeleteCommand` HTTP o el `delete-command` AWS CLI comando para eliminar un recurso de comando. Si la acción de eliminación se realiza correctamente, aparecerá un `statusCode` de HTTP de 204 o 202 y el comando se eliminará automáticamente de la cuenta una vez transcurrido el tiempo máximo de espera de 12 horas. En el caso del estado 204, indica que el comando se ha eliminado.
#### Ejemplo de política de IAM
Antes de usar esta operación de la API, asegúrese de que la política de IAM le autorice a realizar esta acción en el dispositivo. A continuación, se muestra un ejemplo de una política de IAM que permite a un usuario realizar la acción `DeleteCommand`.
En este ejemplo, sustituya:
+ `region` con la Región de AWS, como, por ejemplo, `us-east-1`.
+ `account-id` con el número de la Cuenta de AWS , como, por ejemplo `123456789012`.
+ `command-id` con el identificador único del comando de AWS IoT , como, por ejemplo, `LockDoor`. Si desea recuperar más de un comando, puede especificarlos en la sección *Recursos* de la política de IAM.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:DeleteCommand",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/command-id"
}
}
```
#### Ejemplo de eliminación de un comando (AWS CLI)
Los siguientes ejemplos muestran cómo eliminar un comando mediante el `delete-command` AWS CLI comando. En función de la aplicación, sustituya *``* por el identificador del comando que vaya a eliminar.
```
aws iot delete-command --command-id
```
Si la solicitud a la API se realiza correctamente, el comando generará un código de estado 202 o 204. Puede usar la API `GetCommand` para comprobar que el comando ya no existe en la cuenta.
# Inicio y supervisión de las ejecuciones de comandos
Después de crear un comando, inicie una ejecución en el dispositivo de destino. El dispositivo actualiza los resultados y publica el estado en los temas reservados de MQTT. Recupera y supervisa el estado de ejecución de tu cuenta.
Inicie y supervise los comandos mediante la AWS IoT consola o AWS CLI.
**Topics**
+ [Inicio de la ejecución de un comando](#iot-remote-command-execution-start)
+ [Actualización del resultado de la ejecución de un comando](#iot-remote-command-execution-update)
+ [Recuperación de la ejecución de un comando](#iot-remote-command-execution-get)
+ [Visualización de actualizaciones de comandos mediante el cliente de prueba de MQTT](#iot-remote-command-execution-update-mqtt)
+ [Enumera las ejecuciones de comandos en tu Cuenta de AWS](#iot-remote-command-execution-list)
+ [Eliminación de una ejecución de comandos](#iot-remote-command-execution-delete)
## Inicio de la ejecución de un comando
**importante**
Usted es el único responsable de implementar los comandos de forma segura y que cumpla con las normativas aplicables.
Antes de iniciar una ejecución, asegúrese de que:
+ Creó un comando en el espacio de AWS IoT nombres con la información de carga útil. Al iniciar la ejecución, el dispositivo procesa las instrucciones de carga útil y realiza acciones específicas. Consulte la [Creación de un recurso de comandos](iot-remote-command-create-manage.md#iot-remote-command-create) sección Creación de comandos.
+ Su dispositivo está suscrito a los temas reservados para comandos de MQTT. Al iniciar la ejecución, la información sobre la carga útil se publica en este tema reservado de solicitud de MQTT:
**pueden ser clientes Things o MQTT. **es el nombre de la cosa o el ID de cliente. **Valores admitidos: JSON y CBOR. Para obtener más información, consulte [Temas de comandos](reserved-topics.md#reserved-topics-commands).
```
$aws/commands///executions/+/request/
```
Si no es JSON/CBOR**, utilice este formato de tema de comandos:
```
$aws/commands///executions/+/request
```
### Consideraciones sobre los dispositivos de destino
Especifique el dispositivo de destino para recibir y ejecutar el comando. Utilice un nombre de cosa para los dispositivos registrados o un ID de cliente para los dispositivos no registrados. Tras recibir la carga útil, el dispositivo ejecuta el comando y realiza las acciones especificadas.
#### AWS IoT cosa
Los dispositivos de destino pueden ser cosas registradas en el AWS IoT registro. Las cosas simplifican la búsqueda y la administración de los dispositivos.
Registre los dispositivos como Cosas desde la [página Connect device](https://console.aws.amazon.com/iot/home#/connect-overview) o utilizando [https://docs.aws.amazon.com/iot/latest/apireference/API_CreateThing.html](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateThing.html). Encuentra cosas existentes en [Thing Hub](https://console.aws.amazon.com/iot/home#/thinghub) o usándolas [https://docs.aws.amazon.com/iot/latest/apireference/API_DescribeThing.html](https://docs.aws.amazon.com/iot/latest/apireference/API_DescribeThing.html). Consulte [Administrar cosas con el registro](https://docs.aws.amazon.com/iot/latest/developerguide/thing-registry) para obtener información sobre el registro.
#### ID de cliente
En el caso de los dispositivos no registrados, utilice el ID de cliente.
El ID de cliente es un identificador único que se asigna a los dispositivos. Definido en el protocolo MQTT, contiene caracteres alfanuméricos, guiones bajos o guiones. Cada dispositivo al que se conecta AWS IoT necesita un ID de cliente único.
**nota**
En el caso de las cosas registradas, el ID de cliente puede coincidir con el nombre de la cosa.
Al dirigirse a un ID de cliente específico, los dispositivos deben conectarse AWS IoT utilizando ese ID de cliente para recibir la carga útil.
El ID de cliente es el ID de cliente de MQTT que utilizan los dispositivos al conectarse. AWS IoT Core AWS IoT usa este ID para identificar los dispositivos y administrar las conexiones y suscripciones.
### Consideraciones sobre el tiempo de espera de ejecución de comandos
El tiempo de espera especifica el tiempo (en segundos) que tardan los dispositivos en proporcionar los resultados de la ejecución.
Tras crear una ejecución, se inicia un temporizador. Si el dispositivo se desconecta o no informa de los resultados dentro del tiempo de espera, la ejecución se agota con el estado`TIMED_OUT`.
Predeterminado: 10 segundos. Máximo: 12 horas.
#### Valor de tiempo de espera y estado de ejecución de `TIMED_OUT`
Tanto la nube como el dispositivo pueden informar sobre el tiempo de espera.
Tras enviar el comando, se inicia un temporizador. Si el dispositivo no responde dentro del tiempo de espera, la nube establece el estado de ejecución `TIMED_OUT` con el código `$NO_RESPONSE_FROM_DEVICE` de motivo.
Esto ocurre cuando:
+ El dispositivo se desconectó durante la ejecución.
+ El dispositivo no pudo completar la ejecución dentro del tiempo de espera.
+ El dispositivo no pudo informar sobre su estado dentro del tiempo de espera.
En este caso, cuando se informa del estado de ejecución de `TIMED_OUT` desde la nube, la ejecución del comando es no final. El dispositivo puede publicar una respuesta que sustituya el estado por cualquiera de los estados del terminal:`SUCCEEDED`,, `FAILED` o. `REJECTED` La ejecución del comando pasa entonces a ser terminal y no acepta más actualizaciones.
El dispositivo también puede actualizar un `TIMED_OUT` estado iniciado por la nube informando de que se ha agotado el tiempo de espera al ejecutar el comando. En este caso, el estado de ejecución del comando permanece en`TIMED_OUT`, pero el `statusReason` objeto se actualiza en función de la información proporcionada por el dispositivo. La ejecución del comando pasa entonces a ser terminal y no se aceptan más actualizaciones.
#### Uso de las sesiones persistentes de MQTT
Puede configurar las sesiones persistentes de MQTT para utilizarlas con la función de AWS IoT Device Management comandos. Esta característica resulta especialmente útil en casos en los que el dispositivo se queda sin conexión y quiere asegurarse de que el dispositivo siga recibiendo el comando cuando vuelve a conectarse antes de que se agote el tiempo de espera y siga las instrucciones especificadas.
De forma predeterminada, la caducidad de la sesión persistente de MQTT está establecida en 60 minutos. Si el tiempo de espera de ejecución de comandos está configurado en un valor que supera esta duración, el agente de mensajes puede rechazar las ejecuciones de comandos que se ejecuten durante más de 60 minutos y producir un error. Para ejecutar comandos de más de 60 minutos de duración, puede solicitar un aumento del tiempo de caducidad de la sesión persistente.
**nota**
Para asegurarse de que está utilizando correctamente la función de sesiones persistentes de MQTT, establezca el indicador de inicio limpio en cero. Para obtener más información, consulte [Sesiones persistentes de MQTT](https://docs.aws.amazon.com/iot/latest/developerguide/mqtt.html#mqtt-persistent-sessions).
### Inicio de la ejecución de un comando (consola)
Para empezar a ejecutar el comando desde la consola, vaya a la página [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT consola y lleve a cabo los siguientes pasos.
1. Para ejecutar el comando que ha creado, elija **Ejecutar comando**.
1. Revise la información sobre el comando que creó, incluidos los temas reservados de MQTT y los parámetros, si corresponde.
En el caso de los comandos dinámicos, introduzca los valores de los parámetros o déjelos con los valores predeterminados. Para los parámetros que no tienen un valor predeterminado, debe proporcionar un valor para enviarlo como parte de esta ejecución.
1. Especifique el dispositivo de destino para recibir y ejecutar el comando. El dispositivo se puede especificar como una AWS IoT cosa si se ha registrado AWS IoT o mediante el ID de cliente si el dispositivo aún no se ha registrado. Para obtener más información, consulte [Consideraciones sobre los dispositivos de destino](#iot-command-execution-target)
1. (Opcional) Configure un valor de tiempo de espera para el comando que determine el tiempo durante el que desea que se ejecute el comando antes de que se agote el tiempo de espera. Si el comando debe ejecutarse durante más de 60 minutos, puede que tenga que aumentar el tiempo de caducidad de las sesiones persistentes de MQTT. Para obtener más información, consulte [Consideraciones sobre el tiempo de espera de ejecución de comandos](#iot-command-execution-timeout).
1. Elija **Run command (Ejecutar comando)**.
### Inicio de la ejecución de un comando (AWS CLI)
Utilice la operación de la API del plano de datos [https://docs.aws.amazon.com/iot/latest/apireference/API_StartCommandExecution.html](https://docs.aws.amazon.com/iot/latest/apireference/API_StartCommandExecution.html) HTTP para iniciar la ejecución de un comando. La solicitud y la respuesta de la API se correlacionan mediante el ID de ejecución del comando. Una vez que el dispositivo termine de ejecutar el comando, puede informar del estado y el resultado de la ejecución a la nube publicando un mensaje en el tema de respuesta del comando. Para un código de respuesta personalizado, los códigos de aplicación que poseas pueden procesar el mensaje de respuesta y publicar el resultado en él. AWS IoT
Si los dispositivos se han suscrito al tema de solicitud de comandos, la API `StartCommandExecution`I publicará el mensaje de carga útil en ese tema. La carga útil puede usar cualquier formato de su elección. Para obtener más información, consulte [Carga útil de comandos](iot-remote-command-create-manage.md#iot-commands-payload).
```
$aws/commands///executions/+/request/
```
Si el formato de carga útil no es JSON ni CBOR, a continuación se muestra el formato del tema de solicitud de comandos.
```
$aws/commands///executions/+/request
```
#### Ejemplo de política de IAM
Antes de usar esta operación de la API, asegúrese de que la política de IAM le autorice a realizar esta acción en el dispositivo. A continuación, se muestra un ejemplo de una política de IAM que permite a un usuario realizar la acción `StartCommandExecution`.
En este ejemplo, sustituya:
+ `region` con la Región de AWS, como, por ejemplo, `us-east-1`.
+ `account-id` con el número de la Cuenta de AWS , como, por ejemplo `123456789012`.
+ `command-id`con un identificador único para el AWS IoT comando, como. `LockDoor` Si desea enviar más de un comando, puede especificarlos en la política de IAM.
+ `devices`con `thing` o en `client` función de si sus dispositivos se han registrado como AWS IoT cosas o se han especificado como clientes MQTT.
+ `device-id`con tu AWS IoT `thing-name` o. `client-id`
```
{
"Effect": "Allow",
"Action": [
"iot:StartCommandExecution"
],
"Resource": [
"arn:aws:iot:region:account-id:command/command-id",
"arn:aws:iot:region:account-id:devices/device-id"
]
}
```
Para ver una lista de las claves de condición compatibles`StartCommandExecution`, consulte [las claves de condición AWS IoT](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-policy-keys) en la *Guía del usuario de IAM*.
#### Obtención del punto de conexión del plano de datos específico de la cuenta
Antes de ejecutar el comando de la API, debe obtener la URL del punto de conexión específico de la cuenta para el punto de conexión. Si utiliza puntos finales de doble pila (IPv4y IPv6), utilice el. `iot:Data-ATS` El `iot:Jobs` punto final es solo para. IPv4 Por ejemplo, si ejecuta este comando:
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Devuelve la URL del punto final específica de la cuenta, como se muestra en el ejemplo de respuesta que aparece a continuación.
```
{
"endpointAddress":
"-ats.iot..api.com"
}
```
#### Ejemplo de inicio de la ejecución de un comando (AWS CLI)
En el siguiente ejemplo, se muestra cómo empezar a ejecutar un comando mediante el `start-command-execution` AWS CLI comando.
En este ejemplo, sustituya:
+ *``* con el ARN del comando que desee ejecutar. Puede obtener esta información de la respuesta del comando `create-command` de la CLI. Por ejemplo, si está ejecutando el comando para cambiar el modo de volante, utilice `arn:aws:iot:region:account-id:command/SetComfortSteeringMode`.
+ *``* con el ARN del objeto del dispositivo de destino, que puede ser un objeto de IoT o un cliente de MQTT, para el que desee ejecutar el comando. Por ejemplo, si está ejecutando el comando para el dispositivo de destino `myRegisteredThing`, utilice `arn:aws:iot:region:account-id:thing/myRegisteredThing`.
+ *``* con el punto de conexión específico de la cuenta que ha obtenido en [Obtención del punto de conexión del plano de datos específico de la cuenta](#iot-remote-command-execution-start-endpoint), con el prefijo `https://`. Por ejemplo, `https://123456789012abcd.jobs.iot.us-east-1.amazonaws.com`.
+ (Opcional) También puede especificar un parámetro adicional, `executionTimeoutSeconds`, al realizar la operación de la API`StartCommandExecution`. Este campo opcional especifica el tiempo en segundos dentro del cual el dispositivo debe completar la ejecución del comando. De forma predeterminada, el valor es 10 segundos. Cuando el estado de ejecución del comando sea `CREATED`, se iniciará un temporizador. Si el resultado de la ejecución del comando no se recibe antes de que caduque el temporizador, el estado cambiará automáticamente a `TIMED_OUT`.
+
```
aws iot-jobs-data start-command-execution \
--command-arn \
--target-arn \
--endpoint \
--execution-timeout-seconds 900
```
+ (Opcional) En el caso de los comandos dinámicos, especifique los parámetros y sus valores que se utilizarán para la sustitución. Debe proporcionar un valor para los parámetros que no tengan un DefaultValue establecido al crear el comando. Si un parámetro tiene un DefaultValue, el valor del parámetro que se proporciona aquí tiene prioridad. En el caso de los parámetros que tienen definidas las condiciones de valor, el valor del parámetro que se proporciona aquí debe cumplir la condición.
Basado en el ejemplo de `Light_Power_Status` un comando dinámico:
+
```
aws iot-jobs-data start-command-execution \
--command-arn arn:aws:iot:us-east-1:123456789012:command/Light_Power_Status \
--target-arn arn:aws:iot:us-east-1:123456789012:thing/exampleThing \
--endpoint \
--execution-timeout-seconds 900 \
--parameters "powerStatus={S=ON}"
```
La ejecución de este comando devuelve un ID de ejecución del comando. Puede usar este ID para consultar el estado de ejecución del comando, los detalles y el historial de ejecución del comando.
**nota**
Si el comando ha quedado obsoleto, se producirá un error en la solicitud de la API `StartCommandExecution` con una excepción de validación. Para corregir este error, primero restaure el comando mediante la API `UpdateCommand` y, a continuación, ejecute la solicitud `StartCommandExecution`.
```
{
"executionId": "07e4b780-7eca-4ffd-b772-b76358da5542"
}
```
## Actualización del resultado de la ejecución de un comando
Utilice la operación de la API del plano de datos de MQTT `UpdateCommandExecution` para actualizar el estado o el resultado de la ejecución de un comando.
**nota**
Antes de usar esta API:
El dispositivo debe haber establecido una conexión de MQTT y estar suscrito a los temas de solicitud y respuesta de comandos. Para obtener más información, consulte [Flujo de trabajo de comandos de](iot-remote-command-workflow.md).
Ya debe haber ejecutado este comando mediante la operación de la API `StartCommandExecution`.
### Ejemplo de política de IAM
Antes de usar esta operación de la API, asegúrese de que la política de IAM autorice al dispositivo a realizar estas acciones. A continuación, se muestra un ejemplo de política que autoriza al dispositivo a realizar la acción. Para ver ejemplos adicionales de políticas de IAM que permiten al usuario realizar la acción de `UpdateCommandExecution` MQTT, consulte. [Ejemplos de políticas de conexión y publicación](connect-and-pub.md)
En este ejemplo, sustituya:
+ `Region`con las tuyas Región de AWS, por ejemplo. `us-east-1`
+ `AccountID` con el número de la Cuenta de AWS , como, por ejemplo *`123456789012`*.
+ `ThingName`con el nombre de la AWS IoT cosa a la que apunta la ejecución del comando, por ejemplo*`myRegisteredThing`*.
+ `commands-request-topic`y `commands-response-topic` con los nombres de los temas de solicitud y respuesta de sus AWS IoT comandos. Para obtener más información, consulte [Flujo de trabajo de comandos de](iot-remote-command-workflow.md).
#### Ejemplo de política de IAM para el ID de cliente de MQTT
En el siguiente ejemplo de código se muestra una política de dispositivo de ejemplo cuando se utiliza el ID de cliente de MQTT.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Publish",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/response",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/response/json"
]
},
{
"Effect": "Allow",
"Action": "iot:Receive",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/request",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/response/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/response/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/request/json",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/response/accepted/json",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/clients/${iot:ClientId}/executions/*/response/rejected/json"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/clients/${iot:ClientId}/executions/+/request",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/clients/${iot:ClientId}/executions/+/response/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/clients/${iot:ClientId}/executions/+/response/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/clients/${iot:ClientId}/executions/+/request/json",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/clients/${iot:ClientId}/executions/+/response/accepted/json",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/clients/${iot:ClientId}/executions/+/response/rejected/json"
]
},
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/${iot:ClientId}"
}
]
}
```
#### Ejemplo de política de IAM para un objeto de IoT
En el siguiente ejemplo de código se muestra una política de dispositivo de ejemplo cuando se utiliza un objeto de AWS IoT .
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Publish",
"Resource": "arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/response"
},
{
"Effect": "Allow",
"Action": "iot:Receive",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/request",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/response/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/response/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/request/json",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/response/accepted/json",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/*/response/rejected/json"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/+/request",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/+/response/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/+/response/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/+/request/json",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/+/response/accepted/json",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/commands/things/${iot:Connection.Thing.ThingName}/executions/+/response/rejected/json"
]
},
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/${iot:ClientId}"
}
]
}
```
### Cómo utilizar la API `UpdateCommandExecution`
Una vez recibida la ejecución del comando en el tema de solicitud, el dispositivo procesará el comando. A continuación, utiliza la API `UpdateCommandExecution` para actualizar el estado y el resultado de la ejecución del comando en el siguiente tema de respuesta.
```
$aws/commands///executions//response/
```
En este ejemplo, *``* es el identificador único del dispositivo de destino y *``* es el identificador de la ejecución del comando en el dispositivo de destino. **Pueden ser JSON o CBOR.
**nota**
Si no has registrado tu dispositivo AWS IoT, puedes usar el ID de cliente como identificador en lugar del nombre de una cosa.
```
$aws/commands/clients//executions//response/
```
#### Actualizaciones en el estado de ejecución indicadas por el dispositivo
Los dispositivos pueden usar la API para informar sobre cualquiera de las siguientes actualizaciones de estado relacionadas con la ejecución de un comando. Para obtener más información sobre estos estados, consulte [Estado de la ejecución del comando](iot-remote-command-concepts.md#iot-command-execution-status).
+ `IN_PROGRESS`: cuando el dispositivo comience a ejecutar el comando, podrá actualizar el estado a `IN_PROGRESS`.
+ `SUCCEEDED`: cuando el dispositivo procese correctamente el comando y termine de ejecutarlo, podrá publicar un mensaje en el tema de respuesta como `SUCCEEDED`.
+ `FAILED`: si el dispositivo no ha podido ejecutar el comando, puede publicar un mensaje en el tema de respuesta como `FAILED`.
+ `REJECTED`: si el dispositivo no ha podido aceptar el comando, puede publicar un mensaje en el tema de respuesta como `REJECTED`.
+ `TIMED_OUT`: el estado de ejecución del comando puede cambiar a `TIMED_OUT` debido a cualquiera de los siguientes motivos.
+ No se ha recibido el resultado de la ejecución del comando. Esto puede ocurrir porque la ejecución no se ha completado en el plazo especificado o si el dispositivo no ha podido publicar la información de estado en el tema de respuesta.
+ El dispositivo indica que se ha agotado el tiempo de espera al intentar ejecutar el comando.
Para obtener más información sobre el estado `TIMED_OUT`, consulte [Valor de tiempo de espera y estado de ejecución de `TIMED_OUT`](#iot-command-execution-timeout-status).
#### Consideraciones sobre el uso de la API `UpdateCommandExecution`
A continuación, se indican algunas consideraciones importantes a la hora de utilizar la API `UpdateCommandExecution`.
+ Sus dispositivos pueden usar un `statusReason` objeto opcional para proporcionar información adicional sobre la ejecución. Si sus dispositivos proporcionan este objeto, el `reasonCode` campo del objeto es obligatorio, pero el `reasonDescription` campo es opcional.
+ Cuando los dispositivos utilicen el `statusReason` objeto, `reasonCode` deberán utilizar el patrón `[A-Z0-9_-]+` y no superar los 64 caracteres de longitud. Si lo proporciona`reasonDescription`, asegúrese de que no supere los 1024 caracteres de longitud. Puede utilizar cualquier carácter excepto los caracteres de control, como las líneas nuevas.
+ Los dispositivos pueden usar un objeto de `result` opcional para proporcionar información sobre el resultado de la ejecución del comando, como, por ejemplo, el valor devuelto por una llamada a una función remota. Si proporciona el `result`, debe requerir al menos una entrada.
+ En el campo `result`, debe especificar las entradas como pares de clave-valor. En cada entrada, debe especificar la información del tipo de datos en forma de cadena, booleano o binario. Un tipo de datos de cadena debe usar la clave `s`, un tipo de datos booleano usa la clave `b` y un tipo de datos binario debe usar la clave `bin`. Asegúrese de que estas teclas estén en minúsculas.
+ Si encuentras un error al ejecutar la `UpdateCommandExecution` API, puedes ver el error en el grupo de `AWSIoTLogsV2` registros de Amazon CloudWatch. Para obtener más información sobre la habilitación de registros y la visualización de los registros, consulte [Configure el AWS IoT registro](configure-logging.md).
#### Ejemplo de la API `UpdateCommandExecution`
En el código siguiente se muestra un ejemplo de cómo un dispositivo puede utilizar la API `UpdateCommandExecution` para informar del estado de la ejecución, el campo `statusReason` para proporcionar información adicional sobre el estado y el campo de resultados para proporcionar información sobre el resultado de la ejecución, como, por ejemplo, el porcentaje de batería del automóvil en este caso.
```
{
"status": "IN_PROGRESS",
"statusReason": {
"reasonCode": "200",
"reasonDescription": "Execution_in_progress"
},
"result": {
"car_battery": {
"s": "car battery at 50 percent"
}
}
}
```
## Recuperación de la ejecución de un comando
Tras ejecutar un comando, puede recuperar información sobre la ejecución del comando desde la AWS IoT consola y mediante el AWS CLI. Puede obtener la siguiente información.
**nota**
Para recuperar el último estado de ejecución del comando, el dispositivo debe publicar la información de estado en el tema de respuesta mediante la API de MQTT `UpdateCommandExecution`, tal y como se describe a continuación. Hasta que el dispositivo publique este tema, la API `GetCommandExecution` indicará el estado como `CREATED` o `TIMED_OUT`.
Cada ejecución de comando que cree tendrá:
+ Un **ID de ejecución**, que es un identificador único de la ejecución del comando.
+ El **Estado** de la ejecución del comando. Al ejecutar el comando en el dispositivo de destino, la ejecución del comando entra en un estado `CREATED`. A continuación, puede pasar a otros estados de ejecución de comandos, tal y como se describe a continuación.
+ El **Resultado** de la ejecución del comando.
+ El **ID de comando** único y el dispositivo de destino para el que se han creado las ejecuciones.
+ La **Fecha de inicio**, que muestra el momento en que se creó la ejecución del comando.
### Recuperación de la ejecución de un comando (consola)
Puede recuperar una ejecución del comando desde la consola mediante cualquiera de los siguientes métodos.
+
**Desde la página Centro de comandos**
Vaya a la página [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT consola y lleve a cabo estos pasos.
1. Elija el comando para el que ha creado una ejecución en el dispositivo de destino.
1. En la página de detalles del comando, en la pestaña **Historial de comandos**, aparecerán las ejecuciones que ha creado. Elija la ejecución de la que desee recuperar información.
1. Si los dispositivos han utilizado la API `UpdateCommandExecution` para proporcionar la información de los resultados, puede encontrar esta información en la pestaña **Resultados** de esta página.
+
**Desde la página Centro de objetos**
Si has elegido AWS IoT algo como dispositivo de destino al ejecutar el comando, puedes ver los detalles de la ejecución en la página Thing Hub.
1. Ve a la página [Thing Hub](https://console.aws.amazon.com/iot/home#/thinghub) de la AWS IoT consola y elige el objeto para el que has creado la ejecución del comando.
1. En la página de detalles del objeto, en la opción **Historial de comandos**, aparecerán las ejecuciones que ha creado. Elija la ejecución de la que desee recuperar información.
1. Si los dispositivos han utilizado la API `UpdateCommandExecution` para proporcionar la información de los resultados, puede encontrar esta información en la pestaña **Resultados** de esta página.
### Recuperación de la ejecución de un comando (CLI)
Utilice la operación de la API HTTP del plano de [https://docs.aws.amazon.com/iot/latest/apireference/API_GetCommandExecution.html](https://docs.aws.amazon.com/iot/latest/apireference/API_GetCommandExecution.html) AWS IoT Core control para recuperar información sobre la ejecución de un comando. Ya debe haber ejecutado este comando mediante la operación de la API `StartCommandExecution`.
#### Ejemplo de política de IAM
Antes de usar esta operación de la API, asegúrese de que la política de IAM le autorice a realizar esta acción en el dispositivo. A continuación, se muestra un ejemplo de una política de IAM que permite a un usuario realizar la acción `GetCommandExecution`.
En este ejemplo, sustituya:
+ `region` con la Región de AWS, como, por ejemplo, `us-east-1`.
+ `account-id` con el número de la Cuenta de AWS , como, por ejemplo `123456789012`.
+ `command-id`con su identificador de AWS IoT comando único, como`LockDoor`.
+ `devices`con `thing` o en `client` función de si sus dispositivos se han registrado como AWS IoT cosas o se han especificado como clientes MQTT.
+ `device-id`con tu AWS IoT `thing-name` o. `client-id`
```
{
"Effect": "Allow",
"Action": [
"iot:GetCommandExecution"
],
"Resource": [
"arn:aws:iot:region:account-id:command/command-id",
"arn:aws:iot:region:account-id:devices/device-id"
]
}
```
#### Ejemplo de recuperación de la ejecución de un comando
El siguiente ejemplo muestra cómo recuperar información sobre un comando que se ejecutó con el `start-command-execution` AWS CLI comando. En el siguiente ejemplo se muestra cómo puede recuperar información sobre un comando que se ha ejecutado para desactivar el modo volante.
En este ejemplo, sustituya:
+ *``* con el identificador de la ejecución del comando del que desea recuperar información.
+ *``* con el nombre de recurso de Amazon (ARN) del dispositivo al que se dirige la ejecución. Puede obtener esta información de la respuesta del comando `start-command-execution` de la CLI.
+ Si lo desea, si los dispositivos han utilizado la API `UpdateCommandExection` para proporcionar el resultado de la ejecución, puede especificar si desea incluir el resultado de la ejecución del comando en la respuesta de la API `GetCommandExecution` mediante la API `GetCommandExecution`.
```
aws iot get-command-execution
--execution-id \
--target-arn \
--include-result
```
La ejecución de este comando genera una respuesta que incluye información sobre el ARN de la ejecución del comando, el estado de la ejecución y el momento en que se inició y finalizó. También proporciona un objeto de `statusReason` que incluye información adicional sobre el estado. Para obtener más información sobre los distintos estados y el motivo del estado, consulte [Estado de la ejecución del comando](iot-remote-command-concepts.md#iot-command-execution-status).
En el siguiente código se muestra un ejemplo de respuesta de la solicitud de la API.
**nota**
El campo `completedAt` de la respuesta de ejecución corresponde al momento en que el dispositivo informa a la nube de un estado final. En el caso de un estado `TIMED_OUT`, este campo solo se configurará cuando el dispositivo indique que se ha agotado el tiempo de espera. Cuando la nube establece el estado `TIMED_OUT`, no se actualizará el estado `TIMED_OUT`. Para obtener más información sobre el comportamiento del tiempo de espera, consulte [Consideraciones sobre el tiempo de espera de ejecución de comandos](#iot-command-execution-timeout).
```
{
"executionId": "07e4b780-7eca-4ffd-b772-b76358da5542",
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/LockDoor",
"targetArn": "arn:aws:iot:us-east-1:123456789012:thing/myRegisteredThing",
"status": "SUCCEEDED",
"statusReason": {
"reasonCode": "DEVICE_SUCCESSFULLY_EXECUTED",
"reasonDescription": "SUCCESS"
},
"result": {
"sn": { "s": "ABC-001" },
"digital": { "b": true }
},
"createdAt": "2024-03-23T00:50:10.095000-07:00",
"completedAt": "2024-03-23T00:50:10.095000-07:00"
}
```
## Visualización de actualizaciones de comandos mediante el cliente de prueba de MQTT
Puede usar el cliente de prueba de MQTT para ver el intercambio de mensajes a través de MQTT cuando se utiliza la característica de comandos. Una vez que el dispositivo establezca una conexión MQTT con AWS IoT, puede crear un comando, especificar la carga útil y, a continuación, ejecutarlo en el dispositivo. Al ejecutar el comando, si el dispositivo está suscrito al tema de solicitud reservada de comandos de MQTT, verá el mensaje de carga publicado en este tema.
A continuación, el dispositivo recibe las instrucciones de carga útil y realiza las operaciones especificadas en el dispositivo. AWS IoT A continuación, utiliza la `UpdateCommandExecution` API para publicar el resultado de la ejecución del comando y la información de estado en los temas de respuesta reservados de MQTT para los comandos. AWS IoT Device Management escucha las actualizaciones sobre los temas de respuesta, almacena la información actualizada y publica los registros en Amazon CloudWatch. AWS CloudTrail A continuación, puede recuperar la información más reciente sobre la ejecución de comandos desde la consola o mediante la `GetCommandExecution` API.
En los siguientes pasos se muestra cómo usar el cliente de prueba de MQTT para observar los mensajes.
1. Abra el [cliente de pruebas de MQTT](https://console.aws.amazon.com/iot/home#/test) en la AWS IoT consola.
1. En la pestaña **Suscribirse**, introduzca el siguiente tema y, a continuación, seleccione **Suscribirse**, que ** es el nombre del dispositivo con AWS IoT el que se ha registrado.
**nota**
Puedes encontrar el nombre del dispositivo en la página [Thing Hub](https://console.aws.amazon.com/iot/home#/thinghub) de la AWS IoT consola. Si no has registrado el dispositivo como una cosa, puedes registrarlo al conectarte a AWS IoT desde la [página Conectar dispositivo](https://console.aws.amazon.com/iot/home#/connect-overview).
```
$aws/commands/things//executions/+/request
```
1. (Opcional) En la pestaña **Suscribirse**, también puede introducir los siguientes temas y seleccionar **Suscribirse**.
```
$aws/commands/things/+/executions/+/response/accepted/json
$aws/commands/things/+/executions/+/response/rejected/json
```
1. Después de iniciar la ejecución del comando, la carga útil del mensaje se enviará al dispositivo mediante el tema de solicitud al que se ha suscrito el dispositivo, `$aws/commands/things//executions/+/request`. En el cliente de prueba de MQTT, debería aparecer la carga útil del comando que incluye las instrucciones para que el dispositivo procese el comando.
1. Una vez que el dispositivo comience a ejecutar el comando, podrá publicar actualizaciones de estado en el siguiente tema de respuesta reservado de MQTT para comandos.
```
$aws/commands///executions//response/json
```
Por ejemplo, considere un comando que ejecutó para encender el aire acondicionado del automóvil y reducir la temperatura al valor deseado. En el siguiente JSON se muestra un mensaje de ejemplo que el vehículo publicó en el tema de respuesta, en el que se indica que no pudo ejecutar el comando.
```
{
"deviceId": "My_Car",
"executionId": "07e4b780-7eca-4ffd-b772-b76358da5542",
"status": "FAILED",
"statusReason": {
"reasonCode": "CAR_LOW_ON_BATTERY",
"reasonDescription": "Car battery is lower than 5 percent"
}
}
```
En este caso, puede cargar la batería del automóvil y volver a ejecutar el comando.
## Enumera las ejecuciones de comandos en tu Cuenta de AWS
Tras ejecutar un comando, puede recuperar información sobre la ejecución del comando desde la AWS IoT consola y mediante el AWS CLI. Puede obtener la siguiente información.
+ Un **ID de ejecución**, que es un identificador único de la ejecución del comando.
+ El **Estado** de la ejecución del comando. Al ejecutar el comando en el dispositivo de destino, la ejecución del comando entra en un estado `CREATED`. A continuación, puede pasar a otros estados de ejecución de comandos, tal y como se describe a continuación.
+ El **ID de comando** único y el dispositivo de destino para el que se han creado las ejecuciones.
+ La **Fecha de inicio**, que muestra el momento en que se creó la ejecución del comando.
### Enumeración de las ejecuciones de comandos de la cuenta (consola)
Puede ver todas las ejecuciones de comandos desde la consola mediante cualquiera de los siguientes métodos.
+
**Desde la página Centro de comandos**
Vaya a la página [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT consola y lleve a cabo estos pasos.
1. Elija el comando para el que ha creado una ejecución en el dispositivo de destino.
1. En la página de detalles del comando, vaya a la pestaña **Historial de comandos** y aparecerá una lista de las ejecuciones que ha creado.
+
**Desde la página Centro de objetos**
Si has elegido un AWS IoT objeto como dispositivo de destino al ejecutar el comando y has creado varias ejecuciones de comandos para un solo dispositivo, puedes ver las ejecuciones del dispositivo en la página Thing Hub.
1. Ve a la página [Thing Hub](https://console.aws.amazon.com/iot/home#/thinghub) de la AWS IoT consola y elige el objeto para el que has creado las ejecuciones.
1. En la página de detalles del objeto, en la opción **Historial de comandos**, aparecerá una lista de las ejecuciones que ha creado para el dispositivo.
### Enumeración de las ejecuciones de comandos de la cuenta (CLI)
Utilice la operación de la API HTTP del plano de [https://docs.aws.amazon.com/iot/latest/apireference/API_ListCommandExecutions.html](https://docs.aws.amazon.com/iot/latest/apireference/API_ListCommandExecutions.html) AWS IoT Core control para enumerar todas las ejecuciones de comandos en su cuenta.
#### Ejemplo de política de IAM
Antes de usar esta operación de la API, asegúrese de que la política de IAM le autorice a realizar esta acción en el dispositivo. A continuación, se muestra un ejemplo de una política de IAM que permite a un usuario realizar la acción `ListCommandExecutions`.
En este ejemplo, sustituya:
+ `region` con la Región de AWS, como, por ejemplo, `us-east-1`.
+ `account-id` con el número de la Cuenta de AWS , como, por ejemplo `123456789012`.
+ `command-id`con su identificador de AWS IoT comando único, como`LockDoor`.
```
{
"Effect": "Allow",
"Action": "iot:ListCommandExecutions",
"Resource": *
}
```
#### Ejemplo de enumeración de las ejecuciones de comandos
En el siguiente ejemplo se muestra cómo enumerar las ejecuciones de comandos en la Cuenta de AWS.
Al ejecutar el comando, debe especificar si desea filtrar la lista para que muestre únicamente las ejecuciones de comandos que se hayan creado para un determinado dispositivo mediante el `targetArn` o las ejecuciones de un determinado comando especificado mediante el `commandArn`.
En este ejemplo, sustituya:
+ *``* con el nombre de recurso de Amazon (ARN) del dispositivo al que se dirige la ejecución, como, por ejemplo, `arn:aws:iot:us-east-1:123456789012:thing/b8e4157c98f332cffb37627f`.
+ *``* con el nombre de recurso de Amazon (ARN) del dispositivo al que se dirige la ejecución, como, por ejemplo, `arn:aws:iot:us-east-1:123456789012:thing/b8e4157c98f332cffb37627f`.
+ *``* con el tiempo transcurrido a partir del cual desea enumerar las ejecuciones que se crearon, por ejemplo, `2024-11-01T03:00`.
```
aws iot list-command-executions \
--target-arn \
--started-time-filter '{after=}' \
--sort-order "ASCENDING"
```
Al ejecutar este comando, se genera una respuesta que incluye una lista de las ejecuciones de comandos que ha creado, el momento en que las ejecuciones comenzaron a ejecutarse y el momento en que finalizaron. También proporciona información sobre el estado, así como el objeto de `statusReason` que incluye información adicional sobre el estado.
```
{
"commandExecutions": [
{
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/TestMe002",
"executionId": "b2b654ca-1a71-427f-9669-e74ae9d92d24",
"targetArn": "arn:aws:iot:us-east-1:123456789012:thing/b8e4157c98f332cffb37627f",
"status": "TIMED_OUT",
"createdAt": "2024-11-24T14:39:25.791000-08:00",
"startedAt": "2024-11-24T14:39:25.791000-08:00"
},
{
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/TestMe002",
"executionId": "34bf015f-ef0f-4453-acd0-9cca2d42a48f",
"targetArn": "arn:aws:iot:us-east-1:123456789012:thing/b8e4157c98f332cffb37627f",
"status": "IN_PROGRESS",
"createdAt": "2024-11-24T14:05:36.021000-08:00",
"startedAt": "2024-11-24T14:05:36.021000-08:00"
}
]
}
```
Para obtener más información sobre los distintos estados y el motivo del estado, consulte [Estado de la ejecución del comando](iot-remote-command-concepts.md#iot-command-execution-status).
## Eliminación de una ejecución de comandos
Si ya no quiere usar una ejecución de comandos, puede eliminarla permanentemente de la cuenta.
**nota**
La ejecución de un comando solo se puede eliminar si ha pasado a un estado final, como, por ejemplo, `SUCCEEDED`, `FAILED` o `REJECTED`.
Esta operación solo se puede realizar mediante la AWS IoT Core API o la AWS CLI. No está disponible en la consola.
### Ejemplo de política de IAM
Antes de usar esta operación de la API, asegúrese de que la política de IAM autorice al dispositivo a realizar estas acciones. A continuación, se muestra un ejemplo de política que autoriza al dispositivo a realizar la acción.
En este ejemplo, sustituya:
+ `Region`con tu Región de AWS, como`us-east-1`.
+ `AccountID` con el número de la Cuenta de AWS , como, por ejemplo *`123456789012`*.
+ `CommandID` con el identificador del comando para el que desea eliminar la ejecución.
+ `devices`con `thing` o en `client` función de si sus dispositivos se han registrado como AWS IoT cosas o se han especificado como clientes MQTT.
+ `device-id`con tu AWS IoT `thing-name` o. `client-id`
```
{
"Effect": "Allow",
"Action": [
"iot:DeleteCommandExecution"
],
"Resource": [
"arn:aws:iot:region:account-id:command/command-id",
"arn:aws:iot:region:account-id:devices/device-id"
]
}
```
### Ejemplo de eliminación de una ejecución de comandos
En el siguiente ejemplo, se muestra cómo eliminar un comando mediante el `delete-command` AWS CLI comando. Según la aplicación, sustituya *``* por el identificador de la ejecución del comando que va a eliminar y el *``* por el ARN del dispositivo de destino.
```
aws iot delete-command-execution \
--execution-id \
--target-arn
```
Si la solicitud a la API se realiza correctamente, la ejecución de comandos generará un código de estado 200. Puede usar la API `GetCommandExecution` para comprobar que la ejecución de comandos ya no existe en la cuenta.
# Obsolescencia de un recurso de comandos
Desactive los comandos para indicar que están desactualizados y no deben usarse. Por ejemplo, desactive los comandos que ya no se mantienen de forma activa o al crear comandos más nuevos con el mismo identificador pero con diferentes cargas útiles.
## Consideraciones clave
Consideraciones importantes a la hora de dejar de usar comandos:
+ La desaprobación de un comando no lo elimina. Puede recuperar el comando con su ID y restaurarlo para volver a utilizarlo.
+ Al intentar iniciar nuevas ejecuciones de comandos obsoletos, se genera un error que impide el uso de comandos obsoletos.
+ Para ejecutar un comando obsoleto, restáurelo primero. Tras la restauración, el comando estará disponible para su uso y ejecución habituales en los dispositivos de destino.
+ Si desaprueba un comando mientras las ejecuciones están en curso, seguirán ejecutándose hasta que se complete. Aún puede recuperar el estado de ejecución.
## Obsolescencia de un recurso de comandos (consola)
Para anular un comando de la consola, vaya al [centro de comandos](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT consola y lleve a cabo los siguientes pasos.
1. **Elija el comando que desee desaprobar y, a continuación, en **Acciones**, elija Depredar.**
1. Confirme que desea dar de baja el comando y, a continuación, seleccione **Dejar de utilizar**.
## Obsolescencia de un recurso de comandos (CLI)
Marque los comandos como obsoletos mediante la `update-command` CLI. Debe desaprobar un comando antes de eliminarlo. Para usar un comando obsoleto, restaúrelo primero.
```
aws iot update-command \
--command-id \
--deprecated
```
Por ejemplo, si ha dado de baja el comando `ACSwitch` que actualizó en el ejemplo anterior, en el código siguiente se muestra un ejemplo del resultado de la ejecución del comando.
```
{
"commandId": "turnOffAc",
"deprecated": true,
"lastUpdatedAt": "2024-05-09T23:16:51.370000-07:00"
}
```
## Comprobación del tiempo y el estado de obsolescencia
Usa la `GetCommand` API para determinar si un comando está obsoleto y cuándo fue obsoleto por última vez.
```
aws iot get-command --command-id
```
Este comando genera una respuesta que contiene información sobre el comando, incluidas las marcas de tiempo de creación y obsolescencia del último campo actualizado. Esto ayuda a determinar la duración del comando y si se debe eliminar o reutilizar. A continuación, se muestra un ejemplo de respuesta para el `turnOffAc` comando:
```
{
"commandId": "turnOffAC",
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/turnOffAC",
"namespace": "AWS-IoT",
"payload": {
"content": "testPayload.json",
"contentType": "application/json"
},
"createdAt": "2024-03-23T00:50:10.095000-07:00",
"lastUpdatedAt": "2024-05-09T23:16:51.370000-07:00",
"deprecated": false
}
```
## Restauración de un recurso de comando
Para usar o enviar el `ACSwitch` comando a su dispositivo, restaúrelo primero.
Para restaurar un comando desde la consola, ve al [centro de comandos](https://console.aws.amazon.com/iot/home#/commandHub) de la AWS IoT consola, elige el comando que deseas restaurar y, a continuación, en **Acciones**, selecciona **Restaurar**.
Para restaurar un comando mediante la AWS IoT Core API o la AWS CLI, utilice la operación `UpdateCommand` API o la `update-command` CLI. En el siguiente código se muestra una solicitud y una respuesta de ejemplo.
```
aws iot update-command \
--command-id
--no-deprecated
```
En el siguiente código se muestra un resultado de ejemplo.
```
{
"commandId": "ACSwitch",
"deprecated": false,
"lastUpdatedAt": "2024-05-09T23:17:21.954000-07:00"
}
```