Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# AWS IoT Device Management comandi
**Importante**
Questa documentazione descrive come utilizzare la [funzionalità dei comandi in AWS IoT Device Management](https://docs.aws.amazon.com/iot/latest/developerguide/iot-remote-command-concepts.html#command-iot-namespace). Per informazioni sull'utilizzo di questa funzionalità per AWS IoT FleetWise, consulta [Comandi remoti](https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/remote-commands.html).
L'utente è l'unico responsabile della distribuzione dei comandi in modo sicuro e conforme alle leggi applicabili. Per ulteriori informazioni sulle tue responsabilità, consulta i [Termini di AWS servizio per i servizi](https://aws.amazon.com/service-terms/). AWS IoT
Usa AWS IoT Device Management i comandi per inviare un'istruzione dal cloud a un dispositivo a cui è connesso AWS IoT. I comandi sono indirizzati a un dispositivo alla volta e possono essere utilizzati per applicazioni a bassa latenza e ad alto rendimento, come il recupero dei log lato dispositivo o l'avvio di una modifica dello stato del dispositivo.
*Il comando è una risorsa riutilizzabile gestita da.* AWS IoT Device Management Contiene configurazioni che vengono applicate prima di essere pubblicate sul dispositivo. È possibile predefinire un set di comandi per casi d'uso specifici, come l'accensione di una lampadina o lo sblocco della portiera di un veicolo.
La funzionalità AWS IoT Comandi consente di:
+ Crea modelli di comandi riutilizzabili con payload statici o dinamici, quindi eseguili su dispositivi specifici.
+ Dispositivi di destinazione registrati come AWS IoT oggetti o client MQTT non registrati.
+ Esegui più comandi contemporaneamente sullo stesso dispositivo.
+ Abilita le notifiche degli eventi e monitora lo stato di esecuzione man mano che i dispositivi elaborano i comandi.
I seguenti argomenti mostrano come creare comandi, inviarli al dispositivo e recuperare lo stato riportato dal dispositivo.
**Topics**
+ [Avvio rapido](iot-commands-quickstart.md)
+ [Comandi, concetti e stato](iot-remote-command-concepts.md)
+ [Flusso di lavoro dei comandi di alto livello](iot-remote-command-workflow.md)
+ [Crea e gestisci i comandi](iot-remote-command-create-manage.md)
+ [Avvia e monitora le esecuzioni di comandi](iot-remote-command-execution-start-monitor.md)
+ [Deprecare una risorsa di comando](iot-remote-command-deprecate.md)
# Avvio rapido
Completa questi passaggi per inviare il primo comando:
1. **Prerequisiti**: assicurati di aver effettuato l'onboarding su IoT Core, un dispositivo connesso a IoT Core, le autorizzazioni IAM per le operazioni dell'API Commands e una libreria client MQTT installata sul tuo dispositivo.
1. **Crea un comando**: definisci un comando con un payload statico o un modello di payload che specifica le azioni del dispositivo. Per informazioni, consulta [Crea una risorsa di comando](iot-remote-command-create-manage.md#iot-remote-command-create).
1. **Identifica il tuo dispositivo**: registra il tuo dispositivo come dispositivo IoT o annota il suo ID client MQTT. Per informazioni, consulta [Considerazioni sul dispositivo di destinazione](iot-remote-command-execution-start-monitor.md#iot-command-execution-target).
1. **Configura le autorizzazioni**: configura le politiche IAM che consentono al dispositivo di ricevere comandi e pubblicare risposte.
1. **Sottoscrizione agli argomenti**: configura il dispositivo per sottoscrivere gli argomenti relativi alla richiesta e alla risposta dei comandi. Per informazioni, consulta [Scegliete il dispositivo di destinazione per i vostri comandi e iscrivetevi agli argomenti MQTT](iot-remote-command-workflow.md#command-choose-target).
1. **Esegui il comando**: avvia l'esecuzione del comando sul dispositivo di destinazione. Per informazioni, consulta [Avvia l'esecuzione di un comandoAvvia l'esecuzione di un comando (console)Avviare l'esecuzione di un comando ()AWS CLI](iot-remote-command-execution-start-monitor.md#iot-remote-command-execution-start).
**Casi d'uso comuni:**
+ *Diagnostica remota*: recupero dei registri, esecuzione della diagnostica, controllo dello stato del dispositivo
+ *Aggiornamenti della configurazione*: modifica delle impostazioni, aggiornamento dei parametri, attivazione delle funzionalità
+ *Controllo del dispositivo* -Lock/unlock, power on/off, modifiche alla modalità
# Comandi, concetti e stato
Usa AWS IoT i comandi per inviare istruzioni dal cloud ai dispositivi connessi. Per utilizzare questa funzionalità:
1. Crea un comando con un payload contenente le configurazioni necessarie per l'esecuzione sul dispositivo.
1. Specificate il dispositivo di destinazione che riceverà il payload ed eseguirà le azioni.
1. Esegui il comando sul dispositivo di destinazione e recupera le informazioni sullo stato. Per risolvere i problemi, consulta i log. CloudWatch
Per ulteriori informazioni su questo flusso di lavoro, consulta [Flusso di lavoro dei comandi di alto livello](iot-remote-command-workflow.md).
**Topics**
+ [Comandi, concetti chiave](#iot-command-concepts)
+ [Stati dei comandi](#iot-command-states)
+ [Stato di esecuzione del comando](#iot-command-execution-status)
## Comandi, concetti chiave
I seguenti concetti chiave aiutano a comprendere la funzionalità Comandi. I termini vengono utilizzati in modo coerente in tutta la presente documentazione:
+ *Comando*: un modello riutilizzabile che definisce le istruzioni del dispositivo
+ *Esecuzione*: istanza di un comando in esecuzione su un dispositivo
+ *Nome dell'oggetto*: identificatore per i dispositivi registrati nel registro IoT
+ *Client ID*: identificatore MQTT per dispositivi non registrati
+ *Payload*: i dati delle istruzioni inviati ai dispositivi
+ *Argomento* - Canale MQTT per la comunicazione dei comandi
**Comandi**
I comandi sono istruzioni inviate dal cloud ai dispositivi IoT come messaggi MQTT. Dopo aver ricevuto il payload, i dispositivi elaborano le istruzioni e intraprendono le azioni corrispondenti, come la modifica delle impostazioni di configurazione, la trasmissione delle letture dei sensori o il caricamento dei log. I dispositivi restituiscono quindi i risultati al cloud, abilitando il monitoraggio e il controllo remoti.
**Spazio dei nomi**
Quando crei un comando, specifica il relativo namespace. Per AWS IoT Device Management i comandi, utilizzate lo spazio dei `AWS-IoT` nomi predefinito e fornite un payload o un payloadTemplate. Per AWS IoT FleetWise i comandi, utilizzate lo spazio dei nomi. `AWS-IoT-FleetWise` Per ulteriori informazioni, consulta [Comandi remoti nella Guida](https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/remote-commands.html) per gli *AWS IoT FleetWise sviluppatori*.
**Carico utile**
Quando create un comando, fornite un payload statico che definisca le azioni che il dispositivo deve eseguire. Il payload può utilizzare qualsiasi formato supportato. Per garantire che i dispositivi interpretino correttamente il payload, consigliamo di specificare il tipo di formato del payload. I dispositivi che utilizzano il MQTT5 protocollo possono seguire lo standard MQTT per identificare il formato. Gli indicatori di formato per JSON o CBOR sono disponibili nell'argomento relativo alla richiesta dei comandi.
**Modello di payload**
Un modello di payload definisce un payload di comandi con segnaposti che generano payload diversi in fase di esecuzione in base ai valori dei parametri forniti dall'utente. Ad esempio, anziché creare payload separati per valori di temperatura diversi, create un modello con un segnaposto di temperatura e specificate il valore durante l'esecuzione. Ciò elimina il mantenimento di più payload simili.
**Dispositivo di destinazione**
Per eseguire un comando, specificate un dispositivo di destinazione utilizzando il nome dell'oggetto (per i dispositivi registrati con AWS IoT) o l'ID client MQTT (per i dispositivi non registrati). L'ID client è un identificatore univoco definito nel [MQTT](mqtt.md) protocollo utilizzato per connettere i dispositivi a. AWS IoT Per informazioni dettagliate, vedi [Considerazioni sul dispositivo di destinazione](iot-remote-command-execution-start-monitor.md#iot-command-execution-target).
**Argomenti sui comandi**
Prima di eseguire un comando, i dispositivi devono sottoscrivere l'argomento relativo alla richiesta dei comandi. Quando si esegue un comando, il payload viene inviato al dispositivo su questo argomento. Dopo l'esecuzione, i dispositivi pubblicano i risultati e lo stato nell'argomento di risposta ai comandi. Per ulteriori informazioni, consulta [Argomenti sui comandi](reserved-topics.md#reserved-topics-commands).
**Esecuzione dei comandi**
Un'esecuzione è un'istanza di un comando in esecuzione su un dispositivo di destinazione. Quando si avvia un'esecuzione, il payload viene consegnato al dispositivo e viene generato un ID di esecuzione univoco. Il dispositivo esegue il comando e segnala l'avanzamento a. AWS IoT La logica lato dispositivo determina il comportamento di esecuzione e la segnalazione dello stato su argomenti riservati.
### Condizioni relative al valore dei parametri
Quando create comandi con modelli di payload, definite le condizioni di valore per convalidare i valori dei parametri prima dell'esecuzione. Le condizioni di valore garantiscono che i parametri soddisfino i requisiti, impedendo esecuzioni non valide.
**Operatori supportati per tipo [CommandParameterValue](https://docs.aws.amazon.com//iot/latest/apireference/API_CommandParameterValue.html)**
**Tipi numerici (INTEGER, LONG, DOUBLE, UNSIGNEDLONG)**
+ `EQUALS`- Il valore deve essere uguale al numero specificato
+ `NOT_EQUALS`- Il valore non deve essere uguale al numero specificato
+ `GREATER_THAN`- Il valore deve essere maggiore del numero specificato
+ `GREATER_THAN_EQUALS`- Il valore deve essere maggiore o uguale al numero specificato
+ `LESS_THAN`- Il valore deve essere inferiore al numero specificato
+ `LESS_THAN_EQUALS`- Il valore deve essere inferiore o uguale al numero specificato
+ `IN_RANGE`- Il valore deve rientrare nell'intervallo specificato (incluso)
+ `NOT_IN_RANGE`- Il valore deve essere al di fuori dell'intervallo specificato (incluso)
+ `IN_SET`- Il valore deve corrispondere a uno dei numeri specificati
+ `NOT_IN_SET`- Il valore non deve corrispondere a nessuno dei numeri specificati
**Tipo di stringa (STRING)**
+ `EQUALS`- Il valore deve essere uguale alla stringa specificata
+ `NOT_EQUALS`- Il valore non deve essere uguale alla stringa specificata
+ `IN_SET`- Il valore deve corrispondere a una delle stringhe specificate
+ `NOT_IN_SET`- Il valore non deve corrispondere a nessuna delle stringhe specificate
**Tipo booleano**
+ Le condizioni relative ai valori non sono supportate
**Tipo binario**
+ Le condizioni relative ai valori non sono supportate
**Esempio: comando di controllo della 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"
}
}
}
]
}
]
}
```
In questo esempio, il `temperature` parametro deve essere compreso tra 60 e 80 (inclusi). Le richieste di esecuzione con valori al di fuori di questo intervallo non vengono convalidate.
**Nota**
[Le condizioni di valore vengono valutate al richiamo dell'API. StartCommandExecution ](https://docs.aws.amazon.com//iot/latest/apireference/API_iot-jobs-data_StartCommandExecution.html) Le convalide non riuscite restituiscono un errore e impediscono la creazione dell'esecuzione.
### Valore dei parametri, priorità e valutazione.
Quando si avviano le esecuzioni dei comandi con modelli di payload, i valori dei parametri vengono risolti utilizzando la seguente priorità:
1. **Parametri della richiesta di esecuzione**: i valori forniti nella `StartCommandExecution` richiesta hanno la massima priorità
1. **Valori predefiniti del comando**: se non viene fornito un parametro nella richiesta di esecuzione, `defaultValue` viene utilizzato quello del parametro
1. **Nessun valore**: se non viene fornito nessuno dei due, l'esecuzione ha esito negativo come parametro richiesto per generare la richiesta di esecuzione
Le condizioni di valore vengono valutate in base al valore finale del parametro derivato in precedenza, sulla priorità e prima della creazione dell'esecuzione. Se la convalida fallisce, la richiesta di esecuzione restituisce un errore.
**Esempio: SetTemperature comando con `defaultValue`**
```
{
"parameters": [
{
"name": "temperature",
"type": "INTEGER",
"defaultValue": {"I": 72},
"valueConditions": [
{
"comparisonOperator": "IN_RANGE",
"operand": {"numberRange": {"min": "60", "max": "80"}}
}
]
}
]
}
```
All'avvio dell'esecuzione:
+ Se si fornisce `"temperature": {"I": 75}` nella richiesta, viene utilizzato 75
+ Se si omette il parametro di temperatura, viene utilizzato il valore predefinito 72
+ Entrambi i valori vengono convalidati rispetto alla condizione dell'intervallo [60,80]
## Stati dei comandi
*I comandi Account AWS possono trovarsi in uno dei tre stati seguenti: *Disponibile*, Obsoleto o In *attesa di eliminazione*.*
**Disponibilità**
Una volta completata la creazione, un comando si trova nello stato Disponibile e può essere eseguito sui dispositivi.
**Deprecated**
Contrassegna i comandi come obsoleti quando non sono più necessari. I comandi obsoleti non possono avviare nuove esecuzioni, ma le esecuzioni in sospeso continuano fino al completamento. Per abilitare nuove esecuzioni, ripristina lo stato Disponibile del comando.
**In attesa di eliminazione**
Quando contrassegni un comando per l'eliminazione, questo viene eliminato automaticamente se è obsoleto per un periodo superiore al timeout massimo (impostazione predefinita: 12 ore). Questa azione è permanente. Se non è obsoleto o obsoleto per un periodo inferiore al timeout, il comando entra nello stato In attesa di eliminazione e viene rimosso dopo la scadenza del timeout.
## Stato di esecuzione del comando
Quando si avvia un'esecuzione su un dispositivo di destinazione, il dispositivo entra in `CREATED` stato e può passare ad altri stati in base ai report del dispositivo. È possibile recuperare informazioni sullo stato e tenere traccia delle esecuzioni.
**Nota**
È possibile eseguire più comandi contemporaneamente su un dispositivo. Utilizza il controllo della concorrenza per limitare le esecuzioni per dispositivo e prevenire il sovraccarico. [Per il numero massimo di esecuzioni simultanee per dispositivo, consulta le quote dei comandi.AWS IoT Device Management](https://docs.aws.amazon.com/general/latest/gr/iot_device_management.html#commands-limits)
La tabella seguente mostra gli stati di esecuzione e le relative transizioni in base all'avanzamento dell'esecuzione.
**Stato e origine dell'esecuzione del comando**
| Stato di esecuzione del comando | Avviato dal dispositivo/cloud? | Esecuzione del terminale? | Transizioni di stato consentite |
| --- | --- | --- | --- |
| CREATED | Cloud | No | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/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/it_it/iot/latest/developerguide/iot-remote-command-concepts.html) |
| TIMED\$1OUT | Dispositivo e cloud | No | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/iot-remote-command-concepts.html) |
| SUCCEEDED | Dispositivo | Sì | Non applicabile |
| FAILED | Dispositivo | Sì | Non applicabile |
| REJECTED | Dispositivo | Sì | Non applicabile |
I dispositivi possono pubblicare aggiornamenti sullo stato e sui risultati in qualsiasi momento utilizzando i comandi (argomenti MQTT riservati). Per fornire un contesto aggiuntivo, i dispositivi possono utilizzare `reasonDescription` i campi `reasonCode` e nell'`statusReason`oggetto.
Il diagramma seguente mostra le transizioni dello stato di esecuzione.
![\[Immagine che mostra come lo stato di esecuzione di un comando passa da uno stato all'altro.\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/images/command-execution-status-transitions.png)
**Nota**
Quando non AWS IoT rileva alcuna risposta del dispositivo entro il periodo di timeout, viene impostato `TIMED_OUT` uno stato temporaneo che consente nuovi tentativi e modifiche dello stato. Se il dispositivo segnala esplicitamente`TIMED_OUT`, questo diventa uno stato del terminale senza ulteriori transizioni. Per ulteriori informazioni, consulta [Esecuzioni di comandi non terminali](#iot-command-execution-status-nonterminal).
Le sezioni seguenti descrivono le esecuzioni terminali e non terminali e i relativi stati.
**Topics**
+ [Esecuzioni di comandi non terminali](#iot-command-execution-status-nonterminal)
+ [Esecuzioni di comandi da terminale](#iot-command-execution-status-terminal)
### Esecuzioni di comandi non terminali
Un'esecuzione non è terminale se può accettare aggiornamenti dai dispositivi. *Le esecuzioni non terminali sono considerate attive.* I seguenti stati non sono terminali:
+
**created**
Quando si avvia un'esecuzione dalla AWS IoT console o si utilizza l'`StartCommandExecution`API, le richieste riuscite modificano lo stato in. `CREATED` Da questo stato, le esecuzioni possono passare a qualsiasi altro stato non terminale o terminale.
+
**IN\$1PROGRESS**
Dopo aver ricevuto il payload, i dispositivi possono iniziare a eseguire istruzioni ed eseguire azioni specifiche. Durante l'esecuzione, i dispositivi possono pubblicare risposte all'argomento relativo alla risposta ai comandi e aggiornare lo stato a`IN_PROGRESS`. A partire da`IN_PROGRESS`, le esecuzioni possono passare a qualsiasi stato terminale o non terminale tranne. `CREATED`
**Nota**
L'`UpdateCommandExecution`API può essere richiamata più volte con status. `IN_PROGRESS` Specificate ulteriori dettagli di esecuzione utilizzando l'`statusReason`oggetto.
+
**TIMED\$1OUT**
Sia il cloud che il dispositivo possono attivare questo stato. `IN_PROGRESS`Lo stato delle esecuzioni può cambiare in `CREATED` `TIMED_OUT` per i seguenti motivi:
+ Dopo l'invio del comando, viene avviato un timer. Se il dispositivo non risponde entro la durata specificata, il cloud cambia stato in`TIMED_OUT`. In questo caso, l'esecuzione non è terminale.
+ Il dispositivo può sostituire lo stato di qualsiasi terminale o segnalare un timeout e impostare lo stato su. `TIMED_OUT` In questo caso, lo stato rimane`TIMED_OUT`, ma i campi `StatusReason` dell'oggetto cambiano in base alle informazioni sul dispositivo. L'esecuzione diventa terminale.
Per ulteriori informazioni, consulta [Valore del timeout e stato di `TIMED_OUT` esecuzione](iot-remote-command-execution-start-monitor.md#iot-command-execution-timeout-status).
### Esecuzioni di comandi da terminale
Un'esecuzione diventa terminale quando non accetta più aggiornamenti dai dispositivi. I seguenti stati sono terminali. Le esecuzioni possono passare allo stato di terminale da qualsiasi stato non terminale:`CREATED`,, o. `IN_PROGRESS` `TIMED_OUT`
+
**RIUSCITA**
Se il dispositivo completa con successo l'esecuzione, può pubblicare una risposta all'argomento relativo alla risposta ai comandi e aggiornare lo stato su. `SUCCEEDED`
+
**NON RIUSCITO**
Quando un dispositivo non riesce a completare l'esecuzione, può pubblicare una risposta all'argomento di risposta ai comandi e aggiornare lo stato a`FAILED`. Utilizzate i `reasonDescription` campi `reasonCode` e nell'`statusReason`oggetto, o nei CloudWatch registri, per risolvere gli errori.
+
**REJECTED**
Quando un dispositivo riceve una richiesta non valida o incompatibile, può richiamare l'API con status. `UpdateCommandExecution` `REJECTED` Utilizza i `reasonDescription` campi `reasonCode` e nell'`statusReason`oggetto, o nei CloudWatch registri, per risolvere i problemi.
# Flusso di lavoro dei comandi di alto livello
Questo flusso di lavoro mostra come i dispositivi interagiscono con AWS IoT Device Management i comandi. Tutte le richieste API HTTP utilizzano le [credenziali Sigv4](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) per la firma.
![\[Panoramica del flusso di lavoro di alto livello per i comandi AWS IoT Device Management del dispositivo.\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/images/device-command-workflow.png)
**Topics**
+ [Crea e gestisci i comandi](#command-create-command)
+ [Scegliete il dispositivo di destinazione per i vostri comandi e iscrivetevi agli argomenti MQTT](#command-choose-target)
+ [Avvia e monitora l'esecuzione dei comandi per il dispositivo di destinazione](#command-command-executions)
+ [(Facoltativo) Abilita le notifiche per gli eventi dei comandi](#iot-remote-command-commands-notifications)
## Crea e gestisci i comandi
Per creare e gestire i comandi per i tuoi dispositivi, procedi nel seguente modo.
1.
**Crea una risorsa di comando**
Crea un [comando dal Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) o utilizzando l'[https://docs.aws.amazon.com/iot/latest/apireference/API_CreateCommand.html](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateCommand.html)API.
1.
**Specificare il payload**
Fornisci un payload in qualsiasi formato. Specificate il tipo di contenuto per garantire la corretta interpretazione del dispositivo.
Per i comandi dinamici con modelli di payload, il payload finale viene generato in fase di esecuzione utilizzando i parametri forniti. I modelli supportano solo il formato JSON, ma il payload generato può essere inviato come JSON o CBOR.
1.
**(Facoltativo) Gestisci i comandi creati**
Aggiorna il nome visualizzato e la descrizione dopo la creazione. Contrassegna i comandi come obsoleti quando non sono più necessari o eliminali definitivamente. Per modificare le informazioni sul payload, crea un nuovo comando.
## Scegliete il dispositivo di destinazione per i vostri comandi e iscrivetevi agli argomenti MQTT
Scegli il tuo dispositivo di destinazione e configura gli argomenti MQTT per ricevere comandi e pubblicare risposte.
1.
**Scegli il dispositivo di destinazione per il tuo comando**
Scegli un dispositivo di destinazione per ricevere ed eseguire il comando. Usa un nome oggetto per i dispositivi registrati o un ID client per i dispositivi non registrati. Per ulteriori informazioni, consulta [Considerazioni sul dispositivo di destinazione](iot-remote-command-execution-start-monitor.md#iot-command-execution-target).
1.
**Configura la politica del AWS IoT dispositivo**
Configura una policy IAM che concede le autorizzazioni per ricevere esecuzioni e pubblicare aggiornamenti. Vedi alcuni esempi di [Policy IAM di esempio](iot-remote-command-execution-start-monitor.md#iot-remote-command-execution-update-policy) policy.
1.
**Stabilire una connessione MQTT**
Connect i dispositivi al broker di messaggi e sottoscrivi gli argomenti di richiesta e risposta. I dispositivi richiedono `iot:Connect` l'autorizzazione. Trova l'endpoint del tuo piano dati utilizzando il comando `DescribeEndpoint` API o `describe-endpoint` CLI:
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
L'esecuzione di questo comando restituisce l'endpoint del piano dati specifico dell'account come illustrato di seguito.
```
account-specific-prefix.iot.region.amazonaws.com
```
1.
**Iscriviti agli argomenti relativi ai comandi**
Sottoscrivi l'argomento relativo alla richiesta dei comandi. Quando si avvia un'esecuzione, il broker di messaggi pubblica il payload relativo a questo argomento. Il dispositivo riceve ed elabora il comando.
(Facoltativo) Iscriviti agli argomenti di risposta (`accepted`o`rejected`) per ricevere la conferma se il servizio cloud ha accettato o rifiutato la risposta del dispositivo.
In questo esempio, sostituisci:
+ *``*con `thing` o `client` a seconda che il dispositivo scelto come target sia stato registrato come oggetto IoT o specificato come client MQTT.
+ *``*con l'identificatore univoco del dispositivo bersaglio. Questo ID può essere l'ID univoco del client MQTT o il nome di un oggetto.
**Nota**
Se il tipo di payload non è JSON o CBOR, il ** campo potrebbe non essere presente nell'argomento relativo alla richiesta dei comandi. Per ottenere il formato del payload, si consiglia di utilizzare MQTT5 per ottenere le informazioni sul formato dalle intestazioni dei messaggi MQTT. Per ulteriori informazioni, consulta [Argomenti sui comandi](reserved-topics.md#reserved-topics-commands).
```
$aws/commands///executions/+/request/
$aws/commands///executions/+/response/accepted/
$aws/commands///executions/+/response/rejected/
```
## Avvia e monitora l'esecuzione dei comandi per il dispositivo di destinazione
Dopo aver creato i comandi e specificato le destinazioni per il comando, è possibile avviare l'esecuzione sul dispositivo di destinazione effettuando le seguenti operazioni.
1.
**Avvia l'esecuzione del comando sul dispositivo di destinazione**
Avvia l'esecuzione da [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) o utilizza l'`StartCommandExecution`API con l'endpoint specifico del tuo account. Utilizzalo `iot:Data-ATS` per dual-stack (IPv4/) o solo per. IPv6 `iot:Jobs` IPv4
L'API pubblica il payload nell'argomento di richiesta dei comandi.
**Nota**
Se il dispositivo è offline e utilizza sessioni permanenti MQTT, il comando attende il broker di messaggi. Quando il dispositivo si riconnette prima del timeout, può elaborare il comando e pubblicare i risultati. Se il timeout scade, il timeout di esecuzione scade e il payload verrà scartato.
1.
**Aggiorna il risultato dell'esecuzione del comando**
Il dispositivo riceve il payload, elabora il comando, esegue le azioni specificate e pubblica i risultati nell'argomento di risposta ai comandi utilizzando l'API basata su `UpdateCommandExecution` MQTT. Se è abbonato agli argomenti accettati e rifiutati, il dispositivo riceve la conferma se il servizio cloud ha accettato o rifiutato la risposta.
A seconda di ciò che hai specificato nell'argomento della richiesta, ** possono essere oggetti o client e ** può essere il nome dell' AWS IoT oggetto o l'ID del client MQTT.
**Nota**
Nell'argomento di risposta ai comandi ** possono essere solo JSON o CBOR.
```
$aws/commands///executions//response/
```
1.
**(Facoltativo) Recupera il risultato dell'esecuzione del comando**
Recupera i risultati dell'esecuzione dalla AWS IoT console o utilizzando. `GetCommandExecution` Il dispositivo deve pubblicare i risultati nell'argomento di risposta ai comandi per le informazioni più recenti. Visualizza dettagli aggiuntivi tra cui l'ora dell'ultimo aggiornamento, il risultato e l'ora di completamento.
## (Facoltativo) Abilita le notifiche per gli eventi dei comandi
Iscriviti agli eventi Commands per ricevere notifiche quando lo stato di esecuzione cambia. Per informazioni dettagliate sugli eventi di esecuzione dei comandi, inclusi il formato dei messaggi di evento e gli attributi del payload, vedere[Eventi di esecuzione dei comandi](command-events.md).
1.
**Creazione di una regola dell'argomento**
Iscrivetevi all'argomento Commands events per le notifiche di modifica dello stato. Crea una regola tematica per indirizzare i dati del dispositivo ad altri AWS IoT servizi come AWS Lambda Amazon SQS e AWS Step Functions utilizzando la AWS IoT console o. [Creare una AWS IoT regola](iot-create-rule.md)
In questo esempio, `` sostituiscilo con l'identificatore del comando per il quale desideri ricevere notifiche e `` con lo stato dell'esecuzione del comando.
```
$aws/events/commandExecution//
```
**Nota**
Per ricevere notifiche per tutti i comandi e gli stati di esecuzione dei comandi, è possibile utilizzare caratteri jolly e sottoscrivere il seguente argomento.
```
$aws/events/commandExecution/+/#
```
1.
**Ricevi ed elabora gli eventi dei comandi**
Gestisci i comandi, invia notifiche push e crea applicazioni utilizzando gli eventi sottoscritti.
Il codice seguente mostra un payload di esempio per le notifiche di comandi ed eventi che riceverai.
```
{
"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
}
```
# Crea e gestisci i comandi
Usa AWS IoT Device Management i comandi per configurare azioni remote riutilizzabili o inviare istruzioni immediate ai dispositivi. Crea e gestisci i comandi dalla AWS IoT console o utilizzando. AWS CLI
**Topics**
+ [Crea una risorsa di comando](#iot-remote-command-create)
+ [Recuperare informazioni su un comando](#iot-remote-command-get)
+ [Elenca i comandi nel tuo Account AWS](#iot-remote-command-list)
+ [Aggiornare una risorsa di comando](#iot-remote-command-update)
+ [Deprecare o ripristinare una risorsa di comando](#iot-remote-command-deprecatecmd)
+ [Eliminare una risorsa di comando](#iot-remote-command-delete)
## Crea una risorsa di comando
Fornisci le seguenti informazioni durante la creazione di un comando:
+
**Informazioni generali**
Fornisci un ID di comando univoco per identificare il comando quando lo esegui sui dispositivi di destinazione. Specificate facoltativamente un nome visualizzato, una descrizione e tag per la gestione.
+ **Carico utile**
Per i comandi statici, fornite un payload che definisca le azioni del dispositivo. Specificate il tipo di formato Payload per una corretta interpretazione del dispositivo.
Per i comandi dinamici, vedete l'attributo del modello Payload.
+ **Modello di payload**
Per i comandi dinamici, fornisci un PayloadTemplate con segnaposto e parametri. Fornisci e condizioni opzionali. `defaultValue` AWS IoT Device Management I comandi sostituiscono i segnaposto in fase di esecuzione. I parametri mancanti utilizzano il loro DefaultValue. Tutti i valori devono soddisfare condizioni definite.
Sono supportati i seguenti tipi di segnaposto con distinzione tra maiuscole e minuscole:
+ `${aws:iot:commandexecution::parameter:parameter1}`— Un segnaposto per il valore di un parametro con il nome. `parameter1`
+ `${aws:iot:commandexecution::executionTimeoutSec}`— Un segnaposto per il parametro di timeout di esecuzione del comando fornito in fase di esecuzione.
### Argomenti relativi al payload e ai comandi
Comandi riservati Gli argomenti utilizzano un formato basato sul tipo di formato Payload.
+ Per i `application/json` nostri tipi di `application/cbor` contenuto, usa questo argomento della richiesta:
```
$aws/commands///executions/+/request/
```
+ Per altri tipi di contenuto o formati non specificati, usa questo argomento della richiesta. Il formato Payload viene visualizzato nell'intestazione del messaggio MQTT.
```
$aws/commands///executions/+/request
```
L'argomento di risposta ai comandi utilizza `json` o `cbor` formatta indipendentemente dal tipo di payload. **deve essere `json` o`cbor`:
```
$aws/commands///executions//response/
```
### Crea una risorsa di comando (console)
Le sezioni seguenti descrivono le considerazioni sul formato Payload e la creazione di comandi dalla console.
**Topics**
+ [Formato statico del payload dei comandi](#iot-commands-payload-format)
+ [Formato dinamico del payload dei comandi](#iot-commands-dynamic-payload-format)
+ [Come creare un comando (console)](#iot-commands-console-how)
#### Formato statico del payload dei comandi
Il payload supporta qualsiasi formato fino a 32 KB. Specificate il tipo di formato Payload per un'interpretazione sicura e corretta del dispositivo.
Specificate il tipo di formato Payload utilizzando il `type/subtype` formato (ad esempio, `application/json` o`application/cbor`). Default: `application/octet-stream`. Vedi [Tipi MIME comuni per i](https://developer.mozilla.org/en-US/docs/Web/HTTP/MIME_types/Common_types) formati supportati.
#### Formato dinamico del payload dei comandi
Il PayloadTemplate deve essere un JSON valido con almeno un segnaposto, fino a 32 KB.
Per il `AwsJsonSubstitution` preprocessore, AWS IoT Device Management Commands invia notifiche in formato JSON o CBOR in base alla configurazione del preprocessore.
#### Come creare un comando (console)
Per creare un comando dalla console, vai su [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) e segui questi passaggi:
1. Scegli il **comando Crea**.
1. Specificate un ID di comando univoco.
1. (Facoltativo) Specificate il nome visualizzato, la descrizione e i tag.
1. Carica il file Payload contenente le azioni del dispositivo. Specificate il tipo di formato Payload per una corretta interpretazione del dispositivo.
1. (Facoltativo) Per i modelli di payload JSON con segnaposto, i parametri vengono precompilati nella tabella in linea per la modifica.
1. (Facoltativo) Configura il tipo di valore del parametro (obbligatorio), il valore predefinito e le condizioni.
1. Scegliete **il comando Crea**.
### Creare una risorsa di comando (CLI)
Usa il 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 per creare un comando.
**Topics**
+ [Payload del comando](#iot-commands-payload)
+ [Policy IAM di esempio](#iot-remote-command-create-iam)
+ [Esempio di creazione di comandi statici](#iot-remote-command-create-example)
+ [Esempio di creazione dinamica di comandi](#iot-remote-dynamic-command-create-example)
#### Payload del comando
Fornisci un modello di payload o payload statico. I payload statici sono codificati in base 64. Per i modelli di payload, il payload finale viene generato in fase di esecuzione utilizzando i valori dei parametri. I dispositivi elaborano il payload ed eseguono azioni specificate. Specificate il tipo di contenuto Payload per la corretta ricezione del dispositivo.
**Nota**
I payload non possono essere modificati dopo la creazione del comando. Crea un nuovo comando per modificare il payload.
#### Policy IAM di esempio
Prima di utilizzare questa operazione API, assicurati che la tua policy IAM ti autorizzi a eseguire questa azione sul dispositivo. L'esempio seguente mostra una policy IAM che consente l'autorizzazione dell'utente a eseguire l'`CreateCommand`azione.
In questo esempio, sostituisci:
+ `region`con il tuo Regione AWS, ad esempio`us-east-1`.
+ `account-id`con il tuo Account AWS numero, ad esempio`123456789012`.
+ `command-id`con un identificatore univoco per l'ID del AWS IoT comando, ad esempio`LockDoor`. Se desideri inviare più di un comando, puoi specificare questi comandi nella sezione *Resource* della policy IAM.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:CreateCommand",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/command-id"
}
}
```
#### Esempio di creazione di comandi statici
L'esempio seguente mostra come creare un comando statico. A seconda dell'applicazione, sostituisci:
+ *``*con un identificatore univoco per il comando. Ad esempio, per bloccare la porta di casa, puoi specificare*`LockDoor`*. Ti consigliamo di utilizzare l'UUID. Puoi anche usare caratteri alfanumerici, «-» e «\$1».
+ (Facoltativo) *``* e*``*, che sono campi facoltativi che è possibile utilizzare per fornire un nome descrittivo e una descrizione significativa per il comando, ad esempio. *`Lock the doors of my home`*
+ `namespace`, che è possibile utilizzare per specificare lo spazio dei nomi del comando. Deve esserlo. `AWS-IoT` Per informazioni sull'utilizzo di questa funzionalità per AWS IoT FleetWise, consulta [Comandi remoti](https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/remote-commands.html)
+ `payload`contiene informazioni sul payload che si desidera utilizzare durante l'esecuzione del comando e sul tipo di contenuto.
```
aws iot create-command \
--command-id \
--display-name \
--description \
--namespace AWS-IoT \
--payload '{"content":"eyAibWVzc2FnZSI6ICJIZWxsbyBJb1QiIH0=","contentType":"application/json"}'
```
L'esecuzione di questo comando genera una risposta che contiene l'ID e l'ARN (Amazon resource name) del comando. Ad esempio, se hai specificato il `LockDoor` comando durante la creazione, di seguito viene mostrato un esempio di output dell'esecuzione del comando.
```
{
"commandId": "LockDoor",
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/LockDoor"
}
```
#### Esempio di creazione dinamica di comandi
L'esempio seguente mostra come creare un comando dinamico. A seconda dell'applicazione, sostituisci:
+ *``*con un identificatore univoco per il comando. Ad esempio, per impostare lo stato di alimentazione della luce, è possibile specificare*`Light_Power_Status`*. Ti consigliamo di utilizzare l'UUID. Puoi anche usare caratteri alfanumerici, «-» e «\$1».
+ (Facoltativo) *``* e*``*, che sono campi facoltativi che è possibile utilizzare per fornire un nome descrittivo e una descrizione significativa per il comando, ad esempio. *`Turn a light ON or OFF`*
+ `namespace`, che è possibile utilizzare per specificare lo spazio dei nomi del comando. Deve esserlo. `AWS-IoT` Per informazioni sull'utilizzo di questa funzionalità per AWS IoT FleetWise, consulta [Comandi remoti](https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/remote-commands.html)
+ `payloadTemplate`contiene il modello di playload in formato JSON con segnaposto.
+ `preprocessor`contiene la configurazione per il preprocessore che determina come il PayloadTemplate deve essere elaborato.
+ `mandatoryParameter`contiene i parametri corrispondenti ai segnaposto nel PayloadTemplate, il loro tipo, i valori predefiniti e le condizioni.
```
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']}}]"
```
L'esecuzione di questo comando genera una risposta che contiene l'ID e l'ARN (Amazon resource name) del comando. Ad esempio, se hai specificato il `Light_Power_Status` comando durante la creazione, di seguito viene mostrato un esempio di output dell'esecuzione del comando.
```
{
"commandId": "Light_Power_Status",
"commandArn": "arn:aws:iot:us-east-1:123456789012:command/Light_Power_Status"
}
```
## Recuperare informazioni su un comando
Dopo aver creato un comando, è possibile recuperare informazioni su di esso dalla AWS IoT console e utilizzare il. AWS CLIÈ possibile ottenere le seguenti informazioni.
+ L'ID del comando, il nome della risorsa Amazon (ARN), qualsiasi nome visualizzato e descrizione che hai specificato per il comando.
+ Lo stato del comando, che indica se un comando è disponibile per l'esecuzione sul dispositivo di destinazione o se è obsoleto o eliminato.
+ Il payload o il payloadTemplate che hai fornito.
+ Il preprocessore che hai fornito.
+ I parametri obbligatori che hai fornito.
+ L’ora in cui il comando è stato creato e aggiornato l’ultima volta.
### Recupera una risorsa di comando (console)
Per recuperare un comando dalla console, vai al [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) della AWS IoT console, quindi scegli il comando che hai creato per visualizzarne i dettagli.
Oltre ai dettagli del comando, puoi visualizzare la cronologia dei comandi, che fornisce informazioni sulle esecuzioni del comando sul dispositivo di destinazione. Dopo aver eseguito questo comando sul dispositivo, puoi trovare informazioni sulle esecuzioni in questa scheda.
### Recupera una risorsa di comando (CLI)
Utilizzate l'operazione API del piano di controllo [https://docs.aws.amazon.com/iot/latest/apireference/API_GetCommand.html](https://docs.aws.amazon.com/iot/latest/apireference/API_GetCommand.html)HTTP o il [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 per recuperare informazioni su una risorsa di comando. Devi aver già creato il comando utilizzando la richiesta `CreateCommand` API o la `create-command` CLI.
#### Policy IAM di esempio
Prima di utilizzare questa operazione API, assicurati che la tua policy IAM ti autorizzi a eseguire questa azione sul dispositivo. L'esempio seguente mostra una policy IAM che consente l'autorizzazione dell'utente a eseguire l'`GetCommand`azione.
In questo esempio, sostituisci:
+ `region`con il tuo Regione AWS, ad esempio`us-east-1`.
+ `account-id`con il tuo Account AWS numero, ad esempio`123456789023`.
+ `command-id`con il tuo identificatore di comando AWS IoT univoco, ad esempio `LockDoor` o`Light_Power_Status`. Se desideri recuperare più di un comando, puoi specificare questi comandi nella sezione *Resource* della policy IAM.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:GetCommand",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/command-id"
}
}
```
#### Recupera un esempio di comando ()AWS CLI
L'esempio seguente mostra come recuperare informazioni su un comando utilizzando il. `get-command` AWS CLI A seconda dell'applicazione, *``* sostituiscilo con l'identificatore del comando per il quale desideri recuperare le informazioni. È possibile ottenere queste informazioni dalla risposta della `create-command` CLI.
```
aws iot get-command --command-id
```
L'esecuzione di questo comando genera una risposta che contiene informazioni sul comando, sul payload e sull'ora in cui è stato creato e aggiornato l'ultima volta. Fornisce inoltre informazioni che indicano se un comando è obsoleto o viene eliminato.
Ad esempio, il codice seguente mostra una risposta di esempio.
```
{
"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
}
```
## Elenca i comandi nel tuo Account AWS
Dopo aver creato i comandi, puoi visualizzare i comandi che hai creato nel tuo account. Nell'elenco puoi trovare informazioni su:
+ L'ID del comando e l'eventuale nome visualizzato specificato per i comandi.
+ Il nome della risorsa Amazon (ARN) dei comandi.
+ Lo stato del comando che indica se i comandi sono disponibili per l'esecuzione sul dispositivo di destinazione o se sono obsoleti.
**Nota**
L'elenco non mostra quelli che vengono eliminati dal tuo account. Se i comandi sono in attesa di eliminazione, puoi comunque visualizzarne i dettagli utilizzando il relativo ID di comando.
+ L'ora in cui i comandi sono stati creati e aggiornati l'ultima volta.
### Elenca i comandi nel tuo account (console)
Nella AWS IoT console, puoi trovare l'elenco dei comandi che hai creato e i relativi dettagli accedendo al [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub).
### Elenca i comandi nel tuo account (CLI)
Per elencare i comandi che hai creato, utilizza l'operazione [https://docs.aws.amazon.com/iot/latest/apireference/API_ListCommands.html](https://docs.aws.amazon.com/iot/latest/apireference/API_ListCommands.html)API o la [https://docs.aws.amazon.com/cli/latest/reference/iot/list-commands.html](https://docs.aws.amazon.com/cli/latest/reference/iot/list-commands.html)CLI.
#### Policy IAM di esempio
Prima di utilizzare questa operazione API, assicurati che la tua policy IAM ti autorizzi a eseguire questa azione sul dispositivo. L'esempio seguente mostra una policy IAM che consente l'autorizzazione dell'utente a eseguire l'`ListCommands`azione.
In questo esempio, sostituisci:
+ `region`con il tuo Regione AWS, ad esempio`us-east-1`.
+ `account-id`con il tuo Account AWS numero, ad esempio`123456789012`.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:ListCommands",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/*"
}
}
```
#### Elenca i comandi nell'esempio del tuo account
Il comando seguente mostra come elencare i comandi nel tuo account.
```
aws iot list-commands --namespace "AWS-IoT"
```
L'esecuzione di questo comando genera una risposta che contiene un elenco di comandi creati dall'utente, l'ora in cui i comandi sono stati creati e l'ultimo aggiornamento. Fornisce inoltre informazioni sullo stato del comando, che indicano se un comando è obsoleto o è disponibile per l'esecuzione sul dispositivo di destinazione. Per ulteriori informazioni sui diversi stati e sul motivo dello stato, vedere. [Stato di esecuzione del comando](iot-remote-command-concepts.md#iot-command-execution-status)
## Aggiornare una risorsa di comando
Dopo aver creato un comando, è possibile aggiornare il nome visualizzato e la descrizione del comando.
**Nota**
Il payload del comando non può essere aggiornato. Per aggiornare queste informazioni o utilizzare un payload modificato, è necessario creare un nuovo comando.
### Aggiorna una risorsa di comando (console)
Per aggiornare un comando dalla console, vai al [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) della AWS IoT console ed esegui i seguenti passaggi.
1. Per aggiornare una risorsa di comando esistente, scegli il comando che desideri aggiornare, quindi in **Azioni** scegli **Modifica**.
1. Specificate il nome visualizzato e la descrizione che desiderate utilizzare e tutte le coppie nome-valore come tag per il comando.
1. Scegliete **Modifica** per salvare il comando con le nuove impostazioni.
### Aggiornare una risorsa di comando (CLI)
Utilizza l'operazione API del piano di [https://docs.aws.amazon.com/iot/latest/apireference/API_UpdateCommand.html](https://docs.aws.amazon.com/iot/latest/apireference/API_UpdateCommand.html)controllo o [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 per aggiornare una risorsa di comando. Utilizzando questa API, puoi:
+ Modificare il nome visualizzato e la descrizione di un comando creato.
+ Deprecate una risorsa di comando o ripristinate un comando che è già stato obsoleto.
#### Policy IAM di esempio
Prima di utilizzare questa operazione API, assicurati che la tua policy IAM ti autorizzi a eseguire questa azione sul dispositivo. L'esempio seguente mostra una policy IAM che consente l'autorizzazione dell'utente a eseguire l'`UpdateCommand`azione.
In questo esempio, sostituisci:
+ `region`con il tuo Regione AWS, ad esempio`us-east-1`.
+ `account-id`con il tuo Account AWS numero, ad esempio`123456789012`.
+ `command-id`con il tuo identificatore di comando AWS IoT univoco, ad esempio`LockDoor`. Se desideri recuperare più di un comando, puoi specificare questi comandi nella sezione *Resource* della policy IAM.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:UpdateCommand",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/command-id"
}
}
```
#### Aggiorna le informazioni su un comando examples ()AWS CLI
L'esempio seguente mostra come aggiornare le informazioni su un comando utilizzando il `update-command` AWS CLI comando. Per informazioni su come utilizzare questa API per deprecare o ripristinare una risorsa di comando, consulta. [Aggiornare una risorsa di comando (CLI)](iot-remote-command-deprecate.md#iot-remote-command-deprecate-cli)
L'esempio mostra come aggiornare il nome visualizzato e la descrizione di un comando. A seconda dell'applicazione, *``* sostituiscilo con l'identificatore del comando per il quale desideri recuperare le informazioni.
```
aws iot update-command \
--command-id
--displayname \
--description
```
L'esecuzione di questo comando genera una risposta che contiene le informazioni aggiornate sul comando e l'ora dell'ultimo aggiornamento. Il codice seguente mostra un esempio di richiesta e risposta per l'aggiornamento del nome visualizzato e della descrizione di un comando che spegne l'AC.
```
aws iot update-command \
--command-id \
--displayname \
--description
```
L'esecuzione di questo comando genera la seguente risposta.
```
{
"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"
}
```
## Deprecare o ripristinare una risorsa di comando
Dopo aver creato un comando, se non si desidera più continuare a utilizzarlo, è possibile contrassegnarlo come obsoleto. Quando si depreca un comando, tutte le esecuzioni di comandi in sospeso continueranno a essere eseguite sul dispositivo di destinazione fino a quando non raggiungono lo stato di terminale. Una volta che un comando è diventato obsoleto, se si desidera utilizzarlo, ad esempio per inviare una nuova esecuzione di comando al dispositivo di destinazione, è necessario ripristinarlo.
**Nota**
Non è possibile modificare un comando obsoleto o eseguire nuove esecuzioni per esso. *Per eseguire nuovi comandi sul dispositivo, è necessario ripristinarlo in modo che lo stato del comando passi a Disponibile.*
Per ulteriori informazioni sulla deprecazione e il ripristino di un comando e sulle relative considerazioni, vedere. [Deprecare una risorsa di comando](iot-remote-command-deprecate.md)
## Eliminare una risorsa di comando
Se non desideri più utilizzare un comando, puoi rimuoverlo definitivamente dal tuo account. Se l'operazione di eliminazione ha esito positivo:
+ Se il comando è obsoleto per una durata superiore al timeout massimo di 12 ore, il comando verrà eliminato immediatamente.
+ Se il comando non è obsoleto o lo è stato per una durata inferiore al timeout massimo, il comando sarà in uno stato. `pending deletion` Verrà rimosso automaticamente dal tuo account dopo il timeout massimo di 12 ore.
**Nota**
Il comando potrebbe essere eliminato anche se sono presenti esecuzioni di comandi in sospeso. Il comando sarà in sospeso di eliminazione e verrà rimosso automaticamente dal tuo account.
### Eliminare una risorsa di comando (console)
Per eliminare un comando dalla console, accedi al [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) della AWS IoT console ed esegui i seguenti passaggi.
1. Scegli il comando che desideri eliminare, quindi in **Azioni** scegli **Elimina**.
1. Conferma di voler eliminare il comando, quindi scegli **Elimina**.
Il comando verrà contrassegnato per l'eliminazione e rimosso definitivamente dal tuo account dopo 12 ore.
### Eliminare una risorsa di comando (CLI)
Utilizzate l'operazione API del piano di controllo `DeleteCommand` HTTP o il `delete-command` AWS CLI comando per eliminare una risorsa di comando. Se l'operazione di eliminazione ha esito positivo, vedrai un HTTP `statusCode` di 204 o 202 e il comando verrà eliminato automaticamente dal tuo account dopo la durata massima del timeout di 12 ore. Nel caso dello stato 204, indica che il comando è stato eliminato.
#### Policy IAM di esempio
Prima di utilizzare questa operazione API, assicurati che la tua policy IAM ti autorizzi a eseguire questa azione sul dispositivo. L'esempio seguente mostra una policy IAM che consente l'autorizzazione dell'utente a eseguire l'`DeleteCommand`azione.
In questo esempio, sostituisci:
+ `region`con il tuo Regione AWS, ad esempio`us-east-1`.
+ `account-id`con il tuo Account AWS numero, ad esempio`123456789012`.
+ `command-id`con il tuo identificatore di comando AWS IoT univoco, ad esempio`LockDoor`. Se desideri recuperare più di un comando, puoi specificare questi comandi nella sezione *Resource* della policy IAM.
****
```
{
"Version":"2012-10-17",
"Statement": {
"Action": "iot:DeleteCommand",
"Effect": "Allow",
"Resource": "arn:aws:iot:us-east-1:123456789012:command/command-id"
}
}
```
#### Eliminare un esempio di comando ()AWS CLI
Gli esempi seguenti mostrano come eliminare un comando utilizzando il `delete-command` AWS CLI comando. A seconda dell'applicazione, *``* sostituiscilo con l'identificatore del comando che stai eliminando.
```
aws iot delete-command --command-id
```
Se la richiesta API ha esito positivo, il comando genera un codice di stato di 202 o 204. Puoi utilizzare l'`GetCommand`API per verificare che il comando non esista più nel tuo account.
# Avvia e monitora le esecuzioni di comandi
Dopo aver creato un comando, avvia un'esecuzione sul dispositivo di destinazione. Il dispositivo aggiorna i risultati e pubblica lo stato negli argomenti riservati MQTT. Recupera e monitora lo stato di esecuzione dal tuo account.
Avvia e monitora i comandi utilizzando la AWS IoT console o AWS CLI.
**Topics**
+ [Avvia l'esecuzione di un comando](#iot-remote-command-execution-start)
+ [Aggiorna il risultato dell’esecuzione di un comando](#iot-remote-command-execution-update)
+ [Recupera l'esecuzione di un comando](#iot-remote-command-execution-get)
+ [Visualizzazione degli aggiornamenti dei comandi utilizzando il client di test MQTT](#iot-remote-command-execution-update-mqtt)
+ [Elenca le esecuzioni dei comandi nel tuo Account AWS](#iot-remote-command-execution-list)
+ [Eliminare l'esecuzione di un comando](#iot-remote-command-execution-delete)
## Avvia l'esecuzione di un comando
**Importante**
L'utente è l'unico responsabile della distribuzione dei comandi in modo sicuro e conforme alle leggi applicabili.
Prima di iniziare un'esecuzione, assicurati che:
+ Hai creato un comando nello spazio dei AWS IoT nomi con le informazioni sul payload. All'avvio di Execution, il dispositivo elabora le istruzioni di Payload ed esegue azioni specificate. Vedi [Crea una risorsa di comando](iot-remote-command-create-manage.md#iot-remote-command-create) per la creazione di comandi.
+ Il dispositivo è abbonato agli argomenti riservati di MQTT per i comandi. All'avvio di Execution, le informazioni sul payload vengono pubblicate in questo argomento di richiesta MQTT riservato:
**possono essere client Things o MQTT. **è il nome dell'oggetto o l'ID del client. **Valori supportati: JSON e CBOR. Per ulteriori informazioni, consulta [Argomenti sui comandi](reserved-topics.md#reserved-topics-commands).
```
$aws/commands///executions/+/request/
```
Per formati diversi da JSON/CBOR, usa questo formato Commands Topic**:
```
$aws/commands///executions/+/request
```
### Considerazioni sul dispositivo di destinazione
Specificare il dispositivo di destinazione per ricevere ed eseguire il comando. Usa un nome oggetto per i dispositivi registrati o un ID client per i dispositivi non registrati. Dopo aver ricevuto il payload, il dispositivo esegue il comando ed esegue le azioni specificate.
#### AWS IoT cosa
I dispositivi di destinazione possono essere oggetti registrati nel AWS IoT registro. Le cose semplificano la ricerca e la gestione dei dispositivi.
Registra i dispositivi come oggetti dalla [pagina del dispositivo Connect](https://console.aws.amazon.com/iot/home#/connect-overview) o utilizzando [https://docs.aws.amazon.com/iot/latest/apireference/API_CreateThing.html](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateThing.html). Trova oggetti esistenti da [Thing Hub](https://console.aws.amazon.com/iot/home#/thinghub) o li utilizza [https://docs.aws.amazon.com/iot/latest/apireference/API_DescribeThing.html](https://docs.aws.amazon.com/iot/latest/apireference/API_DescribeThing.html). Per i dettagli della registrazione, vedere [Gestione degli elementi con il registro](https://docs.aws.amazon.com/iot/latest/developerguide/thing-registry).
#### ID client
Per i dispositivi non registrati, usa il Client ID.
L'ID client è un identificatore univoco assegnato ai dispositivi. Definito nel protocollo MQTT, contiene caratteri alfanumerici, caratteri di sottolineatura o trattini. Ogni dispositivo a cui si connette AWS IoT necessita di un ID client univoco.
**Nota**
Per gli oggetti registrati, l'ID client può corrispondere al nome dell'oggetto.
Quando si sceglie come target un ID client specifico, i dispositivi devono connettersi AWS IoT utilizzando tale ID client per ricevere il payload.
Il Client ID è l'ID client MQTT utilizzato dai dispositivi per la connessione a. AWS IoT Core AWS IoT utilizza questo ID per identificare i dispositivi e gestire connessioni e abbonamenti.
### Considerazioni sul timeout dell'esecuzione dei comandi
Il timeout specifica la durata (in secondi) con cui i dispositivi forniscono i risultati di esecuzione.
Dopo aver creato un'esecuzione, viene avviato un timer. Se il dispositivo va offline o non riporta i risultati entro il timeout, l'Esecuzione scade con lo stato`TIMED_OUT`.
Impostazione predefinita: 10 secondi. Massimo: 12 ore.
#### Valore del timeout e stato di `TIMED_OUT` esecuzione
Sia il cloud che il dispositivo possono segnalare il timeout.
Dopo aver inviato il comando, si avvia un timer. Se nessuna risposta del dispositivo arriva entro il timeout, il cloud imposta lo stato di esecuzione su `TIMED_OUT` con codice motivo. `$NO_RESPONSE_FROM_DEVICE`
Ciò si verifica quando:
+ Il dispositivo è andato offline durante l'esecuzione.
+ Il dispositivo non è riuscito a completare l'esecuzione entro il timeout.
+ Il dispositivo non è riuscito a segnalare lo stato entro il timeout.
In questo caso, quando lo stato di esecuzione di `TIMED_OUT` viene segnalato dal cloud, l'esecuzione del comando non è terminale. Il dispositivo può pubblicare una risposta che sostituisce lo stato di uno qualsiasi degli stati del terminale:`SUCCEEDED`, o. `FAILED` `REJECTED` L'esecuzione del comando diventa quindi terminale e non accetta ulteriori aggiornamenti.
Il dispositivo può anche aggiornare uno `TIMED_OUT` stato avviato dal cloud segnalando che si è verificato un timeout durante l'esecuzione del comando. In questo caso, lo stato di esecuzione del comando rimane invariato`TIMED_OUT`, ma l'`statusReason`oggetto viene aggiornato in base alle informazioni riportate dal dispositivo. L'esecuzione del comando diventa quindi terminale e non vengono accettati ulteriori aggiornamenti.
#### Utilizzo di sessioni persistenti MQTT
È possibile configurare le sessioni persistenti MQTT da utilizzare con la funzionalità dei AWS IoT Device Management comandi. Questa funzionalità è particolarmente utile in casi come quando il dispositivo va offline e si desidera assicurarsi che il dispositivo riceva ancora il comando quando torna online prima della durata del timeout ed esegua le istruzioni specificate.
Per impostazione predefinita, la scadenza della sessione persistente MQTT è impostata su 60 minuti. Se il timeout di esecuzione dei comandi è configurato su un valore superiore a tale durata, le esecuzioni di comandi che durano più di 60 minuti possono essere rifiutate dal broker di messaggi e avere esito negativo. Per eseguire comandi che durano più di 60 minuti, puoi richiedere un aumento del tempo di scadenza della sessione persistente.
**Nota**
Per assicurarti di utilizzare correttamente la funzionalità delle sessioni persistenti MQTT, imposta il flag Clean Start su zero. Per ulteriori informazioni, consulta [Sessioni persistenti MQTT](https://docs.aws.amazon.com/iot/latest/developerguide/mqtt.html#mqtt-persistent-sessions).
### Avvia l'esecuzione di un comando (console)
Per iniziare a eseguire il comando dalla console, vai alla pagina [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) della AWS IoT console ed esegui i seguenti passaggi.
1. Per eseguire il comando che hai creato, scegli **Esegui comando**.
1. Esamina le informazioni sul comando che hai creato, inclusi gli argomenti riservati MQTT e i parametri, se applicabile.
Per i comandi dinamici, inserite i valori dei parametri o lasciateli con i valori predefiniti. Per i parametri che non hanno un valore predefinito, è necessario fornire un valore da inviare come parte di questa esecuzione.
1. Specificare il dispositivo di destinazione per ricevere ed eseguire il comando. Il dispositivo può essere specificato come AWS IoT oggetto se è stato registrato AWS IoT o utilizzando l'ID client se il dispositivo non è ancora stato registrato. Per ulteriori informazioni, consulta [Considerazioni sul dispositivo di destinazione](#iot-command-execution-target)
1. (Facoltativo) Configurate un valore di timeout per il comando che determini la durata per la quale desiderate che il comando venga eseguito prima del timeout. Se il comando deve essere eseguito per più di 60 minuti, potrebbe essere necessario aumentare il tempo di scadenza delle sessioni persistenti MQTT. Per ulteriori informazioni, consulta [Considerazioni sul timeout dell'esecuzione dei comandi](#iot-command-execution-timeout).
1. Seleziona **Esegui comando**.
### Avviare l'esecuzione di un comando ()AWS CLI
Utilizzate l'operazione API del piano dati [https://docs.aws.amazon.com/iot/latest/apireference/API_StartCommandExecution.html](https://docs.aws.amazon.com/iot/latest/apireference/API_StartCommandExecution.html)HTTP per avviare l'esecuzione di un comando. La richiesta e la risposta dell'API sono correlate dall'ID di esecuzione del comando. Una volta completata l'esecuzione del comando, il dispositivo può segnalare lo stato e il risultato dell'esecuzione al cloud pubblicando un messaggio nell'argomento di risposta ai comandi. Per un codice di risposta personalizzato, i codici applicativi di tua proprietà possono elaborare il messaggio di risposta e pubblicare il risultato su AWS IoT.
Se i tuoi dispositivi hanno sottoscritto l'argomento relativo alla richiesta dei comandi, l'`StartCommandExecution`API pubblicherà il messaggio di payload sull'argomento. Il payload può utilizzare qualsiasi formato di tua scelta. Per ulteriori informazioni, consulta [Payload del comando](iot-remote-command-create-manage.md#iot-commands-payload).
```
$aws/commands///executions/+/request/
```
Se il formato del payload non è JSON o CBOR, di seguito viene illustrato il formato dell'argomento di richiesta dei comandi.
```
$aws/commands///executions/+/request
```
#### Policy IAM di esempio
Prima di utilizzare questa operazione API, assicurati che la tua policy IAM ti autorizzi a eseguire questa azione sul dispositivo. L'esempio seguente mostra una policy IAM che consente l'autorizzazione dell'utente a eseguire l'`StartCommandExecution`azione.
In questo esempio, sostituisci:
+ `region`con il tuo Regione AWS, ad esempio`us-east-1`.
+ `account-id`con il tuo Account AWS numero, ad esempio`123456789012`.
+ `command-id`con un identificatore univoco per il AWS IoT comando, ad esempio`LockDoor`. Se desideri inviare più di un comando, puoi specificare questi comandi nella policy IAM.
+ `devices`con uno dei due `thing` o `client` a seconda che i dispositivi siano stati registrati come AWS IoT oggetti o siano specificati come client MQTT.
+ `device-id`con il tuo 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"
]
}
```
Per visualizzare un elenco delle chiavi di condizione supportate`StartCommandExecution`, consulta [Condition Keys for AWS IoT](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-policy-keys) nella *IAM User Guide*.
#### Ottieni un endpoint del piano dati specifico dell'account
Prima di eseguire il comando API, è necessario ottenere l'URL dell'endpoint specifico dell'account per l'endpoint. Se utilizzi endpoint dual-stack (and), usa il. IPv4 IPv6 `iot:Data-ATS` L'`iot:Jobs`endpoint è solo per. IPv4 Ad esempio, se si esegue questo comando:
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Restituisce l'URL dell'endpoint specifico dell'account, come mostrato nella risposta di esempio riportata di seguito.
```
{
"endpointAddress":
"-ats.iot..api.com"
}
```
#### Avvia un esempio di esecuzione di comando ()AWS CLI
L'esempio seguente mostra come iniziare l'esecuzione di un comando utilizzando il `start-command-execution` AWS CLI comando.
In questo esempio, sostituisci:
+ *``*con l'ARN per il comando che si desidera eseguire. È possibile ottenere queste informazioni dalla risposta del comando `create-command` CLI. Ad esempio, se stai eseguendo il comando per cambiare la modalità del volante, usa`arn:aws:iot:region:account-id:command/SetComfortSteeringMode`.
+ *``*con il Thing ARN per il dispositivo di destinazione, che può essere un oggetto IoT o un client MQTT, per il quale si desidera eseguire il comando. Ad esempio, se stai eseguendo il comando per il dispositivo di destinazione`myRegisteredThing`, usa. `arn:aws:iot:region:account-id:thing/myRegisteredThing`
+ *``*con l'endpoint specifico dell'account in cui hai ottenuto[Ottieni un endpoint del piano dati specifico dell'account](#iot-remote-command-execution-start-endpoint), preceduto da. `https://` Ad esempio, `https://123456789012abcd.jobs.iot.us-east-1.amazonaws.com`.
+ (Facoltativo) È inoltre possibile specificare un parametro aggiuntivo quando si esegue `executionTimeoutSeconds` l'operazione API. `StartCommandExecution` Questo campo opzionale specifica il tempo in secondi entro il quale il dispositivo deve completare l'esecuzione del comando. Per impostazione predefinita, il valore è 10 secondi. Quando lo stato di esecuzione del comando è impostato su`CREATED`, viene avviato un timer. Se il risultato dell'esecuzione del comando non viene ricevuto prima della scadenza del timer, lo stato cambia automaticamente in`TIMED_OUT`.
+
```
aws iot-jobs-data start-command-execution \
--command-arn \
--target-arn \
--endpoint \
--execution-timeout-seconds 900
```
+ (Facoltativo) Per i comandi dinamici, specificate i parametri e i relativi valori da utilizzare per la sostituzione. È necessario fornire un valore per i parametri che non hanno un valore DefaultValue impostato al momento della creazione del comando. Se un parametro ha un DefaultValue, il valore del parametro fornito qui ha la precedenza. Per i parametri per cui è impostato ValueConditions, il valore del parametro fornito qui deve soddisfare la condizione.
Basato su un esempio di comando `Light_Power_Status` dinamico:
+
```
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}"
```
L'esecuzione di questo comando restituisce un ID di esecuzione del comando. È possibile utilizzare questo ID per interrogare lo stato di esecuzione del comando, i dettagli e la cronologia di esecuzione dei comandi.
**Nota**
Se il comando è obsoleto, la richiesta `StartCommandExecution` API avrà esito negativo con un'eccezione di convalida. Per correggere questo errore, ripristina prima il comando utilizzando l'`UpdateCommand`API, quindi esegui la richiesta. `StartCommandExecution`
```
{
"executionId": "07e4b780-7eca-4ffd-b772-b76358da5542"
}
```
## Aggiorna il risultato dell’esecuzione di un comando
Utilizzate l'operazione API del piano dati `UpdateCommandExecution` MQTT per aggiornare lo stato o il risultato dell'esecuzione di un comando.
**Nota**
Prima di utilizzare questa API:
Il dispositivo deve aver stabilito una connessione MQTT e aver sottoscritto gli argomenti di richiesta e risposta dei comandi. Per ulteriori informazioni, consulta [Flusso di lavoro dei comandi di alto livello](iot-remote-command-workflow.md).
È necessario aver già eseguito questo comando utilizzando l'operazione `StartCommandExecution` API.
### Policy IAM di esempio
Prima di utilizzare questa operazione API, assicurati che la tua policy IAM autorizzi il tuo dispositivo a eseguire queste azioni. Di seguito è riportato un esempio di policy che autorizza il dispositivo a eseguire l'azione. Per ulteriori esempi di policy IAM che consentono l'autorizzazione dell'utente a eseguire l'azione `UpdateCommandExecution` MQTT, vedere. [Esempi di policy di connessione e pubblicazione](connect-and-pub.md)
In questo esempio, sostituisci:
+ `Region`con il tuo Regione AWS, ad esempio`us-east-1`.
+ `AccountID`con il tuo Account AWS numero, ad esempio*`123456789012`*.
+ `ThingName`con il nome dell' AWS IoT oggetto a cui intendi eseguire il comando, ad esempio*`myRegisteredThing`*.
+ `commands-request-topic`e `commands-response-topic` con i nomi degli argomenti di richiesta e risposta dei AWS IoT comandi. Per ulteriori informazioni, consulta [Flusso di lavoro dei comandi di alto livello](iot-remote-command-workflow.md).
#### Esempio di policy IAM per l'ID client MQTT
Il codice seguente mostra un esempio di policy del dispositivo quando si utilizza l'ID client 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}"
}
]
}
```
#### Esempio di policy IAM per l'IoT
Il codice seguente mostra un esempio di policy relativa ai dispositivi quando si utilizza un AWS IoT oggetto.
****
```
{
"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}"
}
]
}
```
### Come usare l'`UpdateCommandExecution`API
Dopo aver ricevuto l'esecuzione del comando nell'argomento della richiesta, il dispositivo elabora il comando. Utilizza quindi l'`UpdateCommandExecution`API per aggiornare lo stato e il risultato dell'esecuzione del comando in base al seguente argomento di risposta.
```
$aws/commands///executions//response/
```
In questo esempio, *``* è l'identificatore univoco del dispositivo di destinazione ed *``* è l'identificatore dell'esecuzione del comando sul dispositivo di destinazione. **Possono essere JSON o CBOR.
**Nota**
Se non hai registrato il dispositivo con AWS IoT, puoi utilizzare l'ID cliente come identificatore anziché il nome dell'oggetto.
```
$aws/commands/clients//executions//response/
```
#### Il dispositivo ha segnalato gli aggiornamenti dello stato di esecuzione
I tuoi dispositivi possono utilizzare l'API per segnalare uno dei seguenti aggiornamenti di stato all'esecuzione del comando. Per ulteriori informazioni su questi stati, consulta[Stato di esecuzione del comando](iot-remote-command-concepts.md#iot-command-execution-status).
+ `IN_PROGRESS`: Quando il dispositivo inizia a eseguire il comando, può aggiornare lo stato a`IN_PROGRESS`.
+ `SUCCEEDED`: Quando il dispositivo elabora correttamente il comando e completa l'esecuzione, può pubblicare un messaggio nell'argomento di risposta come`SUCCEEDED`.
+ `FAILED`: Se il dispositivo non è riuscito a eseguire il comando, può pubblicare un messaggio nell'argomento di risposta come`FAILED`.
+ `REJECTED`: Se il dispositivo non accetta il comando, può pubblicare un messaggio nell'argomento di risposta come`REJECTED`.
+ `TIMED_OUT`: Lo stato di esecuzione del comando può cambiare in `TIMED_OUT` causa di uno dei seguenti motivi.
+ Il risultato dell'esecuzione del comando non è stato ricevuto. Ciò può accadere perché l'esecuzione non è stata completata entro la durata specificata o se il dispositivo non è riuscito a pubblicare le informazioni sullo stato nell'argomento di risposta.
+ Il dispositivo segnala che si è verificato un timeout durante il tentativo di esecuzione del comando.
Per ulteriori informazioni sullo `TIMED_OUT` stato, vedere[Valore del timeout e stato di `TIMED_OUT` esecuzione](#iot-command-execution-timeout-status).
#### Considerazioni sull'utilizzo dell'API `UpdateCommandExecution`
Di seguito sono riportate alcune considerazioni importanti sull'utilizzo dell'`UpdateCommandExecution`API.
+ I tuoi dispositivi possono utilizzare un `statusReason` oggetto opzionale per fornire informazioni aggiuntive sull'esecuzione. Se i dispositivi forniscono questo oggetto, il `reasonCode` campo dell'oggetto è obbligatorio, ma il `reasonDescription` campo è facoltativo.
+ Quando i dispositivi utilizzano l'`statusReason`oggetto, `reasonCode` devono utilizzare lo schema `[A-Z0-9_-]+` e non superare i 64 caratteri di lunghezza. Se lo fornisci`reasonDescription`, assicurati che non superi i 1.024 caratteri di lunghezza. Può utilizzare qualsiasi carattere tranne i caratteri di controllo come le nuove righe.
+ I dispositivi possono utilizzare un `result` oggetto opzionale per fornire informazioni sul risultato dell'esecuzione del comando, ad esempio il valore restituito da una chiamata di funzione remota. Se fornite il`result`, deve essere necessario inserire almeno una voce.
+ Nel `result` campo, si specificano le voci come coppie chiave-valore. Per ogni voce, è necessario specificare le informazioni sul tipo di dati come stringa, booleana o binaria. Un tipo di dati stringa deve utilizzare la chiave`s`, un tipo di dati booleano utilizza la chiave `b` e un tipo di dati binario deve utilizzare la chiave. `bin` Assicurati che queste chiavi siano minuscole.
+ Se riscontri un errore durante l'esecuzione dell'`UpdateCommandExecution`API, puoi visualizzare l'errore nel gruppo di `AWSIoTLogsV2` log di Amazon CloudWatch. Per informazioni sull'abilitazione della registrazione e sulla visualizzazione dei log, consulta. [Configurare la registrazione AWS IoT](configure-logging.md)
#### `UpdateCommandExecution`Esempio di API
Il codice seguente mostra un esempio di come il dispositivo può utilizzare l'`UpdateCommandExecution`API per segnalare lo stato di esecuzione, il `statusReason` campo per fornire informazioni aggiuntive sullo stato e il campo dei risultati per fornire informazioni sul risultato dell'esecuzione, ad esempio la percentuale della batteria dell'auto in questo caso.
```
{
"status": "IN_PROGRESS",
"statusReason": {
"reasonCode": "200",
"reasonDescription": "Execution_in_progress"
},
"result": {
"car_battery": {
"s": "car battery at 50 percent"
}
}
}
```
## Recupera l'esecuzione di un comando
Dopo aver eseguito un comando, è possibile recuperare informazioni sull'esecuzione del comando dalla AWS IoT console e utilizzare il. AWS CLIÈ possibile ottenere le seguenti informazioni.
**Nota**
Per recuperare lo stato di esecuzione del comando più recente, il dispositivo deve pubblicare le informazioni sullo stato nell'argomento della risposta utilizzando l'API `UpdateCommandExecution` MQTT, come descritto di seguito. Fino a quando il dispositivo non pubblicherà questo argomento, l'`GetCommandExecution`API riporterà lo stato come o. `CREATED` `TIMED_OUT`
Ogni esecuzione di comando creata avrà:
+ Un **ID di esecuzione**, che è un identificatore univoco dell’esecuzione del comando.
+ Lo **stato** dell’esecuzione del comando. Quando si esegue il comando sul dispositivo di destinazione, l’esecuzione del comando entra in uno stato `CREATED`. Può quindi passare ad altri stati di esecuzione dei comandi come descritto di seguito.
+ Il **risultato** dell'esecuzione del comando.
+ L’**ID di comando** univoco e il dispositivo di destinazione per il quale sono state create le esecuzioni.
+ La **data di inizio**, che indica l’ora in cui è stata creata l’esecuzione del comando.
### Recupera l'esecuzione di un comando (console)
È possibile recuperare l'esecuzione di un comando dalla console utilizzando uno dei seguenti metodi.
+
**Dalla pagina Command Hub**
Vai alla pagina [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) della AWS IoT console ed esegui questi passaggi.
1. Scegli il comando per il quale hai creato un'esecuzione sul dispositivo di destinazione.
1. Nella pagina dei dettagli del comando, nella scheda **Cronologia dei comandi**, vedrai le esecuzioni che hai creato. Scegli l'esecuzione per la quale desideri recuperare le informazioni.
1. Se i tuoi dispositivi hanno utilizzato l'`UpdateCommandExecution`API per fornire le informazioni sui risultati, puoi trovare queste informazioni nella scheda **Risultati** di questa pagina.
+
**Dalla pagina Thing hub**
Se si è scelto un AWS IoT oggetto come dispositivo di destinazione durante l'esecuzione del comando, è possibile visualizzare i dettagli di esecuzione dalla pagina Thing hub.
1. Vai alla pagina [Thing Hub](https://console.aws.amazon.com/iot/home#/thinghub) nella AWS IoT console e scegli l'oggetto per cui hai creato l'esecuzione del comando.
1. Nella pagina dei dettagli dell'oggetto, **nella cronologia dei comandi**, vedrai le esecuzioni che hai creato. Scegli l'esecuzione per la quale desideri recuperare le informazioni.
1. Se i tuoi dispositivi hanno utilizzato l'`UpdateCommandExecution`API per fornire le informazioni sui risultati, puoi trovare queste informazioni nella scheda **Risultati** di questa pagina.
### Recupera l'esecuzione di un comando (CLI)
Utilizzate l'operazione API HTTP del piano di [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 controllo per recuperare informazioni sull'esecuzione di un comando. È necessario aver già eseguito questo comando utilizzando l'operazione `StartCommandExecution` API.
#### Policy IAM di esempio
Prima di utilizzare questa operazione API, assicurati che la tua policy IAM ti autorizzi a eseguire questa azione sul dispositivo. L'esempio seguente mostra una policy IAM che consente l'autorizzazione dell'utente a eseguire l'`GetCommandExecution`azione.
In questo esempio, sostituisci:
+ `region`con il tuo Regione AWS, ad esempio`us-east-1`.
+ `account-id`con il tuo Account AWS numero, ad esempio`123456789012`.
+ `command-id`con il tuo identificatore di AWS IoT comando univoco, ad esempio`LockDoor`.
+ `devices`con uno dei due `thing` o `client` a seconda che i dispositivi siano stati registrati come AWS IoT oggetti o siano specificati come client MQTT.
+ `device-id`con il tuo 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"
]
}
```
#### Recupera un esempio di esecuzione di comando
L'esempio seguente mostra come recuperare informazioni su un comando che è stato eseguito utilizzando il `start-command-execution` AWS CLI comando. L'esempio seguente mostra come recuperare informazioni su un comando che è stato eseguito per disattivare la modalità volante.
In questo esempio, sostituisci:
+ *``*con l'identificatore per l'esecuzione del comando per il quale si desidera recuperare le informazioni.
+ *``*con l'Amazon Resource Number (ARN) del dispositivo a cui stai indirizzando l'esecuzione. È possibile ottenere queste informazioni dalla risposta del comando `start-command-execution` CLI.
+ Facoltativamente, se i dispositivi hanno utilizzato l'`UpdateCommandExection`API per fornire il risultato dell'esecuzione, è possibile specificare se includere il risultato dell'esecuzione del comando nella risposta dell'API che utilizza l'`GetCommandExecution``GetCommandExecution`API.
```
aws iot get-command-execution
--execution-id \
--target-arn \
--include-result
```
L'esecuzione di questo comando genera una risposta che contiene informazioni sull'ARN dell'esecuzione del comando, sullo stato dell'esecuzione e sull'ora in cui è iniziata l'esecuzione e quando è stata completata. Fornisce inoltre un `statusReason` oggetto che contiene informazioni aggiuntive sullo stato. Per ulteriori informazioni sui diversi stati e sul motivo dello stato, vedere[Stato di esecuzione del comando](iot-remote-command-concepts.md#iot-command-execution-status).
Il codice seguente mostra un esempio di risposta dalla richiesta API.
**Nota**
Il `completedAt` campo nella risposta di esecuzione corrisponde all'ora in cui il dispositivo segnala lo stato di un terminale al cloud. Nel caso dello `TIMED_OUT` status, questo campo verrà impostato solo quando il dispositivo segnala un timeout. Quando lo `TIMED_OUT` stato è impostato dal cloud, lo `TIMED_OUT` stato non viene aggiornato. Per ulteriori informazioni sul comportamento del timeout, consulta[Considerazioni sul timeout dell'esecuzione dei comandi](#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"
}
```
## Visualizzazione degli aggiornamenti dei comandi utilizzando il client di test MQTT
È possibile utilizzare il client di test MQTT per visualizzare lo scambio di messaggi su MQTT quando si utilizza la funzionalità dei comandi. Dopo che il dispositivo ha stabilito una connessione MQTT con AWS IoT, è possibile creare un comando, specificare il payload e quindi eseguirlo sul dispositivo. Quando si esegue il comando, se il dispositivo ha sottoscritto l'argomento di richiesta riservata MQTT per i comandi, viene visualizzato il messaggio di payload pubblicato su questo argomento.
Il dispositivo riceve quindi le istruzioni di payload ed esegue le operazioni specificate sul dispositivo. AWS IoT Utilizza quindi l'`UpdateCommandExecution`API per pubblicare il risultato dell'esecuzione del comando e le informazioni sullo stato negli argomenti di risposta riservati MQTT per i comandi. AWS IoT Device Management ascolta gli aggiornamenti sugli argomenti di risposta e archivia le informazioni aggiornate e pubblica i log su Amazon. AWS CloudTrail CloudWatch È quindi possibile recuperare le informazioni più recenti sull'esecuzione dei comandi dalla console o utilizzando l'API. `GetCommandExecution`
I passaggi seguenti mostrano come utilizzare il client di test MQTT per osservare i messaggi.
1. Aprire il [client di test MQTT](https://console.aws.amazon.com/iot/home#/test) nella AWS IoT console.
1. Nella scheda **Iscriviti**, inserisci il seguente argomento e poi scegli **Iscriviti**, ** dov'è il nome del dispositivo con AWS IoT cui ti sei registrato.
**Nota**
Puoi trovare il nome dell'oggetto per il tuo dispositivo nella pagina [Thing Hub](https://console.aws.amazon.com/iot/home#/thinghub) della AWS IoT console. Se non hai registrato il dispositivo come oggetto, puoi registrarlo al momento della connessione AWS IoT dalla [pagina Connect device](https://console.aws.amazon.com/iot/home#/connect-overview).
```
$aws/commands/things//executions/+/request
```
1. (Facoltativo) Nella scheda **Iscriviti**, puoi anche inserire i seguenti argomenti e scegliere **Iscriviti**.
```
$aws/commands/things/+/executions/+/response/accepted/json
$aws/commands/things/+/executions/+/response/rejected/json
```
1. Quando si avvia l'esecuzione di un comando, il payload del messaggio verrà inviato al dispositivo utilizzando l'argomento di richiesta a cui il dispositivo è abbonato,. `$aws/commands/things//executions/+/request` Nel client di test MQTT, dovresti vedere il payload del comando che contiene le istruzioni per l'elaborazione del comando da parte del dispositivo.
1. Dopo l'avvio dell'esecuzione del comando, il dispositivo può pubblicare aggiornamenti di stato al seguente argomento di risposta riservato MQTT per i comandi.
```
$aws/commands///executions//response/json
```
Ad esempio, prendete in considerazione un comando che avete eseguito per accendere l'aria condizionata dell'auto per ridurre la temperatura al valore desiderato. Il codice JSON seguente mostra un messaggio di esempio pubblicato dal veicolo nell'argomento di risposta, che mostra che non è riuscito a eseguire il 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"
}
}
```
In questo caso, puoi caricare la batteria dell'auto e quindi eseguire nuovamente il comando.
## Elenca le esecuzioni dei comandi nel tuo Account AWS
Dopo aver eseguito un comando, è possibile recuperare informazioni sull'esecuzione del comando dalla AWS IoT console e utilizzare il. AWS CLIÈ possibile ottenere le seguenti informazioni.
+ Un **ID di esecuzione**, che è un identificatore univoco dell’esecuzione del comando.
+ Lo **stato** dell’esecuzione del comando. Quando si esegue il comando sul dispositivo di destinazione, l’esecuzione del comando entra in uno stato `CREATED`. Può quindi passare ad altri stati di esecuzione dei comandi come descritto di seguito.
+ L’**ID di comando** univoco e il dispositivo di destinazione per il quale sono state create le esecuzioni.
+ La **data di inizio**, che indica l’ora in cui è stata creata l’esecuzione del comando.
### Elenca le esecuzioni dei comandi nel tuo account (console)
Puoi vedere tutte le esecuzioni dei comandi dalla console utilizzando uno dei seguenti metodi.
+
**Dalla pagina Command hub**
Vai alla pagina [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) della AWS IoT console ed esegui questi passaggi.
1. Scegli il comando per il quale hai creato un'esecuzione sul dispositivo di destinazione.
1. Nella pagina dei dettagli del comando, vai alla scheda **Cronologia dei comandi** e vedrai un elenco delle esecuzioni che hai creato.
+
**Dalla pagina Thing hub**
Se si è scelto un AWS IoT oggetto come dispositivo di destinazione durante l'esecuzione del comando e si sono create più esecuzioni di comandi per un singolo dispositivo, è possibile visualizzare le esecuzioni per il dispositivo dalla pagina Thing hub.
1. Vai alla pagina [Thing Hub](https://console.aws.amazon.com/iot/home#/thinghub) nella AWS IoT console e scegli l'oggetto per cui hai creato le esecuzioni.
1. Nella pagina dei dettagli dell'oggetto, **nella cronologia dei comandi**, vedrai un elenco di esecuzioni che hai creato per il dispositivo.
### Elenca le esecuzioni dei comandi nel tuo account (CLI)
Utilizza l'operazione API HTTP del piano di [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 controllo per elencare tutte le esecuzioni di comandi nel tuo account.
#### Policy IAM di esempio
Prima di utilizzare questa operazione API, assicurati che la tua policy IAM ti autorizzi a eseguire questa azione sul dispositivo. L'esempio seguente mostra una policy IAM che consente l'autorizzazione dell'utente a eseguire l'`ListCommandExecutions`azione.
In questo esempio, sostituisci:
+ `region`con il tuo Regione AWS, ad esempio`us-east-1`.
+ `account-id`con il tuo Account AWS numero, ad esempio`123456789012`.
+ `command-id`con il tuo identificatore di AWS IoT comando univoco, ad esempio`LockDoor`.
```
{
"Effect": "Allow",
"Action": "iot:ListCommandExecutions",
"Resource": *
}
```
#### Elenca un esempio di esecuzione di comandi
L'esempio seguente mostra come elencare le esecuzioni di comandi in. Account AWS
Quando si esegue il comando, è necessario specificare se filtrare l'elenco per visualizzare solo le esecuzioni di comandi create per un particolare dispositivo utilizzando il`targetArn`, o le esecuzioni per un particolare comando specificato utilizzando. `commandArn`
In questo esempio, sostituisci:
+ *``*con l'Amazon Resource Number (ARN) del dispositivo a cui stai indirizzando l'esecuzione, ad esempio. `arn:aws:iot:us-east-1:123456789012:thing/b8e4157c98f332cffb37627f`
+ *``*con l'Amazon Resource Number (ARN) del dispositivo a cui stai indirizzando l'esecuzione, ad esempio. `arn:aws:iot:us-east-1:123456789012:thing/b8e4157c98f332cffb37627f`
+ *``*con il tempo dopo il quale desideri elencare le esecuzioni che sono state create, ad esempio. `2024-11-01T03:00`
```
aws iot list-command-executions \
--target-arn \
--started-time-filter '{after=}' \
--sort-order "ASCENDING"
```
L'esecuzione di questo comando genera una risposta che contiene un elenco di esecuzioni di comandi create e l'ora in cui le esecuzioni hanno iniziato l'esecuzione e quando sono state completate. Fornisce inoltre informazioni sullo stato e l'`statusReason`oggetto che contiene informazioni aggiuntive sullo stato.
```
{
"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"
}
]
}
```
Per ulteriori informazioni sui diversi stati e sul motivo dello stato, vedere[Stato di esecuzione del comando](iot-remote-command-concepts.md#iot-command-execution-status).
## Eliminare l'esecuzione di un comando
Se non desideri più utilizzare l'esecuzione di un comando, puoi rimuoverla definitivamente dal tuo account.
**Nota**
L'esecuzione di un comando può essere eliminata solo se è entrato in uno stato di terminale`SUCCEEDED`, ad esempio`FAILED`, o`REJECTED`.
Questa operazione può essere eseguita solo utilizzando l' AWS IoT Core API o il AWS CLI. Non è disponibile dalla console.
### Policy IAM di esempio
Prima di utilizzare questa operazione API, assicurati che la tua policy IAM autorizzi il tuo dispositivo a eseguire queste azioni. Di seguito è riportato un esempio di policy che autorizza il dispositivo a eseguire l'azione.
In questo esempio, sostituisci:
+ `Region`con il tuo Regione AWS, ad esempio`us-east-1`.
+ `AccountID`con il tuo Account AWS numero, ad esempio*`123456789012`*.
+ `CommandID`con l'identificatore del comando di cui si desidera eliminare l'esecuzione.
+ `devices`con uno dei due `thing` o `client` a seconda che i dispositivi siano stati registrati come AWS IoT oggetti o siano specificati come client MQTT.
+ `device-id`con il tuo 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"
]
}
```
### Eliminare un esempio di esecuzione di comando
L'esempio seguente mostra come eliminare un comando utilizzando il `delete-command` AWS CLI comando. A seconda dell'applicazione, *``* sostituiscilo con l'identificatore per l'esecuzione del comando che stai eliminando e poi *``* con l'ARN del dispositivo di destinazione.
```
aws iot delete-command-execution \
--execution-id \
--target-arn
```
Se la richiesta API ha esito positivo, l'esecuzione del comando genera un codice di stato 200. Puoi utilizzare l'`GetCommandExecution`API per verificare che l'esecuzione del comando non esista più nel tuo account.
# Deprecare una risorsa di comando
Deprecate i comandi per indicare che sono obsoleti e non devono essere utilizzati. Ad esempio, i comandi obsoleti non vengono più mantenuti attivamente o quando si creano comandi più recenti con lo stesso ID ma payload diversi.
## Considerazioni chiave
Considerazioni importanti sulla deprecazione dei comandi:
+ La deprecazione di un comando non lo elimina. È possibile recuperare il comando utilizzando il relativo ID e ripristinarlo per riutilizzarlo.
+ Il tentativo di avviare nuove esecuzioni su comandi obsoleti genera un errore che impedisce l'uso di comandi obsoleti.
+ Per eseguire un comando obsoleto, è necessario innanzitutto ripristinarlo. Dopo il ripristino, il comando diventa disponibile per l'uso e l'esecuzione regolari sui dispositivi di destinazione.
+ Se si rende obsoleto un comando mentre le esecuzioni sono in corso, queste continuano a funzionare fino al completamento. È comunque possibile recuperare lo stato di esecuzione.
## Deprecare una risorsa di comando (console)
Per rendere obsoleto un comando dalla console, accedi al [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) della AWS IoT console ed esegui i seguenti passaggi.
1. **Scegli il comando che desideri rendere obsoleto, quindi in **Azioni** scegli Deprecate.**
1. **Conferma che desideri rendere obsoleto il comando, quindi scegli Deprecate.**
## Deprecare una risorsa di comando (CLI)
Contrassegna i comandi come obsoleti utilizzando la CLI. `update-command` È necessario rendere obsoleto un comando prima dell'eliminazione. Per utilizzare un comando obsoleto, ripristinalo prima.
```
aws iot update-command \
--command-id \
--deprecated
```
Ad esempio, se avete reso obsoleto il `ACSwitch` comando aggiornato nell'esempio precedente, il codice seguente mostra un esempio di output dell'esecuzione del comando.
```
{
"commandId": "turnOffAc",
"deprecated": true,
"lastUpdatedAt": "2024-05-09T23:16:51.370000-07:00"
}
```
## Controlla l'ora e lo stato di deprecazione
Utilizza l'`GetCommand`API per determinare se un comando è obsoleto e quando è stato deprecato l'ultima volta.
```
aws iot get-command --command-id
```
Questo comando genera una risposta contenente informazioni sul comando, inclusi i timestamp di creazione e deprecazione relativi all'ultimo campo aggiornato. Ciò consente di determinare la durata del comando e se eliminarlo o riutilizzarlo. Di seguito viene illustrato un esempio di risposta per il `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
}
```
## Ripristina una risorsa di comando
Per utilizzare o inviare il `ACSwitch` comando al dispositivo, ripristinalo prima.
Per ripristinare un comando dalla console, vai al [Command Hub](https://console.aws.amazon.com/iot/home#/commandHub) della AWS IoT console, scegli il comando che desideri ripristinare, quindi in **Azioni** scegli **Ripristina**.
Per ripristinare un comando utilizzando l' AWS IoT Core API o il AWS CLI, utilizza l'operazione `UpdateCommand` API o la `update-command` CLI. Il codice seguente mostra un esempio di richiesta e risposta.
```
aws iot update-command \
--command-id
--no-deprecated
```
Il codice seguente mostra un output di esempio.
```
{
"commandId": "ACSwitch",
"deprecated": false,
"lastUpdatedAt": "2024-05-09T23:17:21.954000-07:00"
}
```