

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à.

# Crea e gestisci i lavori utilizzando il AWS CLI
<a name="manage-job-cli"></a>

Questa sezione illustra come creare e gestire i processi.

## Creazione di processi
<a name="create-job"></a>

Per creare un AWS IoT lavoro, utilizzare il **CreateJob** comando. Il processo viene accodato per l'esecuzione nei target (oggetti o gruppi di oggetti) specificati. Per creare un AWS IoT lavoro, è necessario un documento di lavoro che può essere incluso nel corpo della richiesta o come collegamento a un documento Amazon S3. Se il processo include il download di file utilizzando Amazon URLs S3 predefinito, è necessario un ruolo IAM Amazon Resource Name (ARN) che disponga dell'autorizzazione per scaricare il file e conceda l'autorizzazione al servizio Jobs per assumere AWS IoT il ruolo.

[Per ulteriori informazioni sulla sintassi da utilizzare per l'immissione di data e ora utilizzando un comando API o il, consulta Timestamp. AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-types.html#parameter-type-timestamp)

### Firma del codice con i processi
<a name="code-signing-with-jobs"></a>

Se utilizzi la firma del codice per AWS IoT, devi avviare un processo di firma del codice e includere l'output nel documento di lavoro. Questo sostituirà il segnaposto di firma del codice nel documento del processo, che è richiesto come segnaposto finché non viene sostituito da percorso del file di codice firmato utilizzando il **profilo di firma del codice**. Il segnaposto di firma del codice sarà simile a quanto segue:

```
    ${aws:iot:code-sign-signature:s3://region.bucket/code-file@code-file-version-id}
```

Usa il [start-signing-job](https://docs.aws.amazon.com/signer/latest/developerguide/api-startsigningjob.html)comando per creare un processo di firma del codice. `start-signing-job`restituisce un ID di lavoro. Utilizza il comando **describe-signing-job** per ottenere la posizione di Amazon S3 in cui è archiviata la firma. È possibile eseguire il download della firma da Amazon S3. Per ulteriori informazioni sui processi di firma del codice, consulta [Firma del codice per AWS IoT](https://docs.aws.amazon.com/signer/latest/developerguide/Welcome.html).

Il documento del processo deve contenere un segnaposto URL prefirmato per il file del codice e l'output di firma JSON inserito in un bucket Amazon S3 utilizzando il comando **start-signing-job**:

```
{
    "presign": "${aws:iot:s3-presigned-url:https://s3.region.amazonaws.com/bucket/image}",
}
```

### Crea un processo con un documento del processo
<a name="create-job-with-document"></a>

Il comando seguente mostra come creare un lavoro utilizzando un documento di lavoro (*job-document.json*) archiviato in un bucket Amazon S3 (*jobBucket*) e un ruolo con autorizzazione a scaricare file da Amazon S3 (). *S3DownloadRole*

```
aws iot create-job  \
      --job-id 010  \
      --targets arn:aws:iot:us-east-1:123456789012:thing/thingOne  \
      --document-source https://s3.amazonaws.com/amzn-s3-demo-bucket/job-document.json  \
      --timeout-config inProgressTimeoutInMinutes=100 \
      --job-executions-rollout-config "{ \"exponentialRate\": { \"baseRatePerMinute\": 50, \"incrementFactor\": 2, \"rateIncreaseCriteria\": { \"numberOfNotifiedThings\": 1000, \"numberOfSucceededThings\": 1000}}, \"maximumPerMinute\": 1000}" \
      --abort-config "{ \"criteriaList\": [ { \"action\": \"CANCEL\", \"failureType\": \"FAILED\", \"minNumberOfExecutedThings\": 100, \"thresholdPercentage\": 20}, { \"action\": \"CANCEL\", \"failureType\": \"TIMED_OUT\", \"minNumberOfExecutedThings\": 200, \"thresholdPercentage\": 50}]}" \          
      --presigned-url-config "{\"roleArn\":\"arn:aws:iam::123456789012:role/S3DownloadRole\", \"expiresInSec\":3600}"
```

Il processo viene eseguito. *thingOne*

Il parametro `timeout-config` opzionale specifica l'intervallo di tempo a disposizione di ciascun dispositivo per terminare l'esecuzione del processo. Il timer viene avviato quando imposti lo stato di esecuzione del processo su `IN_PROGRESS`. Se lo stato di esecuzione del processo non è impostato su un altro stato terminale prima della scadenza del tempo a disposizione, viene impostato su `TIMED_OUT`.

Il timer in corso non può essere aggiornato e viene applicato a tutte le esecuzioni del processo. Ogni volta che l'esecuzione di un job rimane nello `IN_PROGRESS` stato per un periodo superiore a questo intervallo, fallisce e passa allo stato del terminale`TIMED_OUT`. AWS IoT pubblica anche una notifica MQTT.

Per ulteriori informazioni sulla creazione delle configurazioni dei rollout e delle interruzioni di processo, consulta la sezione relativa alla [Configurazione dei rollout e delle interruzioni di processo](job-rollout-abort.html).

**Nota**  
I documenti dei processi specificati come file Amazon S3 vengono recuperati al momento della creazione del processo. Se modifichi i contenuti del file Amazon S3 usato come origine del documento del processo dopo la creazione del processo, ciò che viene inviato ai destinatari del processo non cambia.

## Aggiornamento di un processo
<a name="update-job"></a>

Utilizza il comando **UpdateJob** per aggiornare un processo. È possibile aggiornare i campi `description`, `presignedUrlConfig`, `jobExecutionsRolloutConfig`, `abortConfig` e `timeoutConfig` di un processo.

```
aws iot update-job  \
  --job-id 010  \
  --description "updated description" \
  --timeout-config inProgressTimeoutInMinutes=100 \
  --job-executions-rollout-config "{ \"exponentialRate\": { \"baseRatePerMinute\": 50, \"incrementFactor\": 2, \"rateIncreaseCriteria\": { \"numberOfNotifiedThings\": 1000, \"numberOfSucceededThings\": 1000}, \"maximumPerMinute\": 1000}}" \
  --abort-config "{ \"criteriaList\": [ { \"action\": \"CANCEL\", \"failureType\": \"FAILED\", \"minNumberOfExecutedThings\": 100, \"thresholdPercentage\": 20}, { \"action\": \"CANCEL\", \"failureType\": \"TIMED_OUT\", \"minNumberOfExecutedThings\": 200, \"thresholdPercentage\": 50}]}" \          
  --presigned-url-config "{\"roleArn\":\"arn:aws:iam::123456789012:role/S3DownloadRole\", \"expiresInSec\":3600}"
```

Per ulteriori informazioni, consulta [Configurazione dei rollout e delle interruzioni di processo](job-rollout-abort.html).

## Annullamento di un processo
<a name="cancel-job"></a>

Utilizza il comando **CancelJob** per annullare un processo. L'annullamento di un lavoro AWS IoT impedisce l'implementazione di nuove esecuzioni di lavoro per il lavoro. Annulla anche tutte le esecuzioni di lavoro che si verificano in uno stato. `QUEUED` AWS IoT mantiene inalterate le esecuzioni di lavoro in uno stato terminale perché il dispositivo ha già completato il lavoro. Se lo stato di esecuzione di un processo è `IN_PROGRESS`, non verrà modificato, a meno che non si utilizzi il parametro opzionale `--force`.

Il comando seguente mostra come annullare un processo con ID 010.

```
aws iot cancel-job --job-id 010
```

Il comando visualizza il seguente output:

```
{
    "jobArn": "string",
    "jobId": "string",
    "description": "string"
}
```

Quando si annulla un processo, le esecuzioni con stato `QUEUED` vengono annullate. Le esecuzioni del processo con stato `IN_PROGRESS` saranno annullate se si specifica il parametro facoltativo `--force`. Le esecuzioni del processo con stato terminale non vengono annullate.

**avvertimento**  
L'annullamento di un processo con stato `IN_PROGRESS` (impostando il parametro `--force`) annulla tutte le esecuzioni dei processi in corso e impedisce al dispositivo che esegue il processo di aggiornarne lo stato di esecuzione. Prestare attenzione e verificare che tutti i dispositivi in cui è in esecuzione un processo annullato possano effettuare il ripristino a uno stato valido.

Lo stato di un lavoro annullato o di una delle relative esecuzioni di lavoro alla fine è costante. AWS IoT interrompe la pianificazione di nuove esecuzioni di lavori ed esecuzioni di lavori per quel `QUEUED` lavoro sui dispositivi il prima possibile. La modifica dello stato dell'esecuzione di un processo in `CANCELED` potrebbe tuttavia richiedere un po' di tempo, a seconda del numero di dispositivi e di altri fattori.

Se un processo viene annullato perché soddisfa i criteri definiti da un oggetto `AbortConfig`, il servizio aggiunge valori popolati automaticamente per i campi `comment` e `reasonCode`. Puoi creare valori personalizzati per `reasonCode` quando l'annullamento del processo è basato sull'utente.

## Annullamento dell'esecuzione di un processo
<a name="cancel-job-execution"></a>

Utilizza il comando **CancelJobExecution** per annullare l'esecuzione di un processo su un dispositivo. Questo comando annulla un processo che si trova in uno stato `QUEUED`. Per annullare l'esecuzione di un processo in corso, è necessario utilizzare il parametro `--force`.

Il comando seguente mostra come annullare l'esecuzione del processo 010 su `myThing`.

```
aws iot cancel-job-execution --job-id 010 --thing-name myThing
```

Il comando non visualizza alcun output.

Annulla l'esecuzione di un processo che si trova in uno stato `QUEUED`. L'esecuzione di un processo con stato `IN_PROGRESS` viene annullata se si specifica il parametro opzionale `--force`. Le esecuzioni del processo con stato terminale non possono essere annullate. 

**avvertimento**  
Quando si annulla l'esecuzione di un processo con uno stato `IN_PROGRESS`, il dispositivo non può aggiornarne lo stato di esecuzione del processo. Prestare attenzione e verificare che il dispositivo possa effettuare il ripristino a uno stato valido.

Se l'esecuzione del processo è in uno stato terminale oppure se è nello stato `IN_PROGRESS` e il parametro `--force` non è impostato su `true`, questo comando genera un'eccezione `InvalidStateTransitionException`.

Lo stato dell'esecuzione di un processo annullato è consistente finale. La modifica dello stato dell'esecuzione di un processo in `CANCELED` potrebbe tuttavia richiedere un po' di tempo, a seconda di vari fattori.

## Eliminare un processo
<a name="delete-job"></a>

Puoi usare il comando **DeleteJob** per eliminare un processo e le relative esecuzioni. Per impostazione predefinita, è possibile eliminare solo un processo in stato terminale (`SUCCEEDED` o `CANCELED`). In caso contrario, viene generata un'eccezione. È possibile eliminare un processo nello stato `IN_PROGRESS` solo se il parametro `force` è impostato su `true`.

Per eliminare un processo, eseguire il seguente comando:

```
aws iot delete-job --job-id 010 --force|--no-force
```

Il comando non visualizza alcun output.

**avvertimento**  
Quando si elimina un processo con uno stato `IN_PROGRESS`, il dispositivo che sta eseguendo il processo non è in grado di accedere alle informazioni sul processo o di aggiornarne lo stato di esecuzione. Procedi con cautela e verifica che tutti i dispositivi in cui è in esecuzione un processo annullato possano effettuare il ripristino a uno stato valido.

L'eliminazione di un processo potrebbe richiedere del tempo, a seconda del numero di esecuzioni create per il processo e di altri fattori. Mentre il processo viene eliminato, il suo stato viene indicato come `DELETION_IN_PROGRESS`. Il tentativo di eliminare o annullare un processo il cui stato è già `DELETION_IN_PROGRESS`restituisce un errore.

Solo 10 processi possono essere nello stato `DELETION_IN_PROGRESS` nello stesso momento. In caso contrario, si verifica un'eccezione `LimitExceededException`.

## Recupero di un documento del processo
<a name="get-job-document"></a>

Usa il comando **GetJobDocument** per recuperare un documento per un processo. Un documento del processo è una descrizione delle operazioni remote che i dispositivi dovranno eseguire.

Esegui il comando seguente per ottenere un documento di processo:

```
aws iot get-job-document --job-id 010
```

Il comando restituisce il documento per il processo specificato:

```
{
    "document": "{\n\t\"operation\":\"install\",\n\t\"url\":\"http://amazon.com/firmWareUpate-01\",\n\t\"data\":\"${aws:iot:s3-presigned-url:https://s3.amazonaws.com/amzn-s3-demo-bucket/datafile}\"\n}"
}
```

**Nota**  
Quando usi questo comando per recuperare un documento di lavoro, i segnaposto URLs non vengono sostituiti da Amazon S3 prefirmato. URLs Quando un dispositivo richiama l'operazione [GetPendingJobExecutions](https://docs.aws.amazon.com/iot/latest/apireference/API_iot-jobs-data_GetPendingJobExecutions.html)API, i segnaposto URLs vengono sostituiti da Amazon S3 URLs prefirmato nel documento di lavoro. 

## Elenco dei processi
<a name="list-jobs"></a>

Per ottenere un elenco di tutti i lavori presenti nel tuo Account AWS, usa il comando. **ListJobs** I dati del processo e i dati relativi all'esecuzione del processo vengono conservati per un periodo di [tempo limitato](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#job-limits). Esegui il comando seguente per elencare tutti i lavori presenti nel tuo Account AWS:

```
aws iot list-jobs
```

Il comando restituisce tutti i processi nell'account ordinati in base allo stato:

```
{
    "jobs": [
        {
            "status": "IN_PROGRESS", 
            "lastUpdatedAt": 1486687079.743, 
            "jobArn": "arn:aws:iot:us-east-1:123456789012:job/013", 
            "createdAt": 1486687079.743, 
            "targetSelection": "SNAPSHOT",
            "jobId": "013"
        }, 
        {
            "status": "SUCCEEDED", 
            "lastUpdatedAt": 1486685868.444, 
            "jobArn": "arn:aws:iot:us-east-1:123456789012:job/012", 
            "createdAt": 1486685868.444, 
            "completedAt": 148668789.690,
            "targetSelection": "SNAPSHOT",
            "jobId": "012"
        }, 
        {
            "status": "CANCELED", 
            "lastUpdatedAt": 1486678850.575, 
            "jobArn": "arn:aws:iot:us-east-1:123456789012:job/011", 
            "createdAt": 1486678850.575, 
            "targetSelection": "SNAPSHOT",
            "jobId": "011"
        }
    ]
}
```

## Descrizione di un processo
<a name="describe-job"></a>

Esegui il comando **DescribeJob** per ottenere lo stato di un processo. Il comando seguente mostra come descrivere un processo:

```
$ aws iot describe-job --job-id 010
```

Il comando restituisce lo stato del processo specificato. Ad esempio: 

```
{
    "documentSource": "https://s3.amazonaws.com/amzn-s3-demo-bucket/job-document.json", 
    "job": {
        "status": "IN_PROGRESS", 
        "jobArn": "arn:aws:iot:us-east-1:123456789012:job/010", 
        "targets": [
            "arn:aws:iot:us-east-1:123456789012:thing/myThing"
        ], 
        "jobProcessDetails": {
            "numberOfCanceledThings": 0, 
            "numberOfFailedThings": 0,
            "numberOfInProgressThings": 0,
            "numberOfQueuedThings": 0,
            "numberOfRejectedThings": 0,
            "numberOfRemovedThings": 0,
            "numberOfSucceededThings": 0,
            "numberOfTimedOutThings": 0,
            "processingTargets": [
                arn:aws:iot:us-east-1:123456789012:thing/thingOne, 
                arn:aws:iot:us-east-1:123456789012:thinggroup/thinggroupOne, 
                arn:aws:iot:us-east-1:123456789012:thing/thingTwo, 
                arn:aws:iot:us-east-1:123456789012:thinggroup/thinggroupTwo 
            ]
        }, 
        "presignedUrlConfig": {
            "expiresInSec": 60, 
            "roleArn": "arn:aws:iam::123456789012:role/S3DownloadRole"
        }, 
        "jobId": "010", 
        "lastUpdatedAt": 1486593195.006, 
        "createdAt": 1486593195.006,
        "targetSelection": "SNAPSHOT",
        "jobExecutionsRolloutConfig": { 
            "exponentialRate": { 
                "baseRatePerMinute": integer,
                "incrementFactor": integer,
                "rateIncreaseCriteria": { 
                    "numberOfNotifiedThings": integer, // Set one or the other
                    "numberOfSucceededThings": integer // of these two values.
                },
            "maximumPerMinute": integer
         }
        },    
        "abortConfig": { 
            "criteriaList": [ 
                { 
                    "action": "string",
                    "failureType": "string",
                    "minNumberOfExecutedThings": integer,
                    "thresholdPercentage": integer
                }
            ]
        },
        "timeoutConfig": { 
           "inProgressTimeoutInMinutes": number
          }
    }
}
```

## Visualizzazione di un elenco delle esecuzioni per un processo
<a name="list-job-executions-for-job"></a>

Un processo in esecuzione in un determinato dispositivo è rappresentato da un oggetto esecuzione del processo. Esegui il comando **ListJobExecutionsForJob** per elencare tutte le esecuzioni per un processo. Segue una descrizione di come visualizzare l'elenco delle esecuzioni per un processo:

```
aws iot list-job-executions-for-job --job-id 010
```

Il comando restituisce un elenco delle esecuzioni del processo:

```
{
    "executionSummaries": [
    {
        "thingArn": "arn:aws:iot:us-east-1:123456789012:thing/thingOne", 
        "jobExecutionSummary": {
            "status": "QUEUED", 
            "lastUpdatedAt": 1486593196.378, 
            "queuedAt": 1486593196.378,
            "executionNumber": 1234567890
        }
    },
    {
        "thingArn": "arn:aws:iot:us-east-1:123456789012:thing/thingTwo", 
        "jobExecutionSummary": {
            "status": "IN_PROGRESS", 
            "lastUpdatedAt": 1486593345.659, 
            "queuedAt": 1486593196.378,
            "startedAt": 1486593345.659,
            "executionNumber": 4567890123
        }
    }
    ]
}
```

## Visualizzazione di un elenco delle esecuzioni di un processo per un oggetto
<a name="list-job-executions-for-thing"></a>

Esegui il comando **ListJobExecutionsForThing** per elencare tutte le esecuzioni di processo in corso su un oggetto. Segue una descrizione di come visualizzare l'elenco delle esecuzioni di processo per un oggetto:

```
aws iot list-job-executions-for-thing --thing-name thingOne
```

Il comando restituisce un elenco delle esecuzioni del processo in corso o che sono avvenute nell'oggetto specificato:

```
{
    "executionSummaries": [
    {
        "jobExecutionSummary": {
            "status": "QUEUED", 
            "lastUpdatedAt": 1486687082.071, 
            "queuedAt": 1486687082.071,
            "executionNumber": 9876543210
        }, 
        "jobId": "013"
    }, 
    {
        "jobExecutionSummary": {
            "status": "IN_PROGRESS",
            "startAt": 1486685870.729, 
            "lastUpdatedAt": 1486685870.729, 
            "queuedAt": 1486685870.729,
            "executionNumber": 1357924680
        }, 
        "jobId": "012"
    }, 
    {
        "jobExecutionSummary": {
            "status": "SUCCEEDED", 
            "startAt": 1486678853.415,
            "lastUpdatedAt": 1486678853.415, 
            "queuedAt": 1486678853.415,
            "executionNumber": 4357680912
        }, 
        "jobId": "011"
    }, 
    {
        "jobExecutionSummary": {
            "status": "CANCELED",
            "startAt": 1486593196.378,
            "lastUpdatedAt": 1486593196.378, 
            "queuedAt": 1486593196.378,
            "executionNumber": 2143174250
        }, 
        "jobId": "010"
    }
    ]
}
```

## Descrizione dell'esecuzione di un processo
<a name="describe-job-execution"></a>

Esegui il comando **DescribeJobExecution** per ottenere lo stato dell'esecuzione di un processo. Per identificare l'esecuzione del processo, devi specificare un ID processo, un nome di oggetto e, facoltativamente, un numero di esecuzione. La sezione seguente mostra come descrivere l'esecuzione di un processo:

```
aws iot describe-job-execution --job-id 017 --thing-name thingOne
```

Il comando restituisce [https://docs.aws.amazon.com/iot/latest/apireference/API_JobExecution.html](https://docs.aws.amazon.com/iot/latest/apireference/API_JobExecution.html). Ad esempio: 

```
{
    "execution": {
        "jobId": "017", 
        "executionNumber": 4516820379,
        "thingArn": "arn:aws:iot:us-east-1:123456789012:thing/thingOne", 
        "versionNumber": 123,
        "createdAt": 1489084805.285, 
        "lastUpdatedAt": 1489086279.937, 
        "startedAt": 1489086279.937, 
        "status": "IN_PROGRESS",
        "approximateSecondsBeforeTimedOut": 100,
        "statusDetails": {
            "status": "IN_PROGRESS", 
            "detailsMap": {
                "percentComplete": "10"
            }
        }
    }
}
```

## Eliminazione dell'esecuzione di un processo.
<a name="delete-job-execution"></a>

Esegui il comando **DeleteJobExecution** per eliminare l'esecuzione di un processo. Per identificare l'esecuzione del processo, devi specificare un ID processo, un nome di oggetto e un numero di esecuzione. La sezione seguente mostra come eliminare l'esecuzione di un processo:

```
aws iot delete-job-execution --job-id 017 --thing-name thingOne --execution-number 1234567890 --force|--no-force
```

Il comando non visualizza alcun output.

Per impostazione predefinita, lo stato di esecuzione del processo deve essere `QUEUED` o terminale (`SUCCEEDED`, `FAILED`, `REJECTED`, `TIMED_OUT`, `REMOVED` o `CANCELED`). In caso contrario, si verifica un errore. Per eliminare l'esecuzione di un processo con uno stato `IN_PROGRESS`, è possibile impostare il parametro `force` su `true`.

**avvertimento**  
Quando elimini l'esecuzione di un processo con stato `IN_PROGRESS`, il dispositivo che sta eseguendo il processo non è in grado di accedere alle informazioni sul processo o di aggiornare lo stato di esecuzione del processo. Prestare attenzione e verificare che il dispositivo possa effettuare il ripristino a uno stato valido.