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.
# Installation AWS IoT Greengrass du logiciel de base avec provisionnement du AWS IoT parc
Cette fonctionnalité est disponible pour les versions 2.4.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.
Avec le provisionnement du AWS IoT parc, vous pouvez configurer AWS IoT pour générer et fournir en toute sécurité des certificats d'appareils X.509 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). Vous pouvez également configurer AWS IoT pour spécifier des groupes d'objets, des types d'objets et des autorisations pour les appareils principaux de Greengrass que vous approvisionnez dans le cadre du provisionnement de flotte. Vous définissez un *modèle de provisionnement* pour définir le mode AWS IoT d'approvisionnement de chaque appareil. Le modèle de provisionnement spécifie les ressources d'objet, de politique et de certificat à créer pour un appareil lors du provisionnement. Pour plus d'informations, consultez la section [Modèles de provisionnement](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html) dans le *Guide du AWS IoT Core développeur*.
AWS IoT Greengrass fournit un plugin de provisionnement de AWS IoT flotte que vous pouvez utiliser pour installer le logiciel AWS IoT Greengrass Core à l'aide AWS des ressources créées par le provisionnement de AWS IoT flotte. Le plugin de provisionnement de flotte utilise le *provisionnement par réclamation*. Les appareils utilisent un certificat de demande d'approvisionnement et une clé privée pour obtenir un certificat de périphérique X.509 et une clé privée uniques qu'ils peuvent utiliser pour leurs opérations régulières. Vous pouvez intégrer le certificat de réclamation et la clé privée dans chaque appareil pendant la fabrication, afin que vos clients puissent activer les appareils ultérieurement lorsque chaque appareil sera en ligne. Vous pouvez utiliser le même certificat de réclamation et la même clé privée pour plusieurs appareils. Pour plus d'informations, consultez la section [Provisionnement par réclamation](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based) dans le *Guide du AWS IoT Core développeur*.
**Note**
Le plug-in de provisionnement de flotte ne prend actuellement pas en charge le stockage de clés privées et de fichiers de certificats dans un module de sécurité matérielle (HSM). Pour utiliser un HSM, [installez le logiciel AWS IoT Greengrass Core avec un provisionnement manuel](manual-installation.md).
Pour installer le logiciel AWS IoT Greengrass Core avec provisionnement de AWS IoT flotte, vous devez configurer les ressources utilisées pour approvisionner Compte AWS les AWS IoT appareils principaux de Greengrass. Ces ressources incluent un modèle de provisionnement, des certificats de réclamation et un rôle [IAM d'échange de jetons](device-service-role.md). Après avoir créé ces ressources, vous pouvez les réutiliser pour approvisionner plusieurs appareils principaux dans un parc. Pour de plus amples informations, veuillez consulter [Configurer le provisionnement du AWS IoT parc pour les appareils principaux de Greengrass](fleet-provisioning-setup.md).
**Important**
Avant de télécharger le logiciel AWS IoT Greengrass Core, vérifiez que votre appareil principal répond à la [configuration requise](greengrass-nucleus-component.md#greengrass-v2-requirements) pour installer et exécuter le logiciel AWS IoT Greengrass Core v2.0.
**Topics**
+ [Conditions préalables](#fleet-provisioning-prerequisites)
+ [Récupérer des points de AWS IoT terminaison](#retrieve-iot-endpoints)
+ [Télécharger les certificats sur l'appareil](#download-claim-certificates)
+ [Configuration de l'environnement de l'appareil](#set-up-device-environment)
+ [Téléchargez le logiciel AWS IoT Greengrass de base](#download-greengrass-core-v2)
+ [Téléchargez le plugin de provisionnement de AWS IoT flotte](#download-fleet-provisioning-plugin)
+ [Installation du logiciel AWS IoT Greengrass de base](#run-greengrass-core-v2-installer-fleet)
+ [Configurer le provisionnement du AWS IoT parc pour les appareils principaux de Greengrass](fleet-provisioning-setup.md)
+ [Configuration du plugin de provisionnement de AWS IoT flotte](fleet-provisioning-configuration.md)
+ [AWS IoT journal des modifications du plugin de provisionnement de flotte](fleet-provisioning-changelog.md)
## Conditions préalables
Pour installer le logiciel AWS IoT Greengrass Core avec le provisionnement du AWS IoT parc, vous devez d'abord [configurer le provisionnement du AWS IoT parc pour les appareils principaux de Greengrass](fleet-provisioning-setup.md). Après avoir effectué ces étapes une fois, vous pouvez utiliser le provisionnement du parc pour installer le logiciel AWS IoT Greengrass Core sur autant d'appareils que vous le souhaitez.
## Récupérer des points de AWS IoT terminaison
Obtenez les AWS IoT points de terminaison qui vous Compte AWS conviennent et enregistrez-les pour les utiliser ultérieurement. Votre appareil utilise ces points de terminaison pour se connecter à AWS IoT. Procédez comme suit :
1. Obtenez le point de terminaison de AWS IoT données pour votre Compte AWS.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. Obtenez le point de terminaison des informations d' AWS IoT identification pour votre Compte AWS.
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## Télécharger les certificats sur l'appareil
L'appareil utilise un certificat de réclamation et une clé privée pour authentifier sa demande de fourniture de AWS ressources et acquérir un certificat de périphérique X.509. Vous pouvez intégrer le certificat de réclamation et la clé privée dans l'appareil pendant la fabrication, ou copier le certificat et la clé sur l'appareil lors de l'installation. Dans cette section, vous devez copier le certificat de réclamation et la clé privée sur l'appareil. Vous téléchargez également le certificat Amazon Root Certificate Authority (CA) sur l'appareil.
**Important**
L'approvisionnement des clés privées des réclamations doit être sécurisé à tout moment, y compris sur les appareils principaux de Greengrass. Nous vous recommandons d'utiliser CloudWatch les statistiques et les journaux Amazon pour détecter les signes d'utilisation abusive, tels que l'utilisation non autorisée du certificat de réclamation pour approvisionner des appareils. Si vous détectez une utilisation abusive, désactivez le certificat de demande d'approvisionnement afin qu'il ne puisse pas être utilisé pour le provisionnement des appareils. Pour plus d'informations, consultez la section [Surveillance AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) dans le *guide du AWS IoT Core développeur*.
Pour vous aider à mieux gérer le nombre d'appareils et les appareils qui s'enregistrent dans le vôtre Compte AWS, vous pouvez spécifier un crochet de préapprovisionnement lorsque vous créez un modèle de provisionnement de flotte. Un hook de pré-provisionnement est une AWS Lambda fonction qui valide les paramètres du modèle fournis par les appareils lors de l'enregistrement. Par exemple, vous pouvez créer un hook de pré-provisionnement qui compare l'identifiant d'un appareil à une base de données afin de vérifier que l'appareil est autorisé à effectuer le provisionnement. Pour plus d'informations, consultez la section [Pre-provisioning hooks](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) dans le Guide du *AWS IoT Core développeur*.
**Pour télécharger les certificats de réclamation sur l'appareil**
1. Copiez le certificat de réclamation et la clé privée sur l'appareil. Si SSH et SCP sont activés sur l'ordinateur de développement et le périphérique, vous pouvez utiliser la `scp` commande sur votre ordinateur de développement pour transférer le certificat de réclamation et la clé privée. L'exemple de commande suivant transfère ces fichiers vers le périphérique dans un dossier nommé `claim-certs` sur votre ordinateur de développement. Remplacez *device-ip-address* par l'adresse IP de votre appareil.
```
scp -r claim-certs/ device-ip-address:~
```
1. Créez le dossier racine Greengrass sur l'appareil. Vous installerez ultérieurement le logiciel AWS IoT Greengrass Core dans ce dossier.
**Note**
Pour Windows, la limitation de la longueur du chemin est de 260 caractères. Si vous utilisez Windows, utilisez un dossier racine tel que `C:\greengrass\v2` ou `D:\greengrass\v2` pour conserver les chemins des composants Greengrass en dessous de la limite de 260 caractères.
------
#### [ Linux or Unix ]
+ `/greengrass/v2`Remplacez-le par le dossier à utiliser.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ *C:\$1greengrass\$1v2*Remplacez-le par le dossier à utiliser.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ *C:\$1greengrass\$1v2*Remplacez-le par le dossier à utiliser.
```
mkdir C:\greengrass\v2
```
------
1. (Linux uniquement) Définissez les autorisations du parent du dossier racine de Greengrass.
+ Remplacez */greengrass* par le parent du dossier racine.
```
sudo chmod 755 /greengrass
```
1. Déplacez les certificats de réclamation vers le dossier racine de Greengrass.
+ Remplacez `/greengrass/v2` ou *C:\$1greengrass\$1v2* par le dossier racine de Greengrass.
------
#### [ Linux or Unix ]
```
sudo mv ~/claim-certs /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
move %USERPROFILE%\claim-certs C:\greengrass\v2
```
------
#### [ PowerShell ]
```
mv -Path ~\claim-certs -Destination C:\greengrass\v2
```
------
1. Téléchargez le certificat de l'autorité de certification racine (CA) Amazon. AWS IoT les certificats sont associés par défaut au certificat de l'autorité de certification racine d'Amazon.
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## Configuration de l'environnement de l'appareil
Suivez les étapes décrites dans cette section pour configurer un appareil Linux ou Windows à utiliser comme périphérique AWS IoT Greengrass principal.
### Configuration d'un appareil Linux
**Pour configurer un appareil Linux pour AWS IoT Greengrass V2**
1. Installez le moteur d'exécution Java, dont le logiciel AWS IoT Greengrass Core a besoin pour fonctionner. Nous vous recommandons d'utiliser les versions de support à long terme d'[Amazon Corretto](https://aws.amazon.com/corretto/) [ou](https://openjdk.java.net/) d'OpenJDK. La version 8 ou supérieure est requise. Les commandes suivantes vous montrent comment installer OpenJDK sur votre appareil.
+ Pour les distributions basées sur Debian ou Ubuntu :
```
sudo apt install default-jdk
```
+ Pour les distributions basées sur Red Hat :
```
sudo yum install java-11-openjdk-devel
```
+ Dans Amazon Linux 2 :
```
sudo amazon-linux-extras install java-openjdk11
```
+ Pour Amazon Linux 2023 :
```
sudo dnf install java-11-amazon-corretto -y
```
Lorsque l'installation est terminée, exécutez la commande suivante pour vérifier que Java s'exécute sur votre appareil Linux.
```
java -version
```
La commande affiche la version de Java exécutée sur le périphérique. Par exemple, sur une distribution basée sur Debian, le résultat peut ressembler à celui de l'exemple suivant.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (Facultatif) Créez l'utilisateur système et le groupe par défaut qui exécutent les composants sur le périphérique. Vous pouvez également choisir de laisser le programme d'installation du logiciel AWS IoT Greengrass Core créer cet utilisateur et ce groupe lors de l'installation avec l'argument `--component-default-user` installer. Pour de plus amples informations, veuillez consulter [Arguments d'installation](configure-installer.md).
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. Vérifiez que l'utilisateur qui exécute le logiciel AWS IoT Greengrass Core (généralement`root`) est autorisé à exécuter `sudo` avec n'importe quel utilisateur et n'importe quel groupe.
1. Exécutez la commande suivante pour ouvrir le `/etc/sudoers` fichier.
```
sudo visudo
```
1. Vérifiez que l'autorisation accordée à l'utilisateur ressemble à l'exemple suivant.
```
root ALL=(ALL:ALL) ALL
```
1. **(Facultatif) Pour [exécuter des fonctions Lambda conteneurisées](run-lambda-functions.md), vous devez activer [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1, et vous devez activer et monter les cgroups de mémoire et de périphériques.** Si vous ne prévoyez pas d'exécuter des fonctions Lambda conteneurisées, vous pouvez ignorer cette étape.
Pour activer ces options cgroups, démarrez le périphérique avec les paramètres du noyau Linux suivants.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Pour plus d'informations sur l'affichage et la définition des paramètres du noyau de votre appareil, consultez la documentation de votre système d'exploitation et de votre chargeur de démarrage. Suivez les instructions pour définir définitivement les paramètres du noyau.
1. Installez toutes les autres dépendances requises sur votre appareil, comme indiqué dans la liste des exigences figurant dans[Exigences relatives aux dispositifs](greengrass-nucleus-component.md#greengrass-v2-requirements).
### Configuration d'un appareil Windows
**Note**
Cette fonctionnalité est disponible pour les versions 2.5.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.
**Pour configurer un appareil Windows pour AWS IoT Greengrass V2**
1. Installez le moteur d'exécution Java, dont le logiciel AWS IoT Greengrass Core a besoin pour fonctionner. Nous vous recommandons d'utiliser les versions de support à long terme d'[Amazon Corretto](https://aws.amazon.com/corretto/) [ou](https://openjdk.java.net/) d'OpenJDK. La version 8 ou supérieure est requise.
1. Vérifiez si Java est disponible sur la variable système [PATH](https://en.wikipedia.org/wiki/PATH_(variable)), et ajoutez-le dans le cas contraire. Le LocalSystem compte exécute le logiciel AWS IoT Greengrass Core. Vous devez donc ajouter Java à la variable système PATH au lieu de la variable utilisateur PATH pour votre utilisateur. Procédez comme suit :
1. Appuyez sur la touche Windows pour ouvrir le menu de démarrage.
1. Tapez **environment variables** pour rechercher les options du système dans le menu Démarrer.
1. Dans les résultats de recherche du menu Démarrer, choisissez **Modifier les variables d'environnement du système** pour ouvrir la fenêtre **des propriétés du système**.
1. Choisissez les **variables d'environnement...** pour ouvrir la fenêtre **des variables d'environnement**.
1. Sous **Variables système**, sélectionnez **Chemin**, puis **Modifier**. Dans la fenêtre **Modifier la variable d'environnement**, vous pouvez afficher chaque chemin sur une ligne distincte.
1. Vérifiez si le chemin d'accès au `bin` dossier d'installation de Java est présent. Le chemin peut ressembler à celui de l'exemple suivant.
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. Si le `bin` dossier de l'installation Java est absent de **Path**, choisissez **Nouveau** pour l'ajouter, puis **OK**.
1. Ouvrez l'invite de commande Windows (`cmd.exe`) en tant qu'administrateur.
1. Créez l'utilisateur par défaut dans le LocalSystem compte sur l'appareil Windows. *password*Remplacez-le par un mot de passe sécurisé.
```
net user /add ggc_user password
```
**Astuce**
En fonction de votre configuration Windows, le mot de passe de l'utilisateur peut être configuré pour expirer à une date ultérieure. Pour vous assurer que vos applications Greengrass continuent de fonctionner, suivez la date d'expiration du mot de passe et mettez-le à jour avant son expiration. Vous pouvez également définir le mot de passe de l'utilisateur pour qu'il n'expire jamais.
Pour vérifier la date d'expiration d'un utilisateur et de son mot de passe, exécutez la commande suivante.
```
net user ggc_user | findstr /C:expires
```
Pour définir le mot de passe d'un utilisateur afin qu'il n'expire jamais, exécutez la commande suivante.
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
Si vous utilisez Windows 10 ou une version ultérieure où la [`wmic`commande est obsolète](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), exécutez la commande suivante PowerShell .
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. Téléchargez et installez l'[PsExecutilitaire](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) de Microsoft sur l'appareil.
1. Utilisez l' PsExec utilitaire pour stocker le nom d'utilisateur et le mot de passe de l'utilisateur par défaut dans l'instance Credential Manager du LocalSystem compte. *password*Remplacez-le par le mot de passe utilisateur que vous avez défini précédemment.
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
S'il **PsExec License Agreement**s'ouvre, choisissez **Accept**d'accepter la licence et exécutez la commande.
**Note**
Sur les appareils Windows, le LocalSystem compte exécute le noyau Greengrass, et vous devez utiliser l' PsExec utilitaire pour stocker les informations utilisateur par défaut dans le LocalSystem compte. L'application Credential Manager stocke ces informations dans le compte Windows de l'utilisateur actuellement connecté, plutôt que dans le LocalSystem compte.
## Téléchargez le logiciel AWS IoT Greengrass de base
Vous pouvez télécharger la dernière version du logiciel AWS IoT Greengrass Core à l'adresse suivante :
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**Note**
Vous pouvez télécharger une version spécifique du logiciel AWS IoT Greengrass Core à l'emplacement suivant. Remplacez *version* par la version à télécharger.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Pour télécharger le logiciel AWS IoT Greengrass Core**
1. Sur votre appareil principal, téléchargez le logiciel AWS IoT Greengrass Core dans un fichier nommé`greengrass-nucleus-latest.zip`.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
Si vous téléchargez ce logiciel, vous acceptez le [contrat de licence du logiciel Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
1. (Facultatif) Pour vérifier la signature du logiciel Greengrass Nucleus
**Note**
Cette fonctionnalité est disponible avec Greengrass nucleus version 2.9.5 et versions ultérieures.
1. Utilisez la commande suivante pour vérifier la signature de votre artefact Greengrass nucleus :
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
Le nom du fichier peut être différent selon la version du JDK que vous installez. *`jdk17.0.6_10`*Remplacez-le par la version du JDK que vous avez installée.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
Le nom du fichier peut être différent selon la version du JDK que vous installez. *`jdk17.0.6_10`*Remplacez-le par la version du JDK que vous avez installée.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. L'`jarsigner`invocation produit une sortie qui indique les résultats de la vérification.
1. Si le fichier zip Greengrass nucleus est signé, le résultat contient l'instruction suivante :
```
jar verified.
```
1. Si le fichier zip Greengrass nucleus n'est pas signé, le résultat contient l'instruction suivante :
```
jar is unsigned.
```
1. Si vous avez fourni l'`-certs`option Jarsigner en même temps que les `-verbose` options `-verify` et, le résultat inclut également des informations détaillées sur le certificat du signataire.
1. Décompressez le logiciel AWS IoT Greengrass Core dans un dossier de votre appareil. *GreengrassInstaller*Remplacez-le par le dossier que vous souhaitez utiliser.
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. (Facultatif) Exécutez la commande suivante pour voir la version du logiciel AWS IoT Greengrass Core.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**Important**
Si vous installez une version du noyau Greengrass antérieure à la version 2.4.0, ne supprimez pas ce dossier après avoir installé le logiciel Core. AWS IoT Greengrass Le logiciel AWS IoT Greengrass Core utilise les fichiers de ce dossier pour s'exécuter.
Si vous avez téléchargé la dernière version du logiciel, vous devez installer la version 2.4.0 ou ultérieure, et vous pouvez supprimer ce dossier après avoir installé le logiciel AWS IoT Greengrass Core.
## Téléchargez le plugin de provisionnement de AWS IoT flotte
Vous pouvez télécharger la dernière version du plugin de provisionnement de AWS IoT flotte à l'adresse suivante :
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim](https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar)-latest.jar
**Note**
Vous pouvez télécharger une version spécifique du plugin de provisionnement de AWS IoT flotte à l'emplacement suivant. Remplacez *version* par la version à télécharger. Pour plus d'informations sur chaque version du plugin de provisionnement de flotte, consultez[AWS IoT journal des modifications du plugin de provisionnement de flotte](fleet-provisioning-changelog.md).
```
https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-version.jar
```
Le plugin de provisionnement de flotte est open source. Pour consulter son code source, consultez le [plugin de provisionnement de AWS IoT flotte](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim) sur GitHub.
**Pour télécharger le plugin de provisionnement de AWS IoT flotte**
+ Sur votre appareil, téléchargez le plug-in de provisionnement de AWS IoT flotte dans un fichier nommé`aws.greengrass.FleetProvisioningByClaim.jar`. *GreengrassInstaller*Remplacez-le par le dossier que vous souhaitez utiliser.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar -OutFile GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
Si vous téléchargez ce logiciel, vous acceptez le [contrat de licence du logiciel Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Installation du logiciel AWS IoT Greengrass de base
Exécutez le programme d'installation avec des arguments qui spécifient les actions suivantes :
+ Effectuez l'installation à partir d'un fichier de configuration partiel qui indique d'utiliser le plug-in de provisionnement de flotte pour provisionner les AWS ressources. Le logiciel AWS IoT Greengrass Core utilise un fichier de configuration qui spécifie la configuration de chaque composant Greengrass de l'appareil. Le programme d'installation crée un fichier de configuration complet à partir du fichier de configuration partiel que vous fournissez et AWS des ressources créées par le plug-in de provisionnement de flotte.
+ Spécifiez d'utiliser l'utilisateur `ggc_user` du système pour exécuter les composants logiciels sur le périphérique principal. Sur les appareils Linux, cette commande indique également d'utiliser le groupe `ggc_group` système, et le programme d'installation crée l'utilisateur et le groupe système pour vous.
+ Configurez le logiciel AWS IoT Greengrass Core en tant que service système qui s'exécute au démarrage. Sur les appareils Linux, cela nécessite le [système d'initialisation Systemd](https://en.wikipedia.org/wiki/Systemd).
**Important**
Sur les appareils Windows Core, vous devez configurer le logiciel AWS IoT Greengrass Core en tant que service système.
Pour plus d'informations sur les arguments que vous pouvez spécifier, consultez[Arguments d'installation](configure-installer.md).
**Note**
Si vous utilisez AWS IoT Greengrass un appareil dont la mémoire est limitée, vous pouvez contrôler la quantité de mémoire utilisée par le logiciel AWS IoT Greengrass Core. Pour contrôler l'allocation de mémoire, vous pouvez définir les options de taille de segment de mémoire JVM dans le paramètre de `jvmOptions` configuration de votre composant Nucleus. Pour de plus amples informations, veuillez consulter [Contrôlez l'allocation de mémoire grâce aux options JVM](configure-greengrass-core-v2.md#jvm-tuning).
**Pour installer le logiciel AWS IoT Greengrass Core**
1. Vérifiez la version du logiciel AWS IoT Greengrass Core.
+ Remplacez *GreengrassInstaller* par le chemin d'accès au dossier contenant le logiciel.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Utilisez un éditeur de texte pour créer un fichier de configuration nommé `config.yaml` à fournir au programme d'installation.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.
```
nano GreengrassInstaller/config.yaml
```
Copiez le contenu YAML suivant dans le fichier. Ce fichier de configuration partiel spécifie les paramètres du plugin de provisionnement de flotte. Pour plus d'informations sur les options que vous pouvez spécifier, consultez[Configuration du plugin de provisionnement de AWS IoT flotte](fleet-provisioning-configuration.md).
------
#### [ Linux or Unix ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
#### [ Windows ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
Ensuite, procédez comme suit :
+ Remplacez *2.16.1* par la version du logiciel AWS IoT Greengrass Core.
+ Remplacez chaque instance de `/greengrass/v2` ou *C:\$1greengrass\$1v2* par le dossier racine de Greengrass.
**Note**
Sur les appareils Windows, vous devez spécifier les séparateurs de chemin sous forme de barres obliques inverses (`\\`) doubles, tels que. `C:\\greengrass\\v2`
+ *us-west-2*Remplacez-le par la AWS région dans laquelle vous avez créé le modèle de provisionnement et les autres ressources.
+ Remplacez le `iotDataEndpoint` par votre point de terminaison de AWS IoT données.
+ Remplacez le point de terminaison `iotCredentialEndpoint` par vos AWS IoT informations d'identification.
+ Remplacez *GreengrassCoreTokenExchangeRoleAlias* par le nom de l'alias du rôle d'échange de jetons.
+ Remplacez *GreengrassFleetProvisioningTemplate* par le nom du modèle de provisionnement de flotte.
+ Remplacez le `claimCertificatePath` par le chemin d'accès au certificat de réclamation sur l'appareil.
+ Remplacez le `claimCertificatePrivateKeyPath` par le chemin d'accès à la clé privée du certificat de réclamation sur l'appareil.
+ Remplacez les paramètres du modèle (`templateParameters`) par les valeurs à utiliser pour approvisionner le périphérique. Cet exemple fait référence à l'[exemple de modèle](fleet-provisioning-setup.md#example-fleet-provisioning-template) qui définit `ThingName` et définit `ThingGroupName` les paramètres.
**Note**
Dans ce fichier de configuration, vous pouvez personnaliser d'autres options de configuration telles que les ports et le proxy réseau à utiliser, comme indiqué dans l'exemple suivant. Pour plus d'informations, consultez la section Configuration du [noyau de Greengrass](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration).
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
Pour utiliser un proxy HTTPS, vous devez utiliser la version 1.1.0 ou ultérieure du plugin de provisionnement de flotte. Vous devez également spécifier le `rootCaPath` sous`system`, comme indiqué dans l'exemple suivant.
```
---
system:
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
services:
...
```
```
---
system:
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
services:
...
```
1. Exécutez le programme d'installation. Spécifiez `--trusted-plugin` pour fournir le plug-in de provisionnement de flotte et spécifiez `--init-config` pour fournir le fichier de configuration.
+ `/greengrass/v2`Remplacez-le par le dossier racine de Greengrass.
+ Remplacez chaque instance de *GreengrassInstaller* par le dossier dans lequel vous avez décompressé le programme d'installation.
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**Important**
Sur les appareils Windows Core, vous `--setup-system-service true` devez spécifier de configurer le logiciel AWS IoT Greengrass Core en tant que service système.
Si vous le spécifiez`--setup-system-service true`, le programme d'installation affiche `Successfully set up Nucleus as a system service` s'il a configuré et exécuté le logiciel en tant que service système. Dans le cas contraire, le programme d'installation n'affiche aucun message s'il installe le logiciel avec succès.
**Note**
Vous ne pouvez pas utiliser l'`deploy-dev-tools`argument pour déployer des outils de développement locaux lorsque vous exécutez le programme d'installation sans l'`--provision true`argument. Pour plus d'informations sur le déploiement de la CLI Greengrass directement sur votre appareil, consultez. [Interface de ligne de commande Greengrass](gg-cli.md)
1. Vérifiez l'installation en consultant les fichiers du dossier racine.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Si l'installation a réussi, le dossier racine contient plusieurs dossiers, tels que `config``packages`, et`logs`.
Si vous avez installé le logiciel AWS IoT Greengrass Core en tant que service système, le programme d'installation exécute le logiciel pour vous. Dans le cas contraire, vous devez exécuter le logiciel manuellement. Pour de plus amples informations, veuillez consulter [Exécutez le logiciel AWS IoT Greengrass Core](run-greengrass-core-v2.md).
Pour plus d'informations sur la configuration et l'utilisation du logiciel AWS IoT Greengrass, consultez les rubriques suivantes :
+ [Configuration du logiciel AWS IoT Greengrass de base](configure-greengrass-core-v2.md)
+ [Développer des AWS IoT Greengrass composants](develop-greengrass-components.md)
+ [Déployer AWS IoT Greengrass des composants sur des appareils](manage-deployments.md)
+ [Interface de ligne de commande Greengrass](gg-cli.md)
# Configurer le provisionnement du AWS IoT parc pour les appareils principaux de Greengrass
Pour [installer le logiciel AWS IoT Greengrass Core avec le provisionnement de flotte](fleet-provisioning.md), vous devez d'abord configurer les ressources suivantes dans votre Compte AWS. Ces ressources permettent aux appareils de s'enregistrer AWS IoT et de fonctionner en tant qu'appareils principaux de Greengrass. Suivez les étapes décrites dans cette section une seule fois pour créer et configurer ces ressources dans votre Compte AWS.
+ Rôle IAM d'échange de jetons, utilisé par les principaux appareils pour autoriser les appels aux AWS services.
+ Alias de AWS IoT rôle pointant vers le rôle d'échange de jetons.
+ (Facultatif) Une AWS IoT politique utilisée par les appareils principaux pour autoriser les appels vers les AWS IoT Greengrass services AWS IoT et. Cette AWS IoT politique doit `iot:AssumeRoleWithCertificate` autoriser l'alias de AWS IoT rôle pointant vers le rôle d'échange de jetons.
Vous pouvez utiliser une AWS IoT politique unique pour tous les appareils principaux de votre parc, ou vous pouvez configurer le modèle de provisionnement de votre flotte afin de créer une AWS IoT politique pour chaque appareil principal.
+ Un modèle AWS IoT de provisionnement de flotte. Ce modèle doit spécifier les éléments suivants :
+ N'importe AWS IoT quel objet, ressource. Vous pouvez spécifier une liste de groupes d'objets existants pour déployer des composants sur chaque appareil lors de sa mise en ligne.
+ Une ressource AWS IoT en matière de politiques. Cette ressource peut définir l'une des propriétés suivantes :
+ Le nom d'une AWS IoT politique existante. Si vous choisissez cette option, les principaux appareils que vous créez à partir de ce modèle utilisent la même AWS IoT politique et vous pouvez gérer leurs autorisations en tant que flotte.
+ Un document AWS IoT de politique. Si vous choisissez cette option, chaque périphérique principal que vous créez à partir de ce modèle utilise une AWS IoT politique unique, et vous pouvez gérer les autorisations pour chaque périphérique principal individuel.
+ Une ressource AWS IoT de certificat. Cette ressource de certificat doit utiliser le `AWS::IoT::Certificate::Id` paramètre pour associer le certificat au périphérique principal. Pour plus d'informations, consultez la section [Just-in-time Provisioning](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html) dans le *Guide du AWS IoT développeur*.
+ Un certificat de demande d' AWS IoT approvisionnement et une clé privée pour le modèle de provisionnement de la flotte. Vous pouvez intégrer ce certificat et cette clé privée dans les appareils pendant la fabrication, afin que les appareils puissent s'enregistrer et s'approvisionner eux-mêmes lorsqu'ils sont mis en ligne.
**Important**
L'approvisionnement des clés privées des réclamations doit être sécurisé à tout moment, y compris sur les appareils principaux de Greengrass. Nous vous recommandons d'utiliser CloudWatch les statistiques et les journaux Amazon pour détecter les signes d'utilisation abusive, tels que l'utilisation non autorisée du certificat de réclamation pour approvisionner des appareils. Si vous détectez une utilisation abusive, désactivez le certificat de demande d'approvisionnement afin qu'il ne puisse pas être utilisé pour le provisionnement des appareils. Pour plus d'informations, consultez la section [Surveillance AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) dans le *guide du AWS IoT Core développeur*.
Pour vous aider à mieux gérer le nombre d'appareils et les appareils qui s'enregistrent dans le vôtre Compte AWS, vous pouvez spécifier un crochet de préapprovisionnement lorsque vous créez un modèle de provisionnement de flotte. Un hook de pré-provisionnement est une AWS Lambda fonction qui valide les paramètres du modèle fournis par les appareils lors de l'enregistrement. Par exemple, vous pouvez créer un hook de pré-provisionnement qui compare l'identifiant d'un appareil à une base de données afin de vérifier que l'appareil est autorisé à le provisionner. Pour plus d'informations, consultez la section [Pre-provisioning hooks](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) dans le Guide du *AWS IoT Core développeur*.
+ AWS IoT Politique que vous associez au certificat de demande d'approvisionnement pour autoriser les appareils à s'enregistrer et à utiliser le modèle de provisionnement de flotte.
**Topics**
+ [Création d'un rôle d'échange de jetons](#create-token-exchange-role)
+ [Création d'une AWS IoT politique](#create-iot-policy)
+ [Création d'un modèle de provisionnement de flotte](#create-provisioning-template)
+ [Création d'un certificat de demande d'approvisionnement et d'une clé privée](#create-claim-certificates)
## Création d'un rôle d'échange de jetons
Les appareils principaux de Greengrass utilisent un rôle de service IAM, appelé rôle d'*échange de jetons*, pour autoriser les appels aux services. AWS L'appareil utilise le fournisseur AWS IoT d'informations d'identification pour obtenir des AWS informations d'identification temporaires pour ce rôle, ce qui lui permet d'interagir avec Amazon Logs AWS IoT, d'envoyer des journaux à Amazon CloudWatch Logs et de télécharger des artefacts de composants personnalisés depuis Amazon S3. Pour de plus amples informations, veuillez consulter [Autoriser les appareils principaux à interagir avec les AWS services](device-service-role.md).
Vous utilisez un *alias de AWS IoT rôle* pour configurer le rôle d'échange de jetons pour les appareils principaux de Greengrass. Les alias de rôle vous permettent de modifier le rôle d'échange de jetons d'un appareil tout en conservant la même configuration. Pour plus d'informations, consultez la section [Autorisation des appels directs vers AWS des services](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html) dans le *Guide du AWS IoT Core développeur*.
Dans cette section, vous allez créer un rôle IAM d'échange de jetons et un alias de AWS IoT rôle pointant vers le rôle. Si vous avez déjà configuré un appareil principal Greengrass, vous pouvez utiliser son rôle d'échange de jetons et son alias de rôle au lieu d'en créer de nouveaux.
**Pour créer un rôle IAM d'échange de jetons**
1. Créez un rôle IAM que votre appareil peut utiliser comme rôle d'échange de jetons. Procédez comme suit :
1. Créez un fichier contenant le document de politique de confiance requis par le rôle d'échange de jetons.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.
```
nano device-role-trust-policy.json
```
Copiez le code JSON suivant dans le fichier.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Créez le rôle d'échange de jetons avec le document de politique de confiance.
+ Remplacez *GreengrassV2TokenExchangeRole* par le nom du rôle IAM à créer.
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. Créez un fichier contenant le document de politique d'accès requis par le rôle d'échange de jetons.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.
```
nano device-role-access-policy.json
```
Copiez le code JSON suivant dans le fichier.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**Note**
Cette politique d'accès n'autorise pas l'accès aux artefacts des composants dans les compartiments S3. Pour déployer des composants personnalisés qui définissent des artefacts dans Amazon S3, vous devez ajouter des autorisations au rôle afin de permettre à votre appareil principal de récupérer les artefacts des composants. Pour de plus amples informations, veuillez consulter [Autoriser l'accès aux compartiments S3 pour les artefacts des composants](device-service-role.md#device-service-role-access-s3-bucket).
Si vous ne possédez pas encore de compartiment S3 pour les artefacts des composants, vous pouvez ajouter ces autorisations ultérieurement après avoir créé un compartiment.
1. Créez la politique IAM à partir du document de stratégie.
+ Remplacez *GreengrassV2TokenExchangeRoleAccess* par le nom de la politique IAM à créer.
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. Associez la politique IAM au rôle d'échange de jetons.
+ Remplacez *GreengrassV2TokenExchangeRole* par le nom du rôle IAM.
+ Remplacez l'ARN de la stratégie par l'ARN de la stratégie IAM que vous avez créée à l'étape précédente.
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
La commande n'a aucune sortie si la demande aboutit.
1. Créez un alias de AWS IoT rôle qui pointe vers le rôle d'échange de jetons.
+ Remplacez *GreengrassCoreTokenExchangeRoleAlias* par le nom de l'alias de rôle à créer.
+ Remplacez l'ARN du rôle par l'ARN du rôle IAM que vous avez créé à l'étape précédente.
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**Note**
Pour créer un alias de rôle, vous devez être autorisé à transmettre le rôle IAM d'échange de jetons à AWS IoT. Si vous recevez un message d'erreur lorsque vous essayez de créer un alias de rôle, vérifiez que votre AWS utilisateur dispose de cette autorisation. Pour plus d'informations, consultez la section [Octroi à un utilisateur des autorisations lui permettant de transférer un rôle à un AWS service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html) dans le *Guide de Gestion des identités et des accès AWS l'utilisateur*.
## Création d'une AWS IoT politique
Une fois que vous avez enregistré un appareil en tant qu' AWS IoT objet, celui-ci peut utiliser un certificat numérique pour s'authentifier. AWS Ce certificat inclut une ou plusieurs AWS IoT politiques qui définissent les autorisations qu'un appareil peut utiliser avec le certificat. Ces politiques permettent à l'appareil de communiquer avec AWS IoT et AWS IoT Greengrass.
Dans le AWS IoT cadre du provisionnement du parc, les appareils se connectent AWS IoT pour créer et télécharger un certificat d'appareil. Dans le modèle de provisionnement de flotte que vous créez dans la section suivante, vous pouvez spécifier s'il AWS IoT attache la même AWS IoT politique aux certificats de tous les appareils ou s'il en crée une nouvelle pour chaque appareil.
Dans cette section, vous allez créer une AWS IoT politique qui AWS IoT s'attache aux certificats de tous les appareils. Grâce à cette approche, vous pouvez gérer les autorisations pour tous les appareils en tant que flotte. Si vous préférez créer une nouvelle AWS IoT politique pour chaque appareil, vous pouvez ignorer cette section et vous référer à la politique qu'elle contient lorsque vous définissez votre modèle de flotte.
**Pour créer une AWS IoT politique**
+ Créez une AWS IoT politique qui définit les AWS IoT autorisations pour votre parc d'appareils principaux Greengrass. La politique suivante permet d'accéder à tous les sujets MQTT et aux opérations Greengrass, afin que votre appareil fonctionne avec les applications personnalisées et les modifications futures qui nécessitent de nouvelles opérations Greengrass. Cette politique autorise également l'`iot:AssumeRoleWithCertificate`autorisation, qui permet à vos appareils d'utiliser le rôle d'échange de jetons que vous avez créé dans la section précédente. Vous pouvez restreindre cette politique en fonction de votre cas d'utilisation. Pour de plus amples informations, veuillez consulter [AWS IoT Politique minimale pour les appareils AWS IoT Greengrass V2 principaux](device-auth.md#greengrass-core-minimal-iot-policy).
Procédez comme suit :
1. Créez un fichier contenant le document de AWS IoT politique dont les appareils principaux de Greengrass ont besoin.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.
```
nano greengrass-v2-iot-policy.json
```
Copiez le code JSON suivant dans le fichier.
+ Remplacez la `iot:AssumeRoleWithCertificate` ressource par l'ARN de l'alias de AWS IoT rôle que vous avez créé dans la section précédente.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-east-1:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
------
1. Créez une AWS IoT politique à partir du document de stratégie.
+ Remplacez *GreengrassV2IoTThingPolicy* par le nom de la politique à créer.
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Subscribe\",
\"iot:Receive\",
\"iot:Connect\",
\"greengrass:*\"
],
\"Resource\": [
\"*\"
]
},
{
\"Effect\": \"Allow\",
\"Action\": \"iot:AssumeRoleWithCertificate\",
\"Resource\": \"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\"
}
]
}",
"policyVersionId": "1"
}
```
------
## Création d'un modèle de provisionnement de flotte
AWS IoT les modèles de provisionnement de flotte définissent comment provisionner AWS IoT les objets, les politiques et les certificats. Pour approvisionner les appareils principaux de Greengrass avec le plug-in de provisionnement de flotte, vous devez créer un modèle qui spécifie les éléments suivants :
+ N'importe AWS IoT quel objet, ressource. Vous pouvez spécifier une liste de groupes d'objets existants pour déployer des composants sur chaque appareil lors de sa mise en ligne.
+ Une ressource AWS IoT en matière de politiques. Cette ressource peut définir l'une des propriétés suivantes :
+ Le nom d'une AWS IoT politique existante. Si vous choisissez cette option, les principaux appareils que vous créez à partir de ce modèle utilisent la même AWS IoT politique et vous pouvez gérer leurs autorisations en tant que flotte.
+ Un document AWS IoT de politique. Si vous choisissez cette option, chaque périphérique principal que vous créez à partir de ce modèle utilise une AWS IoT politique unique, et vous pouvez gérer les autorisations pour chaque périphérique principal individuel.
+ Une ressource AWS IoT de certificat. Cette ressource de certificat doit utiliser le `AWS::IoT::Certificate::Id` paramètre pour associer le certificat au périphérique principal. Pour plus d'informations, consultez la section [Just-in-time Provisioning](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html) dans le *Guide du AWS IoT développeur*.
Dans le modèle, vous pouvez spécifier d'ajouter l' AWS IoT objet à une liste de groupes d'objets existants. Lorsque l'appareil principal se connecte AWS IoT Greengrass pour la première fois, il reçoit des déploiements Greengrass pour chaque groupe d'objets dont il est membre. Vous pouvez utiliser des groupes d'objets pour déployer les derniers logiciels sur chaque appareil dès sa mise en ligne. Pour de plus amples informations, veuillez consulter [Déployer AWS IoT Greengrass des composants sur des appareils](manage-deployments.md).
Le AWS IoT service nécessite des autorisations pour créer et mettre à jour AWS IoT des ressources dans vos appareils Compte AWS lorsque vous approvisionnez des appareils. Pour donner accès au AWS IoT service, vous devez créer un rôle IAM et le fournir lors de la création du modèle. AWS IoT fournit une politique gérée, l'[AWSIoTThingsenregistrement](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration), qui permet d'accéder à toutes les autorisations AWS IoT susceptibles d'être utilisées lors du provisionnement des appareils. Vous pouvez utiliser cette politique gérée ou créer une politique personnalisée qui limite les autorisations de la politique gérée pour votre cas d'utilisation.
Dans cette section, vous créez un rôle IAM qui permet AWS IoT de fournir des ressources pour les appareils, et vous créez un modèle de provisionnement de flotte qui utilise ce rôle IAM.
**Pour créer un modèle de provisionnement de flotte**
1. Créez un rôle IAM AWS IoT capable de fournir des ressources dans votre Compte AWS. Procédez comme suit :
1. Créez un fichier contenant le document de politique de confiance qui permet AWS IoT d'assumer le rôle.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.
```
nano aws-iot-trust-policy.json
```
Copiez le code JSON suivant dans le fichier.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Créez un rôle IAM avec le document de politique de confiance.
+ Remplacez *GreengrassFleetProvisioningRole* par le nom du rôle IAM à créer.
```
aws iam create-role --role-name GreengrassFleetProvisioningRole --assume-role-policy-document file://aws-iot-trust-policy.json
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect",
"iot:Publish",
"iot:Subscribe",
"iot:Receive"
],
"Resource": "*"
}
]
}
```
------
1. Consultez la politique [AWSIoTThingsd'enregistrement](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration), qui permet d'accéder à toutes les autorisations AWS IoT susceptibles d'être utilisées lors de l'approvisionnement des appareils. Vous pouvez utiliser cette politique gérée ou créer une politique personnalisée qui définit des autorisations limitées pour votre cas d'utilisation. Si vous choisissez de créer une politique personnalisée, faites-le maintenant.
1. Associez la politique IAM au rôle de provisionnement de la flotte.
+ Remplacez *GreengrassFleetProvisioningRole* par le nom du rôle IAM.
+ Si vous avez créé une stratégie personnalisée à l'étape précédente, remplacez l'ARN de la stratégie par l'ARN de la stratégie IAM à utiliser.
```
aws iam attach-role-policy --role-name GreengrassFleetProvisioningRole --policy-arn arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration
```
La commande n'a aucune sortie si la demande aboutit.
1. (Facultatif) Créez un *hook de pré-approvisionnement*, qui est une AWS Lambda fonction qui valide les paramètres du modèle fournis par les appareils lors de l'enregistrement. Vous pouvez utiliser un hook de préprovisionnement pour mieux contrôler quels appareils et combien d'appareils sont intégrés dans votre. Compte AWS Pour plus d'informations, consultez la section [Pre-provisioning hooks](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) dans le Guide du *AWS IoT Core développeur*.
1. Créez un modèle de provisionnement de flotte. Procédez comme suit :
1. Créez un fichier contenant le modèle de document de provisionnement.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.
```
nano greengrass-fleet-provisioning-template.json
```
Rédigez le modèle de document de provisionnement. Vous pouvez commencer par l'exemple de modèle de provisionnement suivant, qui indique de créer un AWS IoT objet doté des propriétés suivantes :
+ Le nom de l'objet est la valeur que vous spécifiez dans le paramètre du `ThingName` modèle.
+ L'objet est membre du groupe d'objets que vous spécifiez dans le paramètre du `ThingGroupName` modèle. Le groupe d'objets doit exister dans votre Compte AWS.
+ Le certificat de l'objet est `GreengrassV2IoTThingPolicy` associé à la AWS IoT politique nommée.
Pour plus d'informations, consultez la section [Modèles de provisionnement](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html) dans le *Guide du AWS IoT Core développeur*.
```
{
"Parameters": {
"ThingName": {
"Type": "String"
},
"ThingGroupName": {
"Type": "String"
},
"AWS::IoT::Certificate::Id": {
"Type": "String"
}
},
"Resources": {
"MyThing": {
"OverrideSettings": {
"AttributePayload": "REPLACE",
"ThingGroups": "REPLACE",
"ThingTypeName": "REPLACE"
},
"Properties": {
"AttributePayload": {},
"ThingGroups": [
{
"Ref": "ThingGroupName"
}
],
"ThingName": {
"Ref": "ThingName"
}
},
"Type": "AWS::IoT::Thing"
},
"MyPolicy": {
"Properties": {
"PolicyName": "GreengrassV2IoTThingPolicy"
},
"Type": "AWS::IoT::Policy"
},
"MyCertificate": {
"Properties": {
"CertificateId": {
"Ref": "AWS::IoT::Certificate::Id"
},
"Status": "Active"
},
"Type": "AWS::IoT::Certificate"
}
}
}
```
**Note**
*MyThing**MyPolicy*, et *MyCertificate* sont des noms arbitraires qui identifient chaque spécification de ressource dans le modèle de provisionnement du parc. AWS IoT n'utilise pas ces noms dans les ressources qu'il crée à partir du modèle. Vous pouvez utiliser ces noms ou les remplacer par des valeurs qui vous aident à identifier chaque ressource du modèle.
1. Créez le modèle de provisionnement de flotte à partir du document modèle de provisionnement.
+ Remplacez *GreengrassFleetProvisioningTemplate* par le nom du modèle à créer.
+ Remplacez la description du modèle par une description de votre modèle.
+ Remplacez l'ARN du rôle de provisionnement par l'ARN du rôle que vous avez créé précédemment.
------
#### [ Linux or Unix ]
```
aws iot create-provisioning-template \
--template-name GreengrassFleetProvisioningTemplate \
--description "A provisioning template for Greengrass core devices." \
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" \
--template-body file://greengrass-fleet-provisioning-template.json \
--enabled
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-provisioning-template ^
--template-name GreengrassFleetProvisioningTemplate ^
--description "A provisioning template for Greengrass core devices." ^
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" ^
--template-body file://greengrass-fleet-provisioning-template.json ^
--enabled
```
------
#### [ PowerShell ]
```
aws iot create-provisioning-template `
--template-name GreengrassFleetProvisioningTemplate `
--description "A provisioning template for Greengrass core devices." `
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" `
--template-body file://greengrass-fleet-provisioning-template.json `
--enabled
```
------
**Note**
Si vous avez créé un hook de pré-provisionnement, spécifiez l'ARN de la fonction Lambda du hook de pré-provisionnement avec l'argument. `--pre-provisioning-hook`
```
--pre-provisioning-hook targetArn=arn:aws:lambda:us-west-2:123456789012:function:GreengrassPreProvisioningHook
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"templateArn": "arn:aws:iot:us-west-2:123456789012:provisioningtemplate/GreengrassFleetProvisioningTemplate",
"templateName": "GreengrassFleetProvisioningTemplate",
"defaultVersionId": 1
}
```
## Création d'un certificat de demande d'approvisionnement et d'une clé privée
Les certificats de réclamation sont des certificats X.509 qui permettent aux appareils de s'enregistrer en tant qu' AWS IoT objets et de récupérer un certificat d'appareil X.509 unique à utiliser pour les opérations régulières. Après avoir créé un certificat de réclamation, vous joignez une AWS IoT politique qui permet aux appareils de l'utiliser pour créer des certificats d'appareils uniques et approvisionner à l'aide d'un modèle de provisionnement de flotte. Les appareils dotés du certificat de réclamation peuvent effectuer le provisionnement en utilisant uniquement le modèle de provisionnement que vous autorisez dans la AWS IoT politique.
Dans cette section, vous créez le certificat de réclamation et vous le configurez pour les appareils à utiliser avec le modèle de provisionnement de flotte que vous avez créé dans la section précédente.
**Important**
L'approvisionnement des clés privées des réclamations doit être sécurisé à tout moment, y compris sur les appareils principaux de Greengrass. Nous vous recommandons d'utiliser CloudWatch les statistiques et les journaux Amazon pour détecter les signes d'utilisation abusive, tels que l'utilisation non autorisée du certificat de réclamation pour approvisionner des appareils. Si vous détectez une utilisation abusive, désactivez le certificat de demande d'approvisionnement afin qu'il ne puisse pas être utilisé pour le provisionnement des appareils. Pour plus d'informations, consultez la section [Surveillance AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) dans le *guide du AWS IoT Core développeur*.
Pour vous aider à mieux gérer le nombre d'appareils et les appareils qui s'enregistrent dans le vôtre Compte AWS, vous pouvez spécifier un crochet de préapprovisionnement lorsque vous créez un modèle de provisionnement de flotte. Un hook de pré-provisionnement est une AWS Lambda fonction qui valide les paramètres du modèle fournis par les appareils lors de l'enregistrement. Par exemple, vous pouvez créer un hook de pré-provisionnement qui compare l'identifiant d'un appareil à une base de données afin de vérifier que l'appareil est autorisé à le provisionner. Pour plus d'informations, consultez la section [Pre-provisioning hooks](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) dans le Guide du *AWS IoT Core développeur*.
**Pour créer un certificat de demande d'approvisionnement et une clé privée**
1. Créez un dossier dans lequel vous téléchargerez le certificat de réclamation et la clé privée.
```
mkdir claim-certs
```
1. Créez et enregistrez un certificat et une clé privée à utiliser pour le provisionnement. AWS IoT fournit des certificats clients signés par l'autorité de certification Amazon Root (CA).
------
#### [ Linux or Unix ]
```
aws iot create-keys-and-certificate \
--certificate-pem-outfile "claim-certs/claim.pem.crt" \
--public-key-outfile "claim-certs/claim.public.pem.key" \
--private-key-outfile "claim-certs/claim.private.pem.key" \
--set-as-active
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-keys-and-certificate ^
--certificate-pem-outfile "claim-certs/claim.pem.crt" ^
--public-key-outfile "claim-certs/claim.public.pem.key" ^
--private-key-outfile "claim-certs/claim.private.pem.key" ^
--set-as-active
```
------
#### [ PowerShell ]
```
aws iot create-keys-and-certificate `
--certificate-pem-outfile "claim-certs/claim.pem.crt" `
--public-key-outfile "claim-certs/claim.public.pem.key" `
--private-key-outfile "claim-certs/claim.private.pem.key" `
--set-as-active
```
------
La réponse contient des informations sur le certificat, si la demande aboutit. Enregistrez l'ARN du certificat pour l'utiliser ultérieurement.
1. Créez et attachez une AWS IoT politique qui permet aux appareils d'utiliser le certificat pour créer des certificats d'appareils uniques et de les approvisionner à l'aide du modèle de provisionnement du parc. La politique suivante autorise l'accès à l'API MQTT de provisionnement des appareils. Pour plus d'informations, consultez la section [Device Provisioning MQTT API](https://docs.aws.amazon.com/iot/latest/developerguide/fleet-provision-api.html) dans le Guide du *AWS IoT Core développeur*.
Procédez comme suit :
1. Créez un fichier contenant le document de AWS IoT politique dont les appareils principaux de Greengrass ont besoin.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.
```
nano greengrass-provisioning-claim-iot-policy.json
```
Copiez le code JSON suivant dans le fichier.
+ Remplacez chaque instance de *region* par celle Région AWS où vous avez configuré le provisionnement de la flotte.
+ Remplacez chaque instance de *account-id* par votre Compte AWS identifiant.
+ Remplacez chaque instance de *GreengrassFleetProvisioningTemplate* par le nom du modèle de provisionnement de flotte que vous avez créé dans la section précédente.
------
#### [ JSON ]
****
```
{
"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/GreengrassFleetProvisioningTemplate/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/GreengrassFleetProvisioningTemplate/provision/*"
]
}
]
}
```
------
1. Créez une AWS IoT politique à partir du document de stratégie.
+ Remplacez *GreengrassProvisioningClaimPolicy* par le nom de la politique à créer.
```
aws iot create-policy --policy-name GreengrassProvisioningClaimPolicy --policy-document file://greengrass-provisioning-claim-iot-policy.json
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassProvisioningClaimPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassProvisioningClaimPolicy",
"policyDocument": "{
\"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/GreengrassFleetProvisioningTemplate/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/GreengrassFleetProvisioningTemplate/provision/*\"
]
}
]
}",
"policyVersionId": "1"
}
```
------
1. Joignez la AWS IoT politique au certificat de réclamation d'approvisionnement.
+ Remplacez *GreengrassProvisioningClaimPolicy* par le nom de la politique à joindre.
+ Remplacez l'ARN cible par l'ARN du certificat de demande d'approvisionnement.
```
aws iot attach-policy --policy-name GreengrassProvisioningClaimPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
La commande n'a aucune sortie si la demande aboutit.
Vous disposez désormais d'un certificat de demande d'approvisionnement et d'une clé privée que les appareils peuvent utiliser pour s'enregistrer AWS IoT et s'approvisionner en tant qu'appareils principaux de Greengrass. Vous pouvez intégrer le certificat de réclamation et la clé privée dans les appareils pendant la fabrication, ou copier le certificat et la clé sur les appareils avant d'installer le logiciel AWS IoT Greengrass Core. Pour de plus amples informations, veuillez consulter [Installation AWS IoT Greengrass du logiciel de base avec provisionnement du AWS IoT parc](fleet-provisioning.md).
# Configuration du plugin de provisionnement de AWS IoT flotte
Le plugin de provisionnement de AWS IoT flotte fournit les paramètres de configuration suivants que vous pouvez personnaliser lorsque vous [installez le logiciel AWS IoT Greengrass Core avec le provisionnement de flotte](fleet-provisioning.md).
`rootPath`
Le chemin d'accès au dossier à utiliser comme racine pour le logiciel AWS IoT Greengrass Core.
`awsRegion`
Celui Région AWS que le plugin de provisionnement de flotte utilise pour provisionner les AWS ressources.
`iotDataEndpoint`
Le point AWS IoT de terminaison de données pour votre Compte AWS.
`iotCredentialEndpoint`
Le point de terminaison des informations d' AWS IoT identification de votre Compte AWS.
`iotRoleAlias`
Alias de AWS IoT rôle qui pointe vers un rôle IAM d'échange de jetons. Le fournisseur AWS IoT d'informations d'identification assume ce rôle pour permettre au dispositif principal de Greengrass d'interagir avec AWS les services. Pour de plus amples informations, veuillez consulter [Autoriser les appareils principaux à interagir avec les AWS services](device-service-role.md).
`provisioningTemplate`
Modèle de provisionnement de AWS IoT flotte à utiliser pour provisionner les AWS ressources. Ce modèle doit spécifier les éléments suivants :
+ N'importe AWS IoT quel objet, ressource. Vous pouvez spécifier une liste de groupes d'objets existants pour déployer des composants sur chaque appareil lors de sa mise en ligne.
+ Une ressource AWS IoT en matière de politiques. Cette ressource peut définir l'une des propriétés suivantes :
+ Le nom d'une AWS IoT politique existante. Si vous choisissez cette option, les principaux appareils que vous créez à partir de ce modèle utilisent la même AWS IoT politique, et vous pouvez gérer leurs autorisations en tant que flotte.
+ Un document AWS IoT de politique. Si vous choisissez cette option, chaque périphérique principal que vous créez à partir de ce modèle utilise une AWS IoT politique unique, et vous pouvez gérer les autorisations pour chaque périphérique principal individuel.
+ Une ressource AWS IoT de certificat. Cette ressource de certificat doit utiliser le `AWS::IoT::Certificate::Id` paramètre pour associer le certificat au périphérique principal. Pour plus d'informations, consultez la section [Just-in-time Provisioning](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html) dans le *Guide du AWS IoT développeur*.
Pour plus d'informations, consultez la section [Modèles de provisionnement](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html) dans le *Guide du AWS IoT Core développeur*.
`claimCertificatePath`
Le chemin d'accès au certificat de demande de provisionnement pour le modèle de provisionnement que vous spécifiez dans. `provisioningTemplate` Pour plus d’informations, consultez [CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html) dans la *Référence d’API AWS IoT Core *.
`claimCertificatePrivateKeyPath`
Le chemin d'accès à la clé privée du certificat de demande d'approvisionnement pour le modèle de provisionnement que vous spécifiez dans. `provisioningTemplate` Pour plus d’informations, consultez [CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html) dans la *Référence d’API AWS IoT Core *.
L'approvisionnement des clés privées des réclamations doit être sécurisé à tout moment, y compris sur les appareils principaux de Greengrass. Nous vous recommandons d'utiliser CloudWatch les statistiques et les journaux Amazon pour détecter les signes d'utilisation abusive, tels que l'utilisation non autorisée du certificat de réclamation pour approvisionner des appareils. Si vous détectez une utilisation abusive, désactivez le certificat de demande d'approvisionnement afin qu'il ne puisse pas être utilisé pour le provisionnement des appareils. Pour plus d'informations, consultez la section [Surveillance AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) dans le *guide du AWS IoT Core développeur*.
Pour vous aider à mieux gérer le nombre d'appareils et les appareils qui s'enregistrent dans le vôtre Compte AWS, vous pouvez spécifier un crochet de préapprovisionnement lorsque vous créez un modèle de provisionnement de flotte. Un hook de pré-provisionnement est une AWS Lambda fonction qui valide les paramètres du modèle fournis par les appareils lors de l'enregistrement. Par exemple, vous pouvez créer un hook de pré-provisionnement qui compare l'identifiant d'un appareil à une base de données afin de vérifier que l'appareil est autorisé à effectuer le provisionnement. Pour plus d'informations, consultez la section [Pre-provisioning hooks](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) dans le Guide du *AWS IoT Core développeur*.
`rootCaPath`
Le chemin d'accès au certificat de l'autorité de certification racine (CA) Amazon.
`templateParameters`
(Facultatif) Carte des paramètres à fournir au modèle de provisionnement de flotte. *Pour plus d'informations, consultez la [section sur les paramètres des modèles de provisionnement](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html#parameters-section) dans le Guide du AWS IoT Core développeur.*
`deviceId`
(Facultatif) L'identifiant de l'appareil à utiliser comme identifiant client lorsque le plugin de provisionnement de flotte crée une connexion MQTT avec. AWS IoT
Par défaut : un UUID aléatoire.
`mqttPort`
(Facultatif) Le port à utiliser pour les connexions MQTT.
Valeur par défaut : `8883`
`proxyUrl`
(Facultatif) L'URL du serveur proxy au format`scheme://userinfo@host:port`. Pour utiliser un proxy HTTPS, vous devez utiliser la version 1.1.0 ou ultérieure du plugin de provisionnement de flotte.
+ `scheme`— Le schéma, qui doit être `http` ou`https`.
**Important**
Les appareils principaux de Greengrass doivent exécuter [Greengrass nucleus](greengrass-nucleus-component.md) v2.5.0 ou version ultérieure pour utiliser les proxys HTTPS.
Si vous configurez un proxy HTTPS, vous devez ajouter le certificat CA du serveur proxy au certificat CA racine Amazon de l'appareil principal. Pour de plus amples informations, veuillez consulter [Permettre au périphérique principal de faire confiance à un proxy HTTPS](configure-greengrass-core-v2.md#https-proxy-certificate-trust).
+ `userinfo`— (Facultatif) Les informations relatives au nom d'utilisateur et au mot de passe. Si vous spécifiez ces informations dans le`url`, le périphérique principal de Greengrass ignore les `username` champs et. `password`
+ `host`— Le nom d'hôte ou l'adresse IP du serveur proxy.
+ `port`— (Facultatif) Le numéro de port. Si vous ne spécifiez pas le port, le périphérique principal de Greengrass utilise les valeurs par défaut suivantes :
+ `http`— 80
+ `https`— 443
`proxyUserName`
(Facultatif) Le nom d'utilisateur qui authentifie le serveur proxy.
`proxyPassword`
(Facultatif) Le nom d'utilisateur qui authentifie le serveur proxy.
Parcours CSR
(Facultatif) Le chemin d'accès au fichier de demande de signature de certificat (CSR) à utiliser pour créer le certificat de l'appareil à partir d'un CSR. Pour plus d'informations, consultez la section [Provisioning by claim](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based) dans le *guide du AWS IoT Core développeur*.
csrPrivateKeyParcours
(Facultatif, obligatoire s'`csrPath`il est déclaré) Le chemin d'accès à la clé privée utilisée pour générer le CSR. La clé privée doit avoir été utilisée pour générer le CSR. Pour plus d'informations, consultez la section [Provisioning by claim](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based) dans le *guide du AWS IoT Core développeur*.
Chemin du certificat
(Facultatif) Le chemin à utiliser pour enregistrer le certificat de l'appareil téléchargé.
privateKeyPath
(Facultatif) Le chemin à utiliser pour enregistrer la clé privée de l'appareil téléchargée.
# AWS IoT journal des modifications du plugin de provisionnement de flotte
Le tableau suivant décrit les modifications apportées à chaque version du provisionnement de la AWS IoT flotte par claim plugin (`aws.greengrass.FleetProvisioningByClaim`).
| Version | Modifications |
| --- | --- |
| 1.2.2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.1 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.1.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.0.0 | Première version. |