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. # Premier test de votre carte microcontrôleur Vous pouvez utiliser IDT pour FreeRTOS pour tester votre implémentation des bibliothèques FreeRTOS. Après avoir porté les bibliothèques FreeRTOS pour les pilotes de périphériques de votre carte, exécutez-les pour exécuter les tests AWS IoT Device Tester de qualification sur votre carte microcontrôleur. ## Ajouter des couches de transfert pour les bibliothèques Pour transférer FreeRTOS sur votre appareil, consultez le Guide de portage de [FreeRTOS](https://docs.aws.amazon.com/freertos/latest/portingguide/porting-guide.html). Lors de l'implémentation du référentiel de tests FreeRTOS et du portage des couches FreeRTOS, vous devez fournir `manifest.yml` un chemin d'accès à chaque bibliothèque, y compris le référentiel de tests. Ce fichier se trouvera dans le répertoire racine de votre code source. Consultez les [instructions du fichier manifeste](https://docs.aws.amazon.com/freertos/latest/qualificationguide/afq-checklist-manifest-instr.html) pour plus de détails. ## Configurez vos AWS informations d'identification AWS IoT Device Tester pour communiquer avec le AWS cloud Vous devez configurer vos AWS informations d'identification AWS IoT Device Tester pour pouvoir communiquer avec le AWS Cloud. Pour plus d'informations, voir [Configurer les AWS informations d'identification et la région pour le développement](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html). Les AWS informations d'identification valides sont spécifiées dans le fichier `devicetester_extract_location/devicetester_freertos_[win|mac|linux]/configs/config.json` de configuration. ``` "auth": { "method": "environment" } "auth": { "method": "file", "credentials": { "profile": "" } } ``` L'`auth`attribut du `config.json` fichier possède un champ de méthode qui contrôle AWS l'authentification et peut être déclaré en tant que fichier ou environnement. La définition du champ sur environnement extrait vos AWS informations d'identification des variables d'environnement de votre machine hôte. La définition du champ sur fichier permet d'importer un profil spécifié à partir du fichier de `.aws/credentials` configuration. **Topics** + [Ajouter des couches de transfert pour les bibliothèques](#lts-add-port-layer) + [Configurez vos AWS informations d'identification AWS IoT Device Tester pour communiquer avec le AWS cloud](#lts-cfg-aws-afr) + [Créer un pool d'appareils dans IDT pour FreeRTOS](lts-cfg-dt-dp.md) + [Configurer les paramètres de création, de flash et de test](lts-cfg-dt-ud.md) # Créer un pool d'appareils dans IDT pour FreeRTOS Les appareils à tester sont organisés dans des groupes. Chaque groupe d'appareils se compose d'un ou de plusieurs appareils identiques. Vous pouvez configurer IDT pour FreeRTOS afin de tester un seul appareil ou plusieurs appareils dans un pool. Pour accélérer le processus de qualification, IDT for FreeRTOS peut tester des appareils avec les mêmes spécifications en parallèle. Il utilise une méthode séquentielle pour exécuter un groupe de tests différents pour chaque appareil d'un groupe. Le `device.json` fichier possède un tableau à son niveau supérieur. Chaque attribut du tableau correspond à un nouveau pool de périphériques. Chaque pool de périphériques possède un attribut de tableau d'appareils, dans lequel plusieurs appareils sont déclarés. Dans le modèle, il existe un pool de périphériques et un seul appareil dans ce pool de périphériques. Vous pouvez ajouter un ou plusieurs appareils à un groupe d'appareils en modifiant la section `devices` du modèle `device.json` dans le dossier `configs`. **Note** Tous les appareils d'un même pool doivent avoir les mêmes spécifications techniques et le même SKU. Pour permettre des compilations parallèles du code source pour différents groupes de test, IDT pour FreeRTOS copie le code source dans un dossier de résultats à l'intérieur du dossier extrait d'IDT pour FreeRTOS. Vous devez référencer le chemin du code source dans votre commande de build ou de flash à l'aide de la `testdata.sourcePath` variable. IDT pour FreeRTOS remplace cette variable par un chemin temporaire du code source copié. Pour de plus amples informations, veuillez consulter [IDT pour les variables FreeRTOS](lts-dt-vars.md). Voici un exemple de `device.json` fichier qui a été utilisé pour créer un pool de périphériques avec plusieurs appareils. ``` [ { "id": "pool-id", "sku": "sku", "features": [ { "name": "Wifi", "value": "Yes | No" }, { "name": "Cellular", "value": "Yes | No" }, { "name": "BLE", "value": "Yes | No" }, { "name": "PKCS11", "value": "RSA | ECC | Both" }, { "name": "OTA", "value": "Yes | No", "configs": [ { "name": "OTADataPlaneProtocol", "value": "MQTT | HTTP | None" } ] }, { "name": "KeyProvisioning", "value": "Onboard | Import | Both | No" } ], "devices": [ { "id": "device-id", "connectivity": { "protocol": "uart", "serialPort": "/dev/tty*" }, "secureElementConfig" : { "publicKeyAsciiHexFilePath": "absolute-path-to/public-key-txt-file: contains-the-hex-bytes-public-key-extracted-from-onboard-private-key", "publiDeviceCertificateArn": "arn:partition:iot:region:account-id:resourcetype:resource:qualifier", "secureElementSerialNumber": "secure-element-serialNo-value", "preProvisioned" : "Yes | No", "pkcs11JITPCodeVerifyRootCertSupport": "Yes | No" }, "identifiers": [ { "name": "serialNo", "value": "serialNo-value" } ] } ] } ] ``` Les attributs suivants sont utilisés dans le fichier `device.json` : ** `id` ** Un ID alphanumérique défini par l'utilisateur qui identifie de façon unique un groupe d'appareils. Les appareils appartenant à un groupe doivent être du même type. Lorsque vous exécutez une suite de tests, les appareils du groupe sont utilisés pour paralléliser la charge de travail. ** `sku` ** Une valeur alphanumérique qui identifie de façon unique la carte que vous testez. La référence est utilisée pour effectuer le suivi des cartes qualifiées. Si vous souhaitez mettre votre carte en vente dans le catalogue des appareils AWS partenaires, le SKU que vous spécifiez ici doit correspondre au SKU que vous avez utilisé lors du processus de mise en vente. ** `features` ** Tableau contenant les fonctionnalités prises en charge par l'appareil. AWS IoT Device Tester utilise ces informations pour sélectionner les tests de qualification à exécuter. Les valeurs prises en charge sont : ** `Wifi` ** Indique si la carte contient des fonctionnalités Wi-Fi. ** `Cellular` ** Indique si votre carte est dotée de fonctionnalités cellulaires. ** `PKCS11` ** Indique l'algorithme de cryptographie à clé publique pris en charge par la carte. PKCS11 est requis pour la qualification. Les valeurs prises en charge sont `ECC``RSA`, et`Both`. `Both`indique que le tableau prend en charge les deux `ECC` et`RSA`. ** `KeyProvisioning` ** Indique la méthode d'écriture d'un certificat client X.509 approuvé sur votre carte. Les valeurs valides sont `Import``Onboard`, `Both` et`No`. `Onboard``Both`, ou l'approvisionnement `No` des clés est requis pour la qualification. `Import`à elle seule, n'est pas une option valide pour la qualification. + À utiliser `Import` uniquement si votre forum autorise l'importation de clés privées. `Import`La sélection n'est pas une configuration valide pour la qualification et ne doit être utilisée qu'à des fins de test, en particulier pour les cas de PKCS11 test. `Onboard`, `Both` ou `No` est requis pour la qualification. + À utiliser `Onboard` si votre carte prend en charge les clés privées intégrées (par exemple, si votre appareil possède un élément sécurisé ou si vous préférez générer votre propre paire de clés et votre propre certificat). Veillez à ajouter un élément `secureElementConfig` dans chacune des sections de l'appareil et indiquez le chemin absolu vers le fichier de clé publique dans le champ `publicKeyAsciiHexFilePath`. + À utiliser `Both` si votre tableau prend en charge à la fois l'importation de clés privées et la génération de clés intégrée pour le provisionnement des clés. + À utiliser `No` si votre tableau ne prend pas en charge l'approvisionnement en clés. `No`n'est une option valide que lorsque votre appareil est également préconfiguré. ** `OTA` ** Indique si votre carte mère prend en charge la fonctionnalité de mise à jour over-the-air (OTA). L'attribut `OtaDataPlaneProtocol` indique le protocole de plan de données OTA pris en charge par le périphérique. L'OTA avec le protocole de plan de données HTTP ou MQTT est requis pour la qualification. Pour ignorer l'exécution des tests OTA pendant les tests, définissez la fonctionnalité OTA sur `No` et l'`OtaDataPlaneProtocol`attribut sur`None`. Il ne s'agira pas d'une course de qualification. ** `BLE` ** Indique si la carte prend en charge Bluetooth Low Energy (BLE). ** `devices.id` ** Un identificateur unique défini par l'utilisateur pour l'appareil testé. ** `devices.connectivity.serialPort` ** Le port série de l'ordinateur hôte utilisé pour se connecter aux appareils testés. ** `devices.secureElementConfig.PublicKeyAsciiHexFilePath` ** Obligatoire si votre planche n'est PAS `pre-provisioned` ou n'`PublicDeviceCertificateArn`est pas fournie. Comme `Onboard` il s'agit d'un type obligatoire de fourniture de clés, ce champ est actuellement obligatoire pour le groupe de test FullTransportInterface TLS. Si votre appareil l'est`pre-provisioned`, `PublicKeyAsciiHexFilePath` il est facultatif et n'a pas besoin d'être inclus. Le bloc suivant est un chemin absolu vers le fichier contenant la clé publique en octets hexadécimaux extraite de la clé `Onboard` privée. ``` 3059 3013 0607 2a86 48ce 3d02 0106 082a 8648 ce3d 0301 0703 4200 04cd 6569 ceb8 1bb9 1e72 339f e8cf 60ef 0f9f b473 33ac 6f19 1813 6999 3fa0 c293 5fae 08f1 1ad0 41b7 345c e746 1046 228e 5a5f d787 d571 dcb2 4e8d 75b3 2586 e2cc 0c ``` Si votre clé publique est au format .der, vous pouvez l'encoder directement en hexadécimal pour générer le fichier hexadécimal. Pour générer le fichier hexadécimal à partir d'une clé publique .der, entrez la commande suivante : **xxd** ``` xxd -p pubkey.der > outFile ``` Si votre clé publique est au format .pem, vous pouvez extraire les en-têtes et pieds de page codés en base64 et les décoder au format binaire. Ensuite, vous codez la chaîne binaire en hexadécimal pour générer le fichier hexadécimal. Pour générer un fichier hexadécimal pour une clé publique .pem, procédez comme suit : 1. Exécutez la **base64** commande suivante pour supprimer l'en-tête et le pied de page base64 de la clé publique. La clé décodée, nommée`base64key`, est ensuite sortie dans le fichier `pubkey.der` : ``` base64 —decode base64key > pubkey.der ``` 1. Exécutez la **xxd** commande suivante pour convertir `pubkey.der` au format hexadécimal. La clé obtenue est enregistrée sous `outFile` ``` xxd -p pubkey.der > outFile ``` ** `devices.secureElementConfig.PublicDeviceCertificateArn` ** L'ARN du certificat de votre élément sécurisé qui est téléchargé vers AWS IoT Core. Pour plus d'informations sur le téléchargement de votre certificat vers AWS IoT Core, consultez la section [Certificats client X.509](https://docs.aws.amazon.com/iot/latest/developerguide/x509-client-certs.html) dans le guide du *AWS IoT développeur*. ** `devices.secureElementConfig.SecureElementSerialNumber` ** (Facultatif) Numéro de série de l'élément sécurisé. Le numéro de série est éventuellement utilisé pour créer des certificats d'appareil pour le provisionnement des clés JITR. ** `devices.secureElementConfig.preProvisioned` ** (Facultatif) Réglez sur « Oui » si l'appareil possède un élément sécurisé préconfiguré avec des informations d'identification verrouillées, qui ne peut pas importer, créer ou détruire des objets. Si cet attribut est défini sur **Oui**, vous devez fournir les étiquettes pkcs11 correspondantes. ** `devices.secureElementConfig.pkcs11JITPCodeVerifyRootCertSupport` ** (Facultatif) Définissez ce paramètre sur **Oui** si l'PKCS11 implémentation principale de l'appareil prend en charge le stockage pour JITP. Cela permettra le test JITP lors du `codeverify` test du noyau PKCS 11 et nécessitera la fourniture d'étiquettes de clé de vérification du code, de certificat JITP et de certificat racine PKCS 11. ** `identifiers` ** (Facultatif) Un tableau de paires nom-valeur arbitraires. Vous pouvez utiliser ces valeurs dans les commandes de création et flash décrites dans la section suivante. # Configurer les paramètres de création, de flash et de test IDT pour FreeRTOS crée et affiche automatiquement les tests sur votre carte. Pour activer cela, vous devez configurer IDT pour exécuter les commandes de compilation et de flash pour votre matériel. Les paramètres de création et flash sont configurés dans le modèle de fichier `userdata.json` situé dans le dossier `config`. # Configurer les paramètres pour tester un seul appareil Les paramètres de création, de flash et de test sont définis dans le fichier `configs/userdata.json`. L'exemple JSON suivant montre comment configurer IDT pour FreeRTOS afin de tester plusieurs appareils : ``` { "sourcePath": "", "retainModifiedSourceDirectories": true | false, "freeRTOSVersion": "", "freeRTOSTestParamConfigPath": "{{testData.sourcePath}}/path/from/source/path/to/test_param_config.h", "freeRTOSTestExecutionConfigPath": "{{testData.sourcePath}}/path/from/source/path/to/test_execution_config.h", "buildTool": { "name": "your-build-tool-name", "version": "your-build-tool-version", "command": [ " -any-additional-flags {{testData.sourcePath}}" ] }, "flashTool": { "name": "your-flash-tool-name", "version": "your-flash-tool-version", "command": [ " -any-additional-flags {{testData.sourcePath}} -any-additional-flags" ] }, "testStartDelayms": 0, "echoServerConfiguration": { "keyGenerationMethod": "EC | RSA", "serverPort": 9000 }, "otaConfiguration": { "otaE2EFirmwarePath": "{{testData.sourcePath}}/relative-path-to/ota-image-generated-in-build-process", "otaPALCertificatePath": "/path/to/ota/pal/certificate/on/device", "deviceFirmwarePath" : "/path/to/firmware/image/name/on/device", "codeSigningConfiguration": { "signingMethod": "AWS | Custom", "signerHashingAlgorithm": "SHA1 | SHA256", "signerSigningAlgorithm": "RSA | ECDSA", "signerCertificate": "arn:partition:service:region:account-id:resource:qualifier | /absolute-path-to/signer-certificate-file", "untrustedSignerCertificate": "arn:partition:service:region:account-id:resourcetype:resource:qualifier", "signerCertificateFileName": "signerCertificate-file-name", "compileSignerCertificate": true | false, // ***********Use signerPlatform if you choose AWS for signingMethod*************** "signerPlatform": "AmazonFreeRTOS-Default | AmazonFreeRTOS-TI-CC3220SF" ] } }, ********** This section is used for PKCS #11 labels of private key, public key, device certificate, code verification key, JITP certificate, and root certificate. When configuring PKCS11, you set up labels and you must provide the labels of the device certificate, public key, and private key for the key generation type (EC or RSA) it was created with. If your device supports PKCS11 storage of JITP certificate, code verification key, and root certificate, set 'pkcs11JITPCodeVerifyRootCertSupport' to 'Yes' in device.json and provide the corresponding labels. ********** "pkcs11LabelConfiguration":{ "pkcs11LabelDevicePrivateKeyForTLS": "", "pkcs11LabelDevicePublicKeyForTLS": "", "pkcs11LabelDeviceCertificateForTLS": "", "pkcs11LabelPreProvisionedECDevicePrivateKeyForTLS": "", "pkcs11LabelPreProvisionedECDevicePublicKeyForTLS": "", "pkcs11LabelPreProvisionedECDeviceCertificateForTLS": "", "pkcs11LabelPreProvisionedRSADevicePrivateKeyForTLS": "", "pkcs11LabelPreProvisionedRSADevicePublicKeyForTLS": "", "pkcs11LabelPreProvisionedRSADeviceCertificateForTLS": "", "pkcs11LabelCodeVerifyKey": "", "pkcs11LabelJITPCertificate": "", "pkcs11LabelRootCertificate": "" } } ``` Voici les attributs utilisés dans le fichier `userdata.json` : ** `sourcePath` ** Le chemin d'accès à la racine du code source FreeRTOS porté. ** `retainModifiedSourceDirectories` ** (Facultatif) Vérifie s'il faut conserver les répertoires sources modifiés utilisés lors de la construction et du flashage à des fins de débogage. S'il est défini sur`true`, les répertoires sources modifiés sont nommés RetainedSrc et se trouvent dans les dossiers du journal des résultats de chaque groupe de test exécuté. S'il n'est pas inclus, le champ est défini par défaut sur. `false` ** `freeRTOSTestParamConfigPath` ** Le chemin d'accès au `test_param_config.h` fichier à FreeRTOS-Libraries-Integration-Tests intégrer. Ce fichier doit utiliser la variable `{{testData.sourcePath}}` placeholder pour le rendre relatif à la racine du code source. AWS IoT Device Tester utilise les paramètres de ce fichier pour configurer les tests. ** `freeRTOSTestExecutionConfigPath` ** Le chemin d'accès au `test_execution_config.h` fichier à FreeRTOS-Libraries-Integration-Tests intégrer. Ce fichier doit utiliser la variable d'`{{testData.sourcePath}}`espace réservé pour le rendre relatif à la racine du dépôt. AWS IoT Device Tester utilise ce fichier pour contrôler les tests à exécuter. ** `freeRTOSVersion` ** La version de FreeRTOS, y compris la version de correctif utilisée dans votre implémentation. Voir [Versions prises en charge de AWS IoT Device Tester pour FreeRTOS](https://docs.aws.amazon.com/freertos/latest/userguide/dev-test-versions-afr.html) pour les versions de FreeRTOS compatibles avec FreeRTOS. AWS IoT Device Tester ** `buildTool` ** La commande permettant de créer votre code source. Toutes les références au chemin du code source dans la commande de construction doivent être remplacées par la AWS IoT Device Tester variable`{{testData.sourcePath}}`. Utilisez l'`{{config.idtRootPath}}`espace réservé pour référencer un script de génération relatif au chemin AWS IoT Device Tester racine. ** `flashTool` ** Commande permettant de flasher une image sur votre appareil. Toutes les références au chemin du code source dans la commande flash doivent être remplacées par la AWS IoT Device Tester variable`{{testData.sourcePath}}`. Utilisez l'`{{config.idtRootPath}}`espace réservé pour référencer un script flash relatif au chemin AWS IoT Device Tester racine. La nouvelle structure des tests d'intégration avec FRQ 2.0 ne nécessite pas de variables de chemin telles que `{{enableTests}}` et`{{buildImageName}}`. Les tests OTA de bout en bout sont exécutés avec les modèles de configuration fournis dans le [ FreeRTOS-Libraries-Integration-Tests](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests/blob/main/config_template/) GitHub référentiel. Si les fichiers du GitHub référentiel sont présents dans votre projet source parent, le code source n'est pas modifié entre les tests. Si une image de compilation différente pour OTA de bout en bout est nécessaire, vous devez créer cette image dans le script de génération et la spécifier dans le `userdata.json` fichier spécifié ci-dessous`otaConfiguration`. ** `testStartDelayms` ** Spécifie le nombre de millisecondes que le lanceur de tests FreeRTOS attendra avant de commencer à exécuter les tests. Cela peut être utile si l'appareil testé commence à produire des informations de test importantes avant qu'IDT n'ait la chance de se connecter et de commencer à se connecter en raison de problèmes de réseau ou d'autres problèmes de latence. Cette valeur s'applique uniquement aux groupes de test FreeRTOS, et non aux autres groupes de test qui n'utilisent pas le lanceur de tests FreeRTOS, tels que les tests OTA. Si vous recevez une erreur liée à la valeur **10 attendue mais que vous en avez reçu 5**, ce champ doit être défini sur 5000. ** `echoServerConfiguration` ** Configuration permettant de configurer le serveur d'écho pour le test TLS. Ce champ est obligatoire. ** `keyGenerationMethod` ** Le serveur Echo est configuré avec cette option. Les options sont EC ou RSA. ** `serverPort` ** Le numéro de port sur lequel s'exécute le serveur Echo. ** `otaConfiguration` ** Configuration pour les tests OTA PAL et OTA E2E. Ce champ est obligatoire. **`otaE2EFirmwarePath`** Chemin d'accès à l'image du bin OTA qu'IDT utilise pour les tests OTA de bout en bout. ** `otaPALCertificatePath` ** Le chemin d'accès au certificat pour le test OTA PAL sur l'appareil. Ceci est utilisé pour vérifier la signature. Par exemple, **ecdsa-sha256-signer.crt.pem**. ** `deviceFirmwarePath` ** Chemin d'accès au nom codé en dur de l'image du microprogramme à démarrer. Si votre appareil n'utilise PAS le système de fichiers pour le démarrage du microprogramme, spécifiez ce champ sous la forme`'NA'`. Si votre appareil utilise le système de fichiers pour le démarrage du microprogramme, spécifiez le chemin ou le nom de l'image de démarrage du microprogramme. ** `codeSigningConfiguration` ** ** `signingMethod` ** Méthode de signature de code. Les valeurs possibles sont AWS ou Custom. Pour les régions de Pékin et de Ningxia, utilisez Custom. AWS la signature de code n'est pas prise en charge dans cette région. ** `signerHashingAlgorithm` ** Algorithme de hachage pris en charge sur le périphérique. Les valeurs possibles sont `SHA1` ou `SHA256`. ** `signerSigningAlgorithm` ** Algorithme de signature pris en charge sur le périphérique. Les valeurs possibles sont `RSA` ou `ECDSA`. ** `signerCertificate` ** Certificat de confiance utilisé pour l'OTA. Pour la méthode de signature AWS du code, utilisez l'Amazon Resource Name (ARN) pour le certificat sécurisé chargé sur le AWS Certificate Manager. Pour la méthode de signature de code personnalisée, utilisez le chemin absolu vers le fichier de certificat du signataire. Pour plus d'informations sur la création d'un certificat sécurisé, voir [Création d'un certificat de signature de code](https://docs.aws.amazon.com/freertos/latest/userguide/ota-code-sign-cert.html). ** `untrustedSignerCertificate` ** L'ARN ou le chemin de fichier d'un deuxième certificat utilisé dans certains tests OTA en tant que certificat non fiable. Pour plus d'informations sur la création d'un certificat, voir [Création d'un certificat de signature de code](https://docs.aws.amazon.com//freertos/latest/userguide/ota-code-sign-cert.html). ** `signerCertificateFileName` ** Nom de fichier du certificat de signature de code sur l'appareil. Cette valeur doit correspondre au nom de fichier que vous avez fourni lors de l'exécution de la `aws acm import-certificate` commande. ** `compileSignerCertificate` ** Valeur booléenne qui détermine le statut du certificat de vérification de signature. Les valeurs valides sont `true` et `false`. Définissez cette valeur sur **true** si le certificat de vérification de signature du signataire du code n'est pas fourni ou flashé. Il doit être compilé dans le projet. AWS IoT Device Tester récupère le certificat sécurisé et le compile dans. `aws_codesigner_certificate.h` ** `signerPlatform` ** Algorithme de signature et de hachage utilisé par AWS Code Signer lors de la création de la tâche de mise à jour OTA. Actuellement, les valeurs possibles pour ce champ sont `AmazonFreeRTOS-TI-CC3220SF` et `AmazonFreeRTOS-Default`. + Choisissez `AmazonFreeRTOS-TI-CC3220SF`, si `SHA1` et `RSA`. + Choisissez `AmazonFreeRTOS-Default`, si `SHA256` et `ECDSA`. + Si vous avez besoin de `SHA256` \$1 `RSA` ou `SHA1` \$1 `ECDSA` pour votre configuration, contactez-nous pour obtenir une assistance complémentaire. + Configurez `signCommand` si vous avez choisi `Custom` pour `signingMethod`. ** `signCommand` ** Deux espaces réservés `{{inputImageFilePath}}` et `{{outputSignatureFilePath}}` sont obligatoires dans la commande. `{{inputImageFilePath}}` est le chemin d'accès au fichier de l'image créée par IDT qu’il faut signer. `{{outputSignatureFilePath}} ` est le chemin d’accès au fichier de la signature qui sera généré par le script. ** `pkcs11LabelConfiguration` ** PKCS11 la configuration des étiquettes nécessite au moins un ensemble d'étiquettes d'étiquette de certificat de périphérique, d'étiquette de clé publique et d'étiquette de clé privée pour exécuter les groupes de PKCS11 test. Les PKCS11 étiquettes requises sont basées sur la configuration de votre appareil dans le `device.json` fichier. Si le paramètre pré-provisionné est défini sur **Oui**`device.json`, les étiquettes requises doivent être l'une des suivantes en fonction de ce qui est choisi pour la PKCS11 fonctionnalité. + `PreProvisionedEC` + `PreProvisionedRSA` Si le préprovisionnement est défini sur **Non**`device.json`, les étiquettes requises sont les suivantes : + `pkcs11LabelDevicePrivateKeyForTLS` + `pkcs11LabelDevicePublicKeyForTLS` + `pkcs11LabelDeviceCertificateForTLS` Les trois libellés suivants sont obligatoires uniquement si vous sélectionnez **Oui** pour `pkcs11JITPCodeVerifyRootCertSupport` dans votre `device.json` fichier. + `pkcs11LabelCodeVerifyKey` + `pkcs11LabelRootCertificate` + `pkcs11LabelJITPCertificate` Les valeurs de ces champs doivent correspondre aux valeurs définies dans le Guide de portage de [FreeRTOS](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting-pkcs.html). ** `pkcs11LabelDevicePrivateKeyForTLS` ** (Facultatif) Cette étiquette est utilisée pour l'étiquette PKCS \$111 de la clé privée. Pour les appareils dotés d'un support intégré et d'importation pour l'approvisionnement des clés, cette étiquette est utilisée à des fins de test. Cette étiquette peut être différente de celle définie pour le boîtier préapprovisionné. Si le provisionnement des clés est défini sur **Non** et que le préprovisionnement est défini sur **Oui**`device.json`, ce paramètre ne sera pas défini. ** `pkcs11LabelDevicePublicKeyForTLS` ** (Facultatif) Cette étiquette est utilisée pour l'étiquette PKCS \$111 de la clé publique. Pour les appareils dotés d'un support intégré et d'importation pour l'approvisionnement des clés, cette étiquette est utilisée à des fins de test. Cette étiquette peut être différente de celle définie pour le boîtier préapprovisionné. Si le provisionnement des clés est défini sur **Non** et que le préprovisionnement est défini sur **Oui**`device.json`, ce paramètre ne sera pas défini. ** `pkcs11LabelDeviceCertificateForTLS` ** (Facultatif) Cette étiquette est utilisée pour l'étiquette PKCS \$111 du certificat de l'appareil. Pour les appareils dotés d'un support intégré et d'importation pour l'approvisionnement des clés, cette étiquette sera utilisée à des fins de test. Cette étiquette peut être différente de celle définie pour le boîtier préapprovisionné. Si le provisionnement des clés est défini sur **Non** et que le préprovisionnement est défini sur **Oui**`device.json`, ce paramètre ne sera pas défini. ** `pkcs11LabelPreProvisionedECDevicePrivateKeyForTLS` ** (Facultatif) Cette étiquette est utilisée pour l'étiquette PKCS \$111 de la clé privée. Pour les appareils dotés d'éléments sécurisés ou présentant des limitations matérielles, celui-ci portera une étiquette différente afin de préserver les AWS IoT informations d'identification. Si votre appareil prend en charge le préapprovisionnement avec une clé EC, fournissez cette étiquette. Lorsque PreProvisioned est défini sur **Yes** in`device.json`, cette étiquette, ou les deux`pkcs11LabelPreProvisionedRSADevicePrivateKeyForTLS`, doivent être fournies. Cette étiquette peut être différente de celle définie pour les valises à bord et les valises d'importation. ** `pkcs11LabelPreProvisionedECDevicePublicKeyForTLS` ** (Facultatif) Cette étiquette est utilisée pour l'étiquette PKCS \$111 de la clé publique. Pour les appareils dotés d'éléments sécurisés ou présentant des limitations matérielles, celui-ci portera une étiquette différente afin de préserver les AWS IoT informations d'identification. Si votre appareil prend en charge le préapprovisionnement avec une clé EC, fournissez cette étiquette. Lorsque PreProvisioned est défini sur **Yes** in`device.json`, cette étiquette, ou les deux`pkcs11LabelPreProvisionedRSADevicePublicKeyForTLS`, doivent être fournies. Cette étiquette peut être différente de celle définie pour les valises à bord et les valises d'importation. ** `pkcs11LabelPreProvisionedECDeviceCertificateForTLS` ** (Facultatif) Cette étiquette est utilisée pour l'étiquette PKCS \$111 du certificat de l'appareil. Pour les appareils dotés d'éléments sécurisés ou présentant des limitations matérielles, celui-ci portera une étiquette différente afin de préserver les AWS IoT informations d'identification. Si votre appareil prend en charge le préapprovisionnement avec une clé EC, fournissez cette étiquette. Lorsque PreProvisioned est défini sur **Yes** in`device.json`, cette étiquette, ou les deux`pkcs11LabelPreProvisionedRSADeviceCertificateForTLS`, doivent être fournies. Cette étiquette peut être différente de celle définie pour les valises à bord et les valises d'importation. ** `pkcs11LabelPreProvisionedRSADevicePrivateKeyForTLS` ** (Facultatif) Cette étiquette est utilisée pour l'étiquette PKCS \$111 de la clé privée. Pour les appareils dotés d'éléments sécurisés ou présentant des limitations matérielles, celui-ci portera une étiquette différente afin de préserver les AWS IoT informations d'identification. Si votre appareil prend en charge le préprovisionnement à l'aide d'une clé RSA, fournissez cette étiquette. Lorsque PreProvisioned est défini sur **Yes** in`device.json`, cette étiquette, ou les deux`pkcs11LabelPreProvisionedECDevicePrivateKeyForTLS`, doivent être fournies. ** `pkcs11LabelPreProvisionedRSADevicePublicKeyForTLS` ** (Facultatif) Cette étiquette est utilisée pour l'étiquette PKCS \$111 de la clé publique. Pour les appareils dotés d'éléments sécurisés ou présentant des limitations matérielles, celui-ci portera une étiquette différente afin de préserver les AWS IoT informations d'identification. Si votre appareil prend en charge le préprovisionnement à l'aide d'une clé RSA, fournissez cette étiquette. Lorsque PreProvisioned est défini sur **Yes** in`device.json`, cette étiquette, ou les deux`pkcs11LabelPreProvisionedECDevicePublicKeyForTLS`, doivent être fournies. ** `pkcs11LabelPreProvisionedRSADeviceCertificateForTLS` ** (Facultatif) Cette étiquette est utilisée pour l'étiquette PKCS \$111 du certificat de l'appareil. Pour les appareils dotés d'éléments sécurisés ou présentant des limitations matérielles, celui-ci portera une étiquette différente afin de préserver les AWS IoT informations d'identification. Si votre appareil prend en charge le préprovisionnement à l'aide d'une clé RSA, fournissez cette étiquette. Lorsque PreProvisioned est défini sur **Yes** in`device.json`, cette étiquette, ou les deux`pkcs11LabelPreProvisionedECDeviceCertificateForTLS`, doivent être fournies. ** `pkcs11LabelCodeVerifyKey` ** (Facultatif) Cette étiquette est utilisée pour l'étiquette PKCS \$111 de la clé de vérification du code. Si votre appareil prend en charge le stockage PKCS \$111 du certificat JITP, de la clé de vérification du code et du certificat racine, fournissez cette étiquette. Lorsque `pkcs11JITPCodeVerifyRootCertSupport` la `device.json` valeur Oui est définie sur **Oui**, cette étiquette doit être fournie. ** `pkcs11LabelJITPCertificate` ** (Facultatif) Cette étiquette est utilisée pour l'étiquette PKCS \$111 du certificat JITP. Si votre appareil prend en charge le stockage PKCS \$111 du certificat JITP, de la clé de vérification du code et du certificat racine, fournissez cette étiquette. Lorsque `pkcs11JITPCodeVerifyRootCertSupport` la `device.json` valeur Oui est définie sur **Oui**, cette étiquette doit être fournie. # IDT pour les variables FreeRTOS Les commandes permettant de créer votre code et de flasher l'appareil peuvent nécessiter une connectivité ou d'autres informations sur vos appareils pour fonctionner correctement. AWS IoT Device Tester vous permet de référencer les informations du périphérique dans Flash et de créer des commandes à l'aide de [JsonPath](https://goessner.net/articles/JsonPath/). À l'aide d' JsonPathexpressions simples, vous pouvez récupérer les informations requises spécifiées dans votre `device.json` fichier. ## Variables de chemin IDT pour FreeRTOS définit les variables de chemin suivantes qui peuvent être utilisées dans les lignes de commande et les fichiers de configuration : ** `{{testData.sourcePath}}` ** Développe le code source du chemin d'accès. Si vous utilisez cette variable, elle doit être utilisée dans les commandes flash et build. ** `{{device.connectivity.serialPort}}` ** Extension au port série. ** `{{device.identifiers[?(@.name == 'serialNo')].value[0]}}` ** Extension jusqu'au numéro de série de votre appareil. ** `{{config.idtRootPath}}` ** S'étend jusqu'au chemin AWS IoT Device Tester racine.