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.
# Mise en service des appareils
AWS propose plusieurs méthodes différentes pour approvisionner un appareil et y installer des certificats clients uniques. Cette section décrit chaque méthode et explique comment sélectionner celle qui convient le mieux à votre solution IoT. Ces options sont décrites en détail dans le livre blanc intitulé [Device Manufacturing and Provisioning with X.509 Certificates in AWS IoT Core](https://docs.aws.amazon.com/whitepapers/latest/device-manufacturing-provisioning/device-manufacturing-provisioning.html).
**Sélectionnez l’option qui convient le mieux à votre situation**
+
**Vous pouvez installer des certificats sur les appareils IoT avant qu’ils ne soient délivrés**
Si vous pouvez installer en toute sécurité des certificats clients uniques sur vos appareils IoT avant qu'ils ne soient fournis à l'utilisateur final, vous devez utiliser le [*just-in-time*provisionnement (JITP)](jit-provisioning.md) ou l'[*just-in-time*enregistrement (JITR](auto-register-device-cert.md)).
À l'aide de JITP et JITR, l'autorité de certification (CA) utilisée pour signer le certificat de l'appareil est enregistrée AWS IoT et reconnue AWS IoT lors de la première connexion de l'appareil. L'appareil est approvisionné AWS IoT lors de sa première connexion à l'aide des détails de son modèle de provisionnement.
Pour plus d’informations sur le single thing, le JITP, le JITR et la mise en service groupé d’appareils dotés de certificats uniques, veuillez consulter [Mise en service d'appareils disposant de certificats d'appareils](provision-w-cert.md).
+
**Les utilisateurs finaux ou les installateurs peuvent utiliser une application pour installer des certificats sur leurs appareils IoT**
Si vous ne pouvez pas installer de manière sécurisée des certificats clients uniques sur votre appareil IoT avant qu’ils ne soient fournis à l’utilisateur final, mais que l’utilisateur final ou un installateur peut utiliser une application pour enregistrer les appareils et installer les certificats d’appareils uniques, vous devez utiliser le processus de [mise en service par un utilisateur de confiance](provision-wo-cert.md#trusted-user).
L’utilisation d’un utilisateur de confiance, tel qu’un utilisateur final ou un installateur possédant un compte connu, peut simplifier le processus de fabrication des appareils. Au lieu d'un certificat client unique, les appareils disposent d'un certificat temporaire qui leur permet de se connecter AWS IoT pendant 5 minutes seulement. Au cours de cette fenêtre de 5 minutes, l’utilisateur de confiance obtient un certificat client unique avec une durée de vie plus longue et l’installe sur l’appareil. La durée de vie limitée du certificat de réclamation minimise le risque de compromission du certificat.
Pour de plus amples informations, veuillez consulter [Allocation par utilisateur approuvé](provision-wo-cert.md#trusted-user).
+
**Les utilisateurs finaux NE PEUVENT PAS utiliser une application pour installer des certificats sur leurs appareils IoT**
Si aucune des options précédentes ne fonctionne dans votre solution IoT, la [mise en service par processus de demande](provision-wo-cert.md#claim-based) est une option. Dans le cadre de ce processus, vos appareils IoT disposent d’un certificat de réclamation qui est partagé par les autres appareils de la flotte. La première fois qu'un appareil se connecte à un certificat de réclamation, AWS IoT enregistre l'appareil à l'aide de son modèle de provisionnement et délivre à l'appareil son certificat client unique pour un accès ultérieur. AWS IoT
Cette option permet le provisionnement automatique d'un appareil lorsqu'il se connecte à AWS IoT, mais peut présenter un risque plus important en cas de compromission d'un certificat de réclamation. Si un certificat de demande est compromis, vous pouvez le désactiver. La désactivation du certificat de demande empêche l’enregistrement futur de tous les appareils dotés de ce certificat de demande. Toutefois, la désactivation du certificat de demande ne bloque pas les appareils déjà mis en service.
Pour de plus amples informations, veuillez consulter [Allocation par revendication](provision-wo-cert.md#claim-based).
## Provisionnement d'appareils dans AWS IoT
Lorsque vous approvisionnez un appareil AWS IoT, vous devez créer des ressources pour que vos appareils AWS IoT puissent communiquer en toute sécurité. D'autres ressources peuvent être créées pour vous aider à gérer votre flotte d'appareils. Les ressources suivantes peuvent être créées au cours du processus de mise en service :
+ Un objet IoT.
Les objets IoT sont des entrées dans le registre des AWS IoT appareils. Chaque objet a un nom et un ensemble d'attributs uniques, et est associé à un appareil physique. Les objets peuvent être définis à l'aide d'un type d'objet ou regroupées en groupes d'objets. Pour de plus amples informations, veuillez consulter [Gestion des appareils avec AWS IoT](iot-thing-management.md).
Bien qu'elle ne soit pas nécessaire, la création d'un objet vous permet de gérer votre flotte d'appareils plus efficacement en recherchant les appareils par type d'objet, groupe d'objets et attributs d'objet. Pour de plus amples informations, veuillez consulter [Indexation de la flotte](iot-indexing.md).
**Note**
Pour indexer les données d'état de connectivité de votre objet, approvisionnez votre objet et configurez-le de manière à ce que le nom de l'objet corresponde à l'ID client utilisé dans la demande Connect.
+ Un certificat X.509.
Les appareils utilisent des certificats X.509 pour effectuer une authentification mutuelle avec AWS IoT. Vous pouvez enregistrer un certificat existant ou faire AWS IoT générer et enregistrer un nouveau certificat pour vous. Vous associez un certificat à un appareil en l'attachant à l'objet qui représente l'appareil. Vous devez également copier le certificat et la clé privée associée sur l'appareil. Les appareils présentent le certificat lors de la connexion à AWS IoT. Pour de plus amples informations, veuillez consulter [Authentification](authentication.md).
+ Une stratégie IoT.
Les stratégies IoT définissent les opérations qu’un appareil peut effectuer dans AWS IoT. Les stratégies IoT sont attachées aux certificats des appareils. Lorsqu'un appareil présente le certificat à AWS IoT, il reçoit les autorisations spécifiées dans la politique. Pour de plus amples informations, veuillez consulter [Autorisation](iot-authorization.md). Chaque appareil a besoin d'un certificat pour communiquer avec AWS IoT.
AWS IoT prend en charge le provisionnement automatique de la flotte à l'aide de modèles de provisionnement. Les modèles de provisionnement décrivent les ressources nécessaires AWS IoT pour approvisionner votre appareil. Les modèles contiennent des variables qui vous permettent d'utiliser un modèle pour mettre en service plusieurs appareils. Lorsque vous allouez un appareil, vous spécifiez des valeurs pour les variables spécifiques à l'appareil à l'aide d'un dictionnaire ou d'une *carte*. Pour mettre en service un autre appareil, spécifiez de nouvelles valeurs dans le dictionnaire.
Vous pouvez utiliser l'allocation automatisée, que vos appareils disposent de certificats uniques (et de leur clé privée associée) ou non.
## Approvisionnement de flotte APIs
Il existe plusieurs catégories de produits APIs utilisés dans le provisionnement de flottes :
+ Ces fonctions de plan de contrôle créent et gèrent les modèles de provisionnement de flotte et configurent les stratégies des utilisateurs approuvés.
+ [CreateProvisioningTemplate](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningTemplate.html)
+ [ CreateProvisioningTemplateVersion](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningTemplateVersion.html)
+ [DeleteProvisioningTemplate](https://docs.aws.amazon.com/iot/latest/apireference/API_DeleteProvisioningTemplate.html)
+ [DeleteProvisioningTemplateVersion](https://docs.aws.amazon.com/iot/latest/apireference/API_DeleteProvisioningTemplateVersion.html)
+ [DescribeProvisioningTemplate](https://docs.aws.amazon.com/iot/latest/apireference/API_DescribeProvisioningTemplate.html)
+ [DescribeProvisioningTemplateVersion](https://docs.aws.amazon.com/iot/latest/apireference/API_DescribeProvisioningTemplateVersion.html)
+ [ListProvisioningTemplates](https://docs.aws.amazon.com/iot/latest/apireference/API_ListProvisioningTemplates.html)
+ [ListProvisioningTemplateVersions](https://docs.aws.amazon.com/iot/latest/apireference/API_ListProvisioningTemplateVersions.html)
+ [UpdateProvisioningTemplate](https://docs.aws.amazon.com/iot/latest/apireference/API_UpdateProvisioningTemplate.html)
+ Les utilisateurs approuvés peuvent utiliser cette fonction de plan de contrôle pour générer une demande d'intégration temporaire. Cette demande temporaire est transmise à l'appareil lors de la configuration Wi-Fi ou d’une méthode similaire.
+ [CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html)
+ API MQTT utilisée au cours du processus de provisionnement par des périphériques avec un certificat de demande de provisionnement incorporé dans un périphérique ou transmis par un utilisateur approuvé.
+ [CreateCertificateFromCsr](fleet-provision-api.md#create-cert-csr)
+ [CreateKeysAndCertificate](fleet-provision-api.md#create-keys-cert)
+ [RegisterThing](fleet-provision-api.md#register-thing)
# Mise en service d'appareils qui ne disposent pas de certificats d'appareils à l'aide de la mise en service de flotte
En utilisant le provisionnement du AWS IoT parc, AWS IoT vous pouvez générer et délivrer en toute sécurité des certificats d'appareils et des clés privées à vos appareils lorsqu'ils se connectent AWS IoT pour la première fois. AWS IoT fournit des certificats clients signés par l'autorité de certification Amazon Root (CA).
Il existe deux façons d'utiliser la mise en service de flotte :
+ [Allocation par revendication](#claim-based)
+ [Allocation par utilisateur approuvé](#trusted-user)
## Allocation par revendication
Les appareils peuvent être fabriqués avec un certificat de revendication de mise en service et une clé privée (qui sont des informations d'identification à usage spécial) intégrés. Si ces certificats sont enregistrés AWS IoT, le service peut les échanger contre des certificats d'appareil uniques que l'appareil peut utiliser pour des opérations régulières. Le processus comprend les étapes suivantes :
**Avant de livrer l'appareil**
1. Appelez [https://docs.aws.amazon.com//iot/latest/apireference/API_CreateProvisioningTemplate.html](https://docs.aws.amazon.com//iot/latest/apireference/API_CreateProvisioningTemplate.html) pour créer un modèle de mise en service. Cette API renvoie un ARN de modèle. Pour de plus amples informations, veuillez consulter [API MQTT de mise en service des appareils](fleet-provision-api.md).
Vous pouvez également créer un modèle de provisionnement de flotte dans la AWS IoT console.
1. Dans le volet de navigation, choisissez le menu déroulant **Connect many devices**. Choisissez ensuite **Connect many devices**.
1. Choisissez **Créer un modèle de provisionnement**.
1. Choisissez le **scénario de provisionnement le** mieux adapté à vos processus d'installation. Ensuite, choisissez **Suivant**.
1. Terminez le flux de travail du modèle.
1. Créez les certificats et les clés privées associées qui seront utilisés comme certificats de revendications de mise en service.
1. Enregistrez ces certificats AWS IoT et associez-leur une politique IoT qui restreint l'utilisation des certificats. L'exemple suivant de stratégie IoT limite l'utilisation du certificat associé à cette stratégie aux appareils mis en service.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/provisioning-templates/templateName/provision/*"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/provisioning-templates/templateName/provision/*"
]
}
]
}
```
1. Lorsque vous approvisionnez des appareils, autorisez le AWS IoT service à créer ou à mettre à jour des ressources IoT telles que des objets et des certificats dans votre compte. Pour ce faire, associez la politique `AWSIoTThingsRegistration` gérée à un rôle IAM (appelé rôle de provisionnement) qui fait confiance au principal du AWS IoT service.
1. Fabriquez l'appareil avec le certificat de revendication de mise en service intégré de manière sécurisée.
L'appareil est maintenant prêt à être livré là où il sera installé pour être utilisé.
**Important**
Les clés privées des revendications de mise en service doivent être sécurisées à tout moment, y compris sur l'appareil. Nous vous recommandons d'utiliser AWS IoT CloudWatch des métriques et des journaux pour détecter les signes d'utilisation abusive. Si vous détectez une utilisation abusive, désactivez le certificat de revendication de mise en service afin qu’il ne puisse pas être utilisé pour la mise en service des appareils.
**Pour initialiser l’appareil à utiliser**
1. L'appareil utilise le [AWS IoT Appareil SDKs, appareil mobile SDKs et client AWS IoT d'appareil](iot-sdks.md) pour se connecter et s'authentifier à AWS IoT l'aide du certificat de demande d'approvisionnement installé sur l'appareil.
**Note**
Pour des raisons de sécurité, le s articles `certificateOwnershipToken` retournés par `CreateCertificateFromCsr` et `CreateKeysAndCertificate` expire au bout d’une heure. `RegisterThing` doit être appelé avant l’expiration `certificateOwnershipToken`. Si le certificat créé par `CreateCertificateFromCsr` ou `CreateKeysAndCertificate` n’a pas été activé et n’a pas été attaché à une politique ou à un objet au moment où le jeton expire, le certificat est supprimé. Si le jeton expire, l’appareil peut appeler `CreateCertificateFromCsr` ou `CreateKeysAndCertificate` à nouveau pour générer un nouveau certificat.
1. L'appareil obtient un certificat permanent et une clé privée en utilisant l'une de ces options. L'appareil utilisera le certificat et la clé pour toutes les futures authentifications avec AWS IoT.
1. Appelez [`CreateKeysAndCertificate`](fleet-provision-api.md#create-keys-cert)pour créer un nouveau certificat et une nouvelle clé privée à l'aide de l'autorité de AWS certification.
Or
1. Appelez [`CreateCertificateFromCsr`](fleet-provision-api.md#create-cert-csr) pour générer un certificat à partir d’une demande de signature de certificat qui conserve sa clé privée sécurisée.
1. À partir de l'appareil, appelez [`RegisterThing`](fleet-provision-api.md#register-thing) pour enregistrer ce dernier auprès d' AWS IoT et créer des ressources cloud.
Le service de mise en service de flotte utilise un modèle de mise en service pour définir et créer des ressources en cloud telles que des objets IoT. Le modèle peut spécifier les attributs et les groupes auxquels appartient l’objet. Les groupes d’objets doivent exister avant que le nouvel objet puisse y être ajouté.
1. Après avoir enregistré le certificat permanent sur l’appareil, celui-ci doit se déconnecter de la session qu'il a ouverte avec le certificat de revendication de mise en service et se reconnecter à l'aide du certificat permanent.
L'appareil est maintenant prêt à communiquer normalement avec AWS IoT.
## Allocation par utilisateur approuvé
Dans de nombreux cas, un appareil se connecte AWS IoT pour la première fois lorsqu'un utilisateur de confiance, tel qu'un utilisateur final ou un technicien d'installation, utilise une application mobile pour configurer l'appareil dans son emplacement de déploiement.
**Important**
Vous devez gérer l'accès et l'autorisation de l'utilisateur approuvé pour effectuer cette procédure. Une façon de le faire consiste à fournir et à gérer un compte pour l’utilisateur approuvé qui l’authentifie et lui accorde l’accès aux fonctionnalités AWS IoT et aux opérations d’API requises pour effectuer cette procédure.
**Avant de livrer l'appareil**
1. Appelez [https://docs.aws.amazon.com//iot/latest/apireference/API_CreateProvisioningTemplate.html](https://docs.aws.amazon.com//iot/latest/apireference/API_CreateProvisioningTemplate.html)pour créer un modèle de provisionnement et renvoyer son *templateArn* et*templateName*.
1. Créez un rôle IAM qui permettra à un utilisateur de confiance de lancer le processus de mise en service. Le modèle de mise en service permet uniquement à cet utilisateur de mettre en service un appareil. Par exemple :
```
{
"Effect": "Allow",
"Action": [
"iot:CreateProvisioningClaim"
],
"Resource": [
"arn:aws:iot:aws-region:aws-account-id:provisioningtemplate/templateName"
]
}
```
1. Lorsque vous approvisionnez des appareils, autorisez le AWS IoT service à créer ou à mettre à jour des ressources IoT, telles que des objets et des certificats dans votre compte. Pour ce faire, vous devez associer la politique `AWSIoTThingsRegistration` gérée à un rôle IAM (appelé rôle de *provisionnement*) qui fait confiance au principal du AWS IoT service.
1. Fournissez les moyens d'identifier vos utilisateurs de confiance, par exemple en leur fournissant un compte capable de les authentifier et d'autoriser leurs interactions avec les opérations d' AWS API nécessaires à l'enregistrement de leurs appareils.
**Pour initialiser l’appareil à utiliser**
1. Un utilisateur de confiance se connecte à votre application mobile ou service web de mise en service.
1. L’application mobile ou l’application web utilise le rôle IAM et appelle [https://docs.aws.amazon.com//iot/latest/apireference/API_CreateProvisioningClaim.html](https://docs.aws.amazon.com//iot/latest/apireference/API_CreateProvisioningClaim.html) pour obtenir un certificat de revendication de mise en service temporaire auprès AWS IoT.
**Note**
Pour des raisons de sécurité, le certificat de demande de mise en service temporaire que `CreateProvisioningClaim` renvoie expire au bout de cinq minutes. Les étapes suivantes doivent renvoyer un certificat valide avant l'expiration du certificat de revendication de mise en service temporaire. Les certificats de revendication de mise en service temporaire n'apparaissent pas dans la liste des certificats de votre compte.
1. L'application mobile ou l'application web fournit le certificat de revendication de mise en service à l'appareil ainsi que toutes les informations de configuration nécessaires, notamment les informations d'identification Wi-Fi.
1. L'appareil utilise le certificat de revendication de mise en service temporaire pour se connecter à AWS IoT à l'aide du [AWS IoT Appareil SDKs, appareil mobile SDKs et client AWS IoT d'appareil](iot-sdks.md).
1. L'appareil obtient un certificat permanent et une clé privée en utilisant l'une de ces options dans les cinq minutes suivant la connexion au AWS IoT certificat de demande de provisionnement temporaire. L'appareil utilisera le certificat et la clé renvoyés par ces options pour toute future authentification AWS IoT.
1. Appelez [`CreateKeysAndCertificate`](fleet-provision-api.md#create-keys-cert)pour créer un nouveau certificat et une nouvelle clé privée à l'aide de l'autorité de AWS certification.
Or
1. Appelez [`CreateCertificateFromCsr`](fleet-provision-api.md#create-cert-csr) pour générer un certificat à partir d’une demande de signature de certificat qui conserve sa clé privée sécurisée.
**Note**
N'oubliez pas [`CreateKeysAndCertificate`](fleet-provision-api.md#create-keys-cert)ou [`CreateCertificateFromCsr`](fleet-provision-api.md#create-cert-csr)devez renvoyer un certificat valide dans les cinq minutes suivant la connexion AWS IoT au certificat de réclamation de provisionnement temporaire.
1. L'appareil appelle [`RegisterThing`](fleet-provision-api.md#register-thing)pour enregistrer l'appareil auprès de celui-ci AWS IoT et créer des ressources cloud.
La service de mise en service de flotte utilise un modèle de mise en service pour définir et créer des ressources en cloud telles que des objets IoT. Le modèle peut spécifier les attributs et les groupes auxquels appartient l’objet. Les groupes d’objets doivent exister avant que le nouvel objet puisse y être ajouté.
1. Après avoir enregistré le certificat permanent sur l’appareil, celui-ci doit se déconnecter de la session qu'il a ouverte avec le certificat de revendication de mise en service temporaire et se reconnecter à l'aide du certificat permanent.
L'appareil est maintenant prêt à communiquer normalement avec AWS IoT.
## Utilisation de hooks de pré-provisionnement avec la CLI AWS
La procédure suivante crée un modèle de mise en service avec des hooks de mise en service en amont. La fonction Lambda utilisée ici est un exemple qui peut être modifié.
**Pour créer et appliquer un hook de mise en service en amont à un modèle de mise en service**
1. Créez une fonction Lambda dont l’entrée et la sortie sont définies. Les fonctions Lambda sont hautement personnalisables. `allowProvisioning` et `parameterOverrides` sont nécessaires pour créer des hooks de pré-mise en service. Pour plus d'informations sur la création de fonctions Lambda, consultez la section [Utilisation AWS Lambda avec l'interface de ligne de AWS commande](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-awscli.html).
Voici un exemple de sortie de fonction Lambda :
```
{
"allowProvisioning": True,
"parameterOverrides": {
"incomingKey0": "incomingValue0",
"incomingKey1": "incomingValue1"
}
}
```
1. AWS IoT utilise des politiques basées sur les ressources pour appeler Lambda. Vous devez donc AWS IoT autoriser l'appel de votre fonction Lambda.
**Important**
Assurez-vous d’inclure le `source-arn` ou `source-account` dans les clés de contexte de condition globale des politiques associées à votre action Lambda afin d’empêcher toute manipulation des autorisations. Pour de plus amples informations à ce sujet, veuillez consulter [Prévention du cas de figure de l’adjoint désorienté entre services](cross-service-confused-deputy-prevention.md).
L’exemple suivant utilise [add-permission](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html) pour donner à IoT l’autorisation d’appeler votre fonction Lambda.
```
aws lambda add-permission \
--function-name myLambdaFunction \
--statement-id iot-permission \
--action lambda:InvokeFunction \
--principal iot.amazonaws.com
```
1. Ajoutez un hook de pré-provisionnement à un modèle à l'aide de la commande [create-provisioning-template](https://docs.aws.amazon.com/cli/latest/reference/iot/create-provisioning-template.html)or [update-provisioning-template](https://docs.aws.amazon.com/cli/latest/reference/iot/update-provisioning-template.html).
L'exemple de CLI suivant utilise le [create-provisioning-template](https://docs.aws.amazon.com/cli/latest/reference/iot/create-provisioning-template.html)pour créer un modèle de provisioning doté de hooks de pré-provisionnement :
```
aws iot create-provisioning-template \
--template-name myTemplate \
--provisioning-role-arn arn:aws:iam:us-east-1:1234564789012:role/myRole \
--template-body file://template.json \
--pre-provisioning-hook file://hooks.json
```
La sortie de cette commande ressemble à ce qui suit :
```
{
"templateArn": "arn:aws:iot:us-east-1:1234564789012:provisioningtemplate/myTemplate",
"defaultVersionId": 1,
"templateName": myTemplate
}
```
Pour gagner du temps, vous pouvez également charger un paramètre à partir d'un fichier au lieu de le taper en tant que valeur de paramètre de ligne de commande. Pour plus d’informations, consultez [Loading Chargement AWS CLI from a File paramètres à partir d’un fichier](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html). Le code suivant illustre le paramètre `template` au format JSON étendu :
```
{
"Parameters" : {
"DeviceLocation": {
"Type": "String"
}
},
"Mappings": {
"LocationTable": {
"Seattle": {
"LocationUrl": "https://example.aws"
}
}
},
"Resources" : {
"thing" : {
"Type" : "AWS::IoT::Thing",
"Properties" : {
"AttributePayload" : {
"version" : "v1",
"serialNumber" : "serialNumber"
},
"ThingName" : {"Fn::Join":["",["ThingPrefix_",{"Ref":"SerialNumber"}]]},
"ThingTypeName" : {"Fn::Join":["",["ThingTypePrefix_",{"Ref":"SerialNumber"}]]},
"ThingGroups" : ["widgets", "WA"],
"BillingGroup": "BillingGroup"
},
"OverrideSettings" : {
"AttributePayload" : "MERGE",
"ThingTypeName" : "REPLACE",
"ThingGroups" : "DO_NOTHING"
}
},
"certificate" : {
"Type" : "AWS::IoT::Certificate",
"Properties" : {
"CertificateId": {"Ref": "AWS::IoT::Certificate::Id"},
"Status" : "Active",
"ThingPrincipalType" : "EXCLUSIVE_THING"
}
},
"policy" : {
"Type" : "AWS::IoT::Policy",
"Properties" : {
"PolicyDocument" : {
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action":["iot:Publish"],
"Resource": ["arn:aws:iot:us-east-1:504350838278:topic/foo/bar"]
}]
}
}
}
},
"DeviceConfiguration": {
"FallbackUrl": "https://www.example.com/test-site",
"LocationUrl": {
"Fn::FindInMap": ["LocationTable",{"Ref": "DeviceLocation"}, "LocationUrl"]}
}
}
```
Le code suivant illustre le paramètre `pre-provisioning-hook` au format JSON étendu :
```
{
"targetArn" : "arn:aws:lambda:us-east-1:765219403047:function:pre_provisioning_test",
"payloadVersion" : "2020-04-01"
}
```
# Mise en service d'appareils disposant de certificats d'appareils
AWS IoT propose trois méthodes pour approvisionner des appareils lorsqu'ils disposent déjà d'un certificat d'appareil (et d'une clé privée associée) :
+ Mise en service d'un objet unique avec un modèle de mise en service. Cette option convient si vous devez uniquement mettre en service des appareils un par un.
+ Just-in-time provisionnement (JITP) avec un modèle qui approvisionne un appareil lors de sa première connexion à. AWS IoT Cette option convient si vous devez enregistrer un grand nombre d'appareils, mais que vous n'avez pas d'informations sur ceux-ci que vous pouvez assembler dans une liste de mise en service en bloc.
+ Enregistrement en bloc. Cette option vous permet de spécifier une liste de valeurs de modèle de mise en service d'objet unique qui sont stockées dans un fichier au sein d'un compartiment S3. Cette approche fonctionne bien si vous avez un grand nombre d'appareils connus dont vous pouvez assembler les caractéristiques souhaitées dans une liste.
**Topics**
+ [Mise en service d'un seul objet](single-thing-provisioning.md)
+ [Just-in-time approvisionnement](jit-provisioning.md)
+ [Enregistrement en bloc](bulk-provisioning.md)
# Mise en service d'un seul objet
Pour provisionner un objet, utilisez l'[RegisterThing](https://docs.aws.amazon.com/iot/latest/apireference/API_RegisterThing.html)API ou la commande `register-thing` CLI. La commande de l'interface de ligne de commande `register-thing` accepte les arguments suivants :
--template-body
Modèle de mise en service.
--parameters
Liste de paires nom-valeur pour les paramètres utilisés dans le modèle de mise en service, au format JSON (par exemple, `{"ThingName" : "MyProvisionedThing", "CSR" : "csr-text"}`).
Consultez [Modèles de provisionnement](provision-template.md).
[RegisterThing](https://docs.aws.amazon.com/iot/latest/apireference/API_RegisterThing.html)ou `register-thing` renvoie le ARNs pour les ressources et le texte du certificat qu'il a créé :
```
{
"certificatePem": "certificate-text",
"resourceArns": {
"PolicyLogicalName": "arn:aws:iot:us-west-2:123456789012:policy/2A6577675B7CD1823E271C7AAD8184F44630FFD7",
"certificate": "arn:aws:iot:us-west-2:123456789012:cert/cd82bb924d4c6ccbb14986dcb4f40f30d892cc6b3ce7ad5008ed6542eea2b049",
"thing": "arn:aws:iot:us-west-2:123456789012:thing/MyProvisionedThing"
}
}
```
Si un paramètre est omis du dictionnaire, la valeur par défaut est utilisée. Si aucune valeur par défaut n'est spécifiée, le paramètre n'est pas remplacé par une valeur.
# Just-in-time approvisionnement
Vous pouvez utiliser le just-in-time provisionnement (JITP) pour approvisionner vos appareils lors de leur première tentative de connexion. AWS IoT Pour mettre en service l'appareil, vous devez activer l'enregistrement automatique et associer un modèle de mise en service au certificat CA utilisé pour signer le certificat d'appareil. Les réussites et les erreurs de provisionnement sont enregistrées comme [Métriques de mise en service d'appareils](metrics_dimensions.md#provisioning-metrics) sur Amazon CloudWatch.
**Topics**
+ [Présentation du JITP](#jit-provisioning-overview)
+ [Enregistrer CA à l’aide d’un modèle de mise en service](#jit-provisioning-registerCA-template)
+ [Enregistrer CA à l’aide d’un nom de modèle de mise en service](#jit-provisioning-registerCA-templateName)
## Présentation du JITP
Lorsqu'un appareil tente de se connecter à AWS IoT l'aide d'un certificat signé par un certificat CA enregistré, AWS IoT charge le modèle à partir du certificat CA et l'utilise pour appeler [RegisterThing](fleet-provision-api.md#register-thing). Le flux de travail de mise en service JITP enregistre d’abord un certificat avec une valeur de statut `PENDING_ACTIVATION`. Lorsque le flux de mise en service d’appareil est terminé, le statut du certificat est modifié en `ACTIVE`.
AWS IoT définit les paramètres suivants que vous pouvez déclarer et référencer dans les modèles de provisionnement :
+ `AWS::IoT::Certificate::Country`
+ `AWS::IoT::Certificate::Organization`
+ `AWS::IoT::Certificate::OrganizationalUnit`
+ `AWS::IoT::Certificate::DistinguishedNameQualifier`
+ `AWS::IoT::Certificate::StateName`
+ `AWS::IoT::Certificate::CommonName`
+ `AWS::IoT::Certificate::SerialNumber`
+ `AWS::IoT::Certificate::Id`
Les valeurs de ces paramètres de modèle de mise en service sont limitées à ce que la mise en service JITP peut extraire du champ d'objet du certificat de l'appareil qui est mis en service. Le certificat doit contenir des valeurs pour tous les paramètres du corps du modèle. Le paramètre `AWS::IoT::Certificate::Id` fait référence à un ID généré en interne, et non un ID qui est contenu dans le certificat. Vous pouvez obtenir la valeur de cet ID à l'aide de la `principal()` fonction intégrée à une AWS IoT règle.
**Note**
Vous pouvez approvisionner des appareils à l'aide de la fonction de AWS IoT Core just-in-time provisionnement (JITP) sans avoir à envoyer l'intégralité de la chaîne de confiance lors de la première connexion d'un appareil à. AWS IoT Core La présentation du certificat CA est facultative, mais l’appareil doit envoyer l’extension [SNI (Indication du nom du serveur)](https://datatracker.ietf.org/doc/html/rfc3546#section-3.1) lorsqu’il se connecte à AWS IoT Core.
### Exemple de corps de modèle
Le fichier JSON suivant est un exemple de corps de modèle d’un modèle JITP complet.
```
{
"Parameters":{
"AWS::IoT::Certificate::CommonName":{
"Type":"String"
},
"AWS::IoT::Certificate::SerialNumber":{
"Type":"String"
},
"AWS::IoT::Certificate::Country":{
"Type":"String"
},
"AWS::IoT::Certificate::Id":{
"Type":"String"
}
},
"Resources":{
"thing":{
"Type":"AWS::IoT::Thing",
"Properties":{
"ThingName":{
"Ref":"AWS::IoT::Certificate::CommonName"
},
"AttributePayload":{
"version":"v1",
"serialNumber":{
"Ref":"AWS::IoT::Certificate::SerialNumber"
}
},
"ThingTypeName":"lightBulb-versionA",
"ThingGroups":[
"v1-lightbulbs",
{
"Ref":"AWS::IoT::Certificate::Country"
}
]
},
"OverrideSettings":{
"AttributePayload":"MERGE",
"ThingTypeName":"REPLACE",
"ThingGroups":"DO_NOTHING"
}
},
"certificate":{
"Type":"AWS::IoT::Certificate",
"Properties":{
"CertificateId":{
"Ref":"AWS::IoT::Certificate::Id"
},
"Status":"ACTIVE"
}
},
"policy":{
"Type":"AWS::IoT::Policy",
"Properties":{
"PolicyDocument":"{ \"Version\": \"2012-10-17\", \"Statement\": [{ \"Effect\": \"Allow\", \"Action\":[\"iot:Publish\"], \"Resource\": [\"arn:aws:iot:us-east-1:123456789012:topic/foo/bar\"] }] }"
}
}
}
}
```
Cet exemple de modèle déclare des valeurs pour les paramètres de mise en service `AWS::IoT::Certificate::CommonName`, `AWS::IoT::Certificate::SerialNumber`, `AWS::IoT::Certificate::Country` et `AWS::IoT::Certificate::Id` qui sont extraits du certificat et utilisés dans la section `Resources`. Le flux de travail JITP utilise ensuite ce modèle pour effectuer les actions suivantes :
+ Enregistrer un certificat et définir son état sur PENDING\$1ACTIVE.
+ Créer une ressource d'objet.
+ Créer une ressource de stratégie.
+ Attacher la stratégie au certificat.
+ Attacher le certificat à l'objet.
+ Mettre à jour le statut du certificat en ACTIVE.
Le provisionnement de l'appareil échoue si le certificat ne possède pas toutes les propriétés mentionnées dans la `Parameters` section du`templateBody`. Par exemple, s’il `AWS::IoT::Certificate::Country` est inclus dans le modèle, mais que le certificat ne possède aucune propriété `Country`, la mise en service de l’appareil échoue.
Vous pouvez également l'utiliser CloudTrail pour résoudre les problèmes liés à votre modèle JITP. Pour plus d'informations sur les métriques enregistrées sur Amazon CloudWatch, consultez[Métriques de mise en service d'appareils](metrics_dimensions.md#provisioning-metrics). Pour plus d’informations sur les modèles de mise en service, voir [Modèles de mise en service](provision-template.md).
**Note**
Au cours du processus de provisionnement, le just-in-time provisionnement (JITP) appelle d'autres opérations d'API du plan AWS IoT de contrôle. Ces appels peuvent dépasser les [AWS IoT quotas de limitation](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#throttling-limits) définis pour votre compte et entraîner des appels limités. Veuillez contacter le [AWS service clientèle](https://console.aws.amazon.com/support/home) pour augmenter vos quotas de limitation, si nécessaire.
## Enregistrer CA à l’aide d’un modèle de mise en service
Pour enregistrer une autorité de certification à l’aide d’un modèle de mise en service complet, procédez comme suit :
1. Enregistrez votre modèle de mise en service et les informations ARN du rôle, comme dans l’exemple suivant, sous forme de fichier JSON :
```
{
"templateBody" : "{\r\n \"Parameters\" : {\r\n \"AWS::IoT::Certificate::CommonName\": {\r\n \"Type\": \"String\"\r\n },\r\n \"AWS::IoT::Certificate::SerialNumber\": {\r\n \"Type\": \"String\"\r\n },\r\n \"AWS::IoT::Certificate::Country\": {\r\n \"Type\": \"String\"\r\n },\r\n \"AWS::IoT::Certificate::Id\": {\r\n \"Type\": \"String\"\r\n }\r\n },\r\n \"Resources\": {\r\n \"thing\": {\r\n \"Type\": \"AWS::IoT::Thing\",\r\n \"Properties\": {\r\n \"ThingName\": {\r\n \"Ref\": \"AWS::IoT::Certificate::CommonName\"\r\n },\r\n \"AttributePayload\": {\r\n \"version\": \"v1\",\r\n \"serialNumber\": {\r\n \"Ref\": \"AWS::IoT::Certificate::SerialNumber\"\r\n }\r\n },\r\n \"ThingTypeName\": \"lightBulb-versionA\",\r\n \"ThingGroups\": [\r\n \"v1-lightbulbs\",\r\n {\r\n \"Ref\": \"AWS::IoT::Certificate::Country\"\r\n }\r\n ]\r\n },\r\n \"OverrideSettings\": {\r\n \"AttributePayload\": \"MERGE\",\r\n \"ThingTypeName\": \"REPLACE\",\r\n \"ThingGroups\": \"DO_NOTHING\"\r\n }\r\n },\r\n \"certificate\": {\r\n \"Type\": \"AWS::IoT::Certificate\",\r\n \"Properties\": {\r\n \"CertificateId\": {\r\n \"Ref\": \"AWS::IoT::Certificate::Id\"\r\n },\r\n \"Status\": \"ACTIVE\"\r\n },\r\n \"OverrideSettings\": {\r\n \"Status\": \"DO_NOTHING\"\r\n }\r\n },\r\n \"policy\": {\r\n \"Type\": \"AWS::IoT::Policy\",\r\n \"Properties\": {\r\n \"PolicyDocument\": \"{ \\\"Version\\\": \\\"2012-10-17 \\\", \\\"Statement\\\": [{ \\\"Effect\\\": \\\"Allow\\\", \\\"Action\\\":[\\\"iot:Publish\\\"], \\\"Resource\\\": [\\\"arn:aws:iot:us-east-1:123456789012:topic\/foo\/bar\\\"] }] }\"\r\n }\r\n }\r\n }\r\n}",
"roleArn" : "arn:aws:iam::123456789012:role/JITPRole"
}
```
Dans cet exemple, la valeur du champ `templateBody` doit être un objet JSON spécifié comme une chaîne échappée et ne peut utiliser que les valeurs de la [liste précédente](#jit-provisioning-overview). Vous pouvez utiliser différents outils pour créer l'objet JSON requis, par exemple `json.dumps` (Python) ou `JSON.stringify` (Node). La valeur du champ `roleARN` doit être l'ARN d'un rôle qui est le `AWSIoTThingsRegistration` attaché à celui-ci. De plus, votre modèle peut utiliser un `PolicyName` au lieu du `PolicyDocument` en ligne dans l'exemple.
1. Enregistrez un certificat CA à l'aide de l'opération [Register CACertificate](https://docs.aws.amazon.com/iot/latest/apireference/API_RegisterCACertificate.html) API ou de la commande [https://docs.aws.amazon.com//cli/latest/reference/iot/register-ca-certificate.html](https://docs.aws.amazon.com//cli/latest/reference/iot/register-ca-certificate.html)CLI. Vous allez spécifier le répertoire du modèle de mise en service et les informations ARN du rôle que vous avez enregistrées à l’étape précédente :
L’exemple suivant montre comment enregistrer un certificat CA en mode `DEFAULT` à l’aide du AWS CLI :
```
aws iot register-ca-certificate --ca-certificate file://your-ca-cert --verification-cert file://your-verification-cert
--set-as-active --allow-auto-registration --registration-config file://your-template
```
L’exemple suivant montre comment enregistrer un certificat CA en mode `SNI_ONLY` à l’aide du AWS CLI :
```
aws iot register-ca-certificate --ca-certificate file://your-ca-cert --certificate-mode SNI_ONLY
--set-as-active --allow-auto-registration --registration-config file://your-template
```
Pour en savoir plus, veuillez consulter [Enregistrement des certificats CA](https://docs.aws.amazon.com//iot/latest/developerguide/register-CA-cert.html).
1. (Facultatif) Mettez à jour les paramètres d'un certificat CA à l'aide de l'opération [Update CACertificate](https://docs.aws.amazon.com/iot/latest/apireference/API_UpdateCACertificate.html) API ou de la commande [https://docs.aws.amazon.com//cli/latest/reference/iot/update-ca-certificate.html](https://docs.aws.amazon.com//cli/latest/reference/iot/update-ca-certificate.html)CLI.
L’exemple suivant montre comment mettre à jour un certificat d’autorité de certification à l’aide AWS CLI :
```
aws iot update-ca-certificate --certificate-id caCertificateId
--new-auto-registration-status ENABLE --registration-config file://your-template
```
## Enregistrer CA à l’aide d’un nom de modèle de mise en service
Pour enregistrer CA à l’aide d’un nom de modèle de mise en service, procédez comme suit :
1. Enregistrez le corps de votre modèle de mise en service en tant que fichier JSON. Vous pouvez trouver un exemple de corps de modèle dans un [exemple de corps de modèle](#jit-provisioning-example-templatebody).
1. Pour créer un modèle de provisionnement, utilisez l'[CreateProvisioningTemplate](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningTemplate.html)API ou la commande [https://docs.aws.amazon.com//cli/latest/reference/iot/create-provisioning-template.html](https://docs.aws.amazon.com//cli/latest/reference/iot/create-provisioning-template.html)CLI :
```
aws iot create-provisioning-template --template-name your-template-name \
--template-body file://your-template-body.json --type JITP \
--provisioning-role-arn arn:aws:iam::123456789012:role/test
```
**Note**
Pour le just-in-time provisionnement (JITP), vous devez spécifier le type de modèle à utiliser `JITP` lors de la création du modèle de provisionnement. Pour plus d'informations sur le type de modèle, consultez [CreateProvisioningTemplate](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningTemplate.html)la *référence de l'AWS API*.
1. Pour enregistrer l'autorité de certification avec le nom du modèle, utilisez l'CACertificateAPI [Register](https://docs.aws.amazon.com/iot/latest/apireference/API_RegisterCACertificate.html) ou la commande [https://docs.aws.amazon.com//cli/latest/reference/iot/register-ca-certificate.html](https://docs.aws.amazon.com//cli/latest/reference/iot/register-ca-certificate.html)CLI :
```
aws iot register-ca-certificate --ca-certificate file://your-ca-cert --verification-cert file://your-verification-cert \
--set-as-active --allow-auto-registration --registration-config templateName=your-template-name
```
# Enregistrement en bloc
Vous pouvez utiliser la commande [https://docs.aws.amazon.com/iot/latest/apireference/API_StartThingRegistrationTask.html](https://docs.aws.amazon.com/iot/latest/apireference/API_StartThingRegistrationTask.html) pour enregistrer les objets en bloc. Cette commande prend un modèle de mise en service, un nom de compartiment S3, un nom de clé et un ARN de rôle qui autorise l’accès au fichier dans le compartiment S3. Le fichier du compartiment S3 contient les valeurs utilisées pour remplacer les paramètres dans le modèle. Le fichier doit être au format JSON délimité par une nouvelle ligne. Chaque ligne contient toutes les valeurs des paramètres pour l'enregistrement d'un seul appareil. Par exemple :
```
{"ThingName": "foo", "SerialNumber": "123", "CSR": "csr1"}
{"ThingName": "bar", "SerialNumber": "456", "CSR": "csr2"}
```
Les opérations API suivantes liées à l’enregistrement en masse peuvent être utiles :
+ [ListThingRegistrationTasks](https://docs.aws.amazon.com/iot/latest/apireference/API_ListThingRegistrationTasks.html): Répertorie les tâches actuelles de provisionnement d'objets en masse.
+ [ DescribeThingRegistrationTask](https://docs.aws.amazon.com/iot/latest/apireference/API_DescribeThingRegistrationTask.html): fournit des informations sur une tâche spécifique d'enregistrement d'objets groupés.
+ [StopThingRegistrationTask](https://docs.aws.amazon.com/iot/latest/apireference/API_StopThingRegistrationTask.html): arrête une tâche d'enregistrement d'objets groupés.
+ [ListThingRegistrationTaskReports](https://docs.aws.amazon.com/iot/latest/apireference/API_ListThingRegistrationTaskReports.html): Utilisé pour vérifier les résultats et les échecs d'une tâche d'enregistrement groupée d'objets.
**Note**
Vous ne pouvez exécuter qu'une seule tâche d'enregistrement en bloc à la fois (par compte).
Les opérations d'enregistrement groupé font appel à d'autres opérations AWS IoT de l'API du plan de contrôle. Ces appels peuvent dépasser les [AWS IoT quotas de limitation](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#throttling-limits) définis dans votre compte et provoquer des erreurs de limitation. Contactez [AWS le Support client](https://console.aws.amazon.com/support/home) pour augmenter vos AWS IoT quotas de régulation, si nécessaire.
# Modèles de provisionnement
Un modèle de provisionnement est un document JSON qui utilise des paramètres pour décrire les ressources avec AWS IoT lesquelles votre appareil doit interagir. Un modèle de mise en service contient deux sections : `Parameters` et `Resources`. Il existe deux types de modèles de provisionnement dans AWS IoT. L'un est utilisé pour le just-in-time provisionnement (JITP) et l'enregistrement en masse, et le second est utilisé pour le provisionnement de la flotte.
**Topics**
+ [Section Parameters](#parameters-section)
+ [Section Resources](#resources-section)
+ [Exemple de modèle pour l’enregistrement en bloc](#bulk-template-example)
+ [Exemple de modèle pour le just-in-time provisionnement (JITP)](#JITP-template-example)
+ [Mise en service de flotte](#fleet-provision-template)
## Section Parameters
La section `Parameters` déclare les paramètres utilisés dans la section `Resources`. Chaque paramètre déclare un nom, un type et une valeur facultative par défaut. La valeur par défaut est utilisée lorsque le dictionnaire transmis avec le modèle ne contient pas de valeur pour le paramètre. La section `Parameters` d'un modèle de document ressemble à ce qui suit :
```
{
"Parameters" : {
"ThingName" : {
"Type" : "String"
},
"SerialNumber" : {
"Type" : "String"
},
"Location" : {
"Type" : "String",
"Default" : "WA"
},
"CSR" : {
"Type" : "String"
}
}
}
```
Cet extrait de corps de modèle déclare quatre paramètres : `ThingName`, `SerialNumber`, `Location` et `CSR`. Tous ces paramètres sont de type `String`. Le paramètre `Location` déclare la valeur par défaut `"WA"`.
## Section Resources
La `Resources` section du corps du modèle indique les ressources nécessaires à la communication de votre appareil AWS IoT : un objet, un certificat et une ou plusieurs politiques IoT. Chaque ressource spécifie un nom logique, un type et un ensemble de propriétés.
Un nom logique vous permet de faire référence à une ressource à un autre endroit dans le modèle.
Le type spécifie le type de ressource que vous déclarez. Les types valides sont :
+ `AWS::IoT::Thing`
+ `AWS::IoT::Certificate`
+ `AWS::IoT::Policy`
Les propriétés que vous spécifiez dépendent du type de ressource que vous déclarez.
### Ressources d'objet
Les ressources d'objet sont déclarées à l'aide des propriétés suivantes :
+ `ThingName`: String.
+ `AttributePayload`: Facultatif. Liste de paires nom-valeur.
+ `ThingTypeName`: Facultatif. Chaîne d'un type d'objet associé pour l'objet.
+ `ThingGroups`: Facultatif. Liste des groupes auxquels l'objet appartient.
+ `BillingGroup`: Facultatif. Chaîne pour le nom d’un groupe de facturation associé.
+ `PackageVersions`: Facultatif. Chaîne pour un package associé et les noms de version.
### Ressources de certificat
Les certificats peuvent être spécifiés de l'une des façons suivantes :
+ Demande de signature du certificat (CSR).
+ ID d'un certificat d'appareil existant. (Seul le certificat IDs peut être utilisé avec un modèle de provisionnement de flotte.)
+ Certificat d'appareil créé avec un certificat CA enregistré auprès d' AWS IoT. Si vous avez plusieurs certificats CA enregistrés avec le même champ d'objet, vous devez également transmettre le certificat CA utilisé pour signer le certificat de l'appareil.
**Note**
Lorsque vous déclarez un certificat dans un modèle, vous devez uniquement utiliser ces méthodes. Par exemple, si vous utilisez une CSR, vous ne pouvez pas spécifier d'ID de certificat ou de certificat d'appareil. Pour de plus amples informations, veuillez consulter [Certificats client X.509](x509-client-certs.md).
Pour de plus amples informations, veuillez consulter [Présentation des certificats X.509](authentication.md#x509-certificate-overview).
Les ressources de certificat sont déclarées à l'aide des propriétés suivantes :
+ `CertificateSigningRequest`: String.
+ `CertificateId`: String.
+ `CertificatePem`: String.
+ `CACertificatePem`: String.
+ `Status`: Facultatif. Chaîne qui peut être `ACTIVE` ou `INACTIVE`. ACTIVE est l'option sélectionnée par défaut.
+ `ThingPrincipalType`: Facultatif. Chaîne qui indique le type de relation entre l'objet et le principal (le certificat).
+ `EXCLUSIVE_THING`: Établit une relation exclusive. Le principal ne peut être attaché qu'à cette chose spécifique et à aucune autre.
+ `NON_EXCLUSIVE_THING`: Attache le principal spécifié aux objets. Vous pouvez associer plusieurs objets au principal. Il s'agit de la valeur par défaut si elle n'est pas spécifiée.
**Note**
Vous pouvez également approvisionner des appareils sans certificat d'appareil. Pour de plus amples informations, veuillez consulter [Mise en service d'appareils qui ne disposent pas de certificats d'appareils à l'aide de la mise en service de flotte](provision-wo-cert.md).
Exemples :
+ Certificat spécifié avec une CSR :
```
{
"certificate" : {
"Type" : "AWS::IoT::Certificate",
"Properties" : {
"CertificateSigningRequest": {"Ref" : "CSR"},
"Status" : "ACTIVE"
}
}
}
```
+ Certificat spécifié avec un ID de certificat existant :
```
{
"certificate" : {
"Type" : "AWS::IoT::Certificate",
"Properties" : {
"CertificateId": {"Ref" : "CertificateId"}
}
}
}
```
+ Certificat spécifié avec un fichier .pem de certificat et un fichier .pem de certificat de CA existants :
```
{
"certificate" : {
"Type" : "AWS::IoT::Certificate",
"Properties" : {
"CACertificatePem": {"Ref" : "CACertificatePem"},
"CertificatePem": {"Ref" : "CertificatePem"}
}
}
}
```
+ Attachez exclusivement une chose à un principal :
```
{
"certificate" : {
"Type" : "AWS::IoT::Certificate",
"Properties" : {
"ThingPrincipalType" : "EXCLUSIVE_THING"
}
}
}
```
### Ressources de politique
Les ressources de stratégie sont déclarées à l'aide de l'une des propriétés suivantes :
+ `PolicyName`: Facultatif. String. Un hachage du document de stratégie est utilisé par défaut. Les `PolicyName` peuvent uniquement faire référence à des politiques AWS IoT , mais pas à des politiques IAM. Si vous utilisez une stratégie AWS IoT existante, pour la propriété `PolicyName`, saisissez le nom de la stratégie. N'incluez pas la propriété `PolicyDocument`.
+ `PolicyDocument`: Facultatif. Un objet JSON spécifié comme une chaîne placée dans une séquence d'échappement. Si `PolicyDocument` n'est pas fourni, la stratégie doit déjà être créée.
**Note**
Si une section `Policy` est présente, `PolicyName` ou `PolicyDocument`, mais pas les deux, doit être spécifié.
### Paramètres de remplacement
Si un modèle spécifie une ressource qui existe déjà, la section `OverrideSettings` vous permet de spécifier l'action à effectuer :
`DO_NOTHING`
Conserver la ressource telle qu'elle est.
`REPLACE`
Remplacer la ressource par celle qui est spécifiée dans le modèle.
`FAIL`
Entraîner l'échec de la demande avec `ResourceConflictsException`.
`MERGE`
Valide uniquement pour les propriétés `ThingGroups` et `AttributePayload` d'un `thing`. Fusionnez les attributs existants ou les appartenances aux groupes de l'objet avec ceux spécifiés dans le modèle.
Lorsque vous déclarez une ressource d'objet, vous pouvez spécifier `OverrideSettings` pour les propriétés suivantes :
+ `ATTRIBUTE_PAYLOAD`
+ `THING_TYPE_NAME`
+ `THING_GROUPS`
Lorsque vous déclarez une ressource de certificat, vous pouvez spécifier `OverrideSettings` pour la propriété `Status`.
`OverrideSettings` n'est pas disponible pour les ressources de stratégie.
### Exemple de ressource
L'extrait de modèle suivant déclare un objet, un certificat et une stratégie :
```
{
"Resources" : {
"thing" : {
"Type" : "AWS::IoT::Thing",
"Properties" : {
"ThingName" : {"Ref" : "ThingName"},
"AttributePayload" : { "version" : "v1", "serialNumber" : {"Ref" : "SerialNumber"}},
"ThingTypeName" : "lightBulb-versionA",
"ThingGroups" : ["v1-lightbulbs", {"Ref" : "Location"}]
},
"OverrideSettings" : {
"AttributePayload" : "MERGE",
"ThingTypeName" : "REPLACE",
"ThingGroups" : "DO_NOTHING"
}
},
"certificate" : {
"Type" : "AWS::IoT::Certificate",
"Properties" : {
"CertificateSigningRequest": {"Ref" : "CSR"},
"Status" : "ACTIVE"
}
},
"policy" : {
"Type" : "AWS::IoT::Policy",
"Properties" : {
"PolicyDocument" : "{ \"Version\": \"2012-10-17\", \"Statement\": [{ \"Effect\": \"Allow\", \"Action\":[\"iot:Publish\"], \"Resource\": [\"arn:aws:iot:us-east-1:123456789012:topic/foo/bar\"] }] }"
}
}
}
}
```
L'objet est déclaré avec :
+ Le nom logique `"thing"`.
+ Le type `AWS::IoT::Thing`.
+ Un ensemble de propriétés d'objet.
Les propriétés d'objet comprennent le nom de l'objet, un ensemble d'attributs, un nom de type d'objet facultatif et une liste facultative de groupes d'objets auxquels l'objet appartient.
Les paramètres sont référencés par `{"Ref":"parameter-name"}`. Lorsque le modèle est évalué, les paramètres sont remplacés par la valeur du paramètre à partir du dictionnaire transmis avec le modèle.
Le certificat est déclaré avec :
+ Le nom logique `"certificate"`.
+ Le type `AWS::IoT::Certificate`.
+ Un ensemble de propriétés.
Les propriétés incluent la CSR pour le certificat et la définition de l'état sur `ACTIVE`. Le texte de la CSR est transmis en tant que paramètre dans le dictionnaire transmis avec le modèle.
La stratégie est déclarée avec :
+ Le nom logique `"policy"`.
+ Le type `AWS::IoT::Policy`.
+ Le nom d'une stratégie existante ou un document de stratégie.
## Exemple de modèle pour l’enregistrement en bloc
Le fichier JSON suivant est un exemple de modèle de mise en service complet qui spécifie le certificat avec une CSR :
(La valeur du champ `PolicyDocument` doit être un objet JSON spécifié comme une chaîne placée dans une séquence d'échappement.)
```
{
"Parameters" : {
"ThingName" : {
"Type" : "String"
},
"SerialNumber" : {
"Type" : "String"
},
"Location" : {
"Type" : "String",
"Default" : "WA"
},
"CSR" : {
"Type" : "String"
}
},
"Resources" : {
"thing" : {
"Type" : "AWS::IoT::Thing",
"Properties" : {
"ThingName" : {"Ref" : "ThingName"},
"AttributePayload" : { "version" : "v1", "serialNumber" : {"Ref" : "SerialNumber"}},
"ThingTypeName" : "lightBulb-versionA",
"ThingGroups" : ["v1-lightbulbs", {"Ref" : "Location"}]
}
},
"certificate" : {
"Type" : "AWS::IoT::Certificate",
"Properties" : {
"CertificateSigningRequest": {"Ref" : "CSR"},
"Status" : "ACTIVE",
"ThingPrincipalType" : "EXCLUSIVE_THING"
}
},
"policy" : {
"Type" : "AWS::IoT::Policy",
"Properties" : {
"PolicyDocument" : "{ \"Version\": \"2012-10-17\", \"Statement\": [{ \"Effect\": \"Allow\", \"Action\":[\"iot:Publish\"], \"Resource\": [\"arn:aws:iot:us-east-1:123456789012:topic/foo/bar\"] }] }"
}
}
}
}
```
## Exemple de modèle pour le just-in-time provisionnement (JITP)
Le fichier JSON suivant est un exemple de modèle de mise en service complet qui spécifie un certificat existant avec un ID de certificat :
```
{
"Parameters":{
"AWS::IoT::Certificate::CommonName":{
"Type":"String"
},
"AWS::IoT::Certificate::SerialNumber":{
"Type":"String"
},
"AWS::IoT::Certificate::Country":{
"Type":"String"
},
"AWS::IoT::Certificate::Id":{
"Type":"String"
}
},
"Resources":{
"thing":{
"Type":"AWS::IoT::Thing",
"Properties":{
"ThingName":{
"Ref":"AWS::IoT::Certificate::CommonName"
},
"AttributePayload":{
"version":"v1",
"serialNumber":{
"Ref":"AWS::IoT::Certificate::SerialNumber"
}
},
"ThingTypeName":"lightBulb-versionA",
"ThingGroups":[
"v1-lightbulbs",
{
"Ref":"AWS::IoT::Certificate::Country"
}
]
},
"OverrideSettings":{
"AttributePayload":"MERGE",
"ThingTypeName":"REPLACE",
"ThingGroups":"DO_NOTHING"
}
},
"certificate":{
"Type":"AWS::IoT::Certificate",
"Properties":{
"CertificateId":{
"Ref":"AWS::IoT::Certificate::Id"
},
"Status":"ACTIVE",
"ThingPrincipalType" : "EXCLUSIVE_THING"
}
},
"policy":{
"Type":"AWS::IoT::Policy",
"Properties":{
"PolicyDocument":"{ \"Version\": \"2012-10-17\", \"Statement\": [{ \"Effect\": \"Allow\", \"Action\":[\"iot:Publish\"], \"Resource\": [\"arn:aws:iot:us-east-1:123456789012:topic/foo/bar\"] }] }"
}
}
}
}
```
**Important**
Vous devez l’utiliser `CertificateId` dans un modèle utilisé pour la mise en service JIT.
Pour plus d'informations sur le type de modèle de provisionnement, consultez la référence [https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningTemplate.html#iot-CreateProvisioningTemplate-request-type](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningTemplate.html#iot-CreateProvisioningTemplate-request-type)de l' AWS API.
Pour plus d'informations sur l'utilisation de ce modèle pour le just-in-time provisionnement, voir : [J ust-in-time provisioning](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html).
## Mise en service de flotte
Les modèles de provisionnement de flotte sont utilisés AWS IoT pour configurer la configuration du cloud et des appareils. Ces modèles utilisent les mêmes paramètres et ressources que le JITP et les modèles d'enregistrement en bloc. Pour de plus amples informations, veuillez consulter [Modèles de provisionnement](#provision-template). Les modèles de mise en service de flotte peuvent contenir une section `Mapping` et une section `DeviceConfiguration`. Vous pouvez utiliser des fonctions intrinsèques à l’intérieur d’un modèle de mise en service de flotte pour générer une configuration spécifique à l’appareil. Les modèles de provisionnement de flotte sont nommés ressources et sont identifiés par ARNs (par exemple,`arn:aws:iot:us-west-2:1234568788:provisioningtemplate/templateName`).
### Mappages
La section `Mappings` facultative associe à une clé à un ensemble de valeurs correspondantes portant un nom. Par exemple, si vous souhaitez définir des valeurs en fonction d'une AWS région, vous pouvez créer un mappage qui utilise le Région AWS nom comme clé et qui contient les valeurs que vous souhaitez spécifier pour chaque région spécifique. Pour récupérer les valeurs d'un mappage, utilisez la fonction intrinsèque `Fn::FindInMap`.
Vous ne pouvez pas inclure des paramètres, des pseudo-paramètres ou des fonctions d'appel intrinsèques dans la section `Mappings`.
### Configuration de l’appareil
La section Configuration des appareils contient des données arbitraires que vous souhaitez envoyer à vos appareils lors de la mise en service. Par exemple :
```
{
"DeviceConfiguration": {
"Foo":"Bar"
}
}
```
Si vous envoyez des messages à vos appareils à l'aide du format de charge utile JSON ( JavaScript Object Notation), AWS IoT Core formatez ces données au format JSON. Si vous utilisez le format de charge utile CBOR (Représentation binaire concise des objets), AWS IoT Core formate ces données au format CBOR. La section `DeviceConfiguration` ne prend pas en charge les objets JSON imbriqués.
### Fonctions intrinsèques
Les fonctions intrinsèques sont utilisées dans n'importe quelle section du modèle de mise en service, à l'exception de la section `Mappings`.
`Fn::Join`
Ajoute un ensemble de valeurs dans une seule valeur, séparées par le délimiteur spécifié. Si un délimiteur est une chaîne vide, l’ensemble de valeurs est concaténé avec aucun délimiteur.
`Fn::Join` n’est pas pris en charge pour [Ressources de politique](#policy-resources).
`Fn::Select`
Renvoie un seul objet à partir d'une liste d'objets en fonction de son index.
`Fn::Select` ne recherche pas les valeurs `null` ou ne vérifie pas si l'index sort des limites du tableau. Les deux conditions entraînent une erreur de provisionnement. Assurez-vous donc que vous avez choisi une valeur d'index valide et que la liste contient des valeurs non nulles.
`Fn::FindInMap`
Renvoie la valeur correspondant aux clés dans un mappage à deux niveaux déclaré dans la section `Mappings`.
`Fn::Split`
Divise une chaîne en liste de valeurs de chaîne afin que vous puissiez sélectionner un élément dans la liste de chaînes. Vous spécifiez un délimiteur qui détermine où la chaîne est fractionnée (par exemple, une virgule). Après avoir divisé une chaîne, utilisez `Fn::Select` pour sélectionner un élément.
Par exemple, si une chaîne de sous-réseau séparée par des virgules IDs est importée dans votre modèle de pile, vous pouvez diviser la chaîne à chaque virgule. Dans la liste des sous-réseaux IDs, utilisez cette option `Fn::Select` pour spécifier un ID de sous-réseau pour une ressource.
`Fn::Sub`
Remplace les variables contenues dans une chaîne d'entrée par des valeurs que vous spécifiez. Vous pouvez utiliser cette fonction pour construire des commandes ou des sorties qui incluent des valeurs qui ne sont pas disponibles tant que vous n'avez pas créé ou mis à jour une pile.
### Exemple de modèle pour la mise en service d’une flotte
```
{
"Parameters" : {
"ThingName" : {
"Type" : "String"
},
"SerialNumber": {
"Type": "String"
},
"DeviceLocation": {
"Type": "String"
}
},
"Mappings": {
"LocationTable": {
"Seattle": {
"LocationUrl": "https://example.aws"
}
}
},
"Resources" : {
"thing" : {
"Type" : "AWS::IoT::Thing",
"Properties" : {
"AttributePayload" : {
"version" : "v1",
"serialNumber" : "serialNumber"
},
"ThingName" : {"Ref" : "ThingName"},
"ThingTypeName" : {"Fn::Join":["",["ThingPrefix_",{"Ref":"SerialNumber"}]]},
"ThingGroups" : ["v1-lightbulbs", "WA"],
"BillingGroup": "LightBulbBillingGroup"
},
"OverrideSettings" : {
"AttributePayload" : "MERGE",
"ThingTypeName" : "REPLACE",
"ThingGroups" : "DO_NOTHING"
}
},
"certificate" : {
"Type" : "AWS::IoT::Certificate",
"Properties" : {
"CertificateId": {"Ref": "AWS::IoT::Certificate::Id"},
"Status" : "Active",
"ThingPrincipalType" : "EXCLUSIVE_THING"
}
},
"policy" : {
"Type" : "AWS::IoT::Policy",
"Properties" : {
"PolicyDocument" : {
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action":["iot:Publish"],
"Resource": ["arn:aws:iot:us-east-1:123456789012:topic/foo/bar"]
}]
}
}
}
},
"DeviceConfiguration": {
"FallbackUrl": "https://www.example.com/test-site",
"LocationUrl": {
"Fn::FindInMap": ["LocationTable",{"Ref": "DeviceLocation"}, "LocationUrl"]}
}
}
```
**Note**
Un modèle de mise en service existant peut être mis à jour afin d’ajouter un [hook de mise en service en amont](pre-provisioning-hook.md).
# Hooks de mise en service en amont
AWS recommande d'utiliser des fonctions de pré-approvisionnement lors de la création de modèles de provisionnement afin de mieux contrôler quels appareils et combien d'appareils sont intégrés à votre compte. Les hooks de mise en service en amont sont des fonctions Lambda qui valident les paramètres transmis par l’appareil avant d’autoriser la mise en service de l’appareil. Cette fonction Lambda doit exister dans votre compte avant la mise en service d’un appareil, car elle est appelée chaque fois qu’un appareil envoie une demande via [RegisterThing](fleet-provision-api.md#register-thing).
**Important**
Assurez-vous d’inclure le `source-arn` ou `source-account` dans les clés de contexte de condition globale des politiques associées à votre action Lambda afin d’empêcher toute manipulation des autorisations. Pour de plus amples informations à ce sujet, veuillez consulter [Prévention du cas de figure de l’adjoint désorienté entre services](cross-service-confused-deputy-prevention.md).
Pour que les appareils soient provisionnés, votre fonction Lambda doit accepter l’objet d’entrée et renvoyer l’objet de sortie décrit dans cette section. La mise en service ne se déroule que si la fonction Lambda renvoie un objet avec la valeur `"allowProvisioning": True`.
## Entrée du hook de pré-provisionnement
AWS IoT envoie cet objet à la fonction Lambda lorsqu'un appareil s'enregistre auprès de. AWS IoT
```
{
"claimCertificateId" : "string",
"certificateId" : "string",
"certificatePem" : "string",
"templateArn" : "arn:aws:iot:us-east-1:1234567890:provisioningtemplate/MyTemplate",
"clientId" : "221a6d10-9c7f-42f1-9153-e52e6fc869c1",
"parameters" : {
"string" : "string",
...
}
}
```
L’objet `parameters` transmis à la fonction Lambda contient les propriétés de l’argument `parameters` passé dans la charge utile de la demande [RegisterThing](fleet-provision-api.md#register-thing).
## Valeur de retour du hook de pré-provisionnement
La fonction Lambda doit renvoyer une réponse indiquant si elle a autorisé la demande de mise en service et les valeurs de toutes les propriétés à remplacer.
Voici un exemple de réponse réussie de la fonction de pré-provisionnement.
```
{
"allowProvisioning": true,
"parameterOverrides" : {
"Key": "newCustomValue",
...
}
}
```
Les valeurs `"parameterOverrides"` seront ajoutées au paramètre `"parameters"` dans la charge utile de la demande [RegisterThing](fleet-provision-api.md#register-thing).
**Note**
Si la fonction Lambda échoue, la demande de provisionnement échoue `ACCESS_DENIED` et une erreur est enregistrée dans Logs. CloudWatch
Si la fonction Lambda ne renvoie pas `"allowProvisioning": "true"` dans la réponse, la demande de mise en service échoue avec `ACCESS_DENIED`.
La fonction Lambda doit procéder à l’exécution et renvoyer dans un délai de 5 secondes, sinon la demande de mise en service échoue.
## Exemple Lambda de hook de mise en service
------
#### [ Python ]
Exemple de hook de mise en service en amont Lambda en Python.
```
import json
def pre_provisioning_hook(event, context):
print(event)
return {
'allowProvisioning': True,
'parameterOverrides': {
'DeviceLocation': 'Seattle'
}
}
```
------
#### [ Java ]
Exemple de hook de mise en service en amont Lambda en Java.
Classe de gestionnaire :
```
package example;
import java.util.Map;
import java.util.HashMap;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
public class PreProvisioningHook implements RequestHandler {
public PreProvisioningHookResponse handleRequest(PreProvisioningHookRequest object, Context context) {
Map parameterOverrides = new HashMap();
parameterOverrides.put("DeviceLocation", "Seattle");
PreProvisioningHookResponse response = PreProvisioningHookResponse.builder()
.allowProvisioning(true)
.parameterOverrides(parameterOverrides)
.build();
return response;
}
}
```
Classe de demande :
```
package example;
import java.util.Map;
import lombok.Builder;
import lombok.Data;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class PreProvisioningHookRequest {
private String claimCertificateId;
private String certificateId;
private String certificatePem;
private String templateArn;
private String clientId;
private Map parameters;
}
```
La classe de réponse :
```
package example;
import java.util.Map;
import lombok.Builder;
import lombok.Data;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class PreProvisioningHookResponse {
private boolean allowProvisioning;
private Map parameterOverrides;
}
```
------
#### [ JavaScript ]
Exemple d'un hook de pré-provisionnement Lambda dans. JavaScript
```
exports.handler = function(event, context, callback) {
console.log(JSON.stringify(event, null, 2));
var reply = {
allowProvisioning: true,
parameterOverrides: {
DeviceLocation: 'Seattle'
}
};
callback(null, reply);
}
```
------
# Signature de certificats autogérée à l'aide d' AWS IoT Core un fournisseur de certificats
Vous pouvez créer un fournisseur de AWS IoT Core certificats pour signer les demandes de signature de certificats (CSRs) lors du provisionnement de AWS IoT flotte. Un fournisseur de certificats fait référence à une fonction Lambda et à l'[API `CreateCertificateFromCsr` MQTT pour le provisionnement](https://docs.aws.amazon.com/iot/latest/developerguide/fleet-provision-api.html#create-cert-csr) de flottes. La fonction Lambda accepte un CSR et renvoie un certificat client signé.
Lorsque vous n'avez pas de fournisseur de certificats Compte AWS, l'[API CreateCertificateFromCsr MQTT](https://docs.aws.amazon.com//iot/latest/developerguide/fleet-provision-api.html#create-cert-csr) est appelée lors du provisionnement de la flotte pour générer le certificat à partir d'un CSR. Après avoir créé un fournisseur de certificats, le comportement de l'[API CreateCertificateFromCsr MQTT](https://docs.aws.amazon.com//iot/latest/developerguide/fleet-provision-api.html#create-cert-csr) changera et tous les appels à cette API MQTT appelleront le fournisseur de certificats pour émettre le certificat.
Avec le fournisseur de AWS IoT Core certificats, vous pouvez mettre en œuvre des solutions qui utilisent des autorités de certification privées (CAs) telles que [AWS CA privée](https://docs.aws.amazon.com/privateca/latest/userguide/PcaWelcome.html)d'autres autorités publiques fiables CAs ou votre propre infrastructure à clé publique (PKI) pour signer le CSR. En outre, vous pouvez utiliser le fournisseur de certificats pour personnaliser les champs de votre certificat client tels que les périodes de validité, les algorithmes de signature, les émetteurs et les extensions.
**Important**
Vous ne pouvez créer qu'un seul fournisseur de certificats par Compte AWS. Le changement de comportement de signature s'applique à l'ensemble du parc qui appelle l'[API CreateCertificateFromCsr MQTT](https://docs.aws.amazon.com//iot/latest/developerguide/fleet-provision-api.html#create-cert-csr) jusqu'à ce que vous supprimiez le fournisseur de certificats de votre Compte AWS.
**Topics**
+ [Comment fonctionne la signature de certificats autogérés dans le cadre de l'approvisionnement de flottes](#provisioning-cert-provider-how-it-works)
+ [Entrée de la fonction Lambda du fournisseur de certificats](#provisioning-cert-provider-lambda-input)
+ [Valeur renvoyée par la fonction Lambda du fournisseur de certificats](#provisioning-cert-provider-lambda-return)
+ [Exemple de fonction Lambda](#provisioning-cert-provider-lambda)
+ [Signature de certificats autogérée pour le provisionnement de la flotte](#provisioning-self-certificate-signing)
+ [AWS CLI commandes pour le fournisseur de certificats](#provisioning-cert-provider-cli)
## Comment fonctionne la signature de certificats autogérés dans le cadre de l'approvisionnement de flottes
### Concepts clés
Les concepts suivants fournissent des détails qui peuvent vous aider à comprendre le fonctionnement de la signature de certificats autogérés dans le cadre du provisionnement de AWS IoT flottes. Pour plus d'informations, consultez la section [Provisionnement d'appareils qui ne possèdent pas de certificat d'appareil à l'aide du provisionnement de flotte](https://docs.aws.amazon.com//iot/latest/developerguide/provision-wo-cert.html).
**AWS IoT approvisionnement de flotte**
Le provisionnement de AWS IoT flotte (abréviation de fleet provisioning) permet de AWS IoT Core générer et de délivrer en toute sécurité des certificats d'appareils à vos appareils lorsqu'ils se connectent AWS IoT Core pour la première fois. Vous pouvez utiliser le provisionnement du parc pour connecter des appareils qui ne possèdent pas de certificat d'appareil à AWS IoT Core.
**Demande de signature de certificat (CSR)**
Au cours du processus de provisionnement de flotte, un appareil fait une demande AWS IoT Core via le MQTT de [provisionnement de flotte](https://docs.aws.amazon.com//iot/latest/developerguide/fleet-provision-api.html). APIs Cette demande inclut une demande de signature de certificat (CSR), qui sera signée pour créer un certificat client.
**AWS signature de certificats gérés dans le cadre de l'approvisionnement de la flotte**
AWS géré est le paramètre par défaut pour la signature des certificats dans le cadre du provisionnement de flotte. Avec la signature de certificat AWS gérée, elle AWS IoT Core signera CSRs en utilisant sa propre signature CAs.
**Signature de certificats autogérés dans le cadre du provisionnement de la flotte**
L'autogestion est une autre option pour la signature de certificats dans le cadre de l'approvisionnement de flottes. Avec la signature de certificats autogérée, vous créez un fournisseur de AWS IoT Core certificats à signer CSRs. Vous pouvez utiliser la signature de certificat autogérée pour signer CSRs avec une autorité de certification générée par une autorité de certification AWS privée, une autre autorité de certification approuvée par le public ou votre propre infrastructure à clé publique (PKI).
**AWS IoT Core fournisseur de certificats**
AWS IoT Core un fournisseur de certificats (abréviation de fournisseur de certificats) est une ressource gérée par le client qui est utilisée pour la signature autogérée de certificats dans le cadre de l'approvisionnement de flottes.
### Schéma
Le schéma suivant illustre de manière simplifiée le fonctionnement de la signature automatique des certificats dans le cadre du provisionnement de AWS IoT flottes.
![\[AWS IoT Core fournisseur de certificats pour l'approvisionnement de flottes\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/images/provisioning-cert-provider.png)
+ Lorsqu'un nouvel appareil IoT est fabriqué ou introduit dans le parc, il a besoin de certificats clients pour s'authentifier. AWS IoT Core
+ Dans le cadre du processus de provisionnement de la flotte, l'appareil fait une demande de certificats client par le biais du MQTT de [provisionnement de la flotte](https://docs.aws.amazon.com//iot/latest/developerguide/fleet-provision-api.html). AWS IoT Core APIs Cette demande inclut une demande de signature de certificat (CSR).
+ AWS IoT Core invoque le fournisseur de certificats et transmet le CSR en entrée au fournisseur.
+ Le fournisseur de certificats prend le CSR en entrée et émet un certificat client.
Pour la signature de certificats AWS gérés, AWS IoT Core signe le CSR à l'aide de sa propre autorité de certification et émet un certificat client.
+ Avec le certificat client émis, l'appareil poursuivra le provisionnement de la flotte et établira une connexion sécurisée avec AWS IoT Core.
## Entrée de la fonction Lambda du fournisseur de certificats
AWS IoT Core envoie l'objet suivant à la fonction Lambda lorsqu'un appareil s'enregistre auprès de cette fonction. La valeur de `certificateSigningRequest` est le CSR au [format PEM (Privacy-Enhanced Mail)](https://docs.aws.amazon.com/acm/latest/userguide/import-certificate-format.html) fourni dans la demande. `CreateCertificateFromCsr` `principalId`Il s'agit de l'ID du principal utilisé pour se connecter AWS IoT Core lors de la `CreateCertificateFromCsr` demande. `clientId`est l'ID client défini pour la connexion MQTT.
```
{
"certificateSigningRequest": "string",
"principalId": "string",
"clientId": "string"
}
```
## Valeur renvoyée par la fonction Lambda du fournisseur de certificats
La fonction Lambda doit renvoyer une réponse contenant la `certificatePem` valeur. Voici un exemple de réponse réussie. AWS IoT Core utilisera la valeur de retour (`certificatePem`) pour créer le certificat.
```
{
"certificatePem": "string"
}
```
Si l'enregistrement est réussi, il `CreateCertificateFromCsr` renverra la même chose `certificatePem` dans la `CreateCertificateFromCsr` réponse. Pour plus d'informations, consultez l'exemple de charge utile de réponse de [CreateCertificateFromCsr](https://docs.aws.amazon.com/iot/latest/developerguide/fleet-provision-api.html#create-cert-csr).
## Exemple de fonction Lambda
Avant de créer un fournisseur de certificats, vous devez créer une fonction Lambda pour signer un CSR. Voici un exemple de fonction Lambda en Python. Cette fonction appelle AWS CA privée à signer le CSR d'entrée, à l'aide d'une autorité de certification privée et de l'algorithme de `SHA256WITHRSA` signature. Le certificat client retourné sera valide pendant un an. Pour plus d'informations sur AWS CA privée et comment créer une autorité de certification privée, voir [Qu'est-ce qu'une autorité de certification AWS privée ?](https://docs.aws.amazon.com/privateca/latest/userguide/PcaWelcome.html) et [Création d'une autorité de certification privée](https://docs.aws.amazon.com/privateca/latest/userguide/create-CA.html).
```
import os
import time
import uuid
import boto3
def lambda_handler(event, context):
ca_arn = os.environ['CA_ARN']
csr = (event['certificateSigningRequest']).encode('utf-8')
acmpca = boto3.client('acm-pca')
cert_arn = acmpca.issue_certificate(
CertificateAuthorityArn=ca_arn,
Csr=csr,
Validity={"Type": "DAYS", "Value": 365},
SigningAlgorithm='SHA256WITHRSA',
IdempotencyToken=str(uuid.uuid4())
)['CertificateArn']
# Wait for certificate to be issued
time.sleep(1)
cert_pem = acmpca.get_certificate(
CertificateAuthorityArn=ca_arn,
CertificateArn=cert_arn
)['Certificate']
return {
'certificatePem': cert_pem
}
```
**Important**
Les certificats renvoyés par la fonction Lambda doivent avoir le même nom d'objet et la même clé publique que la demande de signature de certificat (CSR).
La fonction Lambda doit s'exécuter dans 5 secondes.
La fonction Lambda doit se trouver dans la même région que Compte AWS la ressource du fournisseur de certificats.
Le principal du AWS IoT service doit disposer de l'autorisation d'appel pour la fonction Lambda. Pour éviter toute [confusion liée aux adjoints](https://docs.aws.amazon.com//IAM/latest/UserGuide/confused-deputy.html), nous vous recommandons de définir `sourceArn` et `sourceAccount` pour les autorisations d'appel. Pour plus d’informations, consultez [Prévention du problème de l’adjoint confus entre services](https://docs.aws.amazon.com//iot/latest/developerguide/cross-service-confused-deputy-prevention.html).
L'exemple de politique basée sur les ressources suivant pour [Lambda](https://docs.aws.amazon.com//lambda/latest/dg/access-control-resource-based.html) accorde AWS IoT l'autorisation d'invoquer la fonction Lambda :
****
```
{
"Version":"2012-10-17",
"Id": "InvokePermission",
"Statement": [
{
"Sid": "LambdaAllowIotProvider",
"Effect": "Allow",
"Principal": {
"Service": "iot.amazonaws.com"
},
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-1:123456789012:function:my-function",
"Condition": {
"StringEquals": {
"AWS:SourceAccount": "123456789012"
},
"ArnLike": {
"AWS:SourceArn": "arn:aws:iot:us-east-1:123456789012:certificateprovider/my-certificate-provider"
}
}
}
]
}
```
## Signature de certificats autogérée pour le provisionnement de la flotte
Vous pouvez choisir la signature de certificat autogérée pour le provisionnement de la flotte à l'aide AWS CLI de ou. AWS Management Console
### AWS CLI
Pour choisir la signature de certificats autogérée, vous devez créer un fournisseur de AWS IoT Core certificats pour vous connecter CSRs au provisionnement du parc. AWS IoT Core invoque le fournisseur de certificats, qui prend un CSR en entrée et renvoie un certificat client. Pour créer un fournisseur de certificats, utilisez l'opération `CreateCertificateProvider` API ou la commande `create-certificate-provider` CLI.
**Note**
Une fois que vous avez créé un fournisseur de certificats, le comportement de l'[`CreateCertificateFromCsr`API pour le provisionnement de la flotte](https://docs.aws.amazon.com/iot/latest/developerguide/fleet-provision-api.html#create-cert-csr) changera, de sorte que tous les appels vers `CreateCertificateFromCsr` invoqueront le fournisseur de certificats pour créer les certificats. La modification de ce comportement peut prendre quelques minutes après la création d'un fournisseur de certificats.
```
aws iot create-certificate-provider \
--certificateProviderName my-certificate-provider \
--lambdaFunctionArn arn:aws:lambda:us-east-1:123456789012:function:my-function-1 \
--accountDefaultForOperations CreateCertificateFromCsr
```
Voici un exemple de sortie pour cette commande :
```
{
"certificateProviderName": "my-certificate-provider",
"certificateProviderArn": "arn:aws:iot:us-east-1:123456789012:certificateprovider:my-certificate-provider"
}
```
Pour plus d'informations, consultez la *référence `[CreateCertificateProvider](https://docs.aws.amazon.com//iot/latest/apireference/API_CreateCertificateProvider.html)` de *AWS IoT*l'API*.
### AWS Management Console
Pour choisir la signature autogérée des certificats à l'aide de AWS Management Console, procédez comme suit :
1. Accédez à la [console AWS IoT](https://console.aws.amazon.com//iot/home).
1. Dans le menu de navigation de gauche, sous **Sécurité**, choisissez **Signature du certificat**.
1. Sur la page de **signature du certificat**, sous **Détails de signature du certificat**, choisissez **Modifier la méthode de signature du certificat**.
1. Sur la page **Modifier la méthode de signature du certificat**, sous **Méthode de signature du certificat**, sélectionnez **Autogéré**.
1. Dans la section **Paramètres autogérés**, entrez le nom du fournisseur de certificats, puis créez ou choisissez une fonction Lambda.
1. Choisissez **Mise à jour de la signature du certificat**.
## AWS CLI commandes pour le fournisseur de certificats
### Création d'un fournisseur de certificats
Pour créer un fournisseur de certificats, utilisez l'opération `CreateCertificateProvider` API ou la commande `create-certificate-provider` CLI.
**Note**
Une fois que vous avez créé un fournisseur de certificats, le comportement de l'[`CreateCertificateFromCsr`API pour le provisionnement de la flotte](https://docs.aws.amazon.com/iot/latest/developerguide/fleet-provision-api.html#create-cert-csr) changera, de sorte que tous les appels vers `CreateCertificateFromCsr` invoqueront le fournisseur de certificats pour créer les certificats. La modification de ce comportement peut prendre quelques minutes après la création d'un fournisseur de certificats.
```
aws iot create-certificate-provider \
--certificateProviderName my-certificate-provider \
--lambdaFunctionArn arn:aws:lambda:us-east-1:123456789012:function:my-function-1 \
--accountDefaultForOperations CreateCertificateFromCsr
```
Voici un exemple de sortie pour cette commande :
```
{
"certificateProviderName": "my-certificate-provider",
"certificateProviderArn": "arn:aws:iot:us-east-1:123456789012:certificateprovider:my-certificate-provider"
}
```
Pour plus d'informations, consultez la *référence `[CreateCertificateProvider](https://docs.aws.amazon.com//iot/latest/apireference/API_CreateCertificateProvider.html)` de *AWS IoT*l'API*.
### Mettre à jour le fournisseur de certificats
Pour mettre à jour un fournisseur de certificats, utilisez l'opération `UpdateCertificateProvider` API ou la commande `update-certificate-provider` CLI.
```
aws iot update-certificate-provider \
--certificateProviderName my-certificate-provider \
--lambdaFunctionArn arn:aws:lambda:us-east-1:123456789012:function:my-function-2 \
--accountDefaultForOperations CreateCertificateFromCsr
```
Voici un exemple de sortie pour cette commande :
```
{
"certificateProviderName": "my-certificate-provider",
"certificateProviderArn": "arn:aws:iot:us-east-1:123456789012:certificateprovider:my-certificate-provider"
}
```
Pour plus d'informations, consultez la *référence `[UpdateCertificateProvider](https://docs.aws.amazon.com//iot/latest/apireference/API_UpdateCertificateProvider.html)` de *AWS IoT*l'API*.
### Décrire le fournisseur de certificats
Pour décrire un fournisseur de certificats, utilisez l'opération `DescribeCertificateProvider` API ou la commande `describe-certificate-provider` CLI.
```
aws iot describe-certificate-provider --certificateProviderName my-certificate-provider
```
Voici un exemple de sortie pour cette commande :
```
{
"certificateProviderName": "my-certificate-provider",
"lambdaFunctionArn": "arn:aws:lambda:us-east-1:123456789012:function:my-function",
"accountDefaultForOperations": [
"CreateCertificateFromCsr"
],
"creationDate": "2022-11-03T00:15",
"lastModifiedDate": "2022-11-18T00:15"
}
```
Pour plus d'informations, consultez la *référence `[DescribeCertificateProvider](https://docs.aws.amazon.com//iot/latest/apireference/API_DescribeCertificateProvider.html)` de *AWS IoT*l'API*.
### Supprimer le fournisseur de certificats
Pour supprimer un fournisseur de certificats, utilisez l'opération `DeleteCertificateProvider` API ou la commande `delete-certificate-provider` CLI. Si vous supprimez la ressource du fournisseur de certificats, le comportement de `CreateCertificateFromCsr` AWS IoT reprendra et des certificats signés par AWS IoT un CSR seront créés.
```
aws iot delete-certificate-provider --certificateProviderName my-certificate-provider
```
Cette commande ne produit aucune sortie.
Pour plus d'informations, consultez la *référence `[DeleteCertificateProvider](https://docs.aws.amazon.com//iot/latest/apireference/API_DeleteCertificateProvider.html)` de *AWS IoT*l'API*.
### Liste des fournisseurs de certificats
Pour répertorier les fournisseurs de certificats qu' Compte AWS il contient, utilisez l'opération `ListCertificateProviders` API ou la commande `list-certificate-providers` CLI.
```
aws iot list-certificate-providers
```
Voici un exemple de sortie pour cette commande :
```
{
"certificateProviders": [
{
"certificateProviderName": "my-certificate-provider",
"certificateProviderArn": "arn:aws:iot:us-east-1:123456789012:certificateprovider:my-certificate-provider"
}
]
}
```
Pour plus d'informations, consultez la *référence [https://docs.aws.amazon.com//iot/latest/apireference/API_ListCertificateProviders.html](https://docs.aws.amazon.com//iot/latest/apireference/API_ListCertificateProviders.html)de *AWS IoT*l'API*.
# Création de politiques et de rôles IAM pour un utilisateur installant un appareil
**Note**
Ces procédures ne sont destinées à être utilisées que sur instruction de la AWS IoT console.
Pour accéder à cette page depuis la console, ouvrez [créer un nouveau modèle de mise en service](https://console.aws.amazon.com//iot/home#/provisioningtemplate/create/provisioningmethods/trustedUser).
## Pourquoi cela ne peut-il pas être fait dans la AWS IoT console ?
Pour une expérience plus sécurisée, les actions IAM sont effectuées dans la console IAM. Les procédures décrites dans cette section vous indiquent les étapes de création des rôles et politiques IAM nécessaires à l’utilisation du modèle de mise en service.
## Création d’une politique IAM pour l’utilisateur qui installera un appareil
Cette procédure décrit comment créer une politique IAM qui autorise un utilisateur à installer un appareil à l’aide d’un modèle de mise en service.
Au cours de cette procédure, vous allez passer de la console IAM à la AWS IoT console. Nous vous recommandons d’ouvrir les deux consoles en même temps pendant que vous effectuez cette procédure.
**Pour créer une politique IAM pour l’utilisateur qui installera un appareil**
1. Ouvrez la page [Centre de politiques dans la console IAM](https://console.aws.amazon.com//iamv2/home#/policies).
1. Choisissez **Create Policy** (Créer une politique).
1. Sur la page **Créer une politique**, choisissez l'onglet **JSON**.
1. Accédez à la page de la AWS IoT console où vous avez choisi **Configurer la politique et le rôle des utilisateurs**.
1. Dans la **politique de mise en service des échantillons**, choisissez **Copier**.
1. Revenez à la console IAM.
1. Dans l'éditeur **JSON**, collez la politique que vous avez copiée depuis la AWS IoT console. Cette politique est spécifique au modèle que vous créez dans la AWS IoT console.
1. Pour continuer, choisissez **Suivant : Balises**.
1. Sur la page **Ajouter des balises (facultatif)**, choisissez **Ajouter une balise** pour chaque balise que vous souhaitez ajouter à cette politique. Vous pouvez ignorer cette étape si vous n’avez aucune balise à ajouter.
1. Choisissez **Suivant : Vérification** pour continuer.
1. Sur la page **Examiner une stratégie**, procédez comme suit :
1. Dans **Nom\$1**, entrez un nom pour la politique qui vous aidera à vous souvenir de l’objectif de la politique.
Notez le nom que vous donnez à cette politique car vous l’utiliserez dans la procédure suivante.
1. Vous pouvez choisir de saisir une description facultative pour la politique que vous créez.
1. Consultez le reste de cette politique et ses balises.
1. Choisissez **Créer une stratégie** afin de finaliser la création de la stratégie.
Après avoir créé votre nouvelle stratégie, continuez vers [Création d’un rôle IAM pour l’utilisateur qui installera un appareil](#provision-create-role-role) pour créer l’entrée de rôle de l’utilisateur à laquelle vous joindrez cette stratégie.
## Création d’un rôle IAM pour l’utilisateur qui installera un appareil
Ces étapes décrivent comment créer un rôle IAM qui authentifie l’utilisateur qui installera un appareil à l’aide d’un modèle de mise en service.
**Pour créer une politique IAM pour l’utilisateur qui installera un appareil**
1. Ouvrez le centre de [Rôles dans la console IAM](https://console.aws.amazon.com//iamv2/home#/roles).
1. Sélectionnez **Créer un rôle**.
1. Dans **Sélectionner une entité d’approbation**, choisissez le type d’entité d’approbation à laquelle vous souhaitez donner accès au modèle que vous créez.
1. Choisissez ou entrez l’identification de l’entité d’approbation à laquelle vous souhaitez accorder l’accès, puis choisissez **Suivant**.
1. Dans la page **Ajouter des autorisations** dans **Stratégies d’autorisations**, dans la zone de recherche, saisissez le nom de la stratégie que vous avez créée lors de la [procédure précédente](#provision-create-role-policy).
1. Pour la liste de stratégies, choisissez la stratégie que vous avez créée lors de la procédure précédente, puis choisissez **Suivant**.
1. Dans la section **Nommer, vérifier et créer**, procédez comme suit :
1. Pour **Nom du rôle**, saisissez un nom de rôle vous permettant de vous rappeler du but de ce rôle.
1. Dans **Description**, vous pouvez choisir de saisir une description facultative du rôle. L’utilisation de cette étape n’est pas obligatoire pour continuer.
1. Passez en revue les valeurs des **étapes 1** et **2**.
1. Pour **Ajouter des balises (facultatif)**, vous pouvez choisir d’ajouter des balises à ce rôle. L’utilisation de cette étape n’est pas obligatoire pour continuer.
1. Vérifiez que les informations de cette page sont complètes et correctes, puis choisissez **Créer un rôle**.
Après avoir créé le nouveau rôle, revenez à la AWS IoT console pour continuer à créer le modèle.
## Mettre à jour une politique existante pour autoriser un nouveau modèle
Les étapes suivantes décrivent comment ajouter un nouveau modèle à une politique IAM qui autorise un utilisateur à installer un appareil à l’aide d’un modèle de provisioning.
**Pour ajouter un nouveau modèle à une politique IAM existante**
1. Ouvrez la page [Centre de politiques dans la console IAM](https://console.aws.amazon.com//iamv2/home#/policies).
1. Dans le champ de recherche, saisissez le nom de la politique à mettre à jour.
1. Dans la liste située sous le champ de recherche, recherchez la politique que vous souhaitez mettre à jour et choisissez le nom de la politique.
1. Pour le **résumé des politiques**, choisissez l’onglet **JSON**, si ce panneau n’est pas déjà visible.
1. Si vous souhaitez modifier la politique, choisissez **Modifier la politique**.
1. Dans l’éditeur, choisissez l’onglet **JSON**, si ce panneau n’est pas déjà visible.
1. Dans le document de politique, recherchez la déclaration de politique qui contient l’action `iot:CreateProvisioningClaim`.
Si le document de politique ne contient aucune déclaration de politique avec l’action `iot:CreateProvisioningClaim`, copiez l’extrait d’instruction suivant et collez-le en tant qu’entrée supplémentaire dans le tableau `Statement` du document de politique.
**Note**
Cet extrait doit être placé avant le dernier caractère `]` du tableau `Statement`. Vous devrez peut-être ajouter une virgule avant ou après cet extrait pour corriger toute erreur de syntaxe.
```
{
"Effect": "Allow",
"Action": [
"iot:CreateProvisioningClaim"
],
"Resource": [
"--PUT YOUR NEW TEMPLATE ARN HERE--"
]
}
```
1. Accédez à la page de la AWS IoT console où vous avez choisi **Modifier les autorisations du rôle utilisateur**.
1. Recherchez l’**ARN de ressource** du modèle et choisissez **Copier**.
1. Revenez à la console IAM.
1. Collez le nom de ressource Amazon (ARN) copié en haut de la liste des modèles ARNs du `Statement` tableau afin qu'il s'agisse de la première entrée.
S’il s’agit du seul ARN du tableau, supprimez la virgule à la fin de la valeur que vous venez de coller.
1. Passez en revue la déclaration de politique mise à jour et corrigez les erreurs signalées par l’éditeur.
1. Pour enregistrer le document de politique mis à jour, choisissez **Passer en revue la politique**.
1. Choisissez Passer en revue une stratégie, puis **Enregistrer les modifications**.
1. Retournez à la AWS IoT console.
# API MQTT de mise en service des appareils
Le service Fleet Provisioning prend en charge les opérations d'API MQTT suivantes :
+ `CreateCertificateFromCsr`
+ `CreateKeysAndCertificate`
+ `RegisterThing`
Cette API prend en charge les tampons de réponse au format CBOR (Concise Binary JavaScript Object Representation) et au format JSON (Object Notation), selon le *payload-format* sujet. Pour plus de clarté, les exemples de réponse et de demande présentés dans cette section sont présentés au format JSON.
| *payload-format* | Type de données du format de réponse |
| --- | --- |
| CBOR | CBOR (Concise Binary Object Representation, représentation concise d'objets binaires) |
| json | JavaScript Notation d'objets (JSON) |
**Important**
Avant de publier une rubrique de message de demande, abonnez-vous aux rubriques de réponse pour recevoir la réponse. Les messages utilisés par cette API utilisent le protocole de publication et d'abonnement de MQTT pour fournir une interaction de demande et réponse.
Si vous ne vous abonnez pas aux sujets de réponse *avant* de publier une demande, il est possible que vous ne receviez pas les résultats de cette demande.
IoT Core Fleet Provisioning renvoie les résultats de l'API MQTT de provisionnement de l'appareil via la même connexion MQTT que celle utilisée pour publier la demande d'API.
## CreateCertificateFromCsr
Crée un certificat à partir d'une demande de signature de certificat (CSR). AWS IoT fournit des certificats clients signés par l'autorité de certification Amazon Root (CA). Le nouveau certificat a un statut `PENDING_ACTIVATION`. Lorsque vous appelez `RegisterThing` pour provisionner un objet avec ce certificat, l'état du certificat devient `ACTIVE` ou `INACTIVE` comme décrit dans le modèle.
Pour plus d’informations sur la création d’un certificat client à l’aide de votre certificat d’autorité de certification et d’une demande de signature de certificat, reportez-vous à [Création d’un certificat client à l'aide de votre certificat d’autorité de certification](create-device-cert.md).
**Note**
Pour des raisons de sécurité, le `certificateOwnershipToken` renvoyé par `CreateCertificateFromCsr` expire au bout d’une heure. `RegisterThing` doit être appelé avant l’expiration de `certificateOwnershipToken`. Si le certificat créé par `CreateCertificateFromCsr` n'a pas été activé et attaché à une politique ou à un objet au moment où le jeton expire, le certificat est supprimé. Si le jeton expire, l’appareil peut appeler `CreateCertificateFromCsr` pour générer un nouveau certificat.
### CreateCertificateFromCsr demande
Publiez un message avec la rubrique `$aws/certificates/create-from-csr/payload-format`.
`payload-format`
Format de charge utile du message en tant que `cbor` ou `json`.
#### CreateCertificateFromCsr charge utile de la demande
```
{
"certificateSigningRequest": "string"
}
```
`certificateSigningRequest`
La CSR, au format PEM.
### CreateCertificateFromCsr réponse
S'abonner à `$aws/certificates/create-from-csr/payload-format/accepted`
`payload-format`
Format de charge utile du message en tant que `cbor` ou `json`.
#### CreateCertificateFromCsr charge utile de réponse
```
{
"certificateOwnershipToken": "string",
"certificateId": "string",
"certificatePem": "string"
}
```
`certificateOwnershipToken`
Le jeton pour prouver la propriété du certificat lors de la mise en service.
`certificateId`
ID du certificat. Les opérations de gestion de certificats prennent uniquement en compte un ID de certificat.
`certificatePem`
Données du certificat, au format PEM.
### CreateCertificateFromCsr erreur
Pour recevoir des réponses d'erreur, abonnez-vous à `$aws/certificates/create-from-csr/payload-format/rejected`.
`payload-format`
Format de charge utile du message en tant que `cbor` ou `json`.
#### CreateCertificateFromCsr charge utile d'erreur
```
{
"statusCode": int,
"errorCode": "string",
"errorMessage": "string"
}
```
`statusCode`
Le code de statut.
`errorCode`
Code de l’erreur.
`errorMessage`
Message d’erreur.
## CreateKeysAndCertificate
Crée de nouvelles clés et un certificat. AWS IoT fournit des certificats clients signés par l'autorité de certification Amazon Root (CA). Le nouveau certificat a un statut `PENDING_ACTIVATION`. Lorsque vous appelez `RegisterThing` pour provisionner un objet avec ce certificat, l'état du certificat devient `ACTIVE` ou `INACTIVE` comme décrit dans le modèle.
**Note**
Pour des raisons de sécurité, le `certificateOwnershipToken` renvoyé par `CreateKeysAndCertificate` expire au bout d’une heure. `RegisterThing` doit être appelé avant l’expiration de `certificateOwnershipToken`. Si le certificat créé par `CreateKeysAndCertificate` n'a pas été activé et attaché à une politique ou à un objet au moment où le jeton expire, le certificat est supprimé. Si le jeton expire, l’appareil peut appeler `CreateKeysAndCertificate` pour générer un nouveau certificat.
### CreateKeysAndCertificate demande
Publiez un message sur `$aws/certificates/create/payload-format` avec une charge utile de message vide.
`payload-format`
Format de charge utile du message en tant que `cbor` ou `json`.
### CreateKeysAndCertificate réponse
S'abonner à `$aws/certificates/create/payload-format/accepted`
`payload-format`
Format de charge utile du message en tant que `cbor` ou `json`.
#### CreateKeysAndCertificate réponse
```
{
"certificateId": "string",
"certificatePem": "string",
"privateKey": "string",
"certificateOwnershipToken": "string"
}
```
`certificateId`
ID du certificat.
`certificatePem`
Données du certificat, au format PEM.
`privateKey`
Clé privée.
`certificateOwnershipToken`
Le jeton pour prouver la propriété du certificat lors de la mise en service.
### CreateKeysAndCertificate erreur
Pour recevoir des réponses d'erreur, abonnez-vous à `$aws/certificates/create/payload-format/rejected`.
`payload-format`
Format de charge utile du message en tant que `cbor` ou `json`.
#### CreateKeysAndCertificate charge utile d'erreur
```
{
"statusCode": int,
"errorCode": "string",
"errorMessage": "string"
}
```
`statusCode`
Le code de statut.
`errorCode`
Code de l’erreur.
`errorMessage`
Message d’erreur.
## RegisterThing
Alloue un objet à l'aide d'un modèle prédéfini.
### RegisterThing demande
Publier un message sur `$aws/provisioning-templates/templateName/provision/payload-format`
`payload-format`
Format de charge utile du message en tant que `cbor` ou `json`.
`templateName`
Nom du modèle de mise en service.
#### RegisterThing charge utile de la demande
```
{
"certificateOwnershipToken": "string",
"parameters": {
"string": "string",
...
}
}
```
`certificateOwnershipToken`
Le jeton qui prouve la propriété du certificat. AWS IoT génère le jeton lorsque vous créez un certificat via MQTT.
`parameters`
Facultatif. Paires clé-valeur du périphérique utilisées par les [hooks de pré-provisionnement](pre-provisioning-hook.md) pour évaluer la demande d'enregistrement.
### RegisterThing réponse
S'abonner à `$aws/provisioning-templates/templateName/provision/payload-format/accepted`
`payload-format`
Format de charge utile du message en tant que `cbor` ou `json`.
`templateName`
Nom du modèle de mise en service.
#### RegisterThing charge utile de réponse
```
{
"deviceConfiguration": {
"string": "string",
...
},
"thingName": "string"
}
```
`deviceConfiguration`
Configuration de l'appareil définie dans le modèle.
`thingName`
Nom de l'objet IoT créé lors de la mise en service.
### RegisterThing réponse d'erreur
Pour recevoir des réponses d'erreur, abonnez-vous à `$aws/provisioning-templates/templateName/provision/payload-format/rejected`.
`payload-format`
Format de charge utile du message en tant que `cbor` ou `json`.
`templateName`
Nom du modèle de mise en service.
#### RegisterThing charge utile de réponse aux erreurs
```
{
"statusCode": int,
"errorCode": "string",
"errorMessage": "string"
}
```
`statusCode`
Le code de statut.
`errorCode`
Code de l’erreur.
`errorMessage`
Message d’erreur.