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

Creazione di un aggiornamento OTA con AWS CLI

Quando si utilizza il AWS CLI per creare un aggiornamento OTA, si:

Aggiungere una firma digitale all'aggiornamento del firmware

Quando si utilizza il AWS CLI per eseguire aggiornamenti OTA, è possibile utilizzare Code Signing per AWS IoT, oppure è possibile firmare personalmente l'aggiornamento del firmware. Per un elenco degli algoritmi di firma crittografica e hashing supportati da Code Signing for AWS IoT, consulta. SigningConfigurationOverrides Se desideri utilizzare un algoritmo crittografico non supportato da Code Signing for AWS IoT, devi firmare il file binario del firmware prima di caricarlo su Amazon S3.

Firmare l'immagine del firmware con Code Signing per AWS IoT

Per firmare l'immagine del firmware utilizzando Code Signing for AWS IoT, puoi utilizzare uno degli AWS SDK o degli strumenti da riga di comando. Per ulteriori informazioni su Code Signing for AWS IoT, vedi Code Signing for AWS IoT.

Dopo aver installato e configurato gli strumenti di firma del codice, copia l'immagine del firmware non firmata nel bucket Amazon S3 e avvia un processo di firma del codice con i seguenti comandi. AWS CLI Il comando put-signing-profile crea un profilo di firma del codice riutilizzabile. Il comando start-signing-job avvia il processo di firma.

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

Questi sono i parametri per i comandi put-signing-profile e start-signing-job:

Il processo di firma viene avviato e scrive l'immagine del firmware firmata nel bucket Amazon S3 di destinazione. Il nome file per l'immagine del firmware con firma è un GUID. Questo nome file ti servirà per creare un flusso. Puoi trovare il nome del file accedendo alla console Amazon S3 e scegliendo il bucket. Se non viene visualizzato un file con un nome di file GUID, aggiorna il browser.

Il comando visualizza un ARN e un ID processo. Questi valori serviranno in seguito. Per ulteriori informazioni su Code Signing for AWS IoT, consulta Code Signing for. AWS IoT

Aggiungere una firma all'immagine del firmware in modo manuale

Firma digitalmente l'immagine del firmware e carica l'immagine firmata nel bucket Amazon S3.

Creazione di un flusso dell'aggiornamento del firmware

Un flusso è un'interfaccia astratta ai dati che possono essere consumati da un dispositivo. Un flusso può nascondere la complessità dell'accesso ai dati archiviati in posizioni diverse o servizi basati su cloud diversi. Il servizio OTA Update Manager consente di utilizzare più dati, archiviati in varie posizioni in Amazon S3, per eseguire un aggiornamento OTA.

Quando crei un aggiornamento AWS IoT OTA, puoi anche creare uno stream contenente l'aggiornamento del firmware firmato. Creare un file JSON (stream.json) che identifichi l'immagine del firmware con firma. Il file JSON deve contenere il testo seguente:

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

Questi sono gli attributi nel file JSON:

Utilizzare il comando create-stream AWS CLI per creare un flusso.

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

Questi sono gli argomenti del create-stream AWS CLI comando:

Per trovare la chiave oggetto Amazon S3 dell'immagine firmata del firmware, utilizza il aws signer describe-signing-job --job-id my-job-id comando where my-job-id is the job ID visualizzato dal comando. create-signing-job AWS CLI L'output del comando describe-signing-job contiene la chiave dell'immagine firmware con firma.

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

Creazione di un aggiornamento OTA

Usa il create-ota-update AWS CLI comando per creare un processo di aggiornamento OTA.

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 formato

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

Output

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

Di seguito è riportato un esempio di file JSON passato al create-ota-update comando che utilizza Code Signing for. AWS IoT

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

Di seguito è riportato un esempio di file JSON passato al create-ota-update AWS CLI comando che utilizza un file in linea per fornire materiale personalizzato per la firma del codice.

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

Quello che segue è un esempio di un file JSON passato al create-ota-update AWS CLI comando che consente a FreeRTOS OTA di avviare un processo di firma del codice e creare un profilo e uno stream di firma del codice.

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

Quello che segue è un esempio di un file JSON passato al create-ota-update AWS CLI comando che crea un aggiornamento OTA che avvia un processo di firma del codice con un profilo esistente e utilizza il flusso specificato.

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

Quello che segue è un esempio di un file JSON passato al create-ota-update AWS CLI comando che consente a FreeRTOS OTA di creare uno stream con un ID del job di firma del codice esistente.

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

Di seguito è riportato un esempio di file JSON passato al create-ota-update AWS CLI comando che crea un aggiornamento OTA. L'aggiornamento crea un flusso dall'oggetto S3 specificato e usa la firma del codice personalizzata.

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

Creazione di un elenco degli aggiornamenti OTA

È possibile utilizzare il list-ota-updates AWS CLI comando per ottenere un elenco di tutti gli aggiornamenti OTA.

aws iot list-ota-updates

L'output del comando list-ota-updates è simile al seguente.

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

Recupero di informazioni su un aggiornamento OTA

È possibile utilizzare il get-ota-update AWS CLI comando per ottenere lo stato di creazione o eliminazione di un aggiornamento OTA.

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

L'output del comando get-ota-update è simile al seguente.

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

I valori restituiti per otaUpdateStatus includono i seguenti:

Eliminazione dei dati OTA-related

Al momento, non è possibile utilizzare la AWS IoT console per eliminare stream o aggiornamenti OTA. Puoi utilizzarlo AWS CLI per eliminare stream, aggiornamenti OTA e i AWS IoT job creati durante un aggiornamento OTA.

Eliminazione di un flusso OTA

Quando crei un aggiornamento OTA che utilizza MQTT, puoi utilizzare la riga di comando o la AWS IoT console per creare uno stream per suddividere il firmware in blocchi in modo che possa essere inviato tramite MQTT. Puoi eliminare questo stream con il delete-stream AWS CLI comando, come mostrato nell'esempio seguente.

aws iot delete-stream --stream-id your_stream_id

Eliminazione di un aggiornamento OTA

Durante la creazione di un aggiornamento OTA, viene creato quanto segue:

Il comando delete-ota-update elimina solo la voce nel database dei processi di aggiornamento OTA. È necessario utilizzare il comando delete-job per eliminare il processo AWS IoT .

Usa il comando delete-ota-update per eliminare un aggiornamento OTA:

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

Eliminazione di un processo IoT creato per un aggiornamento OTA

FreeRTOS crea un AWS IoT job quando si crea un aggiornamento OTA. Viene inoltre creata l'esecuzione di un processo per ogni dispositivo che elabora il processo. È possibile utilizzare il delete-job AWS CLI comando per eliminare un lavoro e le relative esecuzioni.

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

Il parametro no-force specifica che possono essere eliminati solo i processi che si trovano in uno stato terminale (COMPLETED o CANCELLED). È possibile eliminare un processo che si trova in uno stato non terminale passando il parametro force. Per ulteriori informazioni, consulta API DeleteJob .

Il tempo necessario per eliminare un processo dipende dal numero di esecuzioni di processo create per il processo e da altri fattori. Mentre il processo viene eliminato, il suo stato è DELETION_IN_PROGRESS. Il tentativo di eliminare o annullare un processo il cui stato è già DELETION_IN_PROGRESS restituirà un errore.

Per eliminare l'esecuzione di un processo, puoi utilizzare delete-job-execution. È possibile eliminare l'esecuzione di un processo quando un esiguo numero di dispositivi non riesce a elaborare un processo. In questo modo viene eliminata l'esecuzione del processo per un singolo dispositivo, come mostrato nell'esempio seguente.

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

Come per il delete-job AWS CLI comando, è possibile passare il --force parametro a per delete-job-execution forzare l'eliminazione di un'esecuzione di un lavoro. Per ulteriori informazioni, consulta DeleteJobExecution API.

Per ulteriori informazioni sull'utilizzo dell'applicazione dimostrativa dell'aggiornamento OTA, consulta Over-the-air aggiorna l'applicazione demo.