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.
# Installez le logiciel AWS IoT Greengrass Core avec un provisionnement personnalisé des ressources
Cette fonctionnalité est disponible pour les versions 2.4.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.
Le programme d'installation du logiciel AWS IoT Greengrass Core fournit une interface Java que vous pouvez implémenter dans un plugin personnalisé qui fournit les AWS ressources nécessaires. Vous pouvez développer un plug-in de provisionnement pour utiliser des certificats clients X.509 personnalisés ou pour exécuter des étapes de provisionnement complexes non prises en charge par d'autres processus d'installation. Pour plus d'informations, consultez la section [Création de vos propres certificats clients](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html) dans le *Guide du AWS IoT Core développeur*.
Pour exécuter un plug-in de provisionnement personnalisé lorsque vous installez le logiciel AWS IoT Greengrass Core, vous devez créer un fichier JAR que vous fournissez au programme d'installation. Le programme d'installation exécute le plug-in, qui renvoie une configuration d'approvisionnement qui définit les AWS ressources pour le périphérique principal de Greengrass. Le programme d'installation utilise ces informations pour configurer le logiciel AWS IoT Greengrass Core sur l'appareil. Pour de plus amples informations, veuillez consulter [Développez des plugins de provisionnement personnalisés](develop-custom-provisioning-plugins.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](#custom-provisioning-prerequisites)
+ [Configuration de l'environnement de l'appareil](#set-up-device-environment)
+ [Téléchargez le logiciel AWS IoT Greengrass Core](#download-greengrass-core-v2)
+ [Installation du logiciel AWS IoT Greengrass Core](#run-greengrass-core-v2-installer-custom)
+ [Développez des plugins de provisionnement personnalisés](develop-custom-provisioning-plugins.md)
## Conditions préalables
Pour installer le logiciel AWS IoT Greengrass Core avec un provisionnement personnalisé, vous devez disposer des éléments suivants :
+ Un fichier JAR pour un plugin de provisionnement personnalisé qui implémente le`DeviceIdentityInterface`. Le plug-in de provisionnement personnalisé doit renvoyer des valeurs pour chaque paramètre de configuration du système et du noyau. Dans le cas contraire, vous devez fournir ces valeurs dans le fichier de configuration lors de l'installation. Pour de plus amples informations, veuillez consulter [Développez des plugins de provisionnement personnalisés](develop-custom-provisioning-plugins.md).
## 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 Core
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.
## Installation du logiciel AWS IoT Greengrass Core
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 votre plug-in de provisionnement personnalisé pour provisionner AWS des 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 des AWS ressources créées par le plug-in de provisionnement personnalisé.
+ 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 (Linux)**
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.
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.17.0"
configuration:
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
Ensuite, procédez comme suit :
+ Remplacez *2.17.0* par la version du logiciel AWS IoT Greengrass Core.
+ Remplacez chaque instance de `/greengrass/v2` par le dossier racine de Greengrass.
+ (Facultatif) Spécifiez les valeurs de configuration du système et du noyau. Vous devez définir ces valeurs si votre plugin d'approvisionnement ne les fournit pas.
+ (Facultatif) Spécifiez les paramètres de configuration à fournir à votre plug-in de provisionnement.
**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).
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.17.0"
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"
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
1. Exécutez le programme d'installation. Spécifiez `--trusted-plugin` pour fournir votre plugin de provisionnement personnalisé et spécifiez `--init-config` pour fournir le fichier de configuration.
**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.
+ Remplacez `/greengrass/v2` ou *C:\$1greengrass\$1v2* par le dossier racine de Greengrass.
+ Remplacez chaque instance de *GreengrassInstaller* par le dossier dans lequel vous avez décompressé le programme d'installation.
+ Remplacez le chemin du fichier JAR du plugin de provisionnement personnalisé par le chemin du fichier JAR de votre plugin.
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin /path/to/com.example.CustomProvisioning.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 /path/to/com.example.CustomProvisioning.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 /path/to/com.example.CustomProvisioning.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)
# Développez des plugins de provisionnement personnalisés
Pour développer un plugin de provisionnement personnalisé, créez une classe Java qui implémente l'`com.aws.greengrass.provisioning.DeviceIdentityInterface`interface. Vous pouvez inclure le fichier JAR Greengrass nucleus dans votre projet pour accéder à cette interface et à ses classes. Cette interface définit une méthode qui saisit une configuration de plugin et produit une configuration de provisionnement. La configuration de provisionnement définit les configurations du système et du composant du noyau [Greengrass](greengrass-nucleus-component.md). Le programme d'installation du logiciel AWS IoT Greengrass Core utilise cette configuration de provisionnement pour configurer le logiciel AWS IoT Greengrass Core sur un appareil.
Après avoir développé un plug-in de provisionnement personnalisé, créez-le sous forme de fichier JAR que vous pouvez fournir au programme d'installation du logiciel AWS IoT Greengrass Core pour qu'il exécute votre plug-in lors de l'installation. Le programme d'installation exécute votre plug-in de provisionnement personnalisé dans la même JVM qu'il utilise. Vous pouvez donc créer un fichier JAR contenant uniquement le code de votre plug-in.
**Note**
Le [plugin de provisionnement de AWS IoT flotte](fleet-provisioning.md) implémente le provisionnement de flotte `DeviceIdentityInterface` à utiliser lors de l'installation. Le plugin de provisionnement de flotte est open source, vous pouvez donc explorer son code source pour voir un exemple d'utilisation de l'interface du plug-in de provisionnement. Pour plus d'informations, consultez le [plugin de provisionnement de AWS IoT flotte](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim) sur GitHub.
**Topics**
+ [Exigences](#custom-provisioning-plugin-requirements)
+ [Implémenter l' DeviceIdentityInterface interface](#implement-device-identity-interface)
## Exigences
Pour développer un plugin de provisionnement personnalisé, vous devez créer une classe Java répondant aux exigences suivantes :
+ Utilise le `com.aws.greengrass` package ou un package inclus dans le `com.aws.greengrass` package.
+ Possède un constructeur sans aucun argument.
+ Implémente l'`DeviceIdentityInterface`interface. Pour de plus amples informations, veuillez consulter [Implémenter l' DeviceIdentityInterface interface](#implement-device-identity-interface).
## Implémenter l' DeviceIdentityInterface interface
Pour utiliser l'`com.aws.greengrass.provisioning.DeviceIdentityInterface`interface de votre plugin personnalisé, ajoutez le noyau Greengrass en tant que dépendance à votre projet.
**Pour utiliser le DeviceIdentityInterface dans un projet de plugin de provisionnement personnalisé**
+ Vous pouvez ajouter le fichier JAR du noyau Greengrass en tant que bibliothèque ou ajouter le noyau Greengrass en tant que dépendance Maven. Effectuez l’une des actions suivantes :
+ Pour ajouter le fichier Greengrass nucleus JAR en tant que bibliothèque, téléchargez le logiciel AWS IoT Greengrass Core, qui contient le fichier Greengrass nucleus JAR. 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
Vous pouvez trouver le fichier JAR Greengrass nucleus (`Greengrass.jar`) dans le `lib` dossier du fichier ZIP. Ajoutez ce fichier JAR à votre projet.
+ Pour utiliser le noyau Greengrass dans un projet Maven, ajoutez une dépendance à l'`nucleus`artefact du groupe. `com.aws.greengrass` Vous devez également ajouter le `greengrass-common` dépôt, car le noyau Greengrass n'est pas disponible dans le référentiel central de Maven.
```
...
greengrass-common
greengrass common
https://d2jrmugq4soldf.cloudfront.net/snapshots
...
com.aws.greengrass
nucleus
2.5.0-SNAPSHOT
provided
```
### L' DeviceIdentityInterface interface
L'`com.aws.greengrass.provisioning.DeviceIdentityInterface`interface a la forme suivante.
**Note**
[Vous pouvez également explorer ces classes dans le [package com.aws.greengrass.provisioning du](https://github.com/aws-greengrass/aws-greengrass-nucleus/tree/main/src/main/java/com/aws/greengrass/provisioning) code source du noyau de Greengrass sur.](https://github.com/aws-greengrass/aws-greengrass-nucleus) GitHub
```
public interface com.aws.greengrass.provisioning.DeviceIdentityInterface {
ProvisionConfiguration updateIdentityConfiguration(ProvisionContext context)
throws RetryableProvisioningException, InterruptedException;
// Return the name of the plugin.
String name();
}
com.aws.greengrass.provisioning.ProvisionConfiguration {
SystemConfiguration systemConfiguration;
NucleusConfiguration nucleusConfiguration
}
com.aws.greengrass.provisioning.ProvisionConfiguration.SystemConfiguration {
String certificateFilePath;
String privateKeyPath;
String rootCAPath;
String thingName;
}
com.aws.greengrass.provisioning.ProvisionConfiguration.NucleusConfiguration {
String awsRegion;
String iotCredentialsEndpoint;
String iotDataEndpoint;
String iotRoleAlias;
}
com.aws.greengrass.provisioning.ProvisioningContext {
Map parameterMap;
String provisioningPolicy; // The policy is always "PROVISION_IF_NOT_PROVISIONED".
}
com.aws.greengrass.provisioning.exceptions.RetryableProvisioningException {}
```
Chaque valeur de configuration dans le `SystemConfiguration` et `NucleusConfiguration` est requise pour installer le logiciel AWS IoT Greengrass Core, mais vous pouvez revenir`null`. Si votre plug-in de provisionnement personnalisé renvoie une valeur `null` de configuration, vous devez fournir cette valeur dans la configuration du système ou du noyau lorsque vous créez le `config.yaml` fichier à fournir au programme d'installation du logiciel AWS IoT Greengrass Core. Si votre plugin de provisionnement personnalisé renvoie une valeur non nulle pour une option que vous définissez également dans`config.yaml`, le programme d'installation remplace la valeur in `config.yaml` par la valeur renvoyée par le plugin.