

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Erstellen und verwalten Sie Jobs mit dem AWS CLI
<a name="manage-job-cli"></a>

In diesem Abschnitt wird beschrieben, wie Sie Aufträge erstellen und verwalten.

## Erstellen von Aufträgen
<a name="create-job"></a>

Verwenden Sie den **CreateJob** Befehl, um einen AWS IoT Job zu erstellen. Der Auftrag wird in die Warteschlange für die Ausführung auf den Zielen (Objekten oder Objektgruppen) gesetzt, die Sie angeben. Um einen AWS IoT Job zu erstellen, benötigen Sie ein Jobdokument, das in den Hauptteil der Anfrage oder als Link zu einem Amazon S3 S3-Dokument aufgenommen werden kann. Wenn der Job das Herunterladen von Dateien mit vorsigniertem Amazon S3 beinhaltet URLs, benötigen Sie eine IAM-Rolle mit Amazon Resource Name (ARN), die über die Berechtigung zum Herunterladen der Datei verfügt und dem AWS IoT Jobs-Service die Erlaubnis erteilt, die Rolle zu übernehmen.

[Weitere Informationen zur Syntax bei der Eingabe von Datum und Uhrzeit mithilfe eines API-Befehls oder des finden Sie unter AWS CLI Timestamp.](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-types.html#parameter-type-timestamp)

### Codesignatur mit Aufträgen
<a name="code-signing-with-jobs"></a>

Wenn Sie Codesignatur für verwenden AWS IoT, müssen Sie einen Codesignaturauftrag starten und die Ausgabe in Ihr Jobdokument aufnehmen. Dadurch wird der Platzhalter für die Codezeichensignatur in Ihrem Auftragsdokument ersetzt, der als Platzhalter erforderlich ist, bis er mithilfe Ihres Codesignaturprofils durch den Pfad der **signierten Codedatei** ersetzt wird. Der Platzhalter für die Codesignatur sieht wie folgt aus:

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

Verwenden Sie den [start-signing-job](https://docs.aws.amazon.com/signer/latest/developerguide/api-startsigningjob.html)Befehl, um einen Codesignaturauftrag zu erstellen. `start-signing-job`gibt eine Job-ID zurück. Verwenden Sie den Befehl **describe-signing-job**, um den Amazon S3-Ort abzurufen, an dem die Signatur gespeichert ist. Anschließend können Sie die Signatur von Amazon S3 herunterladen. Weitere Informationen zu Codesignaturaufträgen finden Sie unter [Codesignatur für AWS IoT](https://docs.aws.amazon.com/signer/latest/developerguide/Welcome.html).

Ihr Auftragsdokument muss einen vorsignierten URL Platzhalter für Ihre Code-Datei haben, und die JSON-Signaturausgabe muss in einem Amazon S3-Bucket unter Verwendung des **start-signing-job**-Befehls platziert sein:

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

### Erstellen eines Auftrags mit einem Auftragsdokument
<a name="create-job-with-document"></a>

Der folgende Befehl zeigt, wie Sie einen Job mithilfe eines in einem Amazon S3-Bucket (*job-document.json*) gespeicherten Auftragsdokuments (*jobBucket*) und einer Rolle mit der Berechtigung zum Herunterladen von Dateien von Amazon S3 (*S3DownloadRole*) erstellen.

```
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}"
```

Der Job wird ausgeführt am*thingOne*.

Der optionale `timeout-config`-Parameter gibt die Dauer an, die jedes Gerät für den Abschluss der Ausführung des Auftrags hat. Der Timer wird gestartet, wenn der Status der Auftragsausführung auf `IN_PROGRESS` gesetzt wird. Wird der Status der Auftragsausführung vor Ablauf der Zeit nicht auf einen anderen Terminal-Zustand festgelegt, wird er automatisch auf `TIMED_OUT` festgelegt.

Der Timer für „In Bearbeitung“ kann nicht aktualisiert werden und gilt für alle Auftragsausführungen für den Auftrag. Immer wenn eine Auftragsausführung länger als dieses Intervall im `IN_PROGRESS` Status verbleibt, schlägt sie fehl und wechselt in den `TIMED_OUT` Terminalstatus. AWS IoT veröffentlicht auch eine MQTT-Benachrichtigung.

Weitere Informationen zum Konfigurieren von Auftragsrollouts und -abbrüchen finden Sie unter [Auftragsrollout- und Abbruchkonfiguration](job-rollout-abort.html).

**Anmerkung**  
Auftragsdokumente, die als Amazon S3-Dateien angegeben werden, werden zum Zeitpunkt der Erstellung des Auftrags abgerufen. Wenn Sie den Inhalt der Amazon S3-Datei, die Sie als Quelle Ihres Auftragsdokuments verwendet haben, ändern, nachdem Sie das Auftragsdokument erstellt haben, ändert sich das, was an die Auftragsziele gesendet wird, nicht.

## Aktualisieren eines Auftrags
<a name="update-job"></a>

Um einen Auftrag zu aktualisieren, verwenden Sie den Befehl **UpdateJob**. Sie können die Felder `description`, `presignedUrlConfig`, `jobExecutionsRolloutConfig`, `abortConfig` und `timeoutConfig` eines Auftrags aktualisieren.

```
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}"
```

Weitere Informationen finden Sie unter [Rollout von Aufträgen und Abbruchskonfiguration](job-rollout-abort.html).

## Abbrechen eines Auftrags
<a name="cancel-job"></a>

Um einen Auftrag abzubrechen, verwenden Sie den Befehl **CancelJob**. Durch das Abbrechen eines Jobs AWS IoT werden keine neuen Jobausführungen für den Job bereitgestellt. Außerdem werden alle Auftragsausführungen storniert, die sich in einem bestimmten Status befinden. `QUEUED` AWS IoT lässt alle Auftragsausführungen im Terminalstatus unberührt, da das Gerät den Job bereits abgeschlossen hat. Wenn der Status einer Auftragsausführung `IN_PROGRESS` ist, wird sie auch nicht verändert, es sei denn, Sie verwenden den optionalen `--force`-Parameter.

Der folgende Befehl zeigt, wie Sie einen Auftrag mit der ID 010 abbrechen.

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

Die Ausgabe des Befehls sieht wie folgt aus:

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

Wenn Sie einen Auftrag abbrechen, werden Auftragsausführungen mit dem Status `QUEUED` abgebrochen. Auftragsausführungen mit dem Status `IN_PROGRESS` werden abgebrochen, aber nur, wenn Sie den optionalen `--force`-Parameter angeben. Auftragsausführungen mit einem Terminal-Zustand werden nicht abgebrochen.

**Warnung**  
Der Abbruch eines Auftrags im Status `IN_PROGRESS` (durch Setzen des `--force`-Parameters) bricht alle Auftragsausführungen ab, die sich in Ausführung befinden, was dazu führt, dass das Gerät, das den Auftrag ausführt, den Status der Auftragsausführung nicht aktualisieren kann. Seien Sie vorsichtig, und stellen Sie sicher, dass jedes Gerät, das einen abgebrochenen Auftrag ausführt, in einen gültigen Status zurückkehren kann.

Der Status eines abgebrochenen Auftrags oder einer seiner Jobausführungen ist letztendlich konsistent. AWS IoT beendet die Planung neuer Auftragsausführungen und `QUEUED` Auftragsausführungen für diesen Job auf Geräten so schnell wie möglich. Die Änderung des Status einer Auftragsausführung zu `CANCELED` kann jedoch je nach der Anzahl der Geräte und anderen Faktoren einige Zeit dauern.

Wenn ein Auftrag abgebrochen wurde, da er die von einem `AbortConfig`-Objekt definierten Kriterien erfüllt hat, fügt der Service automatisch eingegebene Werte für die Felder `comment` und `reasonCode` hinzu. Sie können Ihre eigenen Werte für `reasonCode` erstellen, wenn der Abbruch des Auftrags vom Benutzer gesteuert wird.

## Abbrechen einer Auftragsausführung
<a name="cancel-job-execution"></a>

Um eine Auftragsausführung auf einem Gerät abzubrechen, verwenden Sie den **CancelJobExecution**-Befehl. Damit wird eine Auftragsausführung abgebrochen, die sich im Status `QUEUED` befindet. Wenn Sie eine Auftragsausführung abbrechen möchten, die sich in Ausführung befindet, müssen Sie den `--force`-Parameter verwenden.

Der folgende Befehl zeigt, wie die Ausführung von Auftrag 010 auf `myThing` abgebrochen wird.

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

Der Befehl zeigt keine Ausgabe an.

Eine Auftragsausführung, die sich im Status `QUEUED` befindet, wird abgebrochen. Eine Auftragsausführung mit dem Status `IN_PROGRESS` wird abgebrochen, aber nur, wenn Sie den optionalen `--force`-Parameter angeben. Auftragsausführungen mit einem Terminal-Zustand können nicht abgebrochen werden. 

**Warnung**  
Der Abbruch einer Auftragsausführung mit dem Status `IN_PROGRESS` führt dazu, dass das Gerät den Ausführungsstatus für den Auftrag nicht aktualisieren kann. Seien Sie vorsichtig, und stellen Sie sicher, dass das Gerät in der Lage ist, in einen gültigen Status zurückzukehren.

Wenn sich die Auftragsausführung in einem Terminal-Zustand oder im Status `IN_PROGRESS` befindet und der `--force`-Parameter nicht auf `true` gesetzt ist, führt dieser Befehl zu einer `InvalidStateTransitionException`.

Der Status einer abgebrochenen Auftragsausführungen bleibt schließlich konsistent. Das Ändern des Status einer Auftragsausführung zu `CANCELED` kann aufgrund verschiedener Faktoren einige Zeit in Anspruch nehmen.

## Löschen eines Auftrags
<a name="delete-job"></a>

Um einen Auftrag und dessen Auftragsausführungen zu löschen, verwenden Sie den **DeleteJob**-Befehl. Standardmäßig können Sie nur einen Auftrag löschen, der sich in einem Terminal-Zustand (`SUCCEEDED` oder `CANCELED`) befindet. Andernfalls tritt eine Ausnahme auf. Sie können einen Auftrag im Status `IN_PROGRESS` löschen, jedoch nur, wenn der `force`-Parameter auf `true` gesetzt ist.

Um einen Auftrag zu löschen, führen Sie den folgenden Befehl aus:

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

Der Befehl zeigt keine Ausgabe an.

**Warnung**  
Wenn Sie einen Auftrag löschen, der sich im `IN_PROGRESS`-Status befindet, kann das Gerät, das den Auftrag umsetzt, nicht auf Auftragsinformationen zugreifen oder den Status der Auftragsausführung aktualisieren. Seien Sie vorsichtig, und stellen Sie sicher, dass jedes Gerät, das einen gelöschten Auftrag umsetzt, in einen gültigen Status zurückkehren kann.

Das Löschen eines Auftrags kann einige Zeit in Anspruch nehmen, abhängig von der Anzahl der Auftragsausführungen für den Auftrag und anderen Faktoren. Während der Auftrag gelöscht wird, wird `DELETION_IN_PROGRESS` als Status des Auftrags angezeigt. Es tritt ein Fehler auf, wenn Sie versuchen, einen Auftrag abzubrechen oder zu löschen, dessen Status bereits `DELETION_IN_PROGRESS` ist.

Nur 10 Aufträge können gleichzeitig den Status `DELETION_IN_PROGRESS` haben. Andernfalls tritt eine `LimitExceededException` auf.

## Abrufen eines Auftragsdokuments
<a name="get-job-document"></a>

Um ein Auftragsdokument für einen Auftrag abzurufen, verwenden Sie den Befehl **GetJobDocument**. Ein Auftragsdokument ist eine Beschreibung der Remoteoperationen, die von den Geräten ausgeführt werden sollen.

Um ein Auftragsdokument zu erhalten, führen Sie den folgenden Befehl aus:

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

Der Befehl gibt das Auftragsdokument für den angegebenen Auftrag aus:

```
{
    "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}"
}
```

**Anmerkung**  
Wenn Sie diesen Befehl verwenden, um ein Jobdokument abzurufen, werden Platzhalter URLs nicht durch vorsignierte Amazon S3 ersetzt. URLs Wenn ein Gerät den [GetPendingJobExecutions](https://docs.aws.amazon.com/iot/latest/apireference/API_iot-jobs-data_GetPendingJobExecutions.html)API-Vorgang aufruft, URLs werden die Platzhalter URLs im Auftragsdokument durch vorsignierte Amazon S3 ersetzt. 

## Auflisten von Aufträgen
<a name="list-jobs"></a>

Um eine Liste aller Jobs in Ihrem zu erhalten AWS-Konto, verwenden Sie den **ListJobs** Befehl. Auftragsdaten und Auftragsausführungsdaten werden für eine [begrenzte Zeit](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#job-limits)aufbewahrt. Führen Sie den folgenden Befehl aus, um alle Jobs in Ihrem aufzulisten AWS-Konto:

```
aws iot list-jobs
```

Der Befehl listet alle Aufträge in Ihrem Konto nach Auftragsstatus sortiert auf:

```
{
    "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"
        }
    ]
}
```

## Beschreiben eines Auftrags
<a name="describe-job"></a>

Um den Status eines Auftrags abzurufen, führen Sie den Befehl **DescribeJob** aus. Der folgende Befehl zeigt, wie Sie einen Auftrag beschreiben:

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

Der Auftrag gibt den Status des angegebenen Auftrags aus. Beispiel:

```
{
    "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
          }
    }
}
```

## Auflisten von Ausführungen für einen Auftrag
<a name="list-job-executions-for-job"></a>

Ein Auftrag, der auf einem bestimmten Gerät ausgeführt wird, wird durch ein Auftragsausführungsobjekt repräsentiert. Mit dem Befehl **ListJobExecutionsForJob** listen Sie alle Auftragsausführungen für einen Auftrag auf. Nachfolgend sehen Sie, wie Sie die Ausführungen für einen Auftrag auflisten können:

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

Der Befehl gibt eine Liste von Auftragsausführungen zurück:

```
{
    "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
        }
    }
    ]
}
```

## Auflisten von Auftragsausführungen für ein Objekt
<a name="list-job-executions-for-thing"></a>

Mit dem Befehl **ListJobExecutionsForThing** listen Sie alle Auftragsausführungen auf einem Objekt auf. Nachfolgend sehen Sie, wie Sie die Auftragsausführungen für ein Objekt auflisten können:

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

Der Befehl gibt eine Liste der Auftragsausführungen aus, die auf dem angegebenen Objekt ausgeführt werden oder wurden:

```
{
    "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"
    }
    ]
}
```

## Beschreiben der Auftragsausführung
<a name="describe-job-execution"></a>

Mit dem Befehl **DescribeJobExecution** rufen Sie den Status einer Auftragsausführung ab. Sie müssen eine Auftrags-ID und den Namen eines Objekts sowie optional eine Ausführungsnummer angeben, um die Auftragsausführung zu identifizieren. Nachfolgend sehen Sie, wie Sie eine Auftragsausführung beschreiben können:

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

Der Befehl gibt den [https://docs.aws.amazon.com/iot/latest/apireference/API_JobExecution.html](https://docs.aws.amazon.com/iot/latest/apireference/API_JobExecution.html) zurück: Beispiel:

```
{
    "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"
            }
        }
    }
}
```

## Löschen einer Auftragsausführung
<a name="delete-job-execution"></a>

Mit dem **DeleteJobExecution**-Befehl löschen Sie eine Auftragsausführung. Sie müssen eine Auftrags-ID und den Namen eines Objekts und eine Ausführungsnummer angeben, um die Auftragsausführung zu identifizieren. Nachfolgend sehen Sie, wie Sie eine Auftragsausführung löschen können:

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

Der Befehl zeigt keine Ausgabe an.

Standardmäßig muss der Status der Auftragsausführung `QUEUED` oder ein Terminal-Zustand (`SUCCEEDED`, `FAILED`, `REJECTED`, `TIMED_OUT`, `REMOVED` oder `CANCELED`) sein. Andernfalls tritt ein Fehler auf. Um eine Auftragsausführung mit dem Status `IN_PROGRESS` zu löschen, können Sie den `force`-Parameter auf `true` setzen.

**Warnung**  
Wenn Sie eine Auftragsausführung löschen, die sich im `IN_PROGRESS`-Status befindet, kann das Gerät, das den Auftrag ausführt, nicht auf Auftragsinformationen zugreifen oder den Status der Auftragsausführung aktualisieren. Seien Sie vorsichtig, und stellen Sie sicher, dass das Gerät in der Lage ist, in einen gültigen Status zurückzukehren.