Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Création d'une mise à jour OTA avec AWS CLI
Lorsque vous utilisez le AWS CLI pour créer une mise à jour OTA, vous :
1. Signez numériquement votre image de microprogramme.
1. Créez un flux de votre image de microprogramme signée numériquement.
1. Démarrez une tâche de mise à jour OTA.
## Signature numérique de votre mise à jour de microprogramme
Lorsque vous utilisez le AWS CLI pour effectuer des mises à jour OTA, vous pouvez utiliser la signature de code pour AWS IoT, ou vous pouvez signer vous-même la mise à jour de votre microprogramme. Pour obtenir la liste des algorithmes de signature et de hachage cryptographiques pris en charge par Code Signing for AWS IoT, consultez. [ SigningConfigurationOverrides](https://docs.aws.amazon.com/signer/latest/api/API_SigningConfigurationOverrides.html) Si vous souhaitez utiliser un algorithme cryptographique qui n'est pas pris en charge par Code Signing for AWS IoT, vous devez signer le binaire de votre microprogramme avant de le télécharger sur Amazon S3.
### Signature de l'image de votre microprogramme avec Code Signing pour AWS IoT
Pour signer l'image de votre microprogramme à l'aide de Code Signing for AWS IoT, vous pouvez utiliser l'un des [outils de ligne de commande AWS SDKs ou](https://aws.amazon.com/tools/). Pour plus d'informations sur la signature de code pour AWS IoT, consultez la section [Signature de code pour AWS IoT](https://docs.aws.amazon.com/signer/latest/developerguide/Welcome.html).
Après avoir installé et configuré les outils de signature de code, copiez l'image de votre microprogramme non signée dans votre compartiment Amazon S3 et lancez une tâche de signature de code à l'aide des commandes suivantes. AWS CLI La commande **put-signing-profile** crée un profil de signature de code réutilisable. La commande **start-signing-job** démarre la tâche de signature.
```
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
```
**Note**
*your-source-bucket-name*et il *your-destination-bucket-name* peut s'agir du même compartiment Amazon S3.
Voici les paramètres pour les commandes **put-signing-profile** et **start-signing-job** :
**`source`**
Spécifie l'emplacement du microprogramme non signé dans un compartiment S3.
+ `bucketName` : nom de votre compartiment S3.
+ `key` : clé (nom de fichier) de votre microprogramme dans votre compartiment S3.
+ `version` : version S3 de votre microprogramme dans votre compartiment S3. Cela est différent de votre version de microprogramme. Vous pouvez le trouver en accédant à la console Amazon S3, en choisissant votre compartiment, et en haut de la page, à côté de **Versions**, en choisissant **Afficher**.
**`destination`**
Destination sur le périphérique vers laquelle le microprogramme signé dans le compartiment S3 sera copié. Le format de ce paramètre est le même que le paramètre `source`.
**`signing-material`**
L'ARN de votre certificat de signature de code. Cet ARN est généré lorsque vous importez votre certificat dans ACM.
**`signing-parameters`**
Tableau de mappage des paires clé-valeur pour la signature. Ces informations peuvent inclure toutes celles que vous souhaitez utiliser lors de la signature.
Ce paramètre est obligatoire lorsque vous créez un profil de signature de code pour la signature des mises à jour OTA avec la signature de code pour AWS IoT.
**`platform`**
Valeur `platformId` de la plateforme matérielle sur laquelle vous distribuez la mise à jour OTA.
Pour renvoyer la liste des plateformes disponibles et leurs valeurs `platformId`, utilisez la commande `aws signer list-signing-platforms`.
La tâche de signature démarre et écrit l'image du microprogramme signée dans le compartiment Amazon S3 de destination. Le nom de fichier de l'image de microprogramme signée est un GUID. Vous avez besoin de ce nom de fichier lorsque vous créez un flux. Vous pouvez trouver le nom du fichier en accédant à la console Amazon S3 et en choisissant votre compartiment. Si vous ne voyez pas de fichier avec un nom de fichier GUID, actualisez votre navigateur.
La commande affiche un ARN de tâche et un ID de tâche. Vous aurez besoin de ces valeurs plus tard. Pour plus d'informations sur la signature de code pour AWS IoT, consultez la section [Signature de code pour AWS IoT](https://docs.aws.amazon.com/signer/latest/developerguide/Welcome.html).
### Signature manuelle de votre image de microprogramme
Signez numériquement l'image de votre microprogramme et téléchargez l'image de microprogramme signée dans votre compartiment Amazon S3.
## Création d'un flux de votre mise à jour du microprogramme
Un flux est une interface abstraite avec les données, qui peut être utilisée par un périphérique. Le flux masque la complexité de l'accès aux données stockées dans différents emplacements ou différents services basés sur le cloud. Le service OTA Update Manager vous permet d'utiliser plusieurs données, stockées à différents endroits dans Amazon S3, pour effectuer une mise à jour OTA.
Lorsque vous créez une mise à jour AWS IoT OTA, vous pouvez également créer un flux contenant votre mise à jour de microprogramme signée. Créez un fichier JSON (`stream.json`) qui identifie votre image de microprogramme signée. Le fichier JSON doit contenir ce qui suit.
```
[
{
"fileId":"your_file_id",
"s3Location":{
"bucket":"your_bucket_name",
"key":"your_s3_object_key"
}
}
]
```
Voici les attributs dans le fichier JSON :
**`fileId`**
Nombre entier arbitraire compris entre 0 et 255 qui identifie l'image de votre microprogramme.
**`s3Location`**
Le compartiment et la clé du microprogramme pour la création du flux.
**`bucket`**
Le compartiment Amazon S3 dans lequel est stockée votre image de microprogramme non signée.
**`key`**
Le nom de fichier de l'image de microprogramme signée dans le compartiment Amazon S3. Vous pouvez trouver cette valeur dans la console Amazon S3 en consultant le contenu de votre compartiment.
Si vous utilisez Code Signing pour AWS IoT, le nom du fichier est un GUID généré par Code Signing for AWS IoT.
Pour créer un flux, utilisez la commande **create-stream** AWS CLI .
```
aws iot create-stream \
--stream-id your_stream_id \
--description your_description \
--files file://stream.json \
--role-arn your_role_arn
```
Voici les arguments de la **create-stream** AWS CLI commande :
**`stream-id`**
Chaîne arbitraire d'identification du flux.
**`description`**
Description facultative du flux.
**`files`**
Une ou plusieurs références à des fichiers JSON qui contiennent des données sur les images de microprogramme pour créer le flux. Le fichier JSON doit contenir les attributs suivants :
**`fileId`**
Un ID fichier arbitraire.
**`s3Location`**
Le nom du compartiment dans lequel l'image de micrologiciel signée est stockée et la clé (nom de fichier) de l'image de microprogramme signée.
**`bucket`**
Le compartiment Amazon S3 dans lequel l'image du microprogramme signée est stockée.
**`key`**
La clé (nom de fichier) de l'image de microprogramme signée.
Lorsque vous utilisez la signature de code pour AWS IoT, cette clé est un GUID.
Voici un exemple de fichier `stream.json`.
```
[
{
"fileId":123,
"s3Location": {
"bucket":"codesign-ota-bucket",
"key":"48c67f3c-63bb-4f92-a98a-4ee0fbc2bef6"
}
}
]
```
**`role-arn`**
[Rôle de service OTA](create-service-role.md) qui accorde également l'accès au compartiment Amazon S3 dans lequel l'image du microprogramme est stockée.
Pour trouver la clé d'objet Amazon S3 de votre image de microprogramme signée, utilisez la **aws signer describe-signing-job --job-id *my-job-id*** commande où se `my-job-id` trouve l'ID de tâche affiché par la **create-signing-job** AWS CLI commande. La sortie de la commande **describe-signing-job** contient la clé de l'image de microprogramme signée.
```
... text deleted for brevity ...
"signedObject": {
"s3": {
"bucketName": "ota-bucket",
"key": "7309da2c-9111-48ac-8ee4-5a4262af4429"
}
}
... text deleted for brevity ...
```
## Création d'une mise à jour OTA
Utilisez la **create-ota-update** AWS CLI commande pour créer une tâche de mise à jour OTA.
**Note**
N'utilisez pas d'informations personnelles identifiables dans l'ID de tâche de votre mise à jour OTA. Voici quelques exemples d'informations personnelles identifiables :
Noms
Adresses IP
Adresses e-mail
Adresses
Informations bancaires.
Informations médicales.
```
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]
```
Format de `cli-input-json`
```
{
"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"
}
]
}
```
**Champs de `cli-input-json`**
| Nom | Type | Description |
| --- | --- | --- |
| `otaUpdateId` | chaîne (max : 128, min : 1) | ID de la mise à jour OTA à créer. |
| `description` | chaîne (max : 2028) | Description de la mise à jour OTA. |
| `targets` | liste | Appareils ciblés pour recevoir les mises à jour OTA. |
| `protocols` | liste | Protocole utilisé pour transférer l'image de mise à jour OTA. Les valeurs valides sont [HTTP], [MQTT], [HTTP, MQTT]. Lorsque HTTP et MQTT sont tous deux spécifiés, le dispositif cible peut choisir le protocole. |
| `targetSelection` | chaîne | Indique si la mise à jour continuera à s'exécuter (CONTINUOUS) ou sera terminée une fois que tous les objets spécifiés comme cibles l'auront effectuée (SNAPSHOT). Si elle est continue, la mise à jour peut également être exécutée sur un objet lorsqu'une modification est détectée dans une cible. Par exemple, une mise à jour s'exécute sur un objet lorsque ce dernier est ajouté à un groupe cible, même après que la mise à jour a été effectuée par tous les objets qui se trouvaient à l'origine dans le groupe. Valeurs valides : CONTINUOUS \$1 SNAPSHOT. énum : CONTINUOUS \$1 SNAPSHOT |
| `awsJobExecutionsRolloutConfig` | | Configuration pour le déploiement des mises à jour OTA. |
| `maximumPerMinute` | entier (max : 1 000, min : 1) | Nombre maximal d'exécutions de tâches de mise à jour OTA commencées par minute. |
| `exponentialRate` | | Taux d'augmentation pour le déploiement d'une tâche. Ce paramètre vous permet de définir un accroissement du taux exponentiel pour le déploiement d'une tâche. |
| `baseRatePerMinute` | entier (max : 1 000, min : 1) | Nombre minimal d'objets qui seront informés de la présence d'une tâche en attente, par minute, au début du déploiement d'une tâche. Il s'agit du taux initial de déploiement. |
| `rateIncreaseCriteria` | | Critères pour initier l'augmentation du taux de déploiement pour une tâche. AWS IoT prend en charge jusqu'à un chiffre après la virgule (par exemple, 1,5, mais pas 1,55). |
| `numberOfNotifiedThings` | entier (min : 1) | Lorsque ce nombre d'objets a été notifié, cela entraîne une augmentation du taux de déploiement. |
| `numberOfSucceededThings` | entier (min : 1) | Lorsque ce nombre d'objets a réussi l'exécution de leur tâche, cela entraîne une augmentation du taux de déploiement. |
| `awsJobPresignedUrlConfig` | | Informations de configuration pour la pré-signature URLs. |
| `expiresInSec` | long | Combien de temps (en secondes) les documents pré-signés URLs sont valides. Les valeurs autorisées sont comprises entre 60 et 3 600. La valeur par défaut est 1 800 secondes. Les documents pré-signés URLs sont générés lorsqu'une demande pour le document de travail est reçue. |
| `awsJobAbortConfig` | | Les critères qui déterminent quand et comment un arrêt de travail a lieu. |
| `abortCriteriaList` | liste | Liste des critères qui déterminent quand et comment arrêter le travail. |
| `failureType` | chaîne | Type d'échec de l'exécution d'une tâche susceptible de provoquer un arrêt de tâche. enum : FAILED \$1 REJECTED \$1 TIMED\$1OUT \$1 ALL |
| `action` | chaîne | Type de mesure à prendre pour déclencher l'arrêt de travail. enum : CANCEL |
| `minNumberOfExecutedThings` | entier (min : 1) | Le nombre minimum d'objets qui doivent recevoir des notifications d'exécution de la tâche avant que la tâche puisse être arrêtée. |
| `awsJobTimeoutConfig` | | Spécifie la durée pendant laquelle chaque appareil doit terminer son exécution de la tâche. Un minuteur est démarré quand l'état de l'exécution de la tâche a la valeur `IN_PROGRESS`. Si l'état de l'exécution de la tâche n'est pas défini sur un autre état terminal avant l'expiration du minuteur, il sera automatiquement défini avec la valeur `TIMED_OUT`. |
| `inProgressTimeoutInMinutes` | long | Spécifie la durée (en minutes) pendant laquelle cet appareil doit terminer l'exécution de la tâche. Le délai peut être n'importe quelle valeur comprise entre 1 minute et 7 jours (1 à 10 080 minutes). Le minuteur en cours ne peut pas être mis à jour et s'applique à toutes les exécutions de tâche pour la tâche. Chaque fois qu'une tâche d'exécution demeure dans l'état IN\$1PROGRESS plus longtemps que l'intervalle défini, la tâche d'exécution échoue et passe à l'état terminal `TIMED_OUT`. |
| `files` | liste | Fichiers qui seront diffusés par la mise à jour OTA. |
| `fileName` | chaîne | Nom du fichier. |
| `fileType` | entier plage - max. : 255 min. : 0 | Une valeur entière que vous pouvez inclure dans le document de travail pour permettre à vos appareils d'identifier le type de fichier reçu du cloud. |
| `fileVersion` | chaîne | Version du fichier. |
| `fileLocation` | | Emplacement du microprogramme mis à jour. |
| `stream` | | Flux contenant la mise à jour OTA. |
| `streamId` | chaîne (max : 128, min : 1) | ID du flux. |
| `fileId` | entier (max : 255, min : 0) | ID d'un fichier associé à un flux. |
| `s3Location` | | Emplacement du microprogramme mis à jour dans S3. |
| `bucket` | chaîne (min : 1) | Compartiment S3. |
| `key` | chaîne (min : 1) | Clé d'S3 |
| `version` | chaîne | Version du compartiment S3. |
| `codeSigning` | | Méthode de signature de code du fichier. |
| `awsSignerJobId` | chaîne | L'ID du AWSSigner Job créé pour signer le fichier. |
| `startSigningJobParameter` | | Décrire la tâche de signature du code. |
| `signingProfileParameter` | | Décrit le profil de signature du code. |
| `certificateArn` | chaîne | ARN de certificat. |
| `platform` | chaîne | Plateforme matérielle de votre appareil. |
| `certificatePathOnDevice` | chaîne | Emplacement du certificat de signature de code sur votre appareil. |
| `signingProfileName` | chaîne | Nom du profil de signature du code. |
| `destination` | | Emplacement pour écrire fichier dont le code est signé. |
| `s3Destination` | | Décrit l'emplacement dans S3 du microprogramme mis à jour. |
| `bucket` | chaîne (min : 1) | Compartiment S3 qui contient le microprogramme mis à jour. |
| `prefix` | chaîne | Préfixe S3. |
| `customCodeSigning` | | Méthode personnalisée pour la signature de code d'un fichier. |
| `signature` | | Signature du fichier. |
| `inlineDocument` | blob | Représentation binaire codée en base64 de la signature de code. |
| `certificateChain` | | Chaîne de certificats. |
| `certificateName` | chaîne | Nom du certificat. |
| `inlineDocument` | chaîne | Représentation binaire codée en base64 de la chaîne de certificats de signature de code. |
| `hashAlgorithm` | chaîne | Algorithme de hachage utilisé pour la signature de code du fichier. |
| `signatureAlgorithm` | chaîne | Algorithme de signature utilisé pour la signature de code du fichier. |
| `attributes` | map | Une liste de name/attribute paires. |
| `roleArn` | chaîne (max : 2048, min : 20) | Rôle IAM qui donne AWS IoT accès à Amazon S3, aux AWS IoT tâches et aux ressources de signature de AWS code pour créer une tâche de mise à jour OTA. |
| `additionalParameters` | map | Liste de paramètres de mise à jour OTA supplémentaires qui sont des paires nom-valeur. |
| `tags` | liste | Métadonnées qui peuvent être utilisées pour gérer les mises à jour. |
| `Key` | chaîne (max : 128, min : 1) | Clé de la balise. |
| `Value` | chaîne (max : 256, min : 1) | Valeur de la balise. |
Output
```
{
"otaUpdateId": "string",
"awsIotJobId": "string",
"otaUpdateArn": "string",
"awsIotJobArn": "string",
"otaUpdateStatus": "string"
}
```
**AWS CLI champs de sortie**
| Nom | Type | Description |
| --- | --- | --- |
| `otaUpdateId` | chaîne (max : 128, min : 1) | ID de mise à jour OTA. |
| `awsIotJobId` | chaîne | L'ID de AWS IoT tâche associé à la mise à jour OTA. |
| `otaUpdateArn` | chaîne | ARN de mise à jour OTA. |
| `awsIotJobArn` | chaîne | L'ARN de la AWS IoT tâche associé à la mise à jour OTA. |
| `otaUpdateStatus` | chaîne | Statut de la mise à jour OTA. énum : CREATE\$1PENDING CREATE\$1IN\$1PROGRESS CREATE\$1FAILED CREATE\$1COMPLETE \$1 \$1 \$1 |
Voici un exemple de fichier JSON transmis à la **create-ota-update** commande qui utilise la signature de code pour AWS IoT.
```
[
{
"fileName": "firmware.bin",
"fileType": 1,
"fileLocation": {
"stream": {
"streamId": "004",
"fileId":123
}
},
"codeSigning": {
"awsSignerJobId": "48c67f3c-63bb-4f92-a98a-4ee0fbc2bef6"
}
}
]
```
Voici un exemple de fichier JSON transmis à la **create-ota-update** AWS CLI commande qui utilise un fichier en ligne pour fournir du matériel de signature de code personnalisé.
```
[
{
"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"
}
}
}
]
```
Voici un exemple de fichier JSON transmis à la **create-ota-update** AWS CLI commande qui permet à FreeRTOS OTA de démarrer une tâche de signature de code et de créer un profil et un flux de signature de code.
```
[
{
"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"
}
}
}
}
}
]
```
Voici un exemple de fichier JSON transmis à la **create-ota-update** AWS CLI commande qui crée une mise à jour OTA qui lance une tâche de signature de code avec un profil existant et utilise le flux spécifié.
```
[
{
"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"
}
}
}
}
}
]
```
Voici un exemple de fichier JSON transmis à la **create-ota-update** AWS CLI commande qui permet à FreeRTOS OTA de créer un flux avec un identifiant de tâche de signature de code existant.
```
[
{
"fileName": "your_firmware_path_on_device",
"fileType": 1,
"fileVersion": "1",
"codeSigning":{
"awsSignerJobId": "your_signer_job_id"
}
}
]
```
Voici un exemple de fichier JSON transmis à la **create-ota-update** AWS CLI commande qui crée une mise à jour OTA. La mise à jour crée un flux à partir de l'objet S3 spécifié et utilise une signature de code personnalisée.
```
[
{
"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"
}
}
}
]
```
## Affichage des mises à jour OTA
Vous pouvez utiliser la **list-ota-updates** AWS CLI commande pour obtenir une liste de toutes les mises à jour OTA.
```
aws iot list-ota-updates
```
La sortie de la commande **list-ota-updates** se présente comme suit.
```
{
"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
}
]
}
```
## Obtention d'informations sur une mise à jour OTA
Vous pouvez utiliser la **get-ota-update** AWS CLI commande pour obtenir l'état de création ou de suppression d'une mise à jour OTA.
```
aws iot get-ota-update --ota-update-id your-ota-update-id
```
La sortie de la commande **get-ota-update** ressemble à ce qui suit.
```
{
"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"
}
}
```
Les valeurs renvoyées pour `otaUpdateStatus` incluent les éléments suivants :
**`CREATE_PENDING`**
La création d'une mise à jour OTA est en attente.
**`CREATE_IN_PROGRESS`**
Une mise à jour OTA est en cours de création.
**`CREATE_COMPLETE`**
Une mise à jour OTA a été créée.
**`CREATE_FAILED`**
La création d'une mise à jour OTA a échoué.
**`DELETE_IN_PROGRESS`**
Une mise à jour OTA est en cours de suppression.
**`DELETE_FAILED`**
La suppression d'une mise à jour OTA a échoué.
**Note**
Pour obtenir l'état d'exécution d'une mise à jour OTA après sa création, vous devez utiliser la commande **describe-job-execution**. Pour plus d'informations, consultez [Describe Job Execution](https://docs.aws.amazon.com/iot/latest/developerguide/manage-job-cli.html#describe-job-execution).
## Suppression des données OTA
Actuellement, vous ne pouvez pas utiliser la AWS IoT console pour supprimer des flux ou des mises à jour OTA. Vous pouvez utiliser le AWS CLI pour supprimer les flux, les mises à jour OTA et les AWS IoT tâches créées lors d'une mise à jour OTA.
### Suppression d'un flux OTA
Lorsque vous créez une mise à jour OTA qui utilise MQTT, vous pouvez utiliser la ligne de commande ou la AWS IoT console pour créer un flux afin de diviser le microprogramme en plusieurs parties afin qu'il puisse être envoyé via MQTT. Vous pouvez supprimer ce flux à l'aide de la **delete-stream** AWS CLI commande, comme indiqué dans l'exemple suivant.
```
aws iot delete-stream --stream-id your_stream_id
```
### Suppression d'une mise à jour OTA
Lorsque vous créez une mise à jour OTA, les éléments suivants sont créés :
+ Une entrée dans la base de données des tâches de mise à jour OTA.
+ Une AWS IoT tâche pour effectuer la mise à jour.
+ Exécution AWS IoT d'une tâche pour chaque appareil mis à jour.
La commande **delete-ota-update** supprime l'entrée dans la base de données des tâches de mise à jour OTA uniquement. Vous devez utiliser la commande **delete-job** pour supprimer la tâche AWS IoT .
Utilisez la commande **delete-ota-update** pour supprimer une mise à jour OTA.
```
aws iot delete-ota-update --ota-update-id your_ota_update_id
```
**`ota-update-id`**
ID de la mise à jour OTA à supprimer.
**`delete-stream`**
Supprime le flux associé à la mise à jour OTA.
**`force-delete-aws-job`**
Supprime la AWS IoT tâche associée à la mise à jour OTA. Si cet indicateur n'est pas défini et que la tâche est dans l'état `In_Progress`, la tâche n'est pas supprimée.
### Suppression d'une tâche IoT créée pour une mise à jour OTA
FreeRTOS crée AWS IoT une tâche lorsque vous créez une mise à jour OTA. Une exécution de tâche est également créée pour chaque appareil qui traite la tâche. Vous pouvez utiliser la **delete-job** AWS CLI commande pour supprimer une tâche et les exécutions de tâches associées.
```
aws iot delete-job --job-id your-job-id --no-force
```
Le paramètre `no-force` spécifie que seules les tâches qui sont dans un état final (COMPLETED ou CANCELLED) peuvent être supprimées. Vous pouvez supprimer une tâche qui est dans un état non final en transmettant le paramètre `force`. Pour plus d’informations, consultez [DeleteJob API](https://docs.aws.amazon.com/iot/latest/apireference/API_DeleteJob.html).
**Note**
La suppression d'une tâche avec le statut IN\$1PROGRESS interrompt toutes les exécutions de tâche IN\$1PROGRESS sur vos appareils et peut se traduire par le fait qu'un appareil se retrouve dans un état non déterministe. Assurez-vous que chaque appareil exécutant une tâche qui a été supprimée peut être rétabli dans un état connu.
Selon le nombre d'exécutions de tâche créées pour la tâche et plusieurs autres facteurs, la suppression d'une tâche peut prendre du temps. Pendant la suppression de la tâche, son statut est DELETION\$1IN\$1PROGRESS. Toute tentative de suppression ou d'annulation d'une tâche dont le statut est DELETION\$1IN\$1PROGRESS entraîne une erreur.
Vous pouvez utiliser la commande **delete-job-execution** pour supprimer une exécution de tâche. Il se peut que vous souhaitiez supprimer une exécution de tâche lorsqu'un petit nombre d'appareils ne sont pas en mesure de traiter une tâche. Cela supprime l'exécution de tâche pour un seul périphérique, comme illustré dans l'exemple suivant.
```
aws iot delete-job-execution --job-id your-job-id --thing-name
your-thing-name --execution-number your-job-execution-number --no-force
```
Comme pour la **delete-job** AWS CLI commande, vous pouvez passer le `--force` paramètre au pour **delete-job-execution** forcer la suppression de l'exécution d'une tâche. Pour plus d'informations, consultez la section [DeleteJobExecutionAPI](https://docs.aws.amazon.com/iot/latest/apireference/API_DeleteJobExecution.html).
**Note**
La suppression d'une exécution de tâche avec le statut IN\$1PROGRESS interrompt toutes les exécutions de tâche IN\$1PROGRESS sur vos appareils et peut se traduire par le fait qu'un appareil se retrouve dans un état non déterministe. Assurez-vous que chaque appareil exécutant une tâche qui a été supprimée peut être rétabli dans un état connu.
Pour plus d'informations sur l'application de démonstration de mise à jour OTA, consultez [Over-the-air met à jour l'application de démonstration](ota-demo.md).