

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 eines OTA-Updates mit dem AWS CLI
<a name="ota-cli-workflow"></a>

Wenn Sie das verwenden AWS CLI , um ein OTA-Update zu erstellen, gehen Sie wie folgt vor:

1. Signieren Sie Ihr Firmware-Image digital.

1. Erstellen Sie einen Stream Ihres digital signierten Firmware-Images.

1. Starten Sie einen OTA-Update-Job.

## Firmware-Updates digital signieren
<a name="ota-sign-cli"></a>

Wenn Sie das AWS CLI zur Durchführung von OTA-Updates verwenden, können Sie Code Signing für verwenden AWS IoT, oder Sie können Ihr Firmware-Update selbst signieren. Eine Liste der kryptografischen Signaturen und Hashing-Algorithmen, die von Code Signing for unterstützt werden AWS IoT, finden Sie unter. [ SigningConfigurationOverrides](https://docs.aws.amazon.com/signer/latest/api/API_SigningConfigurationOverrides.html) Wenn Sie einen kryptografischen Algorithmus verwenden möchten, der von Code Signing for nicht unterstützt wird AWS IoT, müssen Sie Ihre Firmware-Binärdatei signieren, bevor Sie sie auf Amazon S3 hochladen.

### Signieren Sie Ihr Firmware-Image mit Code Signing für AWS IoT
<a name="ota-sign-csfa"></a>

Um Ihr Firmware-Image mit Code Signing for zu signieren AWS IoT, können Sie eines der [AWS SDKs Befehlszeilentools oder](https://aws.amazon.com/tools/) verwenden. Weitere Informationen zu Code Signing für AWS IoT finden Sie unter [Code Signing für AWS IoT](https://docs.aws.amazon.com/signer/latest/developerguide/Welcome.html).

Nachdem Sie die Codesignatur-Tools installiert und konfiguriert haben, kopieren Sie Ihr unsigniertes Firmware-Image in Ihren Amazon S3 S3-Bucket und starten Sie einen Codesignatur-Job mit den folgenden Befehlen. AWS CLI Der Befehl **put-signing-profile** erstellt ein wiederverwendbares Codesignierungsprofil. Der Befehl **start-signing-job** startet die Signierungsaufgabe.

```
aws signer put-signing-profile \
    --profile-name your_profile_name \
    --signing-material certificateArn=arn:aws:acm::your-region:your-aws-account-id:certificate/your-certificate-id \
    --platform your-hardware-platform \
    --signing-parameters certname=your_certificate_path_on_device
```

```
aws signer start-signing-job \
    --source 's3={bucketName=your_s3_bucket,key=your_s3_object_key,version=your_s3_object_version_id}' \
    --destination 's3={bucketName=your_destination_bucket}' \
    --profile-name your_profile_name
```

**Anmerkung**  
*your-source-bucket-name*und *your-destination-bucket-name* kann derselbe Amazon S3 S3-Bucket sein.

Dies sind die Parameter für die Befehle **put-signing-profile** und **start-signing-job**:

**`source`**  
Gibt den Speicherort der unsignierten Firmware in einem S3-Bucket an.  
+ `bucketName`: Der Name des S3-Buckets.
+ `key`: Der Schlüssel (Dateiname) Ihrer Firmware in Ihrem S3-Bucket.
+ `version`: Die S3-Version Ihrer Firmware in Ihrem S3-Bucket. Diese unterscheidet sich von Ihrer Firmware-Version. Sie finden es, indem Sie zur Amazon S3 S3-Konsole gehen, Ihren Bucket auswählen und oben auf der Seite neben **Versionen** die Option **Anzeigen** auswählen.

**`destination`**  
Das Ziel auf dem Gerät, auf das die signierte Firmware im S3-Bucket kopiert wird. Das Format dieses Parameters ist mit dem von Parameter `source` identisch.

**`signing-material`**  
Der ARN Ihres Codesignierungszertifikats. Dieser ARN wird generiert, wenn Sie Ihr Zertifikat in ACM importieren.

**`signing-parameters`**  
Eine Zuordnung aus Schlüssel-Wert-Paaren für die Signierung. Diese können alle Informationen beinhalten, die Sie beim Signieren verwenden möchten.  
Dieser Parameter ist erforderlich, wenn Sie ein Codesignierungsprofil für das Signieren von OTA-Aktualisierungen mit Code Signing for AWS IoT verwenden.

**`platform`**  
Der `platformId` der Hardwareplattform, auf der Sie das OTA-Update verteilen.  
Um eine Liste der verfügbaren Plattformen und ihrer `platformId`-Werte zurückzugeben, verwenden Sie den Befehl `aws signer list-signing-platforms`.

Der Signaturauftrag wird gestartet und das signierte Firmware-Image wird in den Amazon S3-Ziel-Bucket geschrieben. Der Dateiname für das signierte Firmware-Image ist eine GUID. Sie benötigen diesen Dateinamen, wenn Sie einen Stream erstellen. Sie finden den Dateinamen, indem Sie zur Amazon S3-Konsole gehen und Ihren Bucket auswählen. Wenn Sie keine Datei mit einem GUID-Dateinamen sehen, aktualisieren Sie Ihren Browser.

Der Befehl zeigt einen Aufgaben-ARN und eine Aufgaben-ID an. Diese Werte benötigen Sie später. Weitere Informationen zu Code Signing für AWS IoT finden Sie unter [Code Signing for AWS IoT](https://docs.aws.amazon.com/signer/latest/developerguide/Welcome.html).

### Firmware-Images manuell signieren
<a name="ota-sign-manual"></a>

Signieren Sie Ihr Firmware-Image digital und laden Sie Ihr signiertes Firmware-Image in Ihren Amazon S3 S3-Bucket hoch.

## Erstellen eines Streams Ihres Firmware-Updates
<a name="ota-stream"></a>

Ein Stream ist eine abstrakte Schnittstelle zu Daten, die von einem Gerät verarbeitet werden können. Ein Stream kann die Komplexität des Zugriffs auf Daten verbergen, die an verschiedenen Speicherorten oder in verschiedenen cloudbasierten Services gespeichert sind. Mit dem OTA Update Manager-Service können Sie mehrere Daten verwenden, die an verschiedenen Orten in Amazon S3 gespeichert sind, um ein OTA-Update durchzuführen.

Wenn Sie ein AWS IoT OTA-Update erstellen, können Sie auch einen Stream erstellen, der Ihr signiertes Firmware-Update enthält. Erstellen Sie eine JSON-Datei (`stream.json`), die Ihr signiertes Firmware-Image identifiziert. Die JSON-Datei sollte Folgendes enthalten:

```
[
  {
    "fileId":"your_file_id",
    "s3Location":{
      "bucket":"your_bucket_name",
      "key":"your_s3_object_key"
    }
  }   
]
```

Dies sind die Attribute in der JSON-Datei:

**`fileId`**  
Eine beliebige Ganzzahl zwischen 0 und 255, die Ihr Firmware-Image identifiziert.

**`s3Location`**  
Der Bucket und der Schlüssel für die zu streamende Firmware.    
**`bucket`**  
Der Amazon S3 S3-Bucket, in dem Ihr unsigniertes Firmware-Image gespeichert ist.  
**`key`**  
Der Dateiname Ihres signierten Firmware-Images im Amazon S3 S3-Bucket. Sie finden diesen Wert in der Amazon S3 S3-Konsole, indem Sie sich den Inhalt Ihres Buckets ansehen.  
Wenn Sie Code Signing for verwenden AWS IoT, ist der Dateiname eine GUID, die von Code Signing for AWS IoT generiert wurde.

Verwenden Sie den Befehl **create-stream** AWS CLI , um einen Stream zu erstellen.

```
aws iot create-stream \
    --stream-id your_stream_id \
    --description your_description \
    --files file://stream.json \
    --role-arn your_role_arn
```

Dies sind die Argumente für den **create-stream** AWS CLI Befehl:

**`stream-id`**  
Eine beliebige Zeichenfolge zur Identifizierung des Streams.

**`description`**  
Eine optionale Beschreibung des Streams.

**`files`**  
Einer oder mehrere Verweise auf JSON-Dateien, die Daten über Firmware-Images zum Streamen enthalten. Die JSON-Datei muss die folgenden Attribute enthalten:    
**`fileId`**  
Eine beliebige Datei-ID.  
**`s3Location`**  
Der Bucket-Name, unter dem das signierte Firmware-Image gespeichert ist und der Schlüssel (Dateiname) des signierten Firmware-Images.  
**`bucket`**  
Der Amazon S3 S3-Bucket, in dem das signierte Firmware-Image gespeichert ist.  
**`key`**  
Der Schlüssel (Dateiname) des signierten Firmware-Images.  
Wenn Sie Code Signing for verwenden AWS IoT, ist dieser Schlüssel eine GUID.
Im Folgenden sehen Sie ein Beispiel für eine `stream.json`-Datei.  

```
[
    {
        "fileId":123,
        "s3Location": {
            "bucket":"codesign-ota-bucket",
            "key":"48c67f3c-63bb-4f92-a98a-4ee0fbc2bef6"
        }
    }
]
```

**`role-arn`**  
Die [OTA-Servicerolle](create-service-role.md), die auch Zugriff auf den Amazon S3 S3-Bucket gewährt, in dem das Firmware-Image gespeichert ist.

Um den Amazon S3 S3-Objektschlüssel Ihres signierten Firmware-Images zu finden, verwenden Sie den **aws signer describe-signing-job --job-id *my-job-id*** Befehl where `my-job-id` is the job id displayed by the **create-signing-job** AWS CLI command. Die Ausgabe des Befehls **describe-signing-job** enthält den Schlüssel des signierten Firmware-Images. 

```
... text deleted for brevity ...
  "signedObject": {
    "s3": {
      "bucketName": "ota-bucket",
      "key": "7309da2c-9111-48ac-8ee4-5a4262af4429"
    }
  }
... text deleted for brevity ...
```

## Erstellen eines OTA-Updates
<a name="create-ota-update"></a>

Verwenden Sie den **create-ota-update** AWS CLI Befehl, um einen OTA-Aktualisierungsauftrag zu erstellen.

**Anmerkung**  
Verwenden Sie keine personenbezogenen Daten in Ihrer OTA-Aktualsierungsauftrags-ID. Beispiele für personenbezogene Daten sind:  
Namen.
IP-Adressen.
E-Mail-Adressen.
Speicherorte.
Bankverbindung
Medizinische Informationen

```
aws iot  create-ota-update \
    --ota-update-id value \
    [--description value] \
    --targets value \
    [--protocols value] \
    [--target-selection value] \
    [--aws-job-executions-rollout-config value] \
    [--aws-job-presigned-url-config value] \
    [--aws-job-abort-config value] \
    [--aws-job-timeout-config value] \
    --files value \
    --role-arn value \
    [--additional-parameters value] \
    [--tags value]  \
    [--cli-input-json value] \
    [--generate-cli-skeleton]
```

 `cli-input-json`-Format

```
{
  "otaUpdateId": "string",
  "description": "string",
  "targets": [
    "string"
  ],
  "protocols": [
    "string"
  ],
  "targetSelection": "string",
  "awsJobExecutionsRolloutConfig": {
    "maximumPerMinute": "integer",
    "exponentialRate": {
      "baseRatePerMinute": "integer",
      "incrementFactor": "double",
      "rateIncreaseCriteria": {
        "numberOfNotifiedThings": "integer",
        "numberOfSucceededThings": "integer"
      }
    }
  },
  "awsJobPresignedUrlConfig": {
    "expiresInSec": "long"
  },
  "awsJobAbortConfig": {
    "abortCriteriaList": [
      {
        "failureType": "string",
        "action": "string",
        "thresholdPercentage": "double",
        "minNumberOfExecutedThings": "integer"
      }
    ]
  },
  "awsJobTimeoutConfig": {
    "inProgressTimeoutInMinutes": "long"
  },
  "files": [
    {
      "fileName": "string",
      "fileType": "integer",
      "fileVersion": "string",
      "fileLocation": {
        "stream": {
          "streamId": "string",
          "fileId": "integer"
        },
        "s3Location": {
          "bucket": "string",
          "key": "string",
          "version": "string"
        }
      },
      "codeSigning": {
        "awsSignerJobId": "string",
        "startSigningJobParameter": {
          "signingProfileParameter": {
            "certificateArn": "string",
            "platform": "string",
            "certificatePathOnDevice": "string"
          },
          "signingProfileName": "string",
          "destination": {
            "s3Destination": {
              "bucket": "string",
              "prefix": "string"
            }
          }
        },
        "customCodeSigning": {
          "signature": {
            "inlineDocument": "blob"
          },
          "certificateChain": {
            "certificateName": "string",
            "inlineDocument": "string"
          },
          "hashAlgorithm": "string",
          "signatureAlgorithm": "string"
        }
      },
      "attributes": {
        "string": "string"
      }
    }
  ],
  "roleArn": "string",
  "additionalParameters": {
    "string": "string"
  },
  "tags": [
    {
      "Key": "string",
      "Value": "string"
    }
  ]
}
```


**`cli-input-json`-Felder**  

| Name | Typ | Description | 
| --- | --- | --- | 
| `otaUpdateId` |  Zeichenfolge  (max:128 min:1)  | Die ID des zu erstellenden OTA-Updates. | 
| `description` |  Zeichenfolge  (max:2028)  | Die Beschreibung des OTA-Updates. | 
| `targets` |  list  | Die Zielgeräte für den Empfang der OTA-Updates. | 
| `protocols` |  list  |  Das Protokoll, das zum Übertragen des OTA-Aktualisierungsabbilds verwendet wird. Gültige Werte sind [HTTP], [MQTT], [HTTP, MQTT]. Wenn sowohl HTTP als auch MQTT angegeben sind, kann das Zielgerät das Protokoll auswählen.  | 
| `targetSelection` | Zeichenfolge |  Gibt an, ob das Update weiterhin ausgeführt wird (CONTINUOUS), oder ob es abgeschlossen wird, nachdem alle als Ziele angegebenen Objekte das Update abgeschlossen haben (SNAPSHOT). Bei „continuous“ kann das Update auch für ein Objekt ausgeführt werden, wenn eine Änderung in einem Ziel erkannt wird. Beispielsweise wird ein Update für ein Objekt ausgeführt, wenn das Objekt einer Zielgruppe hinzugefügt wird, auch wenn das Update von allen ursprünglich in der Gruppe befindlichen Objekten abgeschlossen wurde. Gültige Werte: CONTINUOUS \$1 SNAPSHOT. enum: CONTINUOUS \$1 SNAPSHOT  | 
| `awsJobExecutionsRolloutConfig` |  | Konfiguration für den Rollout der OTA-Updates. | 
| `maximumPerMinute` |  Ganzzahl  (max:1000 min:1)  | Die maximale Anzahl der pro Minute gestarteten OTA-Update-Auftragsausführungen. | 
| `exponentialRate` |  |  Die Wachstumsrate für einen Auftrags-Rollout. Dieser Parameter ermöglicht das Definieren eines exponentiellen Anstiegs der Rate für einen Aufgaben-Rollout.  | 
| `baseRatePerMinute` |  Ganzzahl  (max:1000 min:1)  |  Die Mindestanzahl der Objekte pro Minute, die zu Beginn des Aufgaben-Rollouts über eine anstehende Aufgabe benachrichtigt werden. Dies ist die anfängliche Rate des Rollouts.  | 
|   `rateIncreaseCriteria`  |   |  Die Kriterien zur Initiierung der Erhöhung der Rollout-Rate für einen Auftrag. AWS IoT unterstützt bis zu einer Nachkommastelle (z. B. 1,5, aber nicht 1,55).  | 
|   `numberOfNotifiedThings`  |  Ganzzahl  (min:1)  |  Wenn diese Anzahl von Objekten benachrichtigt wurde, wird eine Erhöhung der Rollout-Rate initiiert.  | 
|   `numberOfSucceededThings`  |  Ganzzahl  (min:1)  |  Wenn diese Anzahl von Objekten in ihrer Aufgabenausführung erfolgreich war, wird eine Erhöhung der Rollout-Rate initiiert.  | 
| `awsJobPresignedUrlConfig` |  |  Konfigurationsinformationen für vorsignierte URLs. | 
|   `expiresInSec`  |  long |  Wie lange (in Sekunden) vorsignierte Zeichen gültig URLs sind. Gültige Werte sind 60 - 3600, der Standardwert ist 1800 Sekunden. Vorsignierte URLs werden generiert, wenn eine Anfrage für das Auftragsdokument eingeht.  | 
|   `awsJobAbortConfig`  |   |  Die Kriterien, die bestimmen, wann und wie eine Auftragsunterbrechung stattfindet. | 
|   `abortCriteriaList`  |  list  |  Die Liste der Kriterien, die bestimmen, wann und wie der Job beendet werden soll. | 
|   `failureType`  |  Zeichenfolge |  Die Art der Fehler bei der Auftragsausführung, die zu einer Unterbrechung des Jobs führen können.  enum: FAILED \$1 REJECTED \$1 TIMED\$1OUT \$1 ALL  | 
|   `action`  |  Zeichenfolge |  Die Art der Auftragsaktion, die ergriffen werden muss, um die Auftragsunterbrechung einzuleiten.  enum: CANCEL  | 
|   `minNumberOfExecutedThings`  |  Ganzzahl  (min:1)  |  Die Mindestanzahl von Dingen, die Benachrichtigungen zur Auftragsausführung erhalten müssen, bevor der Job gestoppt werden kann.  | 
|   `awsJobTimeoutConfig`  |   |  Gibt die Dauer an, die jedes Gerät für den Abschluss der Ausführung des Auftrags hat. Ein Timer wird gestartet, wenn der Status der Auftragsausführung auf `IN_PROGRESS` gesetzt wird. Wenn der Status der Auftragsausführung vor Ablauf des Timers auf keinen anderen Endstatus gesetzt wird, wird er automatisch auf `TIMED_OUT` gesetzt.  | 
|   `inProgressTimeoutInMinutes`  |  long |  Gibt die Dauer in Minuten an, die dieses Gerät für den Abschluss der Ausführung dieses Auftrags hat. Das Intervall für die Zeitüberschreitung kann zwischen 1 Minute und 7 Tage (1 bis 10 080 Minuten) betragen. 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 Status IN\$1PROGRESS bleibt, schlägt die Auftragsausführung fehl und wechselt in den Endstatus `TIMED_OUT`.  | 
|   `files`  |  list  |  Die von dem OTA-Update zu streamenden Dateien. | 
|   `fileName`  |  Zeichenfolge |  Der Name der Datei. | 
|   `fileType`  |  Ganzzahl  range- max:255 min:0  |  Ein ganzzahliger Wert, den Sie in das Auftragsdokument aufnehmen können, damit Ihre Geräte den Typ der von der Cloud empfangenen Datei identifizieren können.  | 
|   `fileVersion`  |  Zeichenfolge |  Die Dateiversion. | 
|   `fileLocation`  |   |  Der Speicherort der aktualisierten Firmware. | 
|   `stream`  |   |  Der Stream, der das OTA-Update enthält. | 
|   `streamId`  |  Zeichenfolge  (max:128 min:1)  |  Die Stream-ID. | 
|   `fileId`  |  Ganzzahl  (max:255 min:0)  |  Die ID einer mit einem Stream verbundenen Datei. | 
|   `s3Location`  |   |  Der Speicherort der aktualisierten Firmware in S3. | 
|   `bucket`  |  Zeichenfolge  (min:1)  |  Der S3-Bucket. | 
|   `key`  |  Zeichenfolge  (min:1)  |  Der S3-Schlüssel | 
|   `version`  |  Zeichenfolge |  Die S3-Bucket-Version. | 
|   `codeSigning`  |   |  Die Codesignaturmethode der Datei. | 
|   `awsSignerJobId`  |  Zeichenfolge |  Die ID des AWSSigner Job, der zum Signieren der Datei erstellt wurde. | 
|   `startSigningJobParameter`  |   |  Beschreibt den Code-Signierungsauftrag. | 
|   `signingProfileParameter`  |   |  Beschreibt das Code-Signierungsprofil. | 
|   `certificateArn`  |  Zeichenfolge |  Zertifikat-ARN. | 
|   `platform`  |  Zeichenfolge |  Die Hardware-Plattform Ihres Geräts. | 
|   `certificatePathOnDevice`  |  Zeichenfolge |  Der Speicherort des Zertifikats zur Codesignierung auf Ihrem Gerät. | 
|   `signingProfileName`  |  Zeichenfolge |  Der Name des Code-Signierungsprofils. | 
|   `destination`  |   |  Der Speicherort für die mit Code signierte Datei. | 
|   `s3Destination`  |   |  Beschreibt den Speicherort der aktualisierten Firmware in S3. | 
|   `bucket`  |  Zeichenfolge  (min:1)  |  Der S3-Bucket, der die aktualisierte Firmware enthält. | 
|   `prefix`  |  Zeichenfolge |  Das S3-Präfix. | 
|   `customCodeSigning`  |   |  Eine benutzerdefinierte Methode zum Signieren einer Datei. | 
|   `signature`  |   |  Die Signatur für die Datei. | 
|   `inlineDocument`  |  blob |  Eine base64-kodierte binäre Repräsentation der Codesignatur-Signatur. | 
|   `certificateChain`  |   |  Die Zertifikatskette. | 
|   `certificateName`  |  Zeichenfolge |  Der Name des Zertifikats. | 
|   `inlineDocument`  |  Zeichenfolge |  Eine base64-kodierte binäre Repräsentation der Codesignatur-Zertifikatskette. | 
|   `hashAlgorithm`  |  Zeichenfolge |  Der für die Codesignatur der Datei verwendete Hash-Algorithmus | 
|   `signatureAlgorithm`  |  Zeichenfolge |  Der für die Codesignatur der Datei verwendete Signatur-Algorithmus | 
|   `attributes`  |  map |  Eine Liste von name/attribute Paaren. | 
|   `roleArn`  |  Zeichenfolge  (max:2048 min:20)  |  Die IAM-Rolle, die AWS IoT Zugriff auf Amazon S3, AWS IoT Jobs und AWS Code Signing-Ressourcen gewährt, um einen OTA-Aktualisierungsjob zu erstellen. | 
|   `additionalParameters`  |  map |  Eine Liste der zusätzlichen OTA-Update-Parameter, bei denen es sich um Name/Wert-Paare handelt. | 
|   `tags`  |  list  |  Metadaten, die verwendet werden können, um Updates zu verwalten. | 
|   `Key`  |  Zeichenfolge  (max:128 min:1)  |  Der Tag-Schlüssel. | 
|   `Value`  |  Zeichenfolge  (max:256 min:1)  |  Der Tag-Wert. | 

Ausgabe

```
{
  "otaUpdateId": "string",
  "awsIotJobId": "string",
  "otaUpdateArn": "string",
  "awsIotJobArn": "string",
  "otaUpdateStatus": "string"
}
```


**AWS CLI Ausgabefelder**  

|  Name |  Typ |  Description | 
| --- | --- | --- | 
|   `otaUpdateId`  |  Zeichenfolge  (max:128 min:1)  |  Die OTA-Update-ID. | 
|   `awsIotJobId`  |  Zeichenfolge |  Die mit dem OTA-Update verknüpfte AWS IoT Job-ID. | 
|   `otaUpdateArn`  |  Zeichenfolge |  Der ARN des OTA-Updates. | 
|   `awsIotJobArn`  |  Zeichenfolge |  Der AWS IoT Job-ARN, der dem OTA-Update zugeordnet ist. | 
|   `otaUpdateStatus`  |  Zeichenfolge |  Der Status des OTA-Updates.  enum: CREATE\$1PENDING \$1 CREATE\$1IN\$1PROGRESS \$1 CREATE\$1COMPLETE \$1 CREATE\$1FAILED  | 

Im Folgenden finden Sie ein Beispiel für eine JSON-Datei, die an den **create-ota-update** Befehl übergeben wurde, der Code Signing for verwendet AWS IoT.

```
[
  {
    "fileName": "firmware.bin",                
    "fileType": 1,
    "fileLocation": {
      "stream": {
        "streamId": "004",                         
        "fileId":123
      }                        
    },
    "codeSigning": {
      "awsSignerJobId": "48c67f3c-63bb-4f92-a98a-4ee0fbc2bef6"     
    }
  }
]
```

Im Folgenden finden Sie ein Beispiel für eine JSON-Datei, die an den **create-ota-update** AWS CLI Befehl übergeben wurde und eine Inline-Datei verwendet, um benutzerdefiniertes Codesignaturmaterial bereitzustellen.

```
[
  {
    "fileName": "firmware.bin",
    "fileType": 1,
    "fileLocation": {
      "stream": {
        "streamId": "004",
        "fileId": 123
      }
    },
    "codeSigning": {
      "customCodeSigning":{
        "signature":{
          "inlineDocument":"your_signature"
        },
        "certificateChain": {
          "certificateName": "your_certificate_name",
          "inlineDocument":"your_certificate_chain"
        },
        "hashAlgorithm":"your_hash_algorithm",
        "signatureAlgorithm":"your_signature_algorithm"
      }
    }
  }
]
```

Das Folgende ist ein Beispiel für eine an den **create-ota-update** AWS CLI Befehl übergebene JSON-Datei, die es FreeRTOS OTA ermöglicht, einen Codesignaturauftrag zu starten und ein Codesignaturprofil und einen Stream zu erstellen.

```
[
  {
    "fileName": "your_firmware_path_on_device",
    "fileType": 1,
    "fileVersion": "1",
    "fileLocation": {
      "s3Location": {
        "bucket": "your_bucket_name",
        "key": "your_object_key",
        "version": "your_S3_object_version"
      }
    },
    "codeSigning":{
      "startSigningJobParameter":{
        "signingProfileName": "myTestProfile",
        "signingProfileParameter": {
          "certificateArn": "your_certificate_arn",
          "platform": "your_platform_id",
          "certificatePathOnDevice": "certificate_path"
        },
        "destination": {
          "s3Destination": {
            "bucket": "your_destination_bucket"
          }
        }
      }
    }  
  }
]
```

Das Folgende ist ein Beispiel für eine JSON-Datei, die an den **create-ota-update** AWS CLI Befehl übergeben wird, der ein OTA-Update erstellt, das einen Codesignaturauftrag mit einem vorhandenen Profil startet und den angegebenen Stream verwendet.

```
[
  {
    "fileName": "your_firmware_path_on_device",
    "fileType": 1,
    "fileVersion": "1",
    "fileLocation": {
      "s3Location": {
        "bucket": "your_s3_bucket_name",
        "key": "your_object_key",
        "version": "your_S3_object_version"
      }
    },
    "codeSigning":{
      "startSigningJobParameter":{
        "signingProfileName": "your_unique_profile_name",
        "destination": {
          "s3Destination": {
            "bucket": "your_destination_bucket"
          }
        }
      }
    }  
  }
]
```

Das Folgende ist ein Beispiel für eine an den **create-ota-update** AWS CLI Befehl übergebene JSON-Datei, die es FreeRTOS OTA ermöglicht, einen Stream mit einer vorhandenen Codesignatur-Job-ID zu erstellen.

```
[
  {
    "fileName": "your_firmware_path_on_device",
    "fileType": 1,
    "fileVersion": "1",
    "codeSigning":{
      "awsSignerJobId": "your_signer_job_id"
    }  
  }
]
```

Das Folgende ist ein Beispiel für eine JSON-Datei, die an den **create-ota-update** AWS CLI Befehl übergeben wird, der ein OTA-Update erstellt. Das Update erstellt einen Stream aus dem angegebenen S3-Objekt und verwendet die benutzerdefinierte Codesignierung:

```
[
  {
    "fileName": "your_firmware_path_on_device",
    "fileType": 1,
    "fileVersion": "1",
    "fileLocation": {
      "s3Location": {
        "bucket": "your_bucket_name",
        "key": "your_object_key",
        "version": "your_S3_object_version"
      }
    },
    "codeSigning":{
      "customCodeSigning": {
        "signature":{
          "inlineDocument":"your_signature"
        },
        "certificateChain": {
          "inlineDocument":"your_certificate_chain",
          "certificateName": "your_certificate_path_on_device"
        },
        "hashAlgorithm":"your_hash_algorithm",
        "signatureAlgorithm":"your_sig_algorithm"
      }
    }  
  }
]
```

## Auflisten von OTA-Updates
<a name="list-ota-updates"></a>

Sie können den **list-ota-updates** AWS CLI Befehl verwenden, um eine Liste aller OTA-Updates abzurufen.

```
aws iot list-ota-updates
```

Die Ausgabe des Befehls **list-ota-updates** sieht wie folgt aus:

```
{
  "otaUpdates": [
     
    {
      "otaUpdateId": "my_ota_update2",
      "otaUpdateArn": "arn:aws:iot:us-west-2:123456789012:otaupdate/my_ota_update2",
      "creationDate": 1522778769.042
    },
    {
      "otaUpdateId": "my_ota_update1",
      "otaUpdateArn": "arn:aws:iot:us-west-2:123456789012:otaupdate/my_ota_update1",
      "creationDate": 1522775938.956
    },
    {
      "otaUpdateId": "my_ota_update",
      "otaUpdateArn": "arn:aws:iot:us-west-2:123456789012:otaupdate/my_ota_update",
      "creationDate": 1522775151.031
    }
  ]
}
```

## Informationen über ein OTA-Update abrufen
<a name="get-ota-updates"></a>

Sie können den **get-ota-update** AWS CLI Befehl verwenden, um den Erstellungs- oder Löschstatus eines OTA-Updates abzurufen.

```
aws iot get-ota-update --ota-update-id your-ota-update-id
```

Die Ausgabe des Befehls **get-ota-update** sieht wie folgt aus.

```
{ 
    "otaUpdateInfo": { 
        "otaUpdateId": "ota-update-001", 
        "otaUpdateArn": "arn:aws:iot:region:123456789012:otaupdate/ota-update-001", 
        "creationDate": 1575414146.286, 
        "lastModifiedDate": 1575414149.091, 
        "targets": [ 
            "arn:aws:iot:region:123456789012:thing/myDevice" 
        ], 
        "protocols": [ "HTTP" ], 
        "awsJobExecutionsRolloutConfig": { 
            "maximumPerMinute": 0 
        }, 
        "awsJobPresignedUrlConfig": { 
            "expiresInSec": 1800 
        }, 
        "targetSelection": "SNAPSHOT", 
        "otaUpdateFiles": [ 
            { 
                "fileName": "my_firmware.bin", 
                "fileType": 1,
                "fileLocation": { 
                    "s3Location": { 
                        "bucket": "my-bucket", 
                        "key": "my_firmware.bin", 
                        "version": "AvP3bfJC9gyqnwoxPHuTqM5GWENt4iii" 
                    } 
                }, 
                "codeSigning": { 
                    "awsSignerJobId": "b7a55a54-fae5-4d3a-b589-97ed103737c2", 
                    "startSigningJobParameter": { 
                        "signingProfileParameter": {}, 
                        "signingProfileName": "my-profile-name", 
                        "destination": { 
                            "s3Destination": { 
                                "bucket": "some-ota-bucket", 
                                "prefix": "SignedImages/" 
                            } 
                        } 
                    }, 
                    "customCodeSigning": {} 
                } 
            } 
        ], 
        "otaUpdateStatus": "CREATE_COMPLETE", 
        "awsIotJobId": "AFR_OTA-ota-update-001", 
        "awsIotJobArn": "arn:aws:iot:region:123456789012:job/AFR_OTA-ota-update-001" 
    } 
}
```

Für `otaUpdateStatus` können folgende Werte zurückgegeben werden:

**`CREATE_PENDING`**  
Die Erstellung eines OTA-Updates steht noch aus.

**`CREATE_IN_PROGRESS`**  
Ein OTA-Update wird erstellt.

**`CREATE_COMPLETE`**  
Es wurde ein OTA-Update erstellt.

**`CREATE_FAILED`**  
Die Erstellung eines OTA-Updates ist fehlgeschlagen.

**`DELETE_IN_PROGRESS`**  
Ein OTA-Update wird gelöscht.

**`DELETE_FAILED`**  
Das Löschen eines OTA-Updates ist fehlgeschlagen.

**Anmerkung**  
Um den Ausführungsstatus eines OTA-Updates nach dessen Erstellung abzurufen, müssen Sie den Befehl **describe-job-execution** verwenden. Weitere Informationen finden Sie unter [Beschreiben Sie die Jobausführung](https://docs.aws.amazon.com/iot/latest/developerguide/manage-job-cli.html#describe-job-execution).

## Löschen von OTA-bezogenen Daten
<a name="delete-ota-data"></a>

Derzeit können Sie die AWS IoT Konsole nicht zum Löschen von Streams oder OTA-Updates verwenden. Sie können den verwenden, AWS CLI um Streams, OTA-Updates und die während eines OTA-Updates erstellten AWS IoT Jobs zu löschen.

### Löschen eines OTA-Streams
<a name="delete-ota-stream"></a>

Wenn Sie ein OTA-Update erstellen, das MQTT verwendet, können Sie entweder die Befehlszeile oder die AWS IoT Konsole verwenden, um einen Stream zu erstellen, um die Firmware in Teile aufzuteilen, sodass sie über MQTT gesendet werden kann. Sie können diesen Stream mit dem **delete-stream** AWS CLI Befehl löschen, wie im folgenden Beispiel gezeigt.

```
aws iot delete-stream --stream-id your_stream_id
```

### Löschen eines OTA-Updates
<a name="delete-ota-update"></a>

Beim Erstellen eines OTA-Updates werden folgende Elemente erstellt:
+ Ein Eintrag in der OTA-Update-Job-Datenbank.
+ Ein AWS IoT Job zur Durchführung des Updates.
+ Eine AWS IoT Jobausführung für jedes Gerät, das aktualisiert wird.

Der Befehl **delete-ota-update** löscht nur den Eintrag in der OTA-Update-Job-Datenbank. Zum Löschen des AWS IoT -Jobs müssen Sie den Befehl **delete-job** verwenden.

Verwenden Sie den Befehl **delete-ota-update**, um ein OTA-Update zu löschen:

```
aws iot delete-ota-update --ota-update-id your_ota_update_id
```

**`ota-update-id`**  
Die ID des zu löschenden OTA-Updates.

**`delete-stream`**  
Löscht den Stream, der dem OTA-Update zugeordnet ist.

**`force-delete-aws-job`**  
Löscht den AWS IoT Job, der dem OTA-Update zugeordnet ist. Wenn dieses Flag nicht gesetzt ist und der Job den Status `In_Progress` hat, wird der Job nicht gelöscht.

### Löschen eines für ein OTA-Update erstellten IoT-Jobs
<a name="delete-ota-job"></a>

FreeRTOS erstellt einen AWS IoT Job, wenn Sie ein OTA-Update erstellen. Auch für jedes Gerät, das den Job verarbeitet, wird eine Job-Ausführung erstellt. Sie können den **delete-job** AWS CLI Befehl verwenden, um einen Job und die zugehörigen Jobausführungen zu löschen.

```
aws iot delete-job --job-id your-job-id --no-force
```

Der Parameter `no-force` legt fest, dass nur Jobs gelöscht werden können, die sich in einem Beendigungsstatus (COMPLETED oder CANCELLED) befinden. Indem Sie den Parameter `force` übergeben, können Sie einen Job löschen, der sich nicht in einem Beendigungsstatus befindet. Weitere Informationen finden Sie unter [DeleteJob -API](https://docs.aws.amazon.com/iot/latest/apireference/API_DeleteJob.html).

**Anmerkung**  
Das Löschen eines Jobs mit dem Status IN\$1PROGRESS unterbricht alle Job-Ausführungen, die sich auf Ihren Geräten befinden. Dies kann dazu führen, dass ein Gerät in einem nicht deterministischen Status verbleibt. Stellen Sie sicher, dass jedes Gerät, das einen gelöschten Job ausführt, zu einem bekannten Status zurückkehren kann.

Abhängig von der Anzahl der für die Aufgabe erstellten Aufgabenausführungen und anderen Faktoren kann das Löschen einer Aufgabe einige Minuten dauern. Während die Aufgabe gelöscht wird, hat sie den Status DELETION\$1IN\$1PROGRESS. Der Versuch, einen Job zu löschen oder abzubrechen, dessen Status bereits DELETION\$1IN\$1PROGRESS ist, führt zu einem Fehler.

Mit der **delete-job-execution** können Sie eine Job-Ausführung löschen. Möglicherweise möchten Sie eine Job-Ausführung löschen, wenn eine kleine Anzahl von Geräten einen Job nicht verarbeiten kann. Dadurch wird die Job-Ausführung für ein einzelnes Gerät gelöscht, wie im folgenden Beispiel gezeigt.

```
aws iot delete-job-execution --job-id your-job-id --thing-name
                    your-thing-name --execution-number your-job-execution-number --no-force
```

Wie beim **delete-job** AWS CLI Befehl können Sie den `--force` Parameter an die übergeben, **delete-job-execution** um das Löschen einer Jobausführung zu erzwingen. Weitere Informationen finden Sie unter [DeleteJobExecutionAPI](https://docs.aws.amazon.com/iot/latest/apireference/API_DeleteJobExecution.html).

**Anmerkung**  
Das Löschen einer Job-Ausführung mit dem Status IN\$1PROGRESS unterbricht alle Job-Ausführungen, die den Status IN\$1PROGRESS auf Ihren Geräten haben. Es kann dazu führen, dass ein Gerät in einem nicht deterministischen Status verbleibt. Stellen Sie sicher, dass jedes Gerät, das einen gelöschten Job ausführt, zu einem bekannten Status zurückkehren kann.

Weitere Informationen zur Verwendung der OTA-Update Demo-Anwendung finden Sie unter [Over-the-air aktualisiert die Demo-Anwendung](ota-demo.md).