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.

# Configuration des appareils AWS IoT Greengrass principaux
<a name="setting-up"></a>

Effectuez les tâches décrites dans cette section pour installer, configurer et exécuter le logiciel AWS IoT Greengrass Core.

**Note**  
Cette section décrit l'installation et la configuration avancées du logiciel AWS IoT Greengrass Core. Ces étapes ne s'appliquent pas à Nucleus Lite. Si vous utilisez Nucleus Lite pour la première fois AWS IoT Greengrass V2, nous vous recommandons de suivre le [didacticiel de démarrage](getting-started.md) pour configurer un appareil principal et explorer les fonctionnalités de. AWS IoT Greengrass



**Topics**
+ [Plateformes prises en charge](#supported-platforms)
+ [Exigences relatives aux dispositifs](#device-requirements)
+ [Exigences relatives à la fonction Lambda](#greengrass-v2-lambda-requirements)
+ [Configurez un Compte AWS](#set-up-aws-account)
+ [Installation du logiciel AWS IoT Greengrass de base](install-greengrass-core-v2.md)
+ [Exécutez le logiciel AWS IoT Greengrass Core](run-greengrass-core-v2.md)
+ [Exécuter le logiciel AWS IoT Greengrass Core dans un conteneur Docker](run-greengrass-docker.md)
+ [Configuration du logiciel AWS IoT Greengrass de base](configure-greengrass-core-v2.md)
+ [Mettre à jour le logiciel AWS IoT Greengrass principal (OTA)](update-greengrass-core-v2.md)
+ [Désinstallez le logiciel AWS IoT Greengrass Core](uninstall-greengrass-core-v2.md)

## Plateformes prises en charge
<a name="supported-platforms"></a>
+ [Plateformes prises en charge par Greengrass Nucleus](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [Plateformes prises en charge par Greengrass Nucleus Lite](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)

## Exigences relatives aux dispositifs
<a name="device-requirements"></a>
+ [Exigences relatives à l'appareil Greengrass Nucleus](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [Configuration requise pour les appareils Greengrass Nucleus Lite](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)

## Exigences relatives à la fonction Lambda
<a name="greengrass-v2-lambda-requirements"></a>

**Important**  
Les fonctions Greengrass Lambda ne sont actuellement pas prises en charge par Greengrass nucleus lite.

Votre appareil doit répondre aux exigences suivantes pour exécuter les fonctions Lambda :
+ Système d'exploitation basé sur Linux.
+ Votre appareil doit disposer de la commande `mkfifo` shell.
+ Votre appareil doit exécuter les bibliothèques de langage de programmation requises par une fonction Lambda. Vous devez installer les bibliothèques requises sur le périphérique et les ajouter à la variable d'`PATH`environnement. Greengrass prend en charge toutes les versions compatibles avec Lambda des environnements d'exécution Python, Node.js et Java. Greengrass n'applique aucune restriction supplémentaire aux versions d'exécution Lambda obsolètes. Pour plus d'informations sur la AWS IoT Greengrass prise en charge des environnements d'exécution Lambda, consultez. [Exécuter AWS Lambda des fonctions](run-lambda-functions.md)
+ Pour exécuter des fonctions Lambda conteneurisées, votre appareil doit répondre aux exigences suivantes :
  + Noyau Linux 4.4 ou version ultérieure.
  + Le noyau doit prendre en charge [les cgroups](https://en.wikipedia.org/wiki/Cgroups) v1, et vous devez activer et monter les cgroups suivants :
    + Le groupe *de mémoire* permettant de définir la limite de mémoire AWS IoT Greengrass pour les fonctions Lambda conteneurisées.
    + Le groupe de *périphériques* pour les fonctions Lambda conteneurisées permettant d'accéder aux périphériques ou aux volumes du système.

    Le logiciel AWS IoT Greengrass Core ne prend pas en charge les cgroups v2.

    Pour répondre à cette exigence, 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
    ```
**Astuce**  
Sur un Raspberry Pi, modifiez le `/boot/cmdline.txt` fichier pour définir les paramètres du noyau de l'appareil.
  + Vous devez activer les configurations de noyau Linux suivantes sur l'appareil :
    + Espace de noms :
      + `CONFIG_IPC_NS`
      + `CONFIG_UTS_NS`
      + `CONFIG_USER_NS`
      + `CONFIG_PID_NS`
    + Cgroups :
      + `CONFIG_CGROUP_DEVICE`
      + `CONFIG_CGROUPS`
      + `CONFIG_MEMCG`
    + Autres :
      + `CONFIG_POSIX_MQUEUE`
      + `CONFIG_OVERLAY_FS`
      + `CONFIG_HAVE_ARCH_SECCOMP_FILTER`
      + `CONFIG_SECCOMP_FILTER`
      + `CONFIG_KEYS`
      + `CONFIG_SECCOMP`
      + `CONFIG_SHMEM`
**Astuce**  
Consultez la documentation de votre distribution Linux pour savoir comment vérifier et définir les paramètres du noyau Linux. Vous pouvez également utiliser AWS IoT Device Tester for AWS IoT Greengrass pour vérifier que votre appareil répond à ces exigences. Pour de plus amples informations, veuillez consulter [Utilisation AWS IoT Device Tester pour la AWS IoT Greengrass V2](device-tester-for-greengrass-ug.md).

## Configurez un Compte AWS
<a name="set-up-aws-account"></a>

Si vous n'en avez pas Compte AWS, procédez comme suit pour en créer un.

**Pour vous inscrire à un Compte AWS**

1. Ouvrez l'[https://portal.aws.amazon.com/billing/inscription.](https://portal.aws.amazon.com/billing/signup)

1. Suivez les instructions en ligne.

   Dans le cadre de la procédure d’inscription, vous recevrez un appel téléphonique ou un SMS et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.

   Lorsque vous vous inscrivez à un Compte AWS, un *Utilisateur racine d'un compte AWS*est créé. Par défaut, seul l’utilisateur racine a accès à l’ensemble des Services AWS et des ressources de ce compte. La meilleure pratique de sécurité consiste à attribuer un accès administratif à un utilisateur, et à utiliser uniquement l’utilisateur racine pour effectuer les [tâches nécessitant un accès utilisateur racine](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

Afin de créer un utilisateur administrateur, choisissez l'une des options suivantes :


****  

| Choisissez un moyen de gérer votre administrateur | Pour | En | Vous pouvez également | 
| --- | --- | --- | --- | 
| Dans IAM Identity Center (Recommandé) | Utiliser des identifiants à court terme pour accéder à AWS.C’est conforme aux bonnes pratiques en matière de sécurité. Pour plus d’informations sur les bonnes pratiques, consultez [Bonnes pratiques de sécurité dans IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) dans le *Guide de l’utilisateur IAM*. | Suivant les instructions fournies dans [Mise en route](https://docs.aws.amazon.com//singlesignon/latest/userguide/getting-started.html) dans le Guide de l’utilisateur AWS IAM Identity Center . | Configurez l'accès par programmation en [configurant le AWS CLI à utiliser AWS IAM Identity Center](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-sso.html) dans le guide de l'AWS Command Line Interface utilisateur. | 
| Dans IAM (Non recommandé) | Utiliser les informations d’identification à long terme pour accéder à AWS. | Suivant les instructions fournies dans [Création d’un utilisateur IAM pour l’accès d’urgence](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started-emergency-iam-user.html) dans le Guide de l’utilisateur IAM. | Configurer l’accès par programmation en suivant les instructions fournies dans [Gestion des clés d’accès pour les utilisateurs IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html) dans le Guide de l’utilisateur IAM. | 

# Installation du logiciel AWS IoT Greengrass de base
<a name="install-greengrass-core-v2"></a>

AWS IoT Greengrass s'étend AWS aux appareils périphériques afin qu'ils puissent agir sur les données qu'ils génèrent, tout en les utilisant à des AWS Cloud fins de gestion, d'analyse et de stockage durable. Installez le logiciel AWS IoT Greengrass Core sur les appareils de pointe pour l'intégrer AWS IoT Greengrass et le AWS Cloud.

**Important**  
Avant de télécharger et d'installer 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.

Le logiciel AWS IoT Greengrass Core inclut un programme d'installation qui configure votre appareil en tant qu'appareil principal Greengrass. Lorsque vous exécutez le programme d'installation, vous pouvez configurer des options, telles que le dossier racine et le dossier Région AWS à utiliser. Vous pouvez demander au programme d'installation de créer les ressources requises AWS IoT et IAM pour vous. Vous pouvez également choisir de déployer des outils de développement locaux pour configurer un appareil que vous utilisez pour le développement de composants personnalisés.

Le logiciel de AWS IoT Greengrass base nécessite les ressources suivantes AWS IoT et IAM pour se connecter AWS Cloud et fonctionner :
+ N'importe AWS IoT quel truc. Lorsque vous enregistrez un appareil en tant qu' AWS IoT objet, celui-ci peut utiliser un certificat numérique pour s'authentifier. AWS Ce certificat permet à l'appareil de communiquer avec AWS IoT et AWS IoT Greengrass. Pour de plus amples informations, veuillez consulter [Authentification et autorisation de l'appareil pour AWS IoT Greengrass](device-auth.md).
+ (Facultatif) Un AWS IoT groupe d'objets. Vous utilisez des groupes d'objets pour gérer des flottes d'appareils principaux de Greengrass. Lorsque vous déployez des composants logiciels sur vos appareils, vous pouvez choisir de les déployer sur des appareils individuels ou sur des groupes d'appareils. Vous pouvez ajouter un appareil à un groupe d'objets pour déployer les composants logiciels de ce groupe d'objets sur l'appareil. Pour de plus amples informations, veuillez consulter [Déployer AWS IoT Greengrass des composants sur des appareils](manage-deployments.md).
+ Un rôle IAM. Les appareils Greengrass Core utilisent le fournisseur AWS IoT Core d'informations d'identification pour autoriser les appels aux AWS services dotés d'un rôle IAM. Ce rôle permet à votre appareil d'interagir avec Amazon Logs AWS IoT, d'envoyer des CloudWatch journaux à Amazon Logs et de télécharger des artefacts de composants personnalisés depuis Amazon Simple Storage Service (Amazon S3). Pour de plus amples informations, veuillez consulter [Autoriser les appareils principaux à interagir avec les AWS services](device-service-role.md).
+ Un alias de AWS IoT rôle. Les appareils Greengrass Core utilisent l'alias de rôle pour identifier le rôle IAM à utiliser. L'alias de rôle vous permet de modifier le rôle IAM tout en conservant la même configuration de l'appareil. 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*.

Choisissez l'une des options suivantes pour installer le logiciel AWS IoT Greengrass Core sur votre appareil principal.
+ **Installation rapide**

  Choisissez cette option pour configurer un appareil principal Greengrass en un minimum d'étapes. Le programme d'installation crée les ressources AWS IoT et IAM requises pour vous. Cette option nécessite que vous fournissiez des AWS informations d'identification au programme d'installation pour créer des ressources dans votre Compte AWS.

  Vous ne pouvez pas utiliser cette option pour effectuer une installation derrière un pare-feu ou un proxy réseau. Si vos appareils se trouvent derrière un pare-feu ou un proxy réseau, envisagez une [installation manuelle](manual-installation.md).

  Pour de plus amples informations, veuillez consulter [Installation AWS IoT Greengrass du logiciel Core avec provisionnement automatique des ressources](quick-installation.md).
+ **Installation manuelle**

  Choisissez cette option pour créer les AWS ressources requises manuellement ou pour les installer derrière un pare-feu ou un proxy réseau. En utilisant une installation manuelle, vous n'avez pas besoin d'autoriser le programme d'installation à créer des ressources dans votre ordinateur Compte AWS, car c'est vous qui créez les ressources requises AWS IoT et les ressources IAM. Vous pouvez également configurer votre appareil pour qu'il se connecte sur le port 443 ou via un proxy réseau. Vous pouvez également configurer le logiciel AWS IoT Greengrass Core pour utiliser une clé privée et un certificat que vous stockez dans un module de sécurité matériel (HSM), un module de plateforme sécurisée (TPM) ou un autre élément cryptographique.

  Pour de plus amples informations, veuillez consulter [Installation AWS IoT Greengrass du logiciel Core avec provisionnement manuel des ressources](manual-installation.md).
+ **Installation avec approvisionnement AWS IoT de flotte**

  Choisissez cette option pour créer les AWS ressources requises à partir d'un modèle de provisionnement de AWS IoT flotte. Vous pouvez choisir cette option pour créer des appareils similaires dans un parc, ou si vous fabriquez des appareils que vos clients activeront ultérieurement, tels que des véhicules ou des appareils domotiques. Les appareils utilisent des certificats de réclamation pour authentifier et approvisionner les AWS ressources, y compris un certificat client X.509 que l'appareil utilise AWS Cloud pour se connecter à des fins de fonctionnement normal. Vous pouvez intégrer ou flasher les certificats de réclamation dans le matériel de l'appareil pendant la fabrication, et vous pouvez utiliser le même certificat de réclamation et la même clé pour approvisionner plusieurs appareils. Vous pouvez également configurer les appareils pour qu'ils se connectent sur le port 443 ou via un proxy réseau.

  Pour de plus amples informations, veuillez consulter [Installation AWS IoT Greengrass du logiciel de base avec provisionnement du AWS IoT parc](fleet-provisioning.md).
+ **Installation avec provisionnement personnalisé**

  Choisissez cette option pour développer une application Java personnalisée qui fournit les AWS ressources requises. Vous pouvez choisir cette option si vous [créez vos propres certificats clients X.509](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html) ou si vous souhaitez mieux contrôler le processus de provisionnement. AWS IoT Greengrass fournit une interface que vous pouvez implémenter pour échanger des informations entre votre application de provisionnement personnalisée et le programme d'installation du logiciel AWS IoT Greengrass Core.

  Pour de plus amples informations, veuillez consulter [Installez le logiciel AWS IoT Greengrass Core avec un provisionnement personnalisé des ressources](custom-provisioning.md).

AWS IoT Greengrass fournit également des environnements conteneurisés qui exécutent le logiciel AWS IoT Greengrass Core. Vous pouvez utiliser un Dockerfile pour l'[exécuter AWS IoT Greengrass dans un conteneur Docker](run-greengrass-docker.md).

**Topics**
+ [Installation avec provisionnement automatique](quick-installation.md)
+ [Installation avec provisionnement manuel](manual-installation.md)
+ [Installation avec provisionnement du parc](fleet-provisioning.md)
+ [Installation avec provisionnement personnalisé](custom-provisioning.md)
+ [Arguments d'installation](configure-installer.md)

# Installation AWS IoT Greengrass du logiciel Core avec provisionnement automatique des ressources
<a name="quick-installation"></a>

Le logiciel AWS IoT Greengrass Core inclut un programme d'installation qui configure votre appareil en tant qu'appareil principal Greengrass. Pour configurer rapidement un appareil, le programme d'installation peut configurer l' AWS IoT AWS IoT objet, le groupe d'objets, le rôle IAM et l'alias de AWS IoT rôle dont le périphérique principal a besoin pour fonctionner. Le programme d'installation peut également déployer les outils de développement locaux sur le périphérique principal, afin que vous puissiez utiliser l'appareil pour développer et tester des composants logiciels personnalisés. Le programme d'installation a besoin AWS d'informations d'identification pour provisionner ces ressources et créer le déploiement.

Si vous ne pouvez pas fournir AWS d'informations d'identification à l'appareil, vous pouvez fournir les AWS ressources dont le périphérique principal a besoin pour fonctionner. Vous pouvez également déployer les outils de développement sur un appareil principal pour l'utiliser comme périphérique de développement. Cela vous permet de fournir moins d'autorisations à l'appareil lorsque vous exécutez le programme d'installation. Pour de plus amples informations, veuillez consulter [Installation AWS IoT Greengrass du logiciel Core avec provisionnement manuel des ressources](manual-installation.md).

**Important**  <a name="install-greengrass-core-requirements-note"></a>
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**
+ [Configuration de l'environnement de l'appareil](#set-up-device-environment)
+ [Fournir des AWS informations d'identification à l'appareil](#provide-installer-aws-credentials)
+ [Téléchargez le logiciel AWS IoT Greengrass de base](#download-greengrass-core-v2)
+ [Installation du logiciel AWS IoT Greengrass de base](#run-greengrass-core-v2-installer)

## Configuration de l'environnement de l'appareil
<a name="set-up-device-environment"></a>

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
<a name="set-up-linux-device-environment"></a><a name="set-up-linux-device-environment-procedure"></a>

**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
<a name="set-up-windows-device-environment"></a>

**Note**  
Cette fonctionnalité est disponible pour les versions 2.5.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.<a name="set-up-windows-device-environment-procedure"></a>

**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 **cliquez sur OK**.

1. <a name="set-up-windows-device-environment-open-cmd"></a>Ouvrez l'invite de commande Windows (`cmd.exe`) en tant qu'administrateur.

1. <a name="set-up-windows-device-environment-create"></a>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**  <a name="windows-password-expiration-tip"></a>
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 de manière à ce 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. <a name="set-up-windows-device-psexec"></a>Téléchargez et installez l'[PsExecutilitaire](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) de Microsoft sur l'appareil. 

1. <a name="set-up-windows-device-credentials"></a>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.

## Fournir des AWS informations d'identification à l'appareil
<a name="provide-installer-aws-credentials"></a>

Fournissez vos AWS informations d'identification à votre appareil afin que le programme d'installation puisse fournir les AWS ressources nécessaires. Pour plus d’informations sur les autorisations requises, consultez [Politique IAM minimale permettant au programme d'installation de provisionner les ressources](provision-minimal-iam-policy.md).

**Pour fournir des AWS informations d'identification à l'appareil**
+ <a name="installer-export-aws-credentials"></a>Fournissez vos AWS informations d'identification à l'appareil afin que le programme d'installation puisse fournir les ressources AWS IoT et IAM pour votre appareil principal. Pour renforcer la sécurité, nous vous recommandons d'obtenir des informations d'identification temporaires pour un rôle IAM qui n'accorde que les autorisations minimales nécessaires au provisionnement. Pour de plus amples informations, veuillez consulter [Politique IAM minimale permettant au programme d'installation de provisionner les ressources](provision-minimal-iam-policy.md).
**Note**  
Le programme d'installation n'enregistre ni ne stocke vos informations d'identification.

  Sur votre appareil, effectuez l'une des opérations suivantes pour récupérer les informations d'identification et les mettre à la disposition du programme d'installation du logiciel AWS IoT Greengrass Core :
  + (Recommandé) Utilisez des informations d'identification temporaires provenant de AWS IAM Identity Center

    1. Fournissez l'ID de clé d'accès, la clé d'accès secrète et le jeton de session provenant du centre d'identité IAM. Pour plus d'informations, voir Actualisation **manuelle des informations d'identification dans la section Obtenir et actualiser** [des informations d'identification temporaires](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials) dans le guide de l'*utilisateur d'IAM Identity Center*.

    1. Exécutez les commandes suivantes pour fournir les informations d'identification au logiciel AWS IoT Greengrass Core.

------
#### [ Linux or Unix ]

       ```
       export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
       export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
       export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
       ```

------
#### [ Windows Command Prompt (CMD) ]

       ```
       set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
       set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
       set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
       ```

------
#### [ PowerShell ]

       ```
       $env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
       $env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
       $env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
       ```

------
  + Utilisez les informations d'identification de sécurité temporaires issues d'un rôle IAM :

    1. Fournissez l'ID de clé d'accès, la clé d'accès secrète et le jeton de session correspondant au rôle IAM que vous assumez. Pour plus d'informations sur la façon de récupérer ces informations d'identification, consultez la section [Demande d'informations d'identification de sécurité temporaires](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) dans le *guide de l'utilisateur IAM*.

    1. Exécutez les commandes suivantes pour fournir les informations d'identification au logiciel AWS IoT Greengrass Core.

------
#### [ Linux or Unix ]

       ```
       export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
       export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
       export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
       ```

------
#### [ Windows Command Prompt (CMD) ]

       ```
       set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
       set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
       set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
       ```

------
#### [ PowerShell ]

       ```
       $env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
       $env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
       $env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
       ```

------
  + Utilisez les informations d'identification à long terme d'un utilisateur IAM :

    1. Fournissez l'ID de clé d'accès et la clé d'accès secrète pour votre utilisateur IAM. Vous pouvez créer un utilisateur IAM pour le provisionnement, que vous supprimerez ultérieurement. Pour connaître la politique IAM à communiquer à l'utilisateur, consultez[Politique IAM minimale permettant au programme d'installation de provisionner les ressources](provision-minimal-iam-policy.md). Pour plus d'informations sur la façon de récupérer des informations d'identification à long terme, consultez [la section Gestion des clés d'accès pour les utilisateurs IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) dans le guide de l'*utilisateur IAM*.

    1. Exécutez les commandes suivantes pour fournir les informations d'identification au logiciel AWS IoT Greengrass Core.

------
#### [ Linux or Unix ]

       ```
       export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
       export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
       ```

------
#### [ Windows Command Prompt (CMD) ]

       ```
       set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
       set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
       ```

------
#### [ PowerShell ]

       ```
       $env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
       $env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
       ```

------

    1. (Facultatif) Si vous avez créé un utilisateur IAM pour approvisionner votre appareil Greengrass, supprimez-le.

    1. (Facultatif) Si vous avez utilisé l'ID de clé d'accès et la clé d'accès secrète d'un utilisateur IAM existant, mettez à jour les clés de cet utilisateur afin qu'elles ne soient plus valides. Pour plus d'informations, consultez la section [Mise à jour des clés d'accès](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey) dans le *guide de Gestion des identités et des accès AWS l'utilisateur*.

## Téléchargez le logiciel AWS IoT Greengrass de base
<a name="download-greengrass-core-v2"></a>

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. <a name="installation-download-ggc-software-step"></a>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
   ```

------

   <a name="core-software-license"></a>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. <a name="verify-gg-nucleus-signature"></a>(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. <a name="installation-unzip-ggc-software-step"></a>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**  <a name="installer-folder-2.4.0-warning"></a>
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 de base
<a name="run-greengrass-core-v2-installer"></a>

Exécutez le programme d'installation avec des arguments spécifiant les actions suivantes :
+ <a name="install-argument-aws-resources"></a>Créez les AWS ressources dont le périphérique principal a besoin pour fonctionner.
+ <a name="install-argument-component-default-user"></a>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.
+ <a name="install-argument-system-service"></a>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**  <a name="windows-system-service-requirement-important-note"></a>
Sur les appareils Windows Core, vous devez configurer le logiciel AWS IoT Greengrass Core en tant que service système.

Pour configurer un dispositif de développement avec des outils de développement locaux, spécifiez l'`--deploy-dev-tools true`argument. Le déploiement des outils de développement local peut prendre jusqu'à une minute une fois l'installation terminée. 

Pour plus d'informations sur les arguments que vous pouvez spécifier, consultez[Arguments d'installation](configure-installer.md).

**Note**  
<a name="jvm-tuning-note"></a>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. Exécutez le programme d'installation AWS IoT Greengrass Core. Remplacez les valeurs des arguments dans votre commande comme suit.
**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.<a name="installer-replace-arguments"></a>

   1. `/greengrass/v2`ou *C:\$1greengrass\$1v2* : chemin d'accès au dossier racine à utiliser pour installer le logiciel AWS IoT Greengrass Core.

   1. *GreengrassInstaller*. Le chemin d'accès au dossier dans lequel vous avez décompressé le programme d'installation du logiciel AWS IoT Greengrass Core.

   1. *region*. L' Région AWS endroit dans lequel trouver ou créer des ressources.

   1. *MyGreengrassCore*. Le nom de l' AWS IoT appareil principal de votre Greengrass. Si l'objet n'existe pas, le programme d'installation le crée. Le programme d'installation télécharge les certificats pour s'authentifier en tant qu' AWS IoT objet. Pour de plus amples informations, veuillez consulter [Authentification et autorisation de l'appareil pour AWS IoT Greengrass](device-auth.md).
**Note**  <a name="install-argument-thing-name-constraint"></a>
Le nom de l'objet ne peut pas contenir de caractères deux-points (`:`).

   1. *MyGreengrassCoreGroup*. Le nom du AWS IoT groupe d'objets de votre appareil Greengrass principal. Si le groupe d'objets n'existe pas, le programme d'installation le crée et y ajoute l'objet. Si le groupe d'objets existe et fait l'objet d'un déploiement actif, le périphérique principal télécharge et exécute le logiciel spécifié par le déploiement.
**Note**  <a name="install-argument-thing-group-name-constraint"></a>
Le nom du groupe d'objets ne peut pas contenir de deux-points (`:`).

   1. *GreengrassV2IoTThingPolicy*. Le nom de la AWS IoT politique qui permet aux appareils principaux de Greengrass de communiquer avec AWS IoT et. AWS IoT Greengrass Si la AWS IoT politique n'existe pas, le programme d'installation crée une AWS IoT politique permissive portant ce nom. Vous pouvez restreindre les autorisations de cette politique pour 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).

   1. *GreengrassV2TokenExchangeRole*. Nom du rôle IAM qui permet au périphérique principal de Greengrass d'obtenir AWS des informations d'identification temporaires. Si le rôle n'existe pas, le programme d'installation le crée, puis crée et attache une politique nommée`GreengrassV2TokenExchangeRoleAccess`. Pour de plus amples informations, veuillez consulter [Autoriser les appareils principaux à interagir avec les AWS services](device-service-role.md).

   1. *GreengrassCoreTokenExchangeRoleAlias*. Alias du rôle IAM qui permet au périphérique principal de Greengrass d'obtenir des informations d'identification temporaires ultérieurement. Si l'alias de rôle n'existe pas, le programme d'installation le crée et le pointe vers le rôle IAM que vous spécifiez. Pour de plus amples informations, veuillez consulter [Autoriser les appareils principaux à interagir avec les AWS services](device-service-role.md).

------
#### [ Linux or Unix ]

   ```
   sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
     -jar ./GreengrassInstaller/lib/Greengrass.jar \
     --aws-region region \
     --thing-name MyGreengrassCore \
     --thing-group-name MyGreengrassCoreGroup \
     --thing-policy-name GreengrassV2IoTThingPolicy \
     --tes-role-name GreengrassV2TokenExchangeRole \
     --tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias \
     --component-default-user ggc_user:ggc_group \
     --provision true \
     --setup-system-service true
   ```

------
#### [ Windows Command Prompt (CMD) ]

   ```
   java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
     -jar ./GreengrassInstaller/lib/Greengrass.jar ^
     --aws-region region ^
     --thing-name MyGreengrassCore ^
     --thing-group-name MyGreengrassCoreGroup ^
     --thing-policy-name GreengrassV2IoTThingPolicy ^
     --tes-role-name GreengrassV2TokenExchangeRole ^
     --tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias ^
     --component-default-user ggc_user ^
     --provision true ^
     --setup-system-service true
   ```

------
#### [ PowerShell ]

   ```
   java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
     -jar ./GreengrassInstaller/lib/Greengrass.jar `
     --aws-region region `
     --thing-name MyGreengrassCore `
     --thing-group-name MyGreengrassCoreGroup `
     --thing-policy-name GreengrassV2IoTThingPolicy `
     --tes-role-name GreengrassV2TokenExchangeRole `
     --tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias `
     --component-default-user ggc_user `
     --provision true `
     --setup-system-service true
   ```

------
**Important**  <a name="windows-system-service-installer-argument-important-note"></a>
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.

   Le programme d'installation affiche les messages suivants en cas de succès :
   + Si vous le spécifiez`--provision`, le programme d'installation imprime `Successfully configured Nucleus with provisioned resource details` s'il a correctement configuré les ressources.
   + Si vous le spécifiez`--deploy-dev-tools`, le programme d'installation affiche `Configured Nucleus to deploy aws.greengrass.Cli component` s'il a créé le déploiement avec succès.
   + 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.
   + Si vous ne le spécifiez pas`--setup-system-service true`, le programme d'installation affiche `Launched Nucleus successfully` s'il a réussi et a exécuté le logiciel.

1. Ignorez cette étape si vous avez installé la [Noyau de Greengrass](greengrass-nucleus-component.md) version 2.0.4 ou une version ultérieure. Si vous avez téléchargé la dernière version du logiciel, vous avez installé la version 2.0.4 ou ultérieure.

   Exécutez la commande suivante pour définir les autorisations de fichier requises pour le dossier racine de votre logiciel AWS IoT Greengrass Core. Remplacez-le `/greengrass/v2` par le dossier racine que vous avez spécifié dans votre commande d'installation et remplacez-le */greengrass* par le dossier parent de votre dossier racine.

   ```
   sudo chmod 755 /greengrass/v2 && sudo chmod 755 /greengrass
   ```

<a name="install-greengrass-core-run-software"></a>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).

**Note**  
Par défaut, le rôle IAM créé par le programme d'installation 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.

**Note**  <a name="install-greengrass-core-recognized-note"></a>
<a name="install-greengrass-core-recognized-para"></a>Lorsque le logiciel AWS IoT Greengrass Core se connecte au cloud, votre appareil est reconnu comme un appareil Core.

<a name="install-greengrass-core-next-steps-intro"></a>Pour plus d'informations sur la configuration et l'utilisation du logiciel AWS IoT Greengrass, consultez les rubriques suivantes :<a name="install-greengrass-core-next-steps-links"></a>
+ [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)

# Installation AWS IoT Greengrass du logiciel Core avec provisionnement manuel des ressources
<a name="manual-installation"></a>

Le logiciel AWS IoT Greengrass Core inclut un programme d'installation qui configure votre appareil en tant qu'appareil principal Greengrass. Pour configurer un appareil manuellement, vous pouvez créer les ressources requises AWS IoT et les ressources IAM que l'appareil doit utiliser. Si vous créez ces ressources manuellement, il n'est pas nécessaire de fournir des AWS informations d'identification au programme d'installation.

Lorsque vous installez manuellement le logiciel AWS IoT Greengrass Core, vous pouvez également configurer le périphérique pour qu'il utilise un proxy réseau ou qu'il se connecte AWS au port 443. Vous devrez peut-être spécifier ces options de configuration si votre appareil fonctionne derrière un pare-feu ou un proxy réseau, par exemple. Pour de plus amples informations, veuillez consulter [Connexion au port 443 ou via un proxy réseau](configure-greengrass-core-v2.md#configure-alpn-network-proxy).

Vous pouvez également configurer le logiciel AWS IoT Greengrass Core pour utiliser un module de sécurité matériel (HSM) via l'interface [PKCS \$111](https://en.wikipedia.org/wiki/PKCS_11). Cette fonctionnalité vous permet de stocker en toute sécurité les fichiers de clés privées et de certificats afin qu'ils ne soient pas exposés ou dupliqués dans le logiciel. Vous pouvez stocker des clés privées et des certificats sur un module matériel tel qu'un HSM, un module TPM (Trusted Platform Module) ou un autre élément cryptographique. Cette fonctionnalité n'est disponible que sur les appareils Linux. Pour plus d'informations sur la sécurité matérielle et les conditions requises pour l'utiliser, consultez[Intégration de sécurité matérielle](hardware-security.md).

**Important**  <a name="install-greengrass-core-requirements-note"></a>
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**
+ [Récupérer des points de AWS IoT terminaison](#retrieve-iot-endpoints)
+ [Créez n'importe AWS IoT quoi](#create-iot-thing)
+ [Créez le certificat d'objet](#create-thing-certificate)
+ [Configurer le certificat d'objet](#configure-thing-certificate)
+ [Création d'un rôle d'échange de jetons](#create-token-exchange-role)
+ [Télécharger les certificats sur l'appareil](#download-thing-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)
+ [Installation du logiciel AWS IoT Greengrass Core](#run-greengrass-core-v2-installer-manual)

## Récupérer des points de AWS IoT terminaison
<a name="retrieve-iot-endpoints"></a>

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

## Créez n'importe AWS IoT quoi
<a name="create-iot-thing"></a>

AWS IoT *les objets* représentent les appareils et les entités logiques auxquels ils se connectent AWS IoT. Les appareils Greengrass Core sont AWS IoT des objets. Lorsque vous enregistrez un appareil en tant qu' AWS IoT objet, celui-ci peut utiliser un certificat numérique pour s'authentifier. AWS

Dans cette section, vous allez créer un AWS IoT objet qui représente votre appareil.

**Pour créer AWS IoT quelque chose**

1. Créez n'importe AWS IoT quel objet pour votre appareil. Sur votre ordinateur de développement, exécutez la commande suivante.
   + Remplacez *MyGreengrassCore* par le nom de l'objet à utiliser. Ce nom est également le nom de votre appareil principal Greengrass.
**Note**  <a name="install-argument-thing-name-constraint"></a>
Le nom de l'objet ne peut pas contenir de caractères deux-points (`:`).

   ```
   aws iot create-thing --thing-name MyGreengrassCore
   ```

   La réponse ressemble à l'exemple suivant, si la demande aboutit.

   ```
   {
     "thingName": "MyGreengrassCore",
     "thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
     "thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
   }
   ```

1. (Facultatif) Ajoutez l' AWS IoT objet à un nouveau groupe d'objets ou à un groupe d'objets existant. Vous utilisez des groupes d'objets pour gérer des flottes d'appareils principaux de Greengrass. Lorsque vous déployez des composants logiciels sur vos appareils, vous pouvez cibler des appareils individuels ou des groupes d'appareils. Vous pouvez ajouter un appareil à un groupe d'objets avec un déploiement Greengrass actif pour déployer les composants logiciels de ce groupe d'objets sur l'appareil. Procédez comme suit :

   1. (Facultatif) Créez un AWS IoT groupe d'objets.
      + Remplacez *MyGreengrassCoreGroup* par le nom du groupe d'objets à créer.
**Note**  <a name="install-argument-thing-group-name-constraint"></a>
Le nom du groupe d'objets ne peut pas contenir de deux-points (`:`).

      ```
      aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
      ```

      La réponse ressemble à l'exemple suivant, si la demande aboutit.

      ```
      {
        "thingGroupName": "MyGreengrassCoreGroup",
        "thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
        "thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
      }
      ```

   1. Ajoutez l' AWS IoT objet à un groupe d'objets.
      + Remplacez *MyGreengrassCore* par le nom de votre AWS IoT objet.
      + Remplacez *MyGreengrassCoreGroup* par le nom du groupe d'objets.

      ```
      aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
      ```

      La commande n'a aucune sortie si la demande aboutit.

## Créez le certificat d'objet
<a name="create-thing-certificate"></a>

<a name="create-thing-certificate-intro-1"></a>Lorsque vous enregistrez un appareil en tant qu' AWS IoT objet, celui-ci peut utiliser un certificat numérique pour s'authentifier. AWS Ce certificat permet à l'appareil de communiquer avec AWS IoT et AWS IoT Greengrass.

<a name="create-thing-certificate-intro-2"></a>Dans cette section, vous allez créer et télécharger des certificats que votre appareil peut utiliser pour se connecter AWS.

<a name="create-thing-certificate-intro-3"></a>Si vous souhaitez configurer le logiciel AWS IoT Greengrass Core pour utiliser un module de sécurité matériel (HSM) pour stocker en toute sécurité la clé privée et le certificat, suivez les étapes pour créer le certificat à partir d'une clé privée dans un HSM. Sinon, suivez les étapes pour créer le certificat et la clé privée dans le AWS IoT service. La fonctionnalité de sécurité matérielle n'est disponible que sur les appareils Linux. Pour plus d'informations sur la sécurité matérielle et les conditions requises pour l'utiliser, consultez[Intégration de sécurité matérielle](hardware-security.md).

### Créez le certificat et la clé privée dans le AWS IoT service
<a name="create-thing-certificate-cloud"></a><a name="create-thing-certificate-cloud-steps"></a>

**Pour créer le certificat d'objet**

1. Créez un dossier dans lequel vous téléchargerez les certificats de l' AWS IoT objet.

   ```
   mkdir greengrass-v2-certs
   ```

1. Créez et téléchargez les certificats AWS IoT correspondants.

   ```
   aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
   ```

   La réponse ressemble à l'exemple suivant, si la demande aboutit.

   ```
   {
     "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
     "certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
     "certificatePem": "-----BEGIN CERTIFICATE-----
   MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
    0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
    WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
    EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
    jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
    MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
    WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
    HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
    BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
    k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
    ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
    AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
    KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
    EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
    3rrszlaEXAMPLE=
   -----END CERTIFICATE-----",
     "keyPair": {
       "PublicKey": "-----BEGIN PUBLIC KEY-----\
   MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
   MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
   59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
   hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
   FQIDAQAB\
   -----END PUBLIC KEY-----\
   ",
       "PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
   key omitted for security reasons\
   -----END RSA PRIVATE KEY-----\
   "
     }
   }
   ```

   Enregistrez le nom de ressource Amazon (ARN) du certificat afin de l'utiliser pour configurer le certificat ultérieurement.

### Créez le certificat à partir d'une clé privée dans un HSM
<a name="create-thing-certificate-hardware-security"></a>

**Note**  
Cette fonctionnalité est disponible pour les versions 2.5.3 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. AWS IoT Greengrass ne prend actuellement pas en charge cette fonctionnalité sur les appareils Windows principaux. 

**Pour créer le certificat d'objet**

1. Sur le périphérique principal, initialisez un jeton PKCS \$111 dans le HSM et générez une clé privée. La clé privée doit être une clé RSA de taille RSA-2048 (ou supérieure) ou une clé ECC.
**Note**  <a name="hardware-security-module-requirements-key-notes"></a>
Pour utiliser un module de sécurité matériel avec des clés ECC, vous devez utiliser [Greengrass](greengrass-nucleus-component.md) nucleus v2.5.6 ou version ultérieure.  
Pour utiliser un module de sécurité matériel et un [gestionnaire de secrets](secret-manager-component.md), vous devez utiliser un module de sécurité matériel avec des clés RSA.

   Consultez la documentation de votre HSM pour savoir comment initialiser le jeton et générer la clé privée. Si votre HSM prend en charge l'objet IDs, spécifiez un ID d'objet lorsque vous générez la clé privée. Enregistrez l'ID d'emplacement, le code PIN utilisateur, le libellé de l'objet, l'ID d'objet (si votre HSM en utilise un) que vous spécifiez lorsque vous initialisez le jeton et générez la clé privée. Vous utiliserez ces valeurs ultérieurement lorsque vous importez le certificat d'objet dans le HSM et que vous configurez le logiciel AWS IoT Greengrass principal.

1. Créez une demande de signature de certificat (CSR) à partir de la clé privée. AWS IoT utilise ce CSR pour créer un certificat d'objet pour la clé privée que vous avez générée dans le HSM. Pour plus d'informations sur la création d'un CSR à partir de la clé privée, consultez la documentation de votre HSM. Le CSR est un fichier, tel que`iotdevicekey.csr`.

1. Copiez le CSR de l'appareil vers votre ordinateur de développement. Si SSH et SCP sont activés sur l'ordinateur de développement et le périphérique, vous pouvez utiliser la `scp` commande de votre ordinateur de développement pour transférer le CSR. Remplacez *device-ip-address* par l'adresse IP de votre appareil, puis *\$1/iotdevicekey.csr* par le chemin d'accès au fichier CSR sur l'appareil.

   ```
   scp device-ip-address:~/iotdevicekey.csr iotdevicekey.csr
   ```

1. Sur votre ordinateur de développement, créez un dossier dans lequel vous téléchargerez le certificat AWS IoT correspondant.

   ```
   mkdir greengrass-v2-certs
   ```

1. Utilisez le fichier CSR pour créer et télécharger le certificat correspondant à l' AWS IoT objet sur votre ordinateur de développement.

   ```
   aws iot create-certificate-from-csr --set-as-active --certificate-signing-request=file://iotdevicekey.csr --certificate-pem-outfile greengrass-v2-certs/device.pem.crt
   ```

   La réponse ressemble à l'exemple suivant, si la demande aboutit.

   ```
   {
     "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
     "certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
     "certificatePem": "-----BEGIN CERTIFICATE-----
   MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
    0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
    WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
    EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
    jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
    MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
    WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
    HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
    BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
    k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
    ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
    AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
    KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
    EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
    3rrszlaEXAMPLE=
   -----END CERTIFICATE-----"
   }
   ```

   Enregistrez l'ARN du certificat afin de l'utiliser pour le configurer ultérieurement.

## Configurer le certificat d'objet
<a name="configure-thing-certificate"></a>

Attachez le certificat d' AWS IoT objet à l'objet que vous avez créé précédemment et ajoutez une AWS IoT politique au certificat afin de définir les AWS IoT autorisations pour le périphérique principal.

**Pour configurer le certificat de l'objet**

1. Joignez le certificat à l' AWS IoT objet.
   + Remplacez *MyGreengrassCore* par le nom de votre AWS IoT objet.
   + Remplacez le certificat Amazon Resource Name (ARN) par l'ARN du certificat que vous avez créé à l'étape précédente.

   ```
   aws iot attach-thing-principal --thing-name MyGreengrassCore --principal arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
   ```

   La commande n'a aucune sortie si la demande aboutit.

1. Créez et joignez une AWS IoT politique qui définit les AWS IoT autorisations pour votre appareil principal 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. 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).

   Si vous avez déjà configuré un appareil principal Greengrass, vous pouvez joindre sa AWS IoT politique au lieu d'en créer une nouvelle.

   Procédez comme suit :

   1. Créez un fichier contenant le document de AWS IoT politique dont les appareils principaux de Greengrass ont besoin.

      <a name="nano-command-intro"></a>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.

      ```
      {
        "Version": "2012-10-17",		 	 	 
        "Statement": [
          {
            "Effect": "Allow",
            "Action": [
              "iot:Publish",
              "iot:Subscribe",
              "iot:Receive",
              "iot:Connect",
              "greengrass:*"
            ],
            "Resource": [
              "*"
            ]
          }
        ]
      }
      ```

   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.

      ```
      {
        "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\\": [
                \\"*\\"
              ]
            }
          ]
        }",
        "policyVersionId": "1"
      }
      ```

   1. Joignez la AWS IoT politique au certificat de l' AWS IoT objet.
      + Remplacez *GreengrassV2IoTThingPolicy* par le nom de la politique à joindre.
      + Remplacez l'ARN cible par l'ARN du certificat associé à votre AWS IoT objet.

      ```
      aws iot attach-policy --policy-name GreengrassV2IoTThingPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
      ```

      La commande n'a aucune sortie si la demande aboutit.

## Création d'un rôle d'échange de jetons
<a name="create-token-exchange-role"></a>

<a name="installation-create-token-exchange-role-intro"></a>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).

<a name="installation-create-token-exchange-role-alias-intro"></a>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 de l'appareil. 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. Ensuite, vous configurez l'appareil pour AWS IoT qu'il utilise ce rôle et cet alias.

**Pour créer un rôle IAM d'échange de jetons**

1. <a name="create-token-exchange-role-create-iam-role"></a>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.

      <a name="nano-command-intro"></a>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.

      <a name="nano-command-intro"></a>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. <a name="create-token-exchange-role-create-iot-role-alias"></a>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*.

1. Créez et attachez une AWS IoT politique qui permet à votre appareil principal Greengrass d'utiliser l'alias de rôle pour assumer le rôle d'échange de jetons. Si vous avez déjà configuré un appareil principal Greengrass, vous pouvez associer sa AWS IoT politique d'alias de rôle au lieu d'en créer une nouvelle. Procédez comme suit :

   1. (Facultatif) Créez un fichier contenant le document AWS IoT de politique requis par l'alias de rôle.

      <a name="nano-command-intro"></a>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-role-alias-policy.json
      ```

      Copiez le code JSON suivant dans le fichier.
      + Remplacez l'ARN de la ressource par l'ARN de votre alias de rôle.

      ```
      {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
          {
            "Effect": "Allow",
            "Action": "iot:AssumeRoleWithCertificate",
            "Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
          }
        ]
      }
      ```

   1. Créez une AWS IoT politique à partir du document de stratégie.
      + Remplacez *GreengrassCoreTokenExchangeRoleAliasPolicy* par le nom de la AWS IoT politique à créer.

      ```
      aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
      ```

      La réponse ressemble à l'exemple suivant, si la demande aboutit.

      ```
      {
        "policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
        "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
        "policyDocument": "{
          \\"Version\\":\\"2012-10-17		 	 	 \\",
          \\"Statement\\": [
            {
              \\"Effect\\": \\"Allow\\",
              \\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
              \\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
            }
          ]
        }",
        "policyVersionId": "1"
      }
      ```

   1. Joignez la AWS IoT politique au certificat de l' AWS IoT objet.
      + Remplacez *GreengrassCoreTokenExchangeRoleAliasPolicy* par le nom de la AWS IoT politique d'alias de rôle.
      + Remplacez l'ARN cible par l'ARN du certificat associé à votre AWS IoT objet.

      ```
      aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
      ```

      La commande n'a aucune sortie si la demande aboutit.

## Télécharger les certificats sur l'appareil
<a name="download-thing-certificates"></a>

Auparavant, vous avez téléchargé le certificat de votre appareil sur votre ordinateur de développement. Dans cette section, vous allez copier le certificat sur votre appareil principal pour configurer celui-ci avec les certificats auxquels il se connecte AWS IoT. Vous téléchargez également le certificat de l'autorité de certification racine (CA) Amazon. Si vous utilisez un HSM, vous importez également le fichier de certificat dans le HSM dans cette section.
+ Si vous avez créé le certificat d'objet et la clé privée dans le AWS IoT service précédemment, suivez les étapes pour télécharger les certificats avec la clé privée et les fichiers de certificat.
+ Si vous avez créé le certificat d'objet à partir d'une clé privée dans un module de sécurité matériel (HSM) plus tôt, suivez les étapes pour télécharger les certificats avec la clé privée et le certificat dans un HSM.

### Télécharger des certificats avec clé privée et fichiers de certificats
<a name="download-thing-certificates-without-hardware-security"></a>

**Pour télécharger des certificats sur l'appareil**

1. <a name="installation-copy-thing-certificate-to-device"></a>Copiez le certificat d' AWS IoT objet de votre ordinateur de développement 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 de votre ordinateur de développement pour transférer le certificat. Remplacez *device-ip-address* par l'adresse IP de votre appareil.

   ```
   scp -r greengrass-v2-certs/ device-ip-address:~
   ```

1. <a name="installation-create-greengrass-root-folder"></a>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. <a name="installation-set-greengrass-root-folder-permissions"></a>(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. Copiez les AWS IoT certificats d'objets dans le dossier racine de Greengrass.

------
#### [ Linux or Unix ]
   + `/greengrass/v2`Remplacez-le par le dossier racine de Greengrass.

   ```
   sudo cp -R ~/greengrass-v2-certs/* /greengrass/v2
   ```

------
#### [ Windows Command Prompt ]
   + *C:\$1greengrass\$1v2*Remplacez-le par le dossier à utiliser.

   ```
   robocopy %USERPROFILE%\greengrass-v2-certs C:\greengrass\v2 /E
   ```

------
#### [ PowerShell ]
   + *C:\$1greengrass\$1v2*Remplacez-le par le dossier à utiliser.

   ```
   cp -Path ~\greengrass-v2-certs\* -Destination C:\greengrass\v2
   ```

------

1. <a name="installation-download-root-ca-certificate"></a>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
   ```

------

### Téléchargez les certificats avec la clé privée et le certificat dans un HSM
<a name="download-thing-certificates-with-hardware-security"></a>

**Note**  
Cette fonctionnalité est disponible pour les versions 2.5.3 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. AWS IoT Greengrass ne prend actuellement pas en charge cette fonctionnalité sur les appareils Windows principaux. 

**Pour télécharger des certificats sur l'appareil**

1. <a name="installation-copy-thing-certificate-to-device"></a>Copiez le certificat d' AWS IoT objet de votre ordinateur de développement 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 de votre ordinateur de développement pour transférer le certificat. Remplacez *device-ip-address* par l'adresse IP de votre appareil.

   ```
   scp -r greengrass-v2-certs/ device-ip-address:~
   ```

1. <a name="installation-create-greengrass-root-folder"></a>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. <a name="installation-set-greengrass-root-folder-permissions"></a>(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. Importez le fichier de certificat d'`~/greengrass-v2-certs/device.pem.crt`objet dans le HSM. Consultez la documentation de votre HSM pour savoir comment y importer des certificats. Importez le certificat en utilisant le jeton, l'ID de slot, le code PIN utilisateur, le même libellé d'objet et le même ID d'objet (si votre HSM en utilise un) où vous avez généré la clé privée dans le HSM précédemment.
**Note**  
Si vous avez généré la clé privée plus tôt sans ID d'objet et que le certificat possède un ID d'objet, définissez l'ID d'objet de la clé privée sur la même valeur que le certificat. Consultez la documentation de votre HSM pour savoir comment définir l'ID d'objet pour l'objet clé privée.

1. (Facultatif) Supprimez le fichier de certificat d'objet afin qu'il n'existe que dans le HSM.

   ```
   rm ~/greengrass-v2-certs/device.pem.crt
   ```

1. <a name="installation-download-root-ca-certificate"></a>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
<a name="set-up-device-environment"></a>

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
<a name="set-up-linux-device-environment"></a><a name="set-up-linux-device-environment-procedure"></a>

**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
<a name="set-up-windows-device-environment"></a>

**Note**  
Cette fonctionnalité est disponible pour les versions 2.5.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.<a name="set-up-windows-device-environment-procedure"></a>

**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. <a name="set-up-windows-device-environment-open-cmd"></a>Ouvrez l'invite de commande Windows (`cmd.exe`) en tant qu'administrateur.

1. <a name="set-up-windows-device-environment-create"></a>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**  <a name="windows-password-expiration-tip"></a>
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. <a name="set-up-windows-device-psexec"></a>Téléchargez et installez l'[PsExecutilitaire](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) de Microsoft sur l'appareil. 

1. <a name="set-up-windows-device-credentials"></a>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
<a name="download-greengrass-core-v2"></a>

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. <a name="installation-download-ggc-software-step"></a>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
   ```

------

   <a name="core-software-license"></a>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. <a name="verify-gg-nucleus-signature"></a>(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. <a name="installation-unzip-ggc-software-step"></a>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**  <a name="installer-folder-2.4.0-warning"></a>
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
<a name="run-greengrass-core-v2-installer-manual"></a>

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 les AWS ressources et les certificats que vous avez créés précédemment. 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.
+ <a name="install-argument-component-default-user"></a>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.
+ <a name="install-argument-system-service"></a>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**  <a name="windows-system-service-requirement-important-note"></a>
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**  
<a name="jvm-tuning-note"></a>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).
+ Si vous avez créé le certificat d'objet et la clé privée dans le AWS IoT service précédemment, suivez les étapes pour installer le logiciel AWS IoT Greengrass Core avec les fichiers de clé privée et de certificat.
+ Si vous avez créé le certificat d'objet à partir d'une clé privée dans un module de sécurité matériel (HSM) plus tôt, suivez les étapes pour installer le logiciel AWS IoT Greengrass Core avec la clé privée et le certificat dans un HSM.

### Installez le logiciel AWS IoT Greengrass Core avec les fichiers de clé privée et de certificat
<a name="manual-installation-without-hardware-security"></a>

**Pour installer le logiciel AWS IoT Greengrass Core**

1. <a name="installer-check-greengrass-core-software-version"></a>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.

   <a name="nano-command-intro"></a>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 système et les paramètres du noyau de Greengrass.

   ```
   ---
   system:
     certificateFilePath: "/greengrass/v2/device.pem.crt"
     privateKeyPath: "/greengrass/v2/private.pem.key"
     rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
     rootpath: "/greengrass/v2"
     thingName: "MyGreengrassCore"
   services:
     aws.greengrass.Nucleus:
       componentType: "NUCLEUS"
       version: "2.16.1"
       configuration:
         awsRegion: "us-west-2"
         iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
         iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
         iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
   ```

   Ensuite, procédez comme suit :
   + Remplacez chaque instance de `/greengrass/v2` par le dossier racine de Greengrass.
   + Remplacez *MyGreengrassCore* par le nom de l' AWS IoT objet.
   + *2.16.1*Remplacez-le par la version du logiciel AWS IoT Greengrass Core.
   + Remplacez *us-west-2* par l' Région AWS endroit où vous avez créé les ressources.
   + Remplacez *GreengrassCoreTokenExchangeRoleAlias* par le nom de l'alias du rôle d'échange de jetons.
   + Remplacez le `iotDataEndpoint` par votre point de terminaison de AWS IoT données.
   + Remplacez le point de terminaison `iotCredEndpoint` par vos AWS IoT informations d'identification.
**Note**  
Dans ce fichier de configuration, vous pouvez personnaliser d'autres options de configuration du noyau, 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:
     certificateFilePath: "/greengrass/v2/device.pem.crt"
     privateKeyPath: "/greengrass/v2/private.pem.key"
     rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
     rootpath: "/greengrass/v2"
     thingName: "MyGreengrassCore"
   services:
     aws.greengrass.Nucleus:
       componentType: "NUCLEUS"
       version: "2.16.1"
       configuration:
         awsRegion: "us-west-2"
         iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
         iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
         iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
         mqtt:
           port: 443
         greengrassDataPlanePort: 443
         networkProxy:
           noProxyAddresses: "http://192.168.0.1,www.example.com"
           proxy:
             url: "https://my-proxy-server:1100"
             username: "Mary_Major"
             password: "pass@word1357"
   ```

1. Exécutez le programme d'installation et spécifiez `--init-config` de fournir le fichier de configuration.
   + 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.

------
#### [ Linux or Unix ]

   ```
   sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
     -jar ./GreengrassInstaller/lib/Greengrass.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 ^
     --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 `
     --init-config ./GreengrassInstaller/config.yaml `
     --component-default-user ggc_user `
     --setup-system-service true
   ```

------
**Important**  <a name="windows-system-service-installer-argument-important-note"></a>
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.

   <a name="installer-setup-system-service-output-message"></a>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**  <a name="installer-deploy-dev-tools-without-provision"></a>
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. <a name="installer-verify-installation"></a>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`.

### Installez le logiciel AWS IoT Greengrass principal avec la clé privée et le certificat dans un HSM
<a name="manual-installation-with-hardware-security"></a>

**Note**  
Cette fonctionnalité est disponible pour les versions 2.5.3 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. AWS IoT Greengrass ne prend actuellement pas en charge cette fonctionnalité sur les appareils Windows principaux. 

**Pour installer le logiciel AWS IoT Greengrass Core**

1. <a name="installer-check-greengrass-core-software-version"></a>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. Pour permettre au logiciel AWS IoT Greengrass Core d'utiliser la clé privée et le certificat du HSM, installez le [composant fournisseur PKCS \$111](pkcs11-provider-component.md) lors de l'installation du logiciel AWS IoT Greengrass Core. Le composant fournisseur PKCS \$111 est un plugin que vous pouvez configurer lors de l'installation. Vous pouvez télécharger la dernière version du composant fournisseur PKCS \$111 depuis l'emplacement suivant :
   + [https://d2s8p88vqu9w66.cloudfront. net/releases/Pkcs11Provider/aws.greengrass.crypto.pkcs11Provider-Latest.jar](https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar)

   Téléchargez le plugin du fournisseur PKCS \$111 dans un fichier nommé`aws.greengrass.crypto.Pkcs11Provider.jar`. *GreengrassInstaller*Remplacez-le par le dossier que vous souhaitez utiliser.

   ```
   curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar > GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar
   ```

   <a name="core-software-license"></a>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. Utilisez un éditeur de texte pour créer un fichier de configuration nommé `config.yaml` à fournir au programme d'installation.

   <a name="nano-command-intro"></a>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 système, les paramètres du noyau Greengrass et les paramètres du fournisseur PKCS \$111.

   ```
   ---
   system:
     certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
     privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
     rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
     rootpath: "/greengrass/v2"
     thingName: "MyGreengrassCore"
   services:
     aws.greengrass.Nucleus:
       componentType: "NUCLEUS"
       version: "2.16.1"
       configuration:
         awsRegion: "us-west-2"
         iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
         iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
         iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
     aws.greengrass.crypto.Pkcs11Provider:
       configuration:
         name: "softhsm_pkcs11"
         library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
         slot: 1
         userPin: "1234"
   ```

   Ensuite, procédez comme suit :
   + Remplacez chaque instance du PKCS \$111 par le libellé URIs de l'objet *iotdevicekey* dans lequel vous avez créé la clé privée et importé le certificat.
   + Remplacez chaque instance de `/greengrass/v2` par le dossier racine de Greengrass.
   + Remplacez *MyGreengrassCore* par le nom de l' AWS IoT objet.
   + *2.16.1*Remplacez-le par la version du logiciel AWS IoT Greengrass Core.
   + Remplacez *us-west-2* par l' Région AWS endroit où vous avez créé les ressources.
   + Remplacez *GreengrassCoreTokenExchangeRoleAlias* par le nom de l'alias du rôle d'échange de jetons.
   + Remplacez le `iotDataEndpoint` par votre point de terminaison de AWS IoT données.
   + Remplacez le point de terminaison `iotCredEndpoint` par vos AWS IoT informations d'identification.
   + Remplacez les paramètres de configuration du `aws.greengrass.crypto.Pkcs11Provider` composant par les valeurs de la configuration HSM sur le périphérique principal.
**Note**  
Dans ce fichier de configuration, vous pouvez personnaliser d'autres options de configuration du noyau, 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:
     certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
     privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
     rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
     rootpath: "/greengrass/v2"
     thingName: "MyGreengrassCore"
   services:
     aws.greengrass.Nucleus:
       componentType: "NUCLEUS"
       version: "2.16.1"
       configuration:
         awsRegion: "us-west-2"
         iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
         iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
         iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
         mqtt:
           port: 443
         greengrassDataPlanePort: 443
         networkProxy:
           noProxyAddresses: "http://192.168.0.1,www.example.com"
           proxy:
             url: "https://my-proxy-server:1100"
             username: "Mary_Major"
             password: "pass@word1357"
     aws.greengrass.crypto.Pkcs11Provider:
       configuration:
         name: "softhsm_pkcs11"
         library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
         slot: 1
         userPin: "1234"
   ```

1. Exécutez le programme d'installation et spécifiez `--init-config` de 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.

   ```
   sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
     -jar ./GreengrassInstaller/lib/Greengrass.jar \
     --trusted-plugin ./GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar \
     --init-config ./GreengrassInstaller/config.yaml \
     --component-default-user ggc_user:ggc_group \
     --setup-system-service true
   ```
**Important**  <a name="windows-system-service-installer-argument-important-note"></a>
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.

   <a name="installer-setup-system-service-output-message"></a>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**  <a name="installer-deploy-dev-tools-without-provision"></a>
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. <a name="installer-verify-installation"></a>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`.

<a name="install-greengrass-core-run-software"></a>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).

**Note**  <a name="install-greengrass-core-recognized-note"></a>
<a name="install-greengrass-core-recognized-para"></a>Lorsque le logiciel AWS IoT Greengrass Core se connecte au cloud, votre appareil est reconnu comme un appareil Core.

<a name="install-greengrass-core-next-steps-intro"></a>Pour plus d'informations sur la configuration et l'utilisation du logiciel AWS IoT Greengrass, consultez les rubriques suivantes :<a name="install-greengrass-core-next-steps-links"></a>
+ [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)

# Installation AWS IoT Greengrass du logiciel de base avec provisionnement du AWS IoT parc
<a name="fleet-provisioning"></a>

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**  <a name="install-greengrass-core-requirements-note"></a>
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
<a name="fleet-provisioning-prerequisites"></a>

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
<a name="retrieve-iot-endpoints"></a>

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
<a name="download-claim-certificates"></a>

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**  <a name="installation-fleet-provisioning-secure-claim-private-keys"></a>
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. <a name="installation-create-greengrass-root-folder"></a>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. <a name="installation-set-greengrass-root-folder-permissions"></a>(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. <a name="installation-download-root-ca-certificate"></a>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
<a name="set-up-device-environment"></a>

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
<a name="set-up-linux-device-environment"></a><a name="set-up-linux-device-environment-procedure"></a>

**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
<a name="set-up-windows-device-environment"></a>

**Note**  
Cette fonctionnalité est disponible pour les versions 2.5.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.<a name="set-up-windows-device-environment-procedure"></a>

**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. <a name="set-up-windows-device-environment-open-cmd"></a>Ouvrez l'invite de commande Windows (`cmd.exe`) en tant qu'administrateur.

1. <a name="set-up-windows-device-environment-create"></a>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**  <a name="windows-password-expiration-tip"></a>
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. <a name="set-up-windows-device-psexec"></a>Téléchargez et installez l'[PsExecutilitaire](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) de Microsoft sur l'appareil. 

1. <a name="set-up-windows-device-credentials"></a>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
<a name="download-greengrass-core-v2"></a>

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. <a name="installation-download-ggc-software-step"></a>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
   ```

------

   <a name="core-software-license"></a>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. <a name="verify-gg-nucleus-signature"></a>(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. <a name="installation-unzip-ggc-software-step"></a>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**  <a name="installer-folder-2.4.0-warning"></a>
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
<a name="download-fleet-provisioning-plugin"></a>

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
  ```

------

  <a name="core-software-license"></a>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
<a name="run-greengrass-core-v2-installer-fleet"></a>

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.
+ <a name="install-argument-component-default-user"></a>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.
+ <a name="install-argument-system-service"></a>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**  <a name="windows-system-service-requirement-important-note"></a>
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**  
<a name="jvm-tuning-note"></a>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. <a name="installer-check-greengrass-core-software-version"></a>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.

   <a name="nano-command-intro"></a>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**  <a name="windows-system-service-installer-argument-important-note"></a>
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.

   <a name="installer-setup-system-service-output-message"></a>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**  <a name="installer-deploy-dev-tools-without-provision"></a>
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. <a name="installer-verify-installation"></a>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`.

<a name="install-greengrass-core-run-software"></a>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).

<a name="install-greengrass-core-next-steps-intro"></a>Pour plus d'informations sur la configuration et l'utilisation du logiciel AWS IoT Greengrass, consultez les rubriques suivantes :<a name="install-greengrass-core-next-steps-links"></a>
+ [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
<a name="fleet-provisioning-setup"></a>

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 :<a name="installation-fleet-provisioning-template-requirements"></a>
  + 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**  <a name="installation-fleet-provisioning-secure-claim-private-keys"></a>
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
<a name="create-token-exchange-role"></a>

<a name="installation-create-token-exchange-role-intro"></a>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).

<a name="installation-create-token-exchange-role-alias-intro"></a>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. <a name="create-token-exchange-role-create-iam-role"></a>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.

      <a name="nano-command-intro"></a>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.

      <a name="nano-command-intro"></a>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. <a name="create-token-exchange-role-create-iot-role-alias"></a>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
<a name="create-iot-policy"></a>

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.

     <a name="nano-command-intro"></a>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
<a name="create-provisioning-template"></a>

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 :<a name="installation-fleet-provisioning-template-requirements"></a>
+ 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.

      <a name="nano-command-intro"></a>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.

      <a name="nano-command-intro"></a>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
<a name="create-claim-certificates"></a>

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**  <a name="installation-fleet-provisioning-secure-claim-private-keys"></a>
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.

      <a name="nano-command-intro"></a>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
<a name="fleet-provisioning-configuration"></a>

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`  
<a name="nucleus-component-configuration-iot-data-endpoint"></a>Le point AWS IoT de terminaison de données pour votre Compte AWS.

`iotCredentialEndpoint`  
<a name="nucleus-component-configuration-iot-cred-endpoint"></a>Le point de terminaison des informations d' AWS IoT identification de votre Compte AWS.

`iotRoleAlias`  
<a name="nucleus-component-configuration-iot-role-alias"></a>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 :  <a name="installation-fleet-provisioning-template-requirements"></a>
+ 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.  <a name="nucleus-component-configuration-proxy-url-segments"></a>
+ `scheme`— Le schéma, qui doit être `http` ou`https`.
**Important**  
<a name="https-proxy-greengrass-nucleus-requirement"></a>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
<a name="fleet-provisioning-changelog"></a>

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

# Installez le logiciel AWS IoT Greengrass Core avec un provisionnement personnalisé des ressources
<a name="custom-provisioning"></a>

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**  <a name="install-greengrass-core-requirements-note"></a>
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
<a name="custom-provisioning-prerequisites"></a>

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
<a name="set-up-device-environment"></a>

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
<a name="set-up-linux-device-environment"></a><a name="set-up-linux-device-environment-procedure"></a>

**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
<a name="set-up-windows-device-environment"></a>

**Note**  
Cette fonctionnalité est disponible pour les versions 2.5.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.<a name="set-up-windows-device-environment-procedure"></a>

**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. <a name="set-up-windows-device-environment-open-cmd"></a>Ouvrez l'invite de commande Windows (`cmd.exe`) en tant qu'administrateur.

1. <a name="set-up-windows-device-environment-create"></a>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**  <a name="windows-password-expiration-tip"></a>
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. <a name="set-up-windows-device-psexec"></a>Téléchargez et installez l'[PsExecutilitaire](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) de Microsoft sur l'appareil. 

1. <a name="set-up-windows-device-credentials"></a>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
<a name="download-greengrass-core-v2"></a>

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. <a name="installation-download-ggc-software-step"></a>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
   ```

------

   <a name="core-software-license"></a>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. <a name="verify-gg-nucleus-signature"></a>(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. <a name="installation-unzip-ggc-software-step"></a>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**  <a name="installer-folder-2.4.0-warning"></a>
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
<a name="run-greengrass-core-v2-installer-custom"></a>

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é.
+ <a name="install-argument-component-default-user"></a>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.
+ <a name="install-argument-system-service"></a>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**  <a name="windows-system-service-requirement-important-note"></a>
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**  
<a name="jvm-tuning-note"></a>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. <a name="installer-check-greengrass-core-software-version"></a>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.

   <a name="nano-command-intro"></a>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.16.1"
       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.16.1* 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.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"
         # 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**  <a name="windows-system-service-installer-argument-important-note"></a>
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.

   <a name="installer-setup-system-service-output-message"></a>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**  <a name="installer-deploy-dev-tools-without-provision"></a>
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. <a name="installer-verify-installation"></a>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`.

<a name="install-greengrass-core-run-software"></a>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).

<a name="install-greengrass-core-next-steps-intro"></a>Pour plus d'informations sur la configuration et l'utilisation du logiciel AWS IoT Greengrass, consultez les rubriques suivantes :<a name="install-greengrass-core-next-steps-links"></a>
+ [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
<a name="develop-custom-provisioning-plugins"></a>

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
<a name="custom-provisioning-plugin-requirements"></a>

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
<a name="implement-device-identity-interface"></a>

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.

    ```
    <project ...>
        ...
        <repositories>
            <repository>
                <id>greengrass-common</id>
                <name>greengrass common</name>
                <url>https://d2jrmugq4soldf.cloudfront.net/snapshots</url>
            </repository>
        </repositories>
        ...
        <dependencies>
            <dependency>
                <groupId>com.aws.greengrass</groupId>
                <artifactId>nucleus</artifactId>
                <version>2.5.0-SNAPSHOT</version>
                <scope>provided</scope>
            </dependency>
        </dependencies>
    </project>
    ```

### L' DeviceIdentityInterface interface
<a name="device-identity-interface-shape"></a>

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<String, Object> 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.

# Arguments d'installation
<a name="configure-installer"></a>

Le logiciel AWS IoT Greengrass principal inclut un programme d'installation qui configure le logiciel et fournit les AWS ressources nécessaires au fonctionnement du périphérique principal Greengrass. Le programme d'installation inclut les arguments suivants que vous pouvez spécifier pour configurer l'installation :

`-h`, `--help`  
(Facultatif) Affichez les informations d'aide du programme d'installation.

`--version`  
(Facultatif) Afficher la version du logiciel AWS IoT Greengrass principal.

`-Droot`  
(Facultatif) Le chemin d'accès au dossier à utiliser comme racine pour le logiciel AWS IoT Greengrass Core.  
Cet argument définit une propriété JVM, vous devez donc la spécifier avant `-jar` d'exécuter le programme d'installation. Par exemple, spécifiez `java -Droot="/greengrass/v2" -jar /path/to/Greengrass.jar`.
Par défaut :  
+ Linux : `~/.greengrass`
+ Windows: `%USERPROFILE%/.greengrass`

`-ar`, `--aws-region`  
Le Région AWS logiciel AWS IoT Greengrass Core utilise pour récupérer ou créer les AWS ressources requises.

`-p`, `--provision`  
(Facultatif) Vous pouvez enregistrer cet appareil en tant qu' AWS IoT objet et fournir les AWS ressources dont le périphérique principal a besoin. Si vous le spécifiez`true`, le logiciel AWS IoT Greengrass Core fournit n' AWS IoT importe quel objet, (facultatif) un AWS IoT groupe d'objets, un rôle IAM et un alias de AWS IoT rôle.  
Par défaut : `false`

`-tn`, `--thing-name`  
(Facultatif) Le nom de l' AWS IoT objet que vous enregistrez en tant que périphérique principal. Si l'objet portant le nom n'existe pas dans le vôtre Compte AWS, c'est le logiciel AWS IoT Greengrass Core qui le crée.  
Le nom de l'objet ne peut pas contenir de caractères deux-points (`:`).
Vous devez spécifier `--provision true` pour appliquer cet argument.  
Par défaut : `GreengrassV2IotThing_` plus un UUID aléatoire.

`-tgn`, `--thing-group-name`  
(Facultatif) Le nom du AWS IoT groupe d'objets dans lequel vous ajoutez l' AWS IoT objet de cet appareil principal. Si un déploiement cible ce groupe d'objets, ce périphérique principal reçoit ce déploiement lorsqu'il se connecte à AWS IoT Greengrass. Si le groupe d'objets portant ce nom n'existe pas dans votre Compte AWS répertoire, le logiciel AWS IoT Greengrass Core le crée.  
Le nom du groupe d'objets ne peut pas contenir de deux-points (`:`).
Vous devez spécifier `--provision true` pour appliquer cet argument.

`-tpn`, `--thing-policy-name`  
Cette fonctionnalité est disponible pour les versions 2.4.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.  
(Facultatif) Nom de la AWS IoT politique à associer au certificat d' AWS IoT objet de ce périphérique principal. Si la AWS IoT politique portant ce nom n'existe pas dans votre répertoire Compte AWS, le logiciel AWS IoT Greengrass Core la crée.  
Le logiciel AWS IoT Greengrass Core crée une AWS IoT politique permissive par défaut. Vous pouvez limiter cette politique ou créer une politique personnalisée dans laquelle vous limitez les autorisations pour 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).  
Vous devez spécifier `--provision true` pour appliquer cet argument.  
Par défaut : `GreengrassV2IoTThingPolicy`

`-trn`, `--tes-role-name`  
(Facultatif) Nom du rôle IAM à utiliser pour acquérir des AWS informations d'identification permettant à l'appareil principal d'interagir avec les AWS services. Si le rôle portant ce nom n'existe pas dans votre répertoire Compte AWS, le logiciel AWS IoT Greengrass Core le crée avec la `GreengrassV2TokenExchangeRoleAccess` politique. Ce rôle n'a pas accès à vos compartiments S3 dans lesquels vous hébergez des artefacts de composants. Vous devez donc ajouter des autorisations aux compartiments et objets S3 de vos artefacts lorsque vous créez un composant. Pour de plus amples informations, veuillez consulter [Autoriser les appareils principaux à interagir avec les AWS services](device-service-role.md).  
Vous devez spécifier `--provision true` pour appliquer cet argument.  
Par défaut : `GreengrassV2TokenExchangeRole`

`-tra`, `--tes-role-alias-name`  
(Facultatif) Le nom de l'alias de AWS IoT rôle qui pointe vers le rôle IAM qui fournit les AWS informations d'identification pour ce périphérique principal. Si l'alias de rôle portant ce nom n'existe pas dans votre répertoire Compte AWS, le logiciel AWS IoT Greengrass Core le crée et le pointe vers le rôle IAM que vous spécifiez.  
Vous devez spécifier `--provision true` pour appliquer cet argument.  
Par défaut : `GreengrassV2TokenExchangeRoleAlias`

`-ss`, `--setup-system-service`  
(Facultatif) Vous pouvez configurer le logiciel AWS IoT Greengrass Core en tant que service système qui s'exécute au démarrage de cet appareil. Le nom du service système est`greengrass`. Pour de plus amples informations, veuillez consulter [Configurer le noyau Greengrass en tant que service système](configure-greengrass-core-v2.md#configure-system-service).  
Sur les systèmes d'exploitation Linux, cet argument nécessite que le système d'initialisation systemd soit disponible sur le périphérique.  
Sur les appareils Windows Core, vous devez configurer le logiciel AWS IoT Greengrass Core en tant que service système.
Par défaut : `false`

`-u`, `--component-default-user`  
Le nom ou l'ID de l'utilisateur utilisé par le logiciel AWS IoT Greengrass Core pour exécuter les composants. Par exemple, vous pouvez définir **ggc\$1user**. Cette valeur est obligatoire lorsque vous exécutez le programme d'installation sur les systèmes d'exploitation Windows.  
Sur les systèmes d'exploitation Linux, vous pouvez également éventuellement spécifier le groupe. Spécifiez l'utilisateur et le groupe séparés par deux points. Par exemple, **ggc\$1user:ggc\$1group**.  

Les considérations supplémentaires suivantes s'appliquent aux systèmes d'exploitation Linux :
+ Si vous exécutez le composant en tant que root, l'utilisateur du composant par défaut est celui défini dans le fichier de configuration. Si le fichier de configuration ne définit aucun utilisateur, la valeur par défaut est. `ggc_user:ggc_group` S'ils `ggc_group` existent `ggc_user` ou non, le logiciel les crée.
+ Si vous l'exécutez en tant qu'utilisateur non root, le logiciel AWS IoT Greengrass Core utilise cet utilisateur pour exécuter les composants.
+ Si vous ne spécifiez aucun groupe, le logiciel AWS IoT Greengrass Core utilise le groupe principal de l'utilisateur du système.
Pour de plus amples informations, veuillez consulter [Configurer l'utilisateur qui exécute les composants](configure-greengrass-core-v2.md#configure-component-user).

`-d`, `--deploy-dev-tools`  
(Facultatif) Vous pouvez télécharger et déployer le composant [Greengrass CLI](greengrass-cli-component.md) sur ce périphérique principal. Vous pouvez utiliser cet outil pour développer et déboguer des composants sur ce périphérique principal.  
 <a name="local-dev-tools-production-environment-warning"></a>Nous vous recommandons d'utiliser ce composant uniquement dans les environnements de développement, et non dans les environnements de production. Ce composant permet d'accéder à des informations et à des opérations dont vous n'avez généralement pas besoin dans un environnement de production. Respectez le principe du moindre privilège en déployant ce composant uniquement sur les appareils principaux là où vous en avez besoin. 
Vous devez spécifier `--provision true` pour appliquer cet argument.  
Par défaut : `false`

`-init`, `--init-config`  
(Facultatif) Le chemin d'accès au fichier de configuration à utiliser pour installer le logiciel AWS IoT Greengrass Core. Vous pouvez utiliser cette option pour configurer de nouveaux périphériques principaux avec une configuration de noyau spécifique, par exemple.   
Le fichier de configuration que vous spécifiez fusionne avec le fichier de configuration existant sur le périphérique principal. Cela inclut les composants et les configurations des composants du périphérique principal. Nous recommandons que le fichier de configuration répertorie uniquement les configurations que vous essayez de modifier.

`-tp`, `--trusted-plugin`  
(Facultatif) Le chemin d'accès à un fichier JAR à charger en tant que plugin sécurisé. Utilisez cette option pour fournir des fichiers JAR du plug-in de provisionnement, par exemple pour l'installation avec le [provisionnement du parc](fleet-provisioning.md) ou le [provisionnement personnalisé](custom-provisioning.md), ou pour l'installation avec la clé privée et le certificat dans un module de sécurité [matériel](hardware-security.md).

`-s`, `--start`  
(Facultatif) Vous pouvez démarrer le logiciel AWS IoT Greengrass Core après son installation et, éventuellement, provisionner les ressources.  
Par défaut : `true`

# Exécutez le logiciel AWS IoT Greengrass Core
<a name="run-greengrass-core-v2"></a>

Après avoir [installé le logiciel AWS IoT Greengrass Core](install-greengrass-core-v2.md), exécutez-le pour connecter votre appareil à AWS IoT Greengrass.

Lorsque vous installez le logiciel AWS IoT Greengrass Core, vous pouvez spécifier s'il convient de l'installer en tant que service système avec [systemd](https://en.wikipedia.org/wiki/Systemd). Si vous choisissez cette option, le programme d'installation exécute le logiciel pour vous et le configure pour qu'il s'exécute au démarrage de votre appareil.

**Important**  <a name="windows-system-service-requirement-important-note"></a>
Sur les appareils Windows Core, vous devez configurer le logiciel AWS IoT Greengrass Core en tant que service système.

**Topics**
+ [Vérifiez si le logiciel AWS IoT Greengrass Core fonctionne en tant que service système](#check-system-service)
+ [Exécutez le logiciel AWS IoT Greengrass Core en tant que service système](#run-greengrass-core-system-service)
+ [Exécutez le logiciel AWS IoT Greengrass Core sans service système](#run-greengrass-core-no-system-service)

## Vérifiez si le logiciel AWS IoT Greengrass Core fonctionne en tant que service système
<a name="check-system-service"></a>

Lorsque vous installez le logiciel AWS IoT Greengrass Core, vous pouvez spécifier l'`--setup-system-service true`argument pour installer le logiciel AWS IoT Greengrass Core en tant que service système. Les appareils Linux nécessitent le [système d'initialisation systemd](https://en.wikipedia.org/wiki/Systemd) pour configurer le logiciel AWS IoT Greengrass Core en tant que service système. Si vous utilisez cette option, le programme d'installation exécute le logiciel pour vous et le configure pour qu'il s'exécute au démarrage de votre appareil. Le programme d'installation affiche le message suivant s'il installe correctement le logiciel AWS IoT Greengrass Core en tant que service système.

```
Successfully set up Nucleus as a system service
```

Si vous avez déjà installé le logiciel AWS IoT Greengrass Core et que vous ne disposez pas de la sortie du programme d'installation, vous pouvez vérifier si le logiciel est installé en tant que service système.

**Pour vérifier si le logiciel AWS IoT Greengrass Core est installé en tant que service système**
+ Exécutez la commande suivante pour vérifier l'état du service système Greengrass.

------
#### [ Linux or Unix (systemd) ]

  ```
  sudo systemctl status greengrass.service
  ```

  La réponse ressemble à l'exemple suivant si le logiciel AWS IoT Greengrass Core est installé en tant que service système et actif.

  ```
  ● greengrass.service - Greengrass Core
     Loaded: loaded (/etc/systemd/system/greengrass.service; enabled; vendor preset: disabled)
     Active: active (running) since Thu 2021-02-11 01:33:44 UTC; 4 days ago
   Main PID: 16107 (sh)
     CGroup: /system.slice/greengrass.service
             ├─16107 /bin/sh /greengrass/v2/alts/current/distro/bin/loader
             └─16111 java -Dlog.store=FILE -Droot=/greengrass/v2 -jar /greengrass/v2/alts/current/distro/lib/Greengrass...
  ```

  S'il `systemctl` `greengrass.service` n'est pas trouvé, le logiciel AWS IoT Greengrass Core n'est pas installé en tant que service système. Pour exécuter le logiciel, voir[Exécutez le logiciel AWS IoT Greengrass Core sans service système](#run-greengrass-core-no-system-service).

------
#### [ Windows Command Prompt (CMD) ]

  ```
  sc query greengrass
  ```

  La réponse ressemble à l'exemple suivant si le logiciel AWS IoT Greengrass Core est installé en tant que service Windows et actif.

  ```
  SERVICE_NAME: greengrass
          TYPE               : 10  WIN32_OWN_PROCESS
          STATE              : 4  RUNNING
                                  (STOPPABLE, NOT_PAUSABLE, ACCEPTS_SHUTDOWN)
          WIN32_EXIT_CODE    : 0  (0x0)
          SERVICE_EXIT_CODE  : 0  (0x0)
          CHECKPOINT         : 0x0
          WAIT_HINT          : 0x0
  ```

------
#### [ PowerShell ]

  ```
  Get-Service greengrass
  ```

  La réponse ressemble à l'exemple suivant si le logiciel AWS IoT Greengrass Core est installé en tant que service Windows et actif.

  ```
  Status   Name               DisplayName
  ------   ----               -----------
  Running  greengrass         greengrass
  ```

------

## Exécutez le logiciel AWS IoT Greengrass Core en tant que service système
<a name="run-greengrass-core-system-service"></a>

Si le logiciel AWS IoT Greengrass Core est installé en tant que service système, vous pouvez utiliser le gestionnaire de services système pour démarrer, arrêter et gérer le logiciel. Pour de plus amples informations, veuillez consulter [Configurer le noyau Greengrass en tant que service système](configure-greengrass-core-v2.md#configure-system-service).

**Pour exécuter le logiciel AWS IoT Greengrass Core**
+ Exécutez la commande suivante pour démarrer le logiciel AWS IoT Greengrass Core.

------
#### [ Linux or Unix (systemd) ]

  ```
  sudo systemctl start greengrass.service
  ```

------
#### [ Windows Command Prompt (CMD) ]

  ```
  sc start greengrass
  ```

------
#### [ PowerShell ]

  ```
  Start-Service greengrass
  ```

------

## Exécutez le logiciel AWS IoT Greengrass Core sans service système
<a name="run-greengrass-core-no-system-service"></a>

Sur les appareils Linux principaux, si le logiciel AWS IoT Greengrass Core n'est pas installé en tant que service système, vous pouvez exécuter le script de chargement du logiciel pour exécuter le logiciel.

**Pour exécuter le logiciel AWS IoT Greengrass Core sans service système**
+ Exécutez la commande suivante pour démarrer le logiciel AWS IoT Greengrass Core. Si vous exécutez cette commande dans un terminal, vous devez laisser la session du terminal ouverte pour que le logiciel AWS IoT Greengrass Core continue de fonctionner.
  + Remplacez `/greengrass/v2` ou *C:\$1greengrass\$1v2* par le dossier racine Greengrass que vous utilisez.

  ```
  sudo /greengrass/v2/alts/current/distro/bin/loader
  ```

  Le logiciel imprime le message suivant s'il démarre correctement.

  ```
  Launched Nucleus successfully.
  ```

# Exécuter le logiciel AWS IoT Greengrass Core dans un conteneur Docker
<a name="run-greengrass-docker"></a>

AWS IoT Greengrass peut être configuré pour fonctionner dans un conteneur Docker. Docker est une plate-forme qui fournit les outils nécessaires pour créer, exécuter, tester et déployer des applications basées sur des conteneurs Linux. Lorsque vous exécutez une image AWS IoT Greengrass Docker, vous pouvez choisir de fournir vos AWS informations d'identification au conteneur Docker et d'autoriser le programme d'installation du logiciel AWS IoT Greengrass Core à provisionner automatiquement les AWS ressources dont un périphérique principal Greengrass a besoin pour fonctionner. Si vous ne souhaitez pas fournir AWS d'informations d'identification, vous pouvez provisionner manuellement les AWS ressources et exécuter le logiciel AWS IoT Greengrass Core dans le conteneur Docker.

**Topics**
+ [Exigences et plateformes prises en charge](#greengrass-docker-supported-platforms)
+ [Téléchargements de logiciels](#greengrass-docker-downloads)
+ [Choisissez le mode de provisionnement AWS des ressources](#greengrass-docker-resource-provisioning)
+ [Construire l' AWS IoT Greengrass image à partir d'un Dockerfile](build-greengrass-dockerfile.md)
+ [Exécuter AWS IoT Greengrass dans Docker avec provisionnement automatique](run-greengrass-docker-automatic-provisioning.md)
+ [Exécuter AWS IoT Greengrass dans Docker avec provisionnement manuel](run-greengrass-docker-manual-provisioning.md)
+ [Résolution des problèmes AWS IoT Greengrass dans un conteneur Docker](docker-troubleshooting.md)

## Exigences et plateformes prises en charge
<a name="greengrass-docker-supported-platforms"></a>

Les ordinateurs hôtes doivent répondre aux exigences minimales suivantes pour installer et exécuter le logiciel AWS IoT Greengrass Core dans un conteneur Docker :
+ <a name="docker-host-reqs"></a>Système d'exploitation basé sur Linux doté d'une connexion Internet.
+ <a name="docker-engine-reqs"></a>[Docker Engine](https://docs.docker.com/engine/install/) version 18.09 ou ultérieure.
+ <a name="docker-compose-reqs"></a>(Facultatif) [Docker Compose](https://docs.docker.com/compose/install/) version 1.22 ou ultérieure. Docker Compose n'est requis que si vous souhaitez utiliser la CLI Docker Compose pour exécuter vos images Docker.

Pour exécuter les composants de la fonction Lambda dans le conteneur Docker, vous devez configurer le conteneur pour répondre à des exigences supplémentaires. Pour de plus amples informations, veuillez consulter [Exigences relatives à la fonction Lambda](setting-up.md#greengrass-v2-lambda-requirements).

### Exécuter les composants en mode processus
<a name="docker-container-mode-limitation"></a>

AWS IoT Greengrass ne prend pas en charge l'exécution de fonctions Lambda ou de composants AWS fournis par Lambda dans un environnement d'exécution isolé à l'intérieur du AWS IoT Greengrass conteneur Docker. Vous devez exécuter ces composants en mode processus sans aucune isolation.

Lorsque vous configurez un composant de fonction Lambda, définissez le mode d'isolation sur **Aucun** conteneur. Pour de plus amples informations, veuillez consulter [Exécuter AWS Lambda des fonctions](run-lambda-functions.md). 

Lorsque vous déployez l'un des composants AWS fournis ci-dessous, mettez à jour la configuration de chaque composant pour définir le `containerMode` paramètre sur. `NoContainer` Pour plus d'informations sur les mises à jour de configuration, consultez[Mettre à jour les configurations des composants](update-component-configurations.md).
+ [CloudWatch métriques](cloudwatch-metrics-component.md)
+ [Défenseur de l'appareil](device-defender-component.md)
+ [Firehose](kinesis-firehose-component.md)
+ [Adaptateur de protocole Modbus-RTU](modbus-rtu-protocol-adapter-component.md)
+ [Amazon SNS](sns-component.md)

## AWS IoT Greengrass Téléchargements du logiciel Docker
<a name="greengrass-docker-downloads"></a>

AWS IoT Greengrass fournit un Dockerfile pour créer une image de conteneur sur laquelle le logiciel AWS IoT Greengrass Core et ses dépendances sont installés sur une image de base Amazon Linux 2 (x86\$164). Vous pouvez modifier l'image de base dans le Dockerfile pour l'exécuter AWS IoT Greengrass sur une architecture de plate-forme différente.

Téléchargez le package Dockerfile depuis. [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker)

Le Dockerfile utilise une ancienne version de Greengrass. Vous devez mettre à jour le fichier pour utiliser la version de Greengrass que vous souhaitez. Pour plus d'informations sur la création de l'image du AWS IoT Greengrass conteneur à partir du Dockerfile, consultez. [Créez l'image du AWS IoT Greengrass conteneur à partir d'un Dockerfile](build-greengrass-dockerfile.md)

## Choisissez le mode de provisionnement AWS des ressources
<a name="greengrass-docker-resource-provisioning"></a>

Lorsque vous installez le logiciel AWS IoT Greengrass Core dans un conteneur Docker, vous pouvez choisir de provisionner automatiquement les AWS ressources dont un appareil Greengrass a besoin pour fonctionner ou d'utiliser des ressources que vous provisionnez manuellement.
+ **Approvisionnement automatique des ressources** : le programme d'installation AWS IoT provisionne l' AWS IoT objet, le groupe d'objets, le rôle IAM et l'alias de AWS IoT rôle lorsque vous exécutez l'image du AWS IoT Greengrass conteneur pour la première fois. Le programme d'installation peut également déployer les outils de développement locaux sur le périphérique principal, afin que vous puissiez utiliser l'appareil pour développer et tester des composants logiciels personnalisés. Pour provisionner automatiquement ces ressources, vous devez fournir des AWS informations d'identification en tant que variables d'environnement à l'image Docker.

  Pour utiliser le provisionnement automatique, vous devez définir la variable d'environnement Docker `PROVISION=true` et monter un fichier d'informations d'identification pour fournir vos AWS informations d'identification au conteneur.
+ **Approvisionnement manuel des ressources** : si vous ne souhaitez pas fournir AWS d'informations d'identification au conteneur, vous pouvez configurer manuellement les AWS ressources avant d'exécuter l'image du AWS IoT Greengrass conteneur. Vous devez créer un fichier de configuration pour fournir des informations sur ces ressources au programme d'installation du logiciel AWS IoT Greengrass Core dans le conteneur Docker.

  Pour utiliser le provisionnement manuel, vous devez définir la variable d'environnement Docker. `PROVISION=false` Le provisionnement manuel est l'option par défaut.

Pour de plus amples informations, veuillez consulter [Créez l'image du AWS IoT Greengrass conteneur à partir d'un Dockerfile](build-greengrass-dockerfile.md).

# Créez l'image du AWS IoT Greengrass conteneur à partir d'un Dockerfile
<a name="build-greengrass-dockerfile"></a>

AWS fournit un Dockerfile que vous pouvez télécharger et utiliser pour exécuter le logiciel AWS IoT Greengrass Core dans un conteneur Docker. Les Dockerfiles contiennent le code source permettant de créer des images de AWS IoT Greengrass conteneurs. 

Avant de créer une image de AWS IoT Greengrass conteneur, vous devez configurer votre Dockerfile pour sélectionner la version du logiciel AWS IoT Greengrass Core que vous souhaitez installer. Vous pouvez également configurer des variables d'environnement pour choisir le mode de provisionnement des ressources lors de l'installation et personnaliser d'autres options d'installation. Cette section décrit comment configurer et créer une image AWS IoT Greengrass Docker à partir d'un Dockerfile. 



## Téléchargez le package Dockerfile
<a name="download-dockerfile-package"></a>

Vous pouvez télécharger le package AWS IoT Greengrass Dockerfile à l'adresse suivante : GitHub

[Référentiel Docker AWS Greengrass](https://github.com/aws-greengrass/aws-greengrass-docker)

Après avoir téléchargé le package, extrayez le contenu `download-directory/aws-greengrass-docker-nucleus-version` dans le dossier de votre ordinateur. Le Dockerfile utilise une ancienne version de Greengrass. Vous devez mettre à jour le fichier pour utiliser la version de Greengrass que vous souhaitez.

## Spécifiez la version du logiciel AWS IoT Greengrass Core
<a name="set-dockerfile-build-argument"></a>

Utilisez l'argument build suivant dans le Dockerfile pour spécifier la version du logiciel AWS IoT Greengrass Core que vous souhaitez utiliser dans l'image AWS IoT Greengrass Docker. Par défaut, le Dockerfile utilise la dernière version du logiciel AWS IoT Greengrass Core.

`GREENGRASS_RELEASE_VERSION`  
Version du logiciel AWS IoT Greengrass Core. Par défaut, le Dockerfile télécharge la dernière version disponible du noyau Greengrass. Définissez la valeur sur la version du noyau que vous souhaitez télécharger.

## Définir les variables d'environnement
<a name="set-dockerfile-environment-variables"></a>

Les variables d'environnement vous permettent de personnaliser la façon dont le logiciel AWS IoT Greengrass Core est installé dans le conteneur Docker. Vous pouvez définir des variables d'environnement pour votre image AWS IoT Greengrass Docker de différentes manières. 
+ Pour utiliser les mêmes variables d'environnement pour créer plusieurs images, définissez les variables d'environnement directement dans le Dockerfile.
+ Si vous avez l'`docker run`habitude de démarrer votre conteneur, transmettez des variables d'environnement en tant qu'arguments dans la commande ou définissez des variables d'environnement dans un fichier de variables d'environnement, puis transmettez le fichier en argument. Pour plus d'informations sur la définition des variables d'environnement dans Docker, consultez les [variables d'environnement](https://docs.docker.com/engine/reference/commandline/run/#env) dans la documentation Docker.
+ Si vous avez l'`docker-compose up`habitude de démarrer votre conteneur, définissez les variables d'environnement dans un fichier de variables d'environnement, puis transmettez le fichier en argument. Pour plus d'informations sur la définition des variables d'environnement dans Compose, consultez la [documentation Docker](https://docs.docker.com/compose/environment-variables/).

Vous pouvez configurer les variables d'environnement suivantes pour l'image AWS IoT Greengrass Docker.

**Note**  
Ne modifiez pas la `TINI_KILL_PROCESS_GROUP` variable dans le Dockerfile. Cette variable permet le transfert `SIGTERM` PIDs à tous les membres du groupe PID afin que le logiciel AWS IoT Greengrass Core puisse s'arrêter correctement lorsque le conteneur Docker est arrêté.

`GGC_ROOT_PATH`  
(Facultatif) Le chemin d'accès au dossier du conteneur à utiliser comme racine pour le logiciel AWS IoT Greengrass Core.  
Valeur par défaut : `/greengrass/v2`

`PROVISION`  
(Facultatif) Détermine si le AWS IoT Greengrass Core fournit AWS des ressources.   
+ Si vous le spécifiez`true`, le logiciel AWS IoT Greengrass Core enregistre l'image du conteneur en tant qu' AWS IoT objet et fournit les AWS ressources dont le périphérique principal Greengrass a besoin. Le logiciel de AWS IoT Greengrass base fournit n' AWS IoT importe quel objet, (facultatif) un AWS IoT groupe d'objets, un rôle IAM et un alias de AWS IoT rôle. Pour de plus amples informations, veuillez consulter [Exécuter AWS IoT Greengrass dans un conteneur Docker avec provisionnement automatique des ressources](run-greengrass-docker-automatic-provisioning.md).
+ Si vous le spécifiez`false`, vous devez créer un fichier de configuration à fournir au programme d'installation AWS IoT Greengrass Core qui indique d'utiliser les AWS ressources et les certificats que vous avez créés manuellement. Pour de plus amples informations, veuillez consulter [Exécuter AWS IoT Greengrass dans un conteneur Docker avec provisionnement manuel des ressources](run-greengrass-docker-manual-provisioning.md).
Par défaut: `false`

`AWS_REGION`  
(Facultatif) Le Région AWS logiciel AWS IoT Greengrass Core utilise pour récupérer ou créer les AWS ressources requises.   
Valeur par défaut : `us-east-1`.

`THING_NAME`  
(Facultatif) Le nom de l' AWS IoT objet que vous enregistrez en tant que périphérique principal. Si l'objet portant ce nom n'existe pas dans votre ordinateur Compte AWS, c'est le logiciel AWS IoT Greengrass Core qui le crée.   
Vous devez spécifier `PROVISION=true` pour appliquer cet argument.  
Par défaut : `GreengrassV2IotThing_` plus un UUID aléatoire.

`THING_GROUP_NAME`  
(Facultatif) Le nom du groupe d'objets auquel vous ajoutez ce périphérique principal est. AWS IoT Si un déploiement cible ce groupe d'objets, celui-ci et les autres appareils principaux de ce groupe reçoivent ce déploiement lorsqu'ils se connectent à celui-ci AWS IoT Greengrass. AWS IoT Si le groupe d'objets portant ce nom n'existe pas dans votre Compte AWS répertoire, le logiciel AWS IoT Greengrass Core le crée.  
Vous devez spécifier `PROVISION=true` pour appliquer cet argument.

`TES_ROLE_NAME`  
(Facultatif) Nom du rôle IAM à utiliser pour obtenir des AWS informations d'identification permettant à l'appareil principal de Greengrass d'interagir avec les AWS services. Si le rôle portant ce nom n'existe pas dans votre répertoire Compte AWS, le logiciel AWS IoT Greengrass Core le crée avec la `GreengrassV2TokenExchangeRoleAccess` politique. Ce rôle n'a pas accès à vos compartiments S3 dans lesquels vous hébergez des artefacts de composants. Vous devez donc ajouter des autorisations aux compartiments et objets S3 de vos artefacts lorsque vous créez un composant. Pour de plus amples informations, veuillez consulter [Autoriser les appareils principaux à interagir avec les AWS services](device-service-role.md).  
Par défaut: `GreengrassV2TokenExchangeRole`

`TES_ROLE_ALIAS_NAME`  
(Facultatif) Le nom de l'alias de AWS IoT rôle qui pointe vers le rôle IAM qui fournit les AWS informations d'identification pour le périphérique principal de Greengrass. Si l'alias de rôle portant ce nom n'existe pas dans votre répertoire Compte AWS, le logiciel AWS IoT Greengrass Core le crée et le pointe vers le rôle IAM que vous spécifiez.  
Valeur par défaut : `GreengrassV2TokenExchangeRoleAlias`

`COMPONENT_DEFAULT_USER`  
(Facultatif) Le nom ou l'ID de l'utilisateur et du groupe du système que le logiciel AWS IoT Greengrass Core utilise pour exécuter les composants. Spécifiez l'utilisateur et le groupe, séparés par deux points. Le groupe est facultatif. Par exemple, vous définissez **ggc\$1user:ggc\$1group** ou **ggc\$1user**.  
+ Si vous exécutez en tant que root, l'utilisateur et le groupe définis par le fichier de configuration sont utilisés par défaut. Si le fichier de configuration ne définit pas d'utilisateur ni de groupe, la valeur par défaut est. `ggc_user:ggc_group` S'ils `ggc_group` existent `ggc_user` ou non, le logiciel les crée.
+ Si vous l'exécutez en tant qu'utilisateur non root, le logiciel AWS IoT Greengrass Core utilise cet utilisateur pour exécuter les composants.
+ Si vous ne spécifiez aucun groupe, le logiciel AWS IoT Greengrass Core utilise le groupe principal de l'utilisateur du système.
Pour de plus amples informations, veuillez consulter [Configurer l'utilisateur qui exécute les composants](configure-greengrass-core-v2.md#configure-component-user).

`DEPLOY_DEV_TOOLS`  
Définit s'il faut télécharger et déployer le [composant Greengrass CLI](greengrass-cli-component.md) dans l'image du conteneur. Vous pouvez utiliser la CLI Greengrass pour développer et déboguer des composants localement.  
 <a name="local-dev-tools-production-environment-warning"></a>Nous vous recommandons d'utiliser ce composant uniquement dans les environnements de développement, et non dans les environnements de production. Ce composant permet d'accéder aux informations et aux opérations dont vous n'avez généralement pas besoin dans un environnement de production. Suivez le principe du moindre privilège en déployant ce composant uniquement sur les appareils principaux là où vous en avez besoin. 
Valeur par défaut : `false`

`INIT_CONFIG`  
(Facultatif) Le chemin d'accès au fichier de configuration à utiliser pour installer le logiciel AWS IoT Greengrass Core. Vous pouvez utiliser cette option pour configurer de nouveaux appareils principaux Greengrass avec une configuration de noyau spécifique, ou pour spécifier des ressources provisionnées manuellement, par exemple. Vous devez monter votre fichier de configuration sur le chemin que vous spécifiez dans cet argument. 

`TRUSTED_PLUGIN`  
Cette fonctionnalité est disponible pour les versions 2.4.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.  
(Facultatif) Le chemin d'accès à un fichier JAR à charger en tant que plugin sécurisé. Utilisez cette option pour fournir des fichiers JAR de plug-in de provisionnement, par exemple à installer avec le provisionnement de [flotte ou le provisionnement](fleet-provisioning.md) [personnalisé](custom-provisioning.md). 

`THING_POLICY_NAME`  
Cette fonctionnalité est disponible pour les versions 2.4.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.  
(Facultatif) Nom de la AWS IoT politique à associer au certificat d' AWS IoT objet de ce périphérique principal. Si la AWS IoT politique portant ce nom n'existe pas dans votre ordinateur, Compte AWS le logiciel AWS IoT Greengrass Core la crée.   
Vous devez spécifier `PROVISION=true` pour appliquer cet argument.  
Le logiciel AWS IoT Greengrass Core crée une AWS IoT politique permissive par défaut. Vous pouvez limiter cette politique ou créer une politique personnalisée dans laquelle vous limitez les autorisations pour 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). 

## Spécifiez les dépendances à installer
<a name="dockerfile-run-instruction"></a>

L'instruction RUN du AWS IoT Greengrass Dockerfile prépare l'environnement du conteneur pour exécuter le programme d'installation du logiciel AWS IoT Greengrass Core. Vous pouvez personnaliser les dépendances installées avant que le programme d'installation du logiciel AWS IoT Greengrass Core ne s'exécute dans le conteneur Docker. 

## Construisez l' AWS IoT Greengrass image
<a name="build-greengrass-docker-image"></a>

Utilisez le AWS IoT Greengrass Dockerfile pour créer une image de AWS IoT Greengrass conteneur. Vous pouvez utiliser la CLI Docker ou la CLI Docker Compose pour créer l'image et démarrer le conteneur. Vous pouvez également utiliser la CLI Docker pour créer l'image, puis utiliser Docker Compose pour démarrer votre conteneur à partir de cette image.

------
#### [ Docker ]

1. Sur la machine hôte, exécutez la commande suivante pour passer au répertoire contenant le Dockerfile configuré.

   ```
   cd download-directory/aws-greengrass-docker-nucleus-version
   ```

1. Exécutez la commande suivante pour créer l'image du AWS IoT Greengrass conteneur à partir du Dockerfile.

   ```
   sudo docker build -t "platform/aws-iot-greengrass:nucleus-version" ./
   ```

------
#### [ Docker Compose ]

1. Sur la machine hôte, exécutez la commande suivante pour passer au répertoire contenant le Dockerfile et le fichier Compose.

   ```
   cd download-directory/aws-greengrass-docker-nucleus-version
   ```

1. Exécutez la commande suivante pour utiliser le fichier Compose pour créer l'image du AWS IoT Greengrass conteneur.

   ```
   docker-compose -f docker-compose.yml build
   ```

------

Vous avez créé avec succès l'image du AWS IoT Greengrass conteneur. Le logiciel AWS IoT Greengrass Core est installé sur l'image Docker. Vous pouvez désormais exécuter le logiciel AWS IoT Greengrass Core dans un conteneur Docker.

# Exécuter AWS IoT Greengrass dans un conteneur Docker avec provisionnement automatique des ressources
<a name="run-greengrass-docker-automatic-provisioning"></a>

Ce didacticiel explique comment installer et exécuter le logiciel AWS IoT Greengrass Core dans un conteneur Docker avec des AWS ressources automatiquement provisionnées et des outils de développement locaux. Vous pouvez utiliser cet environnement de développement pour explorer les AWS IoT Greengrass fonctionnalités d'un conteneur Docker. Le logiciel nécessite des AWS informations d'identification pour fournir ces ressources et déployer les outils de développement locaux.

Si vous ne pouvez pas fournir AWS d'informations d'identification au conteneur, vous pouvez fournir les AWS ressources dont le périphérique principal a besoin pour fonctionner. Vous pouvez également déployer les outils de développement sur un appareil principal pour l'utiliser comme périphérique de développement. Cela vous permet de fournir moins d'autorisations à l'appareil lorsque vous exécutez le conteneur. Pour de plus amples informations, veuillez consulter [Exécuter AWS IoT Greengrass dans un conteneur Docker avec provisionnement manuel des ressources](run-greengrass-docker-manual-provisioning.md).



## Conditions préalables
<a name="docker-automatic-provisioning-prereqs"></a>

Pour terminer ce didacticiel, vous avez besoin des éléments suivants.
+ Un Compte AWS. Si vous n'en avez pas, veuillez consulter [Configurez un Compte AWS](setting-up.md#set-up-aws-account). 
+ Un utilisateur AWS IAM autorisé à fournir les ressources AWS IoT et IAM pour un appareil principal Greengrass. Le programme d'installation du logiciel AWS IoT Greengrass Core utilise vos AWS informations d'identification pour provisionner automatiquement ces ressources. Pour plus d'informations sur la politique IAM minimale permettant de provisionner automatiquement les ressources, consultez[Politique IAM minimale permettant au programme d'installation de provisionner les ressources](provision-minimal-iam-policy.md).
+ Une image AWS IoT Greengrass Docker. Vous pouvez [créer une image à partir du AWS IoT Greengrass Dockerfile](build-greengrass-dockerfile.md).
+ L'ordinateur hôte sur lequel vous exécutez le conteneur Docker doit répondre aux exigences suivantes :
  + <a name="docker-host-reqs"></a>Système d'exploitation basé sur Linux doté d'une connexion Internet.
  + <a name="docker-engine-reqs"></a>[Docker Engine](https://docs.docker.com/engine/install/) version 18.09 ou ultérieure.
  + <a name="docker-compose-reqs"></a>(Facultatif) [Docker Compose](https://docs.docker.com/compose/install/) version 1.22 ou ultérieure. Docker Compose n'est requis que si vous souhaitez utiliser la CLI Docker Compose pour exécuter vos images Docker.

## Configurez vos AWS informations d'identification
<a name="configure-aws-credentials-for-docker"></a>

Au cours de cette étape, vous créez un fichier d'informations d'identification sur l'ordinateur hôte qui contient vos informations AWS de sécurité. Lorsque vous exécutez l'image AWS IoT Greengrass Docker, vous devez monter le dossier contenant ce fichier d'identification `/root/.aws/` dans le conteneur Docker. Le AWS IoT Greengrass programme d'installation utilise ces informations d'identification pour provisionner des ressources dans votre Compte AWS. Pour plus d'informations sur la politique IAM minimale requise par le programme d'installation pour provisionner automatiquement les ressources, consultez[Politique IAM minimale permettant au programme d'installation de provisionner les ressources](provision-minimal-iam-policy.md).

1. Récupérez l'un des éléments suivants.
   + Informations d'identification à long terme pour un utilisateur IAM. Pour plus d'informations sur la façon de récupérer des informations d'identification à long terme, consultez [la section Gestion des clés d'accès pour les utilisateurs IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) dans le guide de l'*utilisateur IAM*.
   + (Recommandé) Informations d'identification temporaires pour un rôle IAM. Pour plus d'informations sur la façon de récupérer des informations d'identification temporaires, consultez la section [Utilisation des informations d'identification de sécurité temporaires AWS CLI dans le](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html#using-temp-creds-sdk-cli) *guide de l'utilisateur IAM*.

1. Créez un dossier dans lequel vous placerez votre fichier d'informations d'identification.

   ```
   mkdir ./greengrass-v2-credentials
   ```

1. Utilisez un éditeur de texte pour créer un fichier de configuration nommé `credentials` dans le `./greengrass-v2-credentials` dossier.

   Par exemple, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le `credentials` fichier. 

   ```
   nano ./greengrass-v2-credentials/credentials
   ```

1. Ajoutez vos AWS informations d'identification au `credentials` fichier au format suivant.

   ```
   [default]
   aws_access_key_id = AKIAIOSFODNN7EXAMPLE
   aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   aws_session_token = AQoEXAMPLEH4aoAH0gNCAPy...truncated...zrkuWJOgQs8IZZaIv2BXIa2R4Olgk
   ```

   Inclure uniquement `aws_session_token` pour les informations d'identification temporaires.

**Important**  
Supprimez le fichier d'informations d'identification de l'ordinateur hôte après avoir démarré le AWS IoT Greengrass conteneur. Si vous ne supprimez pas le fichier d'informations d' AWS identification, celles-ci resteront montées dans le conteneur. Pour de plus amples informations, veuillez consulter [Exécuter le logiciel de AWS IoT Greengrass base dans un conteneur](#run-greengrass-image-automatic-provisioning).

## Création d'un fichier d'environnement
<a name="create-env-file-automatic-provisioning"></a>

Ce didacticiel utilise un fichier d'environnement pour définir les variables d'environnement qui seront transmises au programme d'installation du logiciel AWS IoT Greengrass Core dans le conteneur Docker. Vous pouvez également utiliser [l'`--env`argument `-e` or](https://docs.docker.com/engine/reference/commandline/run/#env) dans votre `docker run` commande pour définir des variables d'environnement dans le conteneur Docker ou vous pouvez définir les variables dans [un `environment` bloc](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) du `docker-compose.yml` fichier.

1. Utilisez un éditeur de texte pour créer un fichier d'environnement nommé`.env`.

   Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano afin de créer le `.env` dans le répertoire actuel.

   ```
   nano .env
   ```

1. Copiez le contenu suivant dans le fichier.

   ```
   GGC_ROOT_PATH=/greengrass/v2
   AWS_REGION=region
   PROVISION=true
   THING_NAME=MyGreengrassCore
   THING_GROUP_NAME=MyGreengrassCoreGroup
   TES_ROLE_NAME=GreengrassV2TokenExchangeRole
   TES_ROLE_ALIAS_NAME=GreengrassCoreTokenExchangeRoleAlias
   COMPONENT_DEFAULT_USER=ggc_user:ggc_group
   ```

   Remplacez ensuite les valeurs suivantes.
   + `/greengrass/v2`. Le dossier racine de Greengrass que vous souhaitez utiliser pour l'installation. Vous utilisez la variable d'`GGC_ROOT`environnement pour définir cette valeur.
   + *region*. L' Région AWS endroit où vous avez créé les ressources.
   + *MyGreengrassCore*. Le nom du AWS IoT truc. Si l'objet n'existe pas, le programme d'installation le crée. Le programme d'installation télécharge les certificats pour s'authentifier en tant qu' AWS IoT objet. 
   + *MyGreengrassCoreGroup*. Le nom du groupe AWS IoT d'objets. Si le groupe d'objets n'existe pas, le programme d'installation le crée et y ajoute l'objet. Si le groupe d'objets existe et fait l'objet d'un déploiement actif, le périphérique principal télécharge et exécute le logiciel spécifié par le déploiement.
   +  *GreengrassV2TokenExchangeRole*. Remplacez-le par le nom du rôle d'échange de jetons IAM qui permet au périphérique principal de Greengrass d'obtenir AWS des informations d'identification temporaires. Si le rôle n'existe pas, le programme d'installation le crée, puis crée et attache une politique nommée *GreengrassV2TokenExchangeRole* Access. Pour de plus amples informations, veuillez consulter [Autoriser les appareils principaux à interagir avec les AWS services](device-service-role.md).
   + *GreengrassCoreTokenExchangeRoleAlias*. Alias du rôle d'échange de jetons. Si l'alias de rôle n'existe pas, le programme d'installation le crée et le pointe vers le rôle d'échange de jetons IAM que vous spécifiez. Pour plus d’informations, veuillez consulter la rubrique 
**Note**  <a name="docker-local-dev-tools-production-environment-warning"></a>
Vous pouvez définir la variable d'`DEPLOY_DEV_TOOLS`environnement sur `true` pour déployer le [composant Greengrass CLI](greengrass-cli-component.md), ce qui vous permet de développer des composants personnalisés dans le conteneur Docker. <a name="local-dev-tools-production-environment-warning"></a>Nous vous recommandons d'utiliser ce composant uniquement dans les environnements de développement, et non dans les environnements de production. Ce composant permet d'accéder à des informations et à des opérations dont vous n'avez généralement pas besoin dans un environnement de production. Respectez le principe du moindre privilège en déployant ce composant uniquement sur les appareils principaux là où vous en avez besoin. 

## Exécuter le logiciel de AWS IoT Greengrass base dans un conteneur
<a name="run-greengrass-image-automatic-provisioning"></a>

Ce didacticiel vous montre comment démarrer l'image Docker que vous avez créée dans un conteneur Docker. Vous pouvez utiliser la CLI Docker ou la CLI Docker Compose pour exécuter l'image logicielle AWS IoT Greengrass Core dans un conteneur Docker. 

------
#### [ Docker ]

1. Exécutez la commande suivante pour démarrer le conteneur Docker. 

   ```
   docker run --rm --init -it --name docker-image \
    -v path/to/greengrass-v2-credentials:/root/.aws/:ro \
    --env-file .env \
    -p 8883 \
    your-container-image:version
   ```

   Cet exemple de commande utilise les arguments suivants pour [docker run](https://docs.docker.com/engine/reference/commandline/run/) :
   + <a name="docker-run-rm"></a>[https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm). Nettoie le conteneur à sa sortie.
   + <a name="docker-run-init"></a>[https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process). Utilise un processus d'initialisation dans le conteneur. 
**Note**  
L'`--init`argument est nécessaire pour arrêter le logiciel AWS IoT Greengrass Core lorsque vous arrêtez le conteneur Docker.
   + <a name="docker-run-it"></a>[https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground). (Facultatif) Exécute le conteneur Docker au premier plan en tant que processus interactif. Vous pouvez le remplacer par l'`-d`argument pour exécuter le conteneur Docker en mode détaché à la place. Pour plus d'informations, consultez la section [Détachée ou avant-plan](https://docs.docker.com/engine/reference/run/#detached-vs-foreground) dans la documentation Docker.
   + <a name="docker-run-name"></a>[https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name). Exécute un conteneur nommé `aws-iot-greengrass` 
   + <a name="docker-run-v"></a>[https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/). Monte un volume dans le conteneur Docker pour que le fichier de configuration et les fichiers de certificat puissent être AWS IoT Greengrass exécutés dans le conteneur.
   + <a name="docker-run-env-file"></a>[https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env). (Facultatif) Spécifie le fichier d'environnement pour définir les variables d'environnement qui seront transmises au programme d'installation du logiciel AWS IoT Greengrass Core dans le conteneur Docker. Cet argument n'est obligatoire que si vous avez créé un [fichier d'environnement](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning) pour définir des variables d'environnement. Si vous n'avez pas créé de fichier d'environnement, vous pouvez utiliser des `--env` arguments pour définir des variables d'environnement directement dans votre commande Docker run.
   + <a name="docker-run-p"></a>[https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish). (Facultatif) Publie le port du conteneur 8883 sur la machine hôte. Cet argument est obligatoire si vous souhaitez vous connecter et communiquer via MQTT car il AWS IoT Greengrass utilise le port 8883 pour le trafic MQTT. Pour ouvrir d'autres ports, utilisez des `-p` arguments supplémentaires.
**Note**  <a name="docker-run-cap-drop"></a>
Pour exécuter votre conteneur Docker avec une sécurité accrue, vous pouvez utiliser les `--cap-add` arguments `--cap-drop` et pour activer de manière sélective les fonctionnalités Linux de votre conteneur. Pour plus d'informations, consultez les sections [Privilèges d'exécution et fonctionnalités Linux](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) dans la documentation Docker.

1. <a name="docker-automatic-provisioning-remove-credentials-file"></a>Supprimez les informations d'identification `./greengrass-v2-credentials` de l'appareil hôte.

   ```
   rm -rf ./greengrass-v2-credentials
   ```
**Important**  
Vous supprimez ces informations d'identification, car elles fournissent des autorisations étendues dont le périphérique principal n'a besoin que lors de la configuration. Si vous ne supprimez pas ces informations d'identification, les composants Greengrass et les autres processus exécutés dans le conteneur peuvent y accéder. Si vous devez fournir des AWS informations d'identification à un composant Greengrass, utilisez le service d'échange de jetons. Pour de plus amples informations, veuillez consulter [Interagissez avec les AWS services](interact-with-aws-services.md).

------
#### [ Docker Compose ]

1. Utilisez un éditeur de texte pour créer un fichier Docker Compose nommé`docker-compose.yml`.

   Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano afin de créer le `docker-compose.yml` dans le répertoire actuel.

   ```
   nano docker-compose.yml
   ```
**Note**  
Vous pouvez également télécharger et utiliser la dernière version du fichier Compose AWS fourni à partir de [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/).

1. Ajoutez le contenu suivant au fichier Compose. Votre fichier doit être similaire à l'exemple suivant : *docker-image*Remplacez-le par le nom de votre image Docker. 

   ```
   version: '3.7'
    
   services:
     greengrass:
       init: true
       container_name: aws-iot-greengrass
       image: docker-image
       volumes:
         - ./greengrass-v2-credentials:/root/.aws/:ro 
       env_file: .env
       ports:
         - "8883:8883"
   ```<a name="docker-compose-optional-params"></a>

   Les paramètres suivants de cet exemple de fichier Compose sont facultatifs :
   + `ports`—Publie les ports du conteneur 8883 sur la machine hôte. Ce paramètre est obligatoire si vous souhaitez vous connecter et communiquer via MQTT car il AWS IoT Greengrass utilise le port 8883 pour le trafic MQTT. 
   + `env_file`—Spécifie le fichier d'environnement pour définir les variables d'environnement qui seront transmises au programme d'installation du logiciel AWS IoT Greengrass Core dans le conteneur Docker. Ce paramètre n'est obligatoire que si vous avez créé un [fichier d'environnement](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning) pour définir des variables d'environnement. Si vous n'avez pas créé de fichier d'environnement, vous pouvez utiliser le paramètre d'[environnement](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) pour définir les variables directement dans votre fichier Compose.
**Note**  <a name="docker-compose-cap-drop"></a>
Pour exécuter votre conteneur Docker avec une sécurité accrue, vous pouvez utiliser `cap_drop` et `cap_add` dans votre fichier Compose pour activer de manière sélective les fonctionnalités Linux de votre conteneur. Pour plus d'informations, consultez les sections [Privilèges d'exécution et fonctionnalités Linux](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) dans la documentation Docker.

1. Exécutez la commande suivante pour démarrer le conteneur Docker.

   ```
   docker-compose -f docker-compose.yml up
   ```

1. <a name="docker-automatic-provisioning-remove-credentials-file"></a>Supprimez les informations d'identification `./greengrass-v2-credentials` de l'appareil hôte.

   ```
   rm -rf ./greengrass-v2-credentials
   ```
**Important**  
Vous supprimez ces informations d'identification, car elles fournissent des autorisations étendues dont le périphérique principal n'a besoin que lors de la configuration. Si vous ne supprimez pas ces informations d'identification, les composants Greengrass et les autres processus exécutés dans le conteneur peuvent y accéder. Si vous devez fournir des AWS informations d'identification à un composant Greengrass, utilisez le service d'échange de jetons. Pour de plus amples informations, veuillez consulter [Interagissez avec les AWS services](interact-with-aws-services.md).

------

## Étapes suivantes
<a name="run-greengrass-docker-next-steps"></a>

<a name="run-greengrass-docker-success"></a>AWS IoT Greengrass Le logiciel de base s'exécute désormais dans un conteneur Docker. Exécutez la commande suivante pour récupérer l'ID du conteneur en cours d'exécution.

```
docker ps
```

Vous pouvez ensuite exécuter la commande suivante pour accéder au conteneur et explorer les logiciels AWS IoT Greengrass principaux exécutés à l'intérieur du conteneur.

```
docker exec -it container-id /bin/bash
```

Pour plus d'informations sur la création d'un composant simple, voir [Étape 4 : développer et tester un composant sur votre appareil](create-first-component.md) [Tutoriel : Débuter avec AWS IoT Greengrass V2](getting-started.md)

**Note**  <a name="run-greengrass-commands-in-docker-note"></a>
Lorsque vous exécutez `docker exec` des commandes dans le conteneur Docker, ces commandes ne sont pas enregistrées dans les journaux Docker. Pour enregistrer vos commandes dans les journaux Docker, attachez un shell interactif au conteneur Docker. Pour de plus amples informations, veuillez consulter [Attachez un shell interactif au conteneur Docker](docker-troubleshooting.md#debugging-docker-attach-shell).

Le fichier journal AWS IoT Greengrass Core est appelé `greengrass.log` et se trouve dans`/greengrass/v2/logs`. Les fichiers journaux des composants se trouvent également dans le même répertoire. Pour copier les journaux de Greengrass dans un répertoire temporaire de l'hôte, exécutez la commande suivante :

```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```

Si vous souhaitez conserver les journaux après la sortie ou la suppression d'un conteneur, nous vous recommandons de lier uniquement le `/greengrass/v2/logs` répertoire au répertoire des journaux temporaires sur l'hôte au lieu de monter l'intégralité du répertoire Greengrass. Pour de plus amples informations, veuillez consulter [Persister les logs Greengrass en dehors du conteneur Docker](docker-troubleshooting.md#debugging-docker-persist-logs).

<a name="greengrass-docker-stop"></a>Pour arrêter un conteneur AWS IoT Greengrass Docker en cours d'exécution, exécutez `docker stop` ou`docker-compose -f docker-compose.yml stop`. Cette action est envoyée `SIGTERM` au processus Greengrass et arrête tous les processus associés qui ont été lancés dans le conteneur. Le conteneur Docker est initialisé avec l'`docker-init`exécutable en tant que processus PID 1, ce qui permet de supprimer les processus zombies restants. Pour plus d'informations, consultez la section [Spécifier un processus d'initialisation](https://docs.docker.com/engine/reference/run/#specify-an-init-process) dans la documentation Docker.

<a name="see-docker-troubleshooting"></a>Pour plus d'informations sur la résolution des problèmes liés AWS IoT Greengrass à l'exécution dans un conteneur Docker, consultez[Résolution des problèmes AWS IoT Greengrass dans un conteneur Docker](docker-troubleshooting.md).

# Exécuter AWS IoT Greengrass dans un conteneur Docker avec provisionnement manuel des ressources
<a name="run-greengrass-docker-manual-provisioning"></a>

Ce didacticiel explique comment installer et exécuter le logiciel AWS IoT Greengrass Core dans un conteneur Docker avec des ressources provisionnées AWS manuellement.

**Topics**
+ [Conditions préalables](#docker-manual-provisioning-prereqs)
+ [Récupérer des points de AWS IoT terminaison](#retrieve-iot-endpoints)
+ [Créez n'importe AWS IoT quoi](#create-iot-thing)
+ [Créez le certificat d'objet](#create-thing-certificate-mp)
+ [Création d'un rôle d'échange de jetons](#create-token-exchange-role)
+ [Télécharger les certificats sur l'appareil](#download-thing-certificates)
+ [Création d'un fichier de configuration](#create-docker-install-configuration-file)
+ [Création d'un fichier d'environnement](#create-env-file-manual-provisioning)
+ [Exécuter le logiciel de AWS IoT Greengrass base dans un conteneur](#run-greengrass-image-manual-provisioning)
+ [Étapes suivantes](#run-greengrass-docker-next-steps)

## Conditions préalables
<a name="docker-manual-provisioning-prereqs"></a>

Pour suivre ce didacticiel, vous aurez besoin des éléments suivants :
+ Un Compte AWS. Si vous n'en avez pas, veuillez consulter [Configurez un Compte AWS](setting-up.md#set-up-aws-account). 
+ Une image AWS IoT Greengrass Docker. Vous pouvez [créer une image à partir du AWS IoT Greengrass Dockerfile](build-greengrass-dockerfile.md).
+ L'ordinateur hôte sur lequel vous exécutez le conteneur Docker doit répondre aux exigences suivantes :
  + <a name="docker-host-reqs"></a>Système d'exploitation basé sur Linux doté d'une connexion Internet.
  + <a name="docker-engine-reqs"></a>[Docker Engine](https://docs.docker.com/engine/install/) version 18.09 ou ultérieure.
  + <a name="docker-compose-reqs"></a>(Facultatif) [Docker Compose](https://docs.docker.com/compose/install/) version 1.22 ou ultérieure. Docker Compose n'est requis que si vous souhaitez utiliser la CLI Docker Compose pour exécuter vos images Docker.

## Récupérer des points de AWS IoT terminaison
<a name="retrieve-iot-endpoints"></a>

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

## Créez n'importe AWS IoT quoi
<a name="create-iot-thing"></a>

AWS IoT *les objets* représentent les appareils et les entités logiques auxquels ils se connectent AWS IoT. Les appareils Greengrass Core sont AWS IoT des objets. Lorsque vous enregistrez un appareil en tant qu' AWS IoT objet, celui-ci peut utiliser un certificat numérique pour s'authentifier. AWS

Dans cette section, vous allez créer un AWS IoT objet qui représente votre appareil.

**Pour créer AWS IoT quelque chose**

1. Créez n'importe AWS IoT quel objet pour votre appareil. Sur votre ordinateur de développement, exécutez la commande suivante.
   + Remplacez *MyGreengrassCore* par le nom de l'objet à utiliser. Ce nom est également le nom de votre appareil principal Greengrass.
**Note**  <a name="install-argument-thing-name-constraint"></a>
Le nom de l'objet ne peut pas contenir de caractères deux-points (`:`).

   ```
   aws iot create-thing --thing-name MyGreengrassCore
   ```

   La réponse ressemble à l'exemple suivant, si la demande aboutit.

   ```
   {
     "thingName": "MyGreengrassCore",
     "thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
     "thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
   }
   ```

1. (Facultatif) Ajoutez l' AWS IoT objet à un nouveau groupe d'objets ou à un groupe d'objets existant. Vous utilisez des groupes d'objets pour gérer des flottes d'appareils principaux de Greengrass. Lorsque vous déployez des composants logiciels sur vos appareils, vous pouvez cibler des appareils individuels ou des groupes d'appareils. Vous pouvez ajouter un appareil à un groupe d'objets avec un déploiement Greengrass actif pour déployer les composants logiciels de ce groupe d'objets sur l'appareil. Procédez comme suit :

   1. (Facultatif) Créez un AWS IoT groupe d'objets.
      + Remplacez *MyGreengrassCoreGroup* par le nom du groupe d'objets à créer.
**Note**  <a name="install-argument-thing-group-name-constraint"></a>
Le nom du groupe d'objets ne peut pas contenir de deux-points (`:`).

      ```
      aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
      ```

      La réponse ressemble à l'exemple suivant, si la demande aboutit.

      ```
      {
        "thingGroupName": "MyGreengrassCoreGroup",
        "thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
        "thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
      }
      ```

   1. Ajoutez l' AWS IoT objet à un groupe d'objets.
      + Remplacez *MyGreengrassCore* par le nom de votre AWS IoT objet.
      + Remplacez *MyGreengrassCoreGroup* par le nom du groupe d'objets.

      ```
      aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
      ```

      La commande n'a aucune sortie si la demande aboutit.

## Créez le certificat d'objet
<a name="create-thing-certificate-mp"></a>

<a name="create-thing-certificate-intro-1"></a>Lorsque vous enregistrez un appareil en tant qu' AWS IoT objet, celui-ci peut utiliser un certificat numérique pour s'authentifier. AWS Ce certificat permet à l'appareil de communiquer avec AWS IoT et AWS IoT Greengrass.

<a name="create-thing-certificate-intro-2"></a>Dans cette section, vous allez créer et télécharger des certificats que votre appareil peut utiliser pour se connecter AWS.<a name="create-thing-certificate-cloud-steps"></a>

**Pour créer le certificat d'objet**

1. Créez un dossier dans lequel vous téléchargerez les certificats de l' AWS IoT objet.

   ```
   mkdir greengrass-v2-certs
   ```

1. Créez et téléchargez les certificats AWS IoT correspondants.

   ```
   aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
   ```

   La réponse ressemble à l'exemple suivant, si la demande aboutit.

   ```
   {
     "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
     "certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
     "certificatePem": "-----BEGIN CERTIFICATE-----
   MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
    0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
    WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
    EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
    jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
    MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
    WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
    HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
    BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
    k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
    ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
    AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
    KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
    EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
    3rrszlaEXAMPLE=
   -----END CERTIFICATE-----",
     "keyPair": {
       "PublicKey": "-----BEGIN PUBLIC KEY-----\
   MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
   MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
   59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
   hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
   FQIDAQAB\
   -----END PUBLIC KEY-----\
   ",
       "PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
   key omitted for security reasons\
   -----END RSA PRIVATE KEY-----\
   "
     }
   }
   ```

   Enregistrez le nom de ressource Amazon (ARN) du certificat afin de l'utiliser pour configurer le certificat ultérieurement.

Configurez ensuite le certificat d'objet. Pour de plus amples informations, veuillez consulter [Configurer le certificat d'objet](manual-installation.md#configure-thing-certificate).

## Création d'un rôle d'échange de jetons
<a name="create-token-exchange-role"></a>

<a name="installation-create-token-exchange-role-intro"></a>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).

<a name="installation-create-token-exchange-role-alias-intro"></a>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 de l'appareil. 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. Ensuite, vous configurez l'appareil pour AWS IoT qu'il utilise ce rôle et cet alias.

**Pour créer un rôle IAM d'échange de jetons**

1. <a name="create-token-exchange-role-create-iam-role"></a>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.

      <a name="nano-command-intro"></a>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.

      <a name="nano-command-intro"></a>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. <a name="create-token-exchange-role-create-iot-role-alias"></a>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*.

1. Créez et attachez une AWS IoT politique qui permet à votre appareil principal Greengrass d'utiliser l'alias de rôle pour assumer le rôle d'échange de jetons. Si vous avez déjà configuré un appareil principal Greengrass, vous pouvez associer sa AWS IoT politique d'alias de rôle au lieu d'en créer une nouvelle. Procédez comme suit :

   1. (Facultatif) Créez un fichier contenant le document AWS IoT de politique requis par l'alias de rôle.

      <a name="nano-command-intro"></a>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-role-alias-policy.json
      ```

      Copiez le code JSON suivant dans le fichier.
      + Remplacez l'ARN de la ressource par l'ARN de votre alias de rôle.

      ```
      {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
          {
            "Effect": "Allow",
            "Action": "iot:AssumeRoleWithCertificate",
            "Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
          }
        ]
      }
      ```

   1. Créez une AWS IoT politique à partir du document de stratégie.
      + Remplacez *GreengrassCoreTokenExchangeRoleAliasPolicy* par le nom de la AWS IoT politique à créer.

      ```
      aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
      ```

      La réponse ressemble à l'exemple suivant, si la demande aboutit.

      ```
      {
        "policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
        "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
        "policyDocument": "{
          \\"Version\\":\\"2012-10-17		 	 	 \\",
          \\"Statement\\": [
            {
              \\"Effect\\": \\"Allow\\",
              \\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
              \\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
            }
          ]
        }",
        "policyVersionId": "1"
      }
      ```

   1. Joignez la AWS IoT politique au certificat de l' AWS IoT objet.
      + Remplacez *GreengrassCoreTokenExchangeRoleAliasPolicy* par le nom de la AWS IoT politique d'alias de rôle.
      + Remplacez l'ARN cible par l'ARN du certificat associé à votre AWS IoT objet.

      ```
      aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
      ```

      La commande n'a aucune sortie si la demande aboutit.

## Télécharger les certificats sur l'appareil
<a name="download-thing-certificates"></a>

Auparavant, vous avez téléchargé le certificat de votre appareil sur votre ordinateur de développement. Dans cette section, vous allez télécharger le certificat de l'autorité de certification racine (CA) Amazon. Ensuite, si vous prévoyez d'exécuter le logiciel AWS IoT Greengrass Core dans Docker sur un autre ordinateur que votre ordinateur de développement, vous copiez les certificats sur cet ordinateur hôte. Le logiciel AWS IoT Greengrass Core utilise ces certificats pour se connecter au service AWS IoT cloud.

**Pour télécharger des certificats sur l'appareil**

1. Sur votre ordinateur de développement, téléchargez le certificat Amazon Root Certificate Authority (CA). 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-certs/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
   ```

------
#### [ Windows Command Prompt (CMD) ]

   ```
   curl -o .\greengrass-v2-certs\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
   ```

------
#### [ PowerShell ]

   ```
   iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile .\greengrass-v2-certs\AmazonRootCA1.pem
   ```

------

1. Si vous prévoyez d'exécuter le logiciel AWS IoT Greengrass Core dans Docker sur un appareil différent de celui de votre ordinateur de développement, copiez les certificats sur l'ordinateur hôte. Si SSH et SCP sont activés sur l'ordinateur de développement et sur l'ordinateur hôte, vous pouvez utiliser la `scp` commande de votre ordinateur de développement pour transférer les certificats. Remplacez *device-ip-address* par l'adresse IP de votre ordinateur hôte.

   ```
   scp -r greengrass-v2-certs/ device-ip-address:~
   ```

## Création d'un fichier de configuration
<a name="create-docker-install-configuration-file"></a>

1. Sur l'ordinateur hôte, créez un dossier dans lequel vous placez votre fichier de configuration.

   ```
   mkdir ./greengrass-v2-config
   ```

1. Utilisez un éditeur de texte pour créer un fichier de configuration nommé `config.yaml` dans le `./greengrass-v2-config` dossier.

   Par exemple, vous pouvez exécuter la commande suivante pour utiliser GNU nano afin de créer le`config.yaml`. 

   ```
   nano ./greengrass-v2-config/config.yaml
   ```

1. Copiez le contenu YAML suivant dans le fichier. Ce fichier de configuration partiel spécifie les paramètres du système et les paramètres du noyau de Greengrass.

   ```
   ---
   system:
     certificateFilePath: "/tmp/certs/device.pem.crt"
     privateKeyPath: "/tmp/certs/private.pem.key"
     rootCaPath: "/tmp/certs/AmazonRootCA1.pem"
     rootpath: "/greengrass/v2"
     thingName: "MyGreengrassCore"
   services:
     aws.greengrass.Nucleus:
       componentType: "NUCLEUS"
       version: "nucleus-version"
       configuration:
         awsRegion: "region"
         iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
         iotDataEndpoint: "device-data-prefix-ats.iot.region.amazonaws.com"
         iotCredEndpoint: "device-credentials-prefix.credentials.region.amazonaws.com"
   ```

   Remplacez ensuite les valeurs suivantes :
   + */tmp/certs*. Le répertoire du conteneur Docker dans lequel vous montez les certificats téléchargés lorsque vous démarrez le conteneur.
   + `/greengrass/v2`. Le dossier racine de Greengrass que vous souhaitez utiliser pour l'installation. Vous utilisez la variable d'`GGC_ROOT`environnement pour définir cette valeur.
   + *MyGreengrassCore*. Le nom du AWS IoT truc.
   + *nucleus-version*. Version du logiciel AWS IoT Greengrass Core à installer. Cette valeur doit correspondre à la version de l'image Docker ou du Dockerfile que vous avez téléchargé. Si vous avez téléchargé l'image Greengrass Docker avec la `latest` balise, utilisez-la ****docker inspect *image-id***** pour voir la version de l'image.
   + *region*. L' Région AWS endroit où vous avez créé vos AWS IoT ressources. Vous devez également spécifier la même valeur pour la variable d'`AWS_REGION`environnement dans votre [fichier d'environnement](#create-env-file-manual-provisioning).
   + *GreengrassCoreTokenExchangeRoleAlias*. Alias du rôle d'échange de jetons.
   + *device-data-prefix*. Le préfixe de votre point de terminaison AWS IoT de données.
   + *device-credentials-prefix*. Le préfixe du point de terminaison de vos AWS IoT informations d'identification.

## Création d'un fichier d'environnement
<a name="create-env-file-manual-provisioning"></a>

Ce didacticiel utilise un fichier d'environnement pour définir les variables d'environnement qui seront transmises au programme d'installation du logiciel AWS IoT Greengrass Core dans le conteneur Docker. Vous pouvez également utiliser [l'`--env`argument `-e` or](https://docs.docker.com/engine/reference/commandline/run/#env) dans votre `docker run` commande pour définir des variables d'environnement dans le conteneur Docker ou vous pouvez définir les variables dans [un `environment` bloc](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) du `docker-compose.yml` fichier.

1. Utilisez un éditeur de texte pour créer un fichier d'environnement nommé`.env`.

   Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano afin de créer le `.env` dans le répertoire actuel.

   ```
   nano .env
   ```

1. Copiez le contenu suivant dans le fichier.

   ```
   GGC_ROOT_PATH=/greengrass/v2
   AWS_REGION=region
   PROVISION=false
   COMPONENT_DEFAULT_USER=ggc_user:ggc_group
   INIT_CONFIG=/tmp/config/config.yaml
   ```

   Remplacez ensuite les valeurs suivantes.
   + `/greengrass/v2`. Le chemin d'accès au dossier racine à utiliser pour installer le logiciel AWS IoT Greengrass Core.
   + *region*. L' Région AWS endroit où vous avez créé vos AWS IoT ressources. Vous devez spécifier la même valeur pour le paramètre `awsRegion` de configuration dans votre [fichier de configuration](#create-docker-install-configuration-file).
   + */tmp/config/*. Le dossier dans lequel vous montez le fichier de configuration lorsque vous démarrez le conteneur Docker.
**Note**  <a name="docker-local-dev-tools-production-environment-warning"></a>
Vous pouvez définir la variable d'`DEPLOY_DEV_TOOLS`environnement sur `true` pour déployer le [composant Greengrass CLI](greengrass-cli-component.md), ce qui vous permet de développer des composants personnalisés dans le conteneur Docker. <a name="local-dev-tools-production-environment-warning"></a>Nous vous recommandons d'utiliser ce composant uniquement dans les environnements de développement, et non dans les environnements de production. Ce composant permet d'accéder à des informations et à des opérations dont vous n'avez généralement pas besoin dans un environnement de production. Respectez le principe du moindre privilège en déployant ce composant uniquement sur les appareils principaux là où vous en avez besoin. 

## Exécuter le logiciel de AWS IoT Greengrass base dans un conteneur
<a name="run-greengrass-image-manual-provisioning"></a>

Ce didacticiel explique comment démarrer l'image Docker que vous avez créée dans un conteneur Docker. Vous pouvez utiliser la CLI Docker ou la CLI Docker Compose pour exécuter l'image logicielle AWS IoT Greengrass Core dans un conteneur Docker. 

------
#### [ Docker ]
+ Ce didacticiel vous montre comment démarrer l'image Docker que vous avez créée dans un conteneur Docker. 

  ```
  docker run --rm --init -it --name docker-image \
   -v path/to/greengrass-v2-config:/tmp/config/:ro \
   -v path/to/greengrass-v2-certs:/tmp/certs:ro \ 
   --env-file .env \
   -p 8883 \
   your-container-image:version
  ```

  Cet exemple de commande utilise les arguments suivants pour [docker run](https://docs.docker.com/engine/reference/commandline/run/) :
  + <a name="docker-run-rm"></a>[https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm). Nettoie le conteneur à sa sortie.
  + <a name="docker-run-init"></a>[https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process). Utilise un processus d'initialisation dans le conteneur. 
**Note**  
L'`--init`argument est nécessaire pour arrêter le logiciel AWS IoT Greengrass Core lorsque vous arrêtez le conteneur Docker.
  + <a name="docker-run-it"></a>[https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground). (Facultatif) Exécute le conteneur Docker au premier plan en tant que processus interactif. Vous pouvez le remplacer par l'`-d`argument pour exécuter le conteneur Docker en mode détaché à la place. Pour plus d'informations, consultez la section [Détachée ou avant-plan](https://docs.docker.com/engine/reference/run/#detached-vs-foreground) dans la documentation Docker.
  + <a name="docker-run-name"></a>[https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name). Exécute un conteneur nommé `aws-iot-greengrass` 
  + <a name="docker-run-v"></a>[https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/). Monte un volume dans le conteneur Docker pour que le fichier de configuration et les fichiers de certificat puissent être AWS IoT Greengrass exécutés dans le conteneur.
  + <a name="docker-run-env-file"></a>[https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env). (Facultatif) Spécifie le fichier d'environnement pour définir les variables d'environnement qui seront transmises au programme d'installation du logiciel AWS IoT Greengrass Core dans le conteneur Docker. Cet argument n'est obligatoire que si vous avez créé un [fichier d'environnement](#create-env-file-manual-provisioning) pour définir des variables d'environnement. Si vous n'avez pas créé de fichier d'environnement, vous pouvez utiliser des `--env` arguments pour définir des variables d'environnement directement dans votre commande Docker run.
  + <a name="docker-run-p"></a>[https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish). (Facultatif) Publie le port du conteneur 8883 sur la machine hôte. Cet argument est obligatoire si vous souhaitez vous connecter et communiquer via MQTT car il AWS IoT Greengrass utilise le port 8883 pour le trafic MQTT. Pour ouvrir d'autres ports, utilisez des `-p` arguments supplémentaires.
**Note**  <a name="docker-run-cap-drop"></a>
Pour exécuter votre conteneur Docker avec une sécurité accrue, vous pouvez utiliser les `--cap-add` arguments `--cap-drop` et pour activer de manière sélective les fonctionnalités Linux de votre conteneur. Pour plus d'informations, consultez [Privilèges d'exécution et fonctionnalités Linux](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) dans la documentation Docker.

------
#### [ Docker Compose ]

1. Utilisez un éditeur de texte pour créer un fichier Docker Compose nommé`docker-compose.yml`.

   Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano afin de créer le `docker-compose.yml` dans le répertoire actuel.

   ```
   nano docker-compose.yml
   ```
**Note**  
Vous pouvez également télécharger et utiliser la dernière version du fichier Compose AWS fourni à partir de [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/).

1. Ajoutez le contenu suivant au fichier Compose. Votre fichier doit être similaire à l'exemple suivant : *your-container-name:version*Remplacez-le par le nom de votre image Docker. 

   ```
   version: '3.7'
    
   services:
     greengrass:
       init: true
       build:
         context: .
       container_name: aws-iot-greengrass
       image: your-container-name:version
       volumes:
         - /path/to/greengrass-v2-config:/tmp/config/:ro
         - /path/to/greengrass-v2-certs:/tmp/certs:ro 
       env_file: .env
       ports:
         - "8883:8883"
   ```<a name="docker-compose-optional-params"></a>

   Les paramètres suivants de cet exemple de fichier Compose sont facultatifs :
   + `ports`—Publie les ports du conteneur 8883 sur la machine hôte. Ce paramètre est obligatoire si vous souhaitez vous connecter et communiquer via MQTT car il AWS IoT Greengrass utilise le port 8883 pour le trafic MQTT. 
   + `env_file`—Spécifie le fichier d'environnement pour définir les variables d'environnement qui seront transmises au programme d'installation du logiciel AWS IoT Greengrass Core dans le conteneur Docker. Ce paramètre n'est obligatoire que si vous avez créé un [fichier d'environnement](#create-env-file-manual-provisioning) pour définir des variables d'environnement. Si vous n'avez pas créé de fichier d'environnement, vous pouvez utiliser le paramètre d'[environnement](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) pour définir les variables directement dans votre fichier Compose.
**Note**  <a name="docker-compose-cap-drop"></a>
Pour exécuter votre conteneur Docker avec une sécurité accrue, vous pouvez utiliser `cap_drop` et `cap_add` dans votre fichier Compose pour activer de manière sélective les fonctionnalités Linux de votre conteneur. Pour plus d'informations, consultez [Privilèges d'exécution et fonctionnalités Linux](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) dans la documentation Docker.

1. Exécutez la commande suivante pour démarrer le conteneur.

   ```
   docker-compose -f docker-compose.yml up
   ```

------

## Étapes suivantes
<a name="run-greengrass-docker-next-steps"></a>

<a name="run-greengrass-docker-success"></a>AWS IoT Greengrass Le logiciel de base s'exécute désormais dans un conteneur Docker. Exécutez la commande suivante pour récupérer l'ID du conteneur en cours d'exécution.

```
docker ps
```

Vous pouvez ensuite exécuter la commande suivante pour accéder au conteneur et explorer les logiciels AWS IoT Greengrass principaux exécutés à l'intérieur du conteneur.

```
docker exec -it container-id /bin/bash
```

Pour plus d'informations sur la création d'un composant simple, voir [Étape 4 : développer et tester un composant sur votre appareil](create-first-component.md) [Tutoriel : Débuter avec AWS IoT Greengrass V2](getting-started.md)

**Note**  <a name="run-greengrass-commands-in-docker-note"></a>
Lorsque vous exécutez `docker exec` des commandes dans le conteneur Docker, ces commandes ne sont pas enregistrées dans les journaux Docker. Pour enregistrer vos commandes dans les journaux Docker, attachez un shell interactif au conteneur Docker. Pour de plus amples informations, veuillez consulter [Attachez un shell interactif au conteneur Docker](docker-troubleshooting.md#debugging-docker-attach-shell).

Le fichier journal AWS IoT Greengrass Core est appelé `greengrass.log` et se trouve dans`/greengrass/v2/logs`. Les fichiers journaux des composants se trouvent également dans le même répertoire. Pour copier les journaux de Greengrass dans un répertoire temporaire de l'hôte, exécutez la commande suivante :

```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```

Si vous souhaitez conserver les journaux après la sortie ou la suppression d'un conteneur, nous vous recommandons de lier uniquement le `/greengrass/v2/logs` répertoire au répertoire des journaux temporaires sur l'hôte au lieu de monter l'intégralité du répertoire Greengrass. Pour de plus amples informations, veuillez consulter [Persister les logs Greengrass en dehors du conteneur Docker](docker-troubleshooting.md#debugging-docker-persist-logs).

<a name="greengrass-docker-stop"></a>Pour arrêter un conteneur AWS IoT Greengrass Docker en cours d'exécution, exécutez `docker stop` ou`docker-compose -f docker-compose.yml stop`. Cette action est envoyée `SIGTERM` au processus Greengrass et arrête tous les processus associés qui ont été lancés dans le conteneur. Le conteneur Docker est initialisé avec l'`docker-init`exécutable en tant que processus PID 1, ce qui permet de supprimer les processus zombies restants. Pour plus d'informations, consultez la section [Spécifier un processus d'initialisation](https://docs.docker.com/engine/reference/run/#specify-an-init-process) dans la documentation Docker.

<a name="see-docker-troubleshooting"></a>Pour plus d'informations sur la résolution des problèmes liés AWS IoT Greengrass à l'exécution dans un conteneur Docker, consultez[Résolution des problèmes AWS IoT Greengrass dans un conteneur Docker](docker-troubleshooting.md).

# Résolution des problèmes AWS IoT Greengrass dans un conteneur Docker
<a name="docker-troubleshooting"></a>

Utilisez les informations suivantes pour résoudre les problèmes liés à l'exécution AWS IoT Greengrass dans un conteneur Docker et pour résoudre les problèmes liés AWS IoT Greengrass au conteneur Docker.

**Topics**
+ [Résolution des problèmes liés à l'exécution du conteneur Docker](#troubleshooting-container-errors)
+ [Débogage AWS IoT Greengrass dans un conteneur Docker](#debugging-greengrass-in-docker)

## Résolution des problèmes liés à l'exécution du conteneur Docker
<a name="troubleshooting-container-errors"></a>

Utilisez les informations suivantes pour résoudre les problèmes liés à l'exécution AWS IoT Greengrass dans un conteneur Docker.

**Topics**
+ [Erreur : impossible d'effectuer une connexion interactive à partir d'un appareil autre que TTY](#docker-troubleshootin-ecr-get-login-password)
+ [Erreur : options inconnues : - no-include-email](#docker-troubleshooting-cli-version)
+ [Erreur : Un pare-feu bloque le partage de fichiers entre les fenêtres et les conteneurs.](#docker-troubleshooting-firewall)
+ [Erreur : une erreur s'est produite (AccessDeniedException) lors de l'appel de l' GetAuthorizationToken opération : L'utilisateur : arn:aws:iam : ::user/ <user-name>n'*account-id*est pas autorisé à effectuer : ecr : on resource : \$1 GetAuthorizationToken](#docker-troubleshooting-ecr-perms)
+ [Erreur : vous avez atteint votre limite de taux d'attraction](#docker-troubleshooting-too-many-requests)

### Erreur : impossible d'effectuer une connexion interactive à partir d'un appareil autre que TTY
<a name="docker-troubleshootin-ecr-get-login-password"></a>

Cette erreur peut se produire lorsque vous exécutez la `aws ecr get-login-password` commande. Assurez-vous d'avoir installé la dernière AWS CLI version 2 ou version 1. Nous vous recommandons d'utiliser la AWS CLI version 2. Pour plus d’informations, consultez [Installation d’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) dans le *Guide de l’utilisateur AWS Command Line Interface *.

### Erreur : options inconnues : - no-include-email
<a name="docker-troubleshooting-cli-version"></a>

Cette erreur peut se produire lorsque vous exécutez la `aws ecr get-login` commande. Assurez-vous que la dernière AWS CLI version est installée (par exemple, Run :`pip install awscli --upgrade --user`). Pour plus d'informations, consultez la section [Installation du AWS Command Line Interface sous Microsoft Windows](https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html) dans le *Guide de AWS Command Line Interface l'utilisateur*.

### Erreur : Un pare-feu bloque le partage de fichiers entre les fenêtres et les conteneurs.
<a name="docker-troubleshooting-firewall"></a>

Vous pouvez recevoir cette erreur ou un `Firewall Detected` message lors de l'exécution de Docker sur un ordinateur Windows. Ce problème peut également survenir si vous êtes connecté à un réseau privé virtuel (VPN) et que vos paramètres réseau empêchent le montage du lecteur partagé. Dans ce cas, désactivez le VPN et réexécutez le conteneur Docker.

### Erreur : une erreur s'est produite (AccessDeniedException) lors de l'appel de l' GetAuthorizationToken opération : L'utilisateur : arn:aws:iam : ::user/ <user-name>n'*account-id*est pas autorisé à effectuer : ecr : on resource : \$1 GetAuthorizationToken
<a name="docker-troubleshooting-ecr-perms"></a>

Vous pouvez recevoir cette erreur lors de l'exécution de la `aws ecr get-login-password` commande si vous ne disposez pas des autorisations suffisantes pour accéder à un référentiel Amazon ECR. Pour plus d'informations, consultez les [exemples de politiques relatives aux référentiels Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html) et [l'accès à un référentiel Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/security_iam_id-based-policy-examples.html) dans le guide de l'utilisateur *Amazon ECR.*

### Erreur : vous avez atteint votre limite de taux d'attraction
<a name="docker-troubleshooting-too-many-requests"></a>

Docker Hub limite le nombre de pull requests que les utilisateurs anonymes et gratuits de Docker Hub peuvent effectuer. Si vous dépassez les limites de débit pour les pull requests anonymes ou gratuites destinées aux utilisateurs, vous recevez l'une des erreurs suivantes : 

  

```
ERROR: toomanyrequests: Too Many Requests.
```

  

```
You have reached your pull rate limit.
```

Pour résoudre ces erreurs, vous pouvez attendre quelques heures avant d'essayer une autre pull request. Si vous prévoyez de soumettre régulièrement un grand nombre de pull requests, consultez le [site Web de Docker Hub](https://www.docker.com/increase-rate-limits) pour obtenir des informations sur les limites de débit et les options d'authentification et de mise à niveau de votre compte Docker. 

## Débogage AWS IoT Greengrass dans un conteneur Docker
<a name="debugging-greengrass-in-docker"></a>

Pour déboguer les problèmes avec un conteneur Docker, vous pouvez conserver les journaux d'exécution Greengrass ou attacher un shell interactif au conteneur Docker.

### Persister les logs Greengrass en dehors du conteneur Docker
<a name="debugging-docker-persist-logs"></a>

Après avoir arrêté un AWS IoT Greengrass conteneur, vous pouvez utiliser la `docker cp ` commande suivante pour copier les journaux Greengrass du conteneur Docker vers un répertoire de journaux temporaire. 

```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```

Pour conserver les journaux même après la sortie ou la suppression d'un conteneur, vous devez exécuter le conteneur AWS IoT Greengrass Docker après avoir monté le répertoire par liaison. `/greengrass/v2/logs` 

Pour monter le `/greengrass/v2/logs` répertoire par liaison, effectuez l'une des opérations suivantes lorsque vous exécutez un nouveau conteneur AWS IoT Greengrass Docker.
+ Incluez `-v /tmp/logs:/greengrass/v2/logs:ro` dans votre `docker run` commande.

  Modifiez le `volumes` bloc dans le fichier Compose pour inclure la ligne suivante avant d'exécuter votre `docker-compose up` commande.

  ```
  volumes:
   - /tmp/logs:/greengrass/v2/logs:ro
  ```

Vous pouvez ensuite consulter vos journaux `/tmp/logs` sur votre hôte pour voir les journaux de Greengrass lorsqu' AWS IoT Greengrass il est exécuté dans le conteneur Docker.

Pour plus d'informations sur l'exécution des conteneurs Greengrass Docker, consultez et [Exécuter AWS IoT Greengrass dans Docker avec provisionnement manuel](run-greengrass-docker-manual-provisioning.md) [Exécuter AWS IoT Greengrass dans Docker avec provisionnement automatique](run-greengrass-docker-automatic-provisioning.md)

### Attachez un shell interactif au conteneur Docker
<a name="debugging-docker-attach-shell"></a>

Lorsque vous exécutez `docker exec` des commandes dans le conteneur Docker, ces commandes ne sont pas capturées dans les journaux Docker. L'enregistrement de vos commandes dans les journaux Docker peut vous aider à étudier l'état du conteneur Greengrass Docker. Effectuez l’une des actions suivantes :
+ Exécutez la commande suivante dans un terminal séparé pour associer l'entrée, la sortie et l'erreur standard de votre terminal au conteneur en cours d'exécution. Cela vous permet de visualiser et de contrôler le conteneur Docker depuis votre terminal actuel.

  ```
  docker attach container-id
  ```
+ Exécutez la commande suivante dans un terminal séparé. Cela vous permet d'exécuter vos commandes en mode interactif, même si le conteneur n'est pas attaché.

  ```
  docker exec -it container-id sh -c "command > /proc/1/fd/1"
  ```

Pour un AWS IoT Greengrass dépannage général, voir[Résolution des problèmes AWS IoT Greengrass V2](troubleshooting.md).

# Configuration du logiciel AWS IoT Greengrass de base
<a name="configure-greengrass-core-v2"></a>

Le logiciel AWS IoT Greengrass Core propose des options que vous pouvez utiliser pour configurer le logiciel. Vous pouvez créer des déploiements pour configurer le logiciel AWS IoT Greengrass principal sur chaque appareil principal.

**Topics**
+ [Déployez le composant Greengrass nucleus](#configure-nucleus-component)
+ [Configurer le noyau Greengrass en tant que service système](#configure-system-service)
+ [Contrôlez l'allocation de mémoire grâce aux options JVM](#jvm-tuning)
+ [Configurer l'utilisateur qui exécute les composants](#configure-component-user)
+ [Configuration des limites de ressources système pour les composants](#configure-component-system-resource-limits)
+ [Connexion au port 443 ou via un proxy réseau](#configure-alpn-network-proxy)
+ [Utiliser un certificat d'appareil signé par une autorité de certification privée](#configure-nucleus-private-ca)
+ [Configurer les délais d'expiration et les paramètres de cache du MQTT](#configure-mqtt)
+ [Configurer Greengrass Nucleus sur le réseau IPv6](#configure-ipv6)

## Déployez le composant Greengrass nucleus
<a name="configure-nucleus-component"></a>

AWS IoT Greengrass fournit le logiciel AWS IoT Greengrass Core sous forme de composant que vous pouvez déployer sur vos appareils principaux Greengrass. Vous pouvez créer un déploiement pour appliquer la même configuration à plusieurs appareils principaux de Greengrass. Pour plus d’informations, consultez [Noyau de Greengrass](greengrass-nucleus-component.md) et [Mettre à jour le logiciel AWS IoT Greengrass principal (OTA)](update-greengrass-core-v2.md).

## Configurer le noyau Greengrass en tant que service système
<a name="configure-system-service"></a>

Vous devez configurer le logiciel AWS IoT Greengrass Core en tant que service système dans le système d'initialisation de votre appareil pour effectuer les opérations suivantes :
+ Démarrez le logiciel AWS IoT Greengrass Core au démarrage de l'appareil. Il s'agit d'une bonne pratique si vous gérez de grands parcs d'appareils.
+ Installez et exécutez les composants du plugin. Plusieurs composants AWS fournis sont des modules d'extension, ce qui leur permet de s'interfacer directement avec le noyau de Greengrass. Pour plus d'informations sur les types de composants, consultez[Types de composants](develop-greengrass-components.md#component-types).
+ Appliquez les mises à jour over-the-air (OTA) au logiciel principal de l'appareil AWS IoT Greengrass principal. Pour de plus amples informations, veuillez consulter [Mettre à jour le logiciel AWS IoT Greengrass principal (OTA)](update-greengrass-core-v2.md).
+ Permettez aux composants de redémarrer le logiciel AWS IoT Greengrass principal ou le périphérique principal lorsqu'un déploiement met à jour le composant vers une nouvelle version ou met à jour certains paramètres de configuration. Pour plus d'informations, consultez l'[étape du cycle de vie du bootstrap](component-recipe-reference.md#bootstrap-lifecycle-definition).

**Important**  <a name="windows-system-service-requirement-important-note"></a>
Sur les appareils Windows Core, vous devez configurer le logiciel AWS IoT Greengrass Core en tant que service système.

**Topics**
+ [Configurer le noyau en tant que service système (Linux)](#configure-system-service-linux)
+ [Configuration du noyau en tant que service système (Windows)](#configure-system-service-windows)

### Configurer le noyau en tant que service système (Linux)
<a name="configure-system-service-linux"></a>

Les appareils Linux prennent en charge différents systèmes d'initialisation, tels que initd, systemd et systemV. Vous utilisez `--setup-system-service true` cet argument lorsque vous installez le logiciel AWS IoT Greengrass Core pour démarrer le noyau en tant que service système et le configurez pour qu'il soit lancé au démarrage du périphérique. Le programme d'installation configure le logiciel AWS IoT Greengrass Core en tant que service système avec systemd.

Vous pouvez également configurer manuellement le noyau pour qu'il s'exécute en tant que service système. L'exemple suivant est un fichier de service pour systemd.

```
[Unit]
Description=Greengrass Core

[Service]
Type=simple
PIDFile=/greengrass/v2/alts/loader.pid
RemainAfterExit=no
Restart=on-failure
RestartSec=10
ExecStart=/bin/sh /greengrass/v2/alts/current/distro/bin/loader

[Install]
WantedBy=multi-user.target
```

Après avoir configuré le service système, vous pouvez exécuter les commandes suivantes pour configurer le démarrage du périphérique au démarrage et pour démarrer ou arrêter le logiciel AWS IoT Greengrass Core.
+ Pour vérifier l'état du service (systemd)

  ```
  sudo systemctl status greengrass.service
  ```
+ Pour permettre au noyau de démarrer au démarrage de l'appareil.

  ```
  sudo systemctl enable greengrass.service
  ```
+ Pour empêcher le noyau de démarrer au démarrage de l'appareil.

  ```
  sudo systemctl disable greengrass.service
  ```
+ Pour démarrer le logiciel AWS IoT Greengrass Core.

  ```
  sudo systemctl start greengrass.service
  ```
+ Pour arrêter le logiciel AWS IoT Greengrass Core.

  ```
  sudo systemctl stop greengrass.service
  ```

### Configuration du noyau en tant que service système (Windows)
<a name="configure-system-service-windows"></a>

Vous utilisez `--setup-system-service true` cet argument lorsque vous installez le logiciel AWS IoT Greengrass Core pour démarrer le noyau en tant que service Windows et le configurez pour qu'il démarre au démarrage du périphérique.

Après avoir configuré le service, vous pouvez exécuter les commandes suivantes pour configurer le démarrage du périphérique au démarrage et pour démarrer ou arrêter le logiciel AWS IoT Greengrass Core. Vous devez exécuter l'invite de commande ou PowerShell en tant qu'administrateur pour exécuter ces commandes.

------
#### [ Windows Command Prompt (CMD) ]
+ Pour vérifier l'état du service

  ```
  sc query "greengrass"
  ```
+ Pour permettre au noyau de démarrer au démarrage de l'appareil.

  ```
  sc config "greengrass" start=auto
  ```
+ Pour empêcher le noyau de démarrer au démarrage de l'appareil.

  ```
  sc config "greengrass" start=disabled
  ```
+ Pour démarrer le logiciel AWS IoT Greengrass Core.

  ```
  sc start "greengrass"
  ```
+ Pour arrêter le logiciel AWS IoT Greengrass Core.

  ```
  sc stop "greengrass"
  ```
**Note**  <a name="windows-ignore-shutdown-signal-behavior-note"></a>
Sur les appareils Windows, le logiciel AWS IoT Greengrass Core ignore ce signal d'arrêt lorsqu'il arrête les processus des composants Greengrass. Si le logiciel AWS IoT Greengrass Core ignore le signal d'arrêt lorsque vous exécutez cette commande, attendez quelques secondes, puis réessayez.

------
#### [ PowerShell ]
+ Pour vérifier l'état du service

  ```
  Get-Service -Name "greengrass"
  ```
+ Pour permettre au noyau de démarrer au démarrage de l'appareil.

  ```
  Set-Service -Name "greengrass" -Status stopped -StartupType automatic
  ```
+ Pour empêcher le noyau de démarrer au démarrage de l'appareil.

  ```
  Set-Service -Name "greengrass" -Status stopped -StartupType disabled
  ```
+ Pour démarrer le logiciel AWS IoT Greengrass Core.

  ```
  Start-Service -Name "greengrass"
  ```
+ Pour arrêter le logiciel AWS IoT Greengrass Core.

  ```
  Stop-Service -Name "greengrass"
  ```
**Note**  <a name="windows-ignore-shutdown-signal-behavior-note"></a>
Sur les appareils Windows, le logiciel AWS IoT Greengrass Core ignore ce signal d'arrêt lorsqu'il arrête les processus des composants Greengrass. Si le logiciel AWS IoT Greengrass Core ignore le signal d'arrêt lorsque vous exécutez cette commande, attendez quelques secondes, puis réessayez.

------

## Contrôlez l'allocation de mémoire grâce aux options JVM
<a name="jvm-tuning"></a>

Si vous utilisez AWS IoT Greengrass un appareil dont la mémoire est limitée, vous pouvez utiliser les options de machine virtuelle Java (JVM) pour contrôler la taille maximale du tas, les modes de collecte des déchets et les options du compilateur, qui contrôlent la quantité de mémoire utilisée par le logiciel AWS IoT Greengrass Core. La taille du segment de mémoire dans la JVM détermine la quantité de mémoire qu'une application peut utiliser avant la [collecte des déchets](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/introduction.html) ou avant que l'application ne manque de mémoire. La taille de tas maximale indique la quantité maximale de mémoire que la machine virtuelle Java peut allouer lorsqu'elle augmente le tas dans le cadre d'une activité intensive. 

Pour contrôler l'allocation de mémoire, créez un nouveau déploiement ou révisez un déploiement existant qui inclut le composant noyau, et spécifiez vos options JVM dans le paramètre de `jvmOptions` configuration de la [configuration du composant noyau](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-jvm-options). 

Selon vos besoins, vous pouvez exécuter le logiciel AWS IoT Greengrass Core avec une allocation de mémoire réduite ou avec une allocation de mémoire minimale. 

**Allocation de mémoire réduite**  
Pour exécuter le logiciel AWS IoT Greengrass Core avec une allocation de mémoire réduite, nous vous recommandons d'utiliser l'exemple de mise à jour de fusion de configuration suivant pour définir les options JVM dans votre configuration Nucleus :

```
{
  "jvmOptions": "-XX:+UseSerialGC -XX:TieredStopAtLevel=1"
}
```

**Allocation de mémoire minimale**  
Pour exécuter le logiciel AWS IoT Greengrass Core avec une allocation de mémoire minimale, nous vous recommandons d'utiliser l'exemple de mise à jour de fusion de configuration suivant pour définir les options JVM dans votre configuration Nucleus :

```
{
  "jvmOptions": "-Xmx32m -XX:+UseSerialGC -Xint"
}
```

**Important**  
L'exécution du logiciel AWS IoT Greengrass Core avec une allocation de mémoire minimale peut avoir un impact significatif sur les performances des systèmes peu performants, car la JVM effectue plus de traitement lorsqu'elle utilise moins de mémoire. Nous vous recommandons de régler les options pour équilibrer vos besoins en termes de mémoire et de performances.

Ces exemples de mises à jour de fusion de configuration utilisent les options JVM suivantes :

`-XX:+UseSerialGC`  
Spécifie l'utilisation de la collecte des déchets en série pour l'espace de mémoire JVM. Le ramasse-miettes en série est plus lent, mais utilise moins de mémoire que les autres implémentations de collecte de déchets JVM.

`-XX:TieredStopAtLevel=1`  
Indique à la JVM d'utiliser le compilateur Java just-in-time (JIT) une seule fois. Comme le code compilé JIT utilise de l'espace dans la mémoire de l'appareil, l'utilisation du compilateur JIT à plusieurs reprises consomme plus de mémoire qu'une seule compilation.

`-XmxNNm`  
Définit la taille maximale du segment de mémoire JVM.  
Si vous définissez une taille de tas maximale trop faible, vous risquez de ralentir les performances ou de provoquer out-of-memory des erreurs. Nous vous recommandons de mesurer votre utilisation actuelle du tas avant de définir une taille maximale avec l'`-XmxNNm`option. Configurez votre JVM avec l'option `-XX:NativeMemoryTracking=detail` JVM. Mesurez ensuite votre utilisation actuelle du tas à l'aide de la demande de `VM.native_memory` commande dans l'utilitaire [jcmd](https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/tooldescr006.html).
Si la mesure du tas n'est pas une option, utilisez-la `-Xmx64m` comme valeur de départ pour limiter la taille du tas à 64 Mo. Vous pouvez ensuite diminuer progressivement la taille maximale du tas à partir de là. Pour une allocation de mémoire minimale, `-Xmx32m` utilisez-la comme valeur de départ pour limiter la taille du tas à 32 Mo.  
Vous pouvez augmenter ou diminuer la `-Xmx` valeur en fonction de vos besoins réels ; toutefois, nous vous recommandons vivement de ne pas définir la taille maximale du segment de mémoire en dessous de 16 Mo. La taille de segment de mémoire JVM nécessaire peut également varier au fil du temps en fonction des composants du plug-in déployés sur le périphérique principal. Si la taille maximale du tas est trop faible pour votre environnement, le logiciel AWS IoT Greengrass Core peut rencontrer des erreurs inattendues en raison d'une mémoire insuffisante. Si les performances sont plus lentes ou si vous rencontrez des erreurs en raison d'une mémoire insuffisante, revenez à un paramètre dont le fonctionnement a été vérifié. Par exemple, si la taille normale de votre tas engagé est`41428KB`, utilisez-le `-Xmx40m` pour limiter légèrement l'utilisation du tas.

`-Xint`  
Indique à la JVM de ne pas utiliser le compilateur just-in-time (JIT). Au lieu de cela, la JVM s'exécute en mode interprété uniquement. Ce mode est plus lent (potentiellement 20 fois plus lent pour les déploiements sur des systèmes bas de gamme) que l'exécution de code compilé JIT ; toutefois, le code compilé n'utilise aucun espace en mémoire.

Pour plus d'informations sur la création de mises à jour de fusion de configuration, consultez[Mettre à jour les configurations des composants](update-component-configurations.md).

## Configurer l'utilisateur qui exécute les composants
<a name="configure-component-user"></a>

Le logiciel AWS IoT Greengrass Core peut exécuter des processus de composants en tant qu'utilisateur du système et en tant que groupe différent de celui qui exécute le logiciel. Cela augmente la sécurité, car vous pouvez exécuter le logiciel AWS IoT Greengrass principal en tant que root ou en tant qu'utilisateur administrateur, sans accorder ces autorisations aux composants qui s'exécutent sur le périphérique principal.

Le tableau suivant indique les types de composants que le logiciel AWS IoT Greengrass Core peut exécuter en tant qu'utilisateur que vous spécifiez. Pour de plus amples informations, veuillez consulter [Types de composants](develop-greengrass-components.md#component-types).


| Type de composant | Configuration de l'utilisateur du composant | 
| --- | --- | 
|  Noyau  |  <a name="polaris-no-para"></a> ![\[No\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/images/icon-no.png) Non   | 
|  Plugin  |  <a name="polaris-no-para"></a> ![\[No\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/images/icon-no.png) Non   | 
|  Générique  |  <a name="polaris-yes-para"></a> ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/images/icon-yes.png) Oui   | 
|  Lambda (non conteneurisé)  |  <a name="polaris-yes-para"></a> ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/images/icon-yes.png) Oui   | 
|  Lambda (conteneurisé)  |  <a name="polaris-yes-para"></a> ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/images/icon-yes.png) Oui   | 

Vous devez créer l'utilisateur du composant avant de pouvoir le spécifier dans une configuration de déploiement. Sur les appareils Windows, vous devez également enregistrer le nom d'utilisateur et le mot de passe de l'utilisateur dans l'instance du gestionnaire d'informations d'identification du LocalSystem compte. Pour de plus amples informations, veuillez consulter [Configuration d'un utilisateur de composant sur les appareils Windows](#create-component-user-windows).

Lorsque vous configurez l'utilisateur du composant sur un appareil basé sur Linux, vous pouvez éventuellement spécifier un groupe. Vous spécifiez l'utilisateur et le groupe séparés par deux points (`:`) au format suivant :`user:group`. Si vous ne spécifiez aucun groupe, le logiciel AWS IoT Greengrass Core utilise par défaut le groupe principal de l'utilisateur. Vous pouvez utiliser le nom ou l'ID pour identifier l'utilisateur et le groupe. 

Sur les appareils basés sur Linux, vous pouvez également exécuter des composants en tant qu'utilisateur du système qui n'existe pas, également appelé utilisateur inconnu, pour renforcer la sécurité. Un processus Linux peut signaler tout autre processus exécuté par le même utilisateur. Un utilisateur inconnu n'exécute aucun autre processus. Vous pouvez donc exécuter des composants en tant qu'utilisateur inconnu pour empêcher les composants de signaler d'autres composants sur le périphérique principal. Pour exécuter des composants en tant qu'utilisateur inconnu, spécifiez un ID utilisateur qui n'existe pas sur le périphérique principal. Vous pouvez également spécifier un ID de groupe qui n'existe pas pour fonctionner en tant que groupe inconnu.

Vous pouvez configurer l'utilisateur pour chaque composant et pour chaque périphérique principal.
+ **Configuration pour un composant**

  Vous pouvez configurer chaque composant pour qu'il s'exécute avec un utilisateur spécifique à ce composant. Lorsque vous créez un déploiement, vous pouvez spécifier l'utilisateur pour chaque composant dans la `runWith` configuration de ce composant. Le logiciel AWS IoT Greengrass Core exécute les composants en tant qu'utilisateur spécifié si vous les configurez. Sinon, il exécute par défaut les composants en tant qu'utilisateur par défaut que vous configurez pour le périphérique principal. Pour plus d'informations sur la spécification de l'utilisateur du composant dans la configuration de déploiement, consultez le paramètre [`runWith`](create-deployments.md#component-run-with-config)de configuration dans[Créer des déploiements](create-deployments.md).
+ **Configuration de l'utilisateur par défaut pour un appareil principal**

  Vous pouvez configurer un utilisateur par défaut que le logiciel AWS IoT Greengrass Core utilise pour exécuter les composants. Lorsque le logiciel AWS IoT Greengrass Core exécute un composant, il vérifie si vous avez spécifié un utilisateur pour ce composant et l'utilise pour exécuter le composant. Si le composant ne spécifie aucun utilisateur, le logiciel AWS IoT Greengrass Core exécute le composant en tant qu'utilisateur par défaut que vous avez configuré pour le périphérique principal. Pour de plus amples informations, veuillez consulter [Configuration de l'utilisateur du composant par défaut](#configure-default-component-user).

**Note**  
Sur les appareils Windows, vous devez spécifier au moins un utilisateur par défaut pour exécuter les composants.  
Sur les appareils basés sur Linux, les considérations suivantes s'appliquent si vous ne configurez pas un utilisateur pour exécuter des composants :   
Si vous exécutez le logiciel AWS IoT Greengrass Core en tant qu'utilisateur root, le logiciel n'exécutera aucun composant. Vous devez spécifier un utilisateur par défaut pour exécuter les composants si vous exécutez en tant que root.
Si vous exécutez le logiciel AWS IoT Greengrass Core en tant qu'utilisateur non root, le logiciel exécute les composants sous le nom de cet utilisateur.

**Topics**
+ [Configuration d'un utilisateur de composant sur les appareils Windows](#create-component-user-windows)
+ [Configuration de l'utilisateur du composant par défaut](#configure-default-component-user)

### Configuration d'un utilisateur de composant sur les appareils Windows
<a name="create-component-user-windows"></a>

**Pour configurer un utilisateur de composants sur un appareil Windows**

1. Créez l'utilisateur du composant dans le LocalSystem compte de l'appareil.

   ```
   net user /add component-user password
   ```

1. Utilisez [l' PsExec utilitaire Microsoft](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) pour stocker le nom d'utilisateur et le mot de passe de l'utilisateur du composant dans l'instance Credential Manager du LocalSystem compte.

   ```
   psexec -s cmd /c cmdkey /generic:component-user /user:component-user /pass:password
   ```
**Note**  
Sur les appareils Windows, le LocalSystem compte exécute le noyau Greengrass et vous devez utiliser PsExec l'utilitaire pour stocker les informations utilisateur du composant dans LocalSystem le compte. L'application Credential Manager stocke ces informations dans le compte Windows de l'utilisateur actuellement connecté, plutôt que dans le LocalSystem compte.

### Configuration de l'utilisateur du composant par défaut
<a name="configure-default-component-user"></a>

Vous pouvez utiliser un déploiement pour configurer l'utilisateur par défaut sur un appareil principal. Dans ce déploiement, vous mettez à jour la configuration des [composants du noyau](greengrass-nucleus-component.md).

**Note**  
Vous pouvez également définir l'utilisateur par défaut lorsque vous installez le logiciel AWS IoT Greengrass Core avec l'`--component-default-user`option. Pour de plus amples informations, veuillez consulter [Installation du logiciel AWS IoT Greengrass de base](install-greengrass-core-v2.md).

[Créez un déploiement](create-deployments.md) qui spécifie la mise à jour de configuration suivante pour le `aws.greengrass.Nucleus` composant.

------
#### [ Linux ]

```
{
  "runWithDefault": {
    "posixUser": "ggc_user:ggc_group"
  }
}
```

------
#### [ Windows ]

```
{
  "runWithDefault": {
    "windowsUser": "ggc_user"
  }
}
```

**Note**  
L'utilisateur que vous spécifiez doit exister, et le nom d'utilisateur et le mot de passe de cet utilisateur doivent être stockés dans l'instance du gestionnaire d'informations d'identification du LocalSystem compte sur votre appareil Windows. Pour de plus amples informations, veuillez consulter [Configuration d'un utilisateur de composant sur les appareils Windows](#create-component-user-windows).

------

L'exemple suivant définit un déploiement pour un appareil basé sur Linux configuré en tant qu'utilisateur par défaut et `ggc_user` `ggc_group` en tant que groupe par défaut. La mise à jour `merge` de configuration nécessite un objet JSON sérialisé.

```
{
  "components": {
    "aws.greengrass.Nucleus": {
      "version": "2.16.1",
      "configurationUpdate": {
        "merge": "{\"runWithDefault\":{\"posixUser\":\"ggc_user:ggc_group\"}}"
      }
    }
  }
}
```

## Configuration des limites de ressources système pour les composants
<a name="configure-component-system-resource-limits"></a>

**Note**  
Cette fonctionnalité est disponible pour les versions 2.4.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. AWS IoT Greengrass ne prend actuellement pas en charge cette fonctionnalité sur les appareils Windows principaux. 

Vous pouvez configurer l'utilisation maximale du processeur et de la RAM que les processus de chaque composant peuvent utiliser sur le périphérique principal.

Le tableau suivant indique les types de composants compatibles avec les limites de ressources du système. Pour de plus amples informations, veuillez consulter [Types de composants](develop-greengrass-components.md#component-types).


| Type de composant | Configurer les limites des ressources du système | 
| --- | --- | 
|  Noyau  |  <a name="polaris-no-para"></a> ![\[No\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/images/icon-no.png) Non   | 
|  Plugin  |  <a name="polaris-no-para"></a> ![\[No\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/images/icon-no.png) Non   | 
|  Générique  |  <a name="polaris-yes-para"></a> ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/images/icon-yes.png) Oui   | 
|  Lambda (non conteneurisé)  |  <a name="polaris-yes-para"></a> ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/images/icon-yes.png) Oui   | 
|  Lambda (conteneurisé)  |  <a name="polaris-no-para"></a> ![\[No\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/images/icon-no.png) Non   | 

**Important**  
Les limites de ressources système ne sont pas prises en charge lorsque vous [exécutez le logiciel AWS IoT Greengrass Core dans un conteneur Docker](run-greengrass-docker.md).

Vous pouvez configurer les limites de ressources système pour chaque composant et pour chaque périphérique principal.
+ **Configuration pour un composant**

  Vous pouvez configurer chaque composant avec des limites de ressources système spécifiques à ce composant. Lorsque vous créez un déploiement, vous pouvez spécifier les limites de ressources système pour chaque composant du déploiement. Si le composant prend en charge les limites de ressources du système, le logiciel AWS IoT Greengrass principal applique ces limites aux processus du composant. Si vous ne spécifiez aucune limite de ressources système pour un composant, le logiciel AWS IoT Greengrass Core utilise les valeurs par défaut que vous avez configurées pour le périphérique principal. Pour de plus amples informations, veuillez consulter [Créer des déploiements](create-deployments.md).
+ **Configuration des valeurs par défaut pour un périphérique principal**

  Vous pouvez configurer les limites de ressources système par défaut que le logiciel AWS IoT Greengrass Core applique aux composants compatibles avec ces limites. Lorsque le logiciel AWS IoT Greengrass Core exécute un composant, il applique les limites de ressources système que vous spécifiez pour ce composant. Si ce composant ne spécifie pas de limites de ressources système, le logiciel AWS IoT Greengrass Core applique les limites de ressources système par défaut que vous configurez pour le périphérique principal. Si vous ne spécifiez pas de limites de ressources système par défaut, le logiciel AWS IoT Greengrass Core n'applique aucune limite de ressources système par défaut. Pour de plus amples informations, veuillez consulter [Configuration des limites de ressources système par défaut](#configure-default-component-system-resource-limits).

### Configuration des limites de ressources système par défaut
<a name="configure-default-component-system-resource-limits"></a>

Vous pouvez déployer le [composant Greengrass nucleus](greengrass-nucleus-component.md) pour configurer les limites de ressources système par défaut pour un périphérique principal. Pour configurer les limites de ressources système par défaut, [créez un déploiement](create-deployments.md) qui spécifie la mise à jour de configuration suivante pour le `aws.greengrass.Nucleus` composant.

```
{
  "runWithDefault": {
    "systemResourceLimits": {
      "cpu": cpuTimeLimit,
      "memory": memoryLimitInKb
    }
  }
}
```

L'exemple suivant définit un déploiement qui configure la limite de temps du processeur à`2`, ce qui équivaut à 50 % d'utilisation sur un appareil doté de 4 cœurs de processeur. Cet exemple configure également l'utilisation de la mémoire à 100 Mo.

```
{
  "components": {
    "aws.greengrass.Nucleus": {
      "version": "2.16.1",
      "configurationUpdate": {
        "merge": "{\"runWithDefault\":{\"systemResourceLimits\":\"cpus\":2,\"memory\":102400}}}"
      }
    }
  }
}
```

## Connexion au port 443 ou via un proxy réseau
<a name="configure-alpn-network-proxy"></a>

AWS IoT Greengrass les périphériques principaux communiquent avec eux AWS IoT Core à l'aide du protocole de messagerie MQTT avec authentification client TLS. Par convention, MQTT via TLS utilise le port 8883. Toutefois, par mesure de sécurité, les environnements restrictifs peuvent limiter le trafic entrant et sortant à une petite plage de ports TCP. Par exemple, un pare-feu d'entreprise peut ouvrir le port 443 pour le trafic HTTPS, mais fermer les autres ports qui sont utilisés pour des protocoles moins courants, tels que le port 8883 pour le trafic MQTT. D'autres environnements restrictifs peuvent exiger que tout le trafic passe par un proxy avant de se connecter à Internet.

**Note**  
Les appareils principaux de Greengrass qui exécutent le [composant Greengrass nucleus](greengrass-nucleus-component.md) v2.0.3 et versions antérieures utilisent le port 8443 pour se connecter au point de terminaison du plan de données. AWS IoT Greengrass Ces appareils doivent être en mesure de se connecter à ce point de terminaison sur le port 8443. Pour de plus amples informations, veuillez consulter [Autoriser le trafic des appareils via un proxy ou un pare-feu](allow-device-traffic.md).

Pour activer la communication dans ces scénarios, AWS IoT Greengrass propose les options de configuration suivantes :
+ **Communication MQTT via le port 443**. Si votre réseau autorise les connexions au port 443, vous pouvez configurer le périphérique principal de Greengrass pour utiliser le port 443 pour le trafic MQTT au lieu du port par défaut 8883. Il peut s'agir d'une connexion directe au port 443 ou d'une connexion via un serveur réseau proxy. Contrairement à la configuration par défaut, qui utilise l'authentification client basée sur des certificats, le MQTT sur le port 443 utilise le [rôle de service de périphérique](device-service-role.md) pour l'authentification.

  Pour de plus amples informations, veuillez consulter [Configurer MQTT sur le port 443](#configure-mqtt-port-443).
+ **Communication HTTPS via le port 443**. Le logiciel AWS IoT Greengrass Core envoie le trafic HTTPS via le port 8443 par défaut, mais vous pouvez le configurer pour utiliser le port 443. AWS IoT Greengrass utilise l'extension TLS ALPN ([Application Layer Protocol Network](https://tools.ietf.org/html/rfc7301)) pour activer cette connexion. Comme pour la configuration par défaut, le protocole HTTPS sur le port 443 utilise une authentification client basée sur des certificats.
**Important**  
Pour utiliser ALPN et activer la communication HTTPS sur le port 443, votre appareil principal doit exécuter Java 8 update 252 ou version ultérieure. Toutes les mises à jour de Java version 9 et ultérieures sont également compatibles avec ALPN.

  Pour de plus amples informations, veuillez consulter [Configuration du protocole HTTPS sur le port 443](#configure-https-port-443).
+ **Connexion via un proxy réseau**. Vous pouvez configurer un serveur proxy réseau pour servir d'intermédiaire pour la connexion au périphérique principal de Greengrass. AWS IoT Greengrass prend en charge l'authentification de base pour les proxys HTTP et HTTPS.

  <a name="https-proxy-greengrass-nucleus-requirement"></a>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.

  Le logiciel AWS IoT Greengrass Core transmet la configuration du proxy aux composants via les variables `ALL_PROXY``HTTP_PROXY`,`HTTPS_PROXY`, et d'`NO_PROXY`environnement. Les composants doivent utiliser ces paramètres pour se connecter via le proxy. Les composants utilisent des bibliothèques communes (telles que boto3, cURL et le `requests` package python) qui utilisent généralement ces variables d'environnement par défaut pour établir des connexions. Si un composant spécifie également ces variables d'environnement, AWS IoT Greengrass il ne les remplace pas.

  Pour de plus amples informations, veuillez consulter [Configuration d'un proxy réseau](#configure-network-proxy).

### Configurer MQTT sur le port 443
<a name="configure-mqtt-port-443"></a>

Vous pouvez configurer MQTT sur le port 443 sur les périphériques principaux existants ou lorsque vous installez le logiciel AWS IoT Greengrass Core sur un nouveau périphérique principal.

**Topics**
+ [Configurer MQTT sur le port 443 sur les périphériques principaux existants](#configure-mqtt-port-443-deployment)
+ [Configurer MQTT sur le port 443 lors de l'installation](#configure-mqtt-port-443-installer)

#### Configurer MQTT sur le port 443 sur les périphériques principaux existants
<a name="configure-mqtt-port-443-deployment"></a>

Vous pouvez utiliser un déploiement pour configurer MQTT sur le port 443 sur un périphérique à cœur unique ou sur un groupe de périphériques principaux. Dans ce déploiement, vous mettez à jour la configuration des [composants du noyau](greengrass-nucleus-component.md). Le noyau redémarre lorsque vous mettez à jour sa `mqtt` configuration.

Pour configurer MQTT sur le port 443, [créez un déploiement](create-deployments.md) qui spécifie la mise à jour de configuration suivante pour le `aws.greengrass.Nucleus` composant.

```
{
  "mqtt": {
    "port": 443
  }
}
```

L'exemple suivant définit un déploiement qui configure MQTT sur le port 443. La mise à jour `merge` de configuration nécessite un objet JSON sérialisé.

```
{
  "components": {
    "aws.greengrass.Nucleus": {
      "version": "2.16.1",
      "configurationUpdate": {
        "merge": "{\"mqtt\":{\"port\":443}}"
      }
    }
  }
}
```

#### Configurer MQTT sur le port 443 lors de l'installation
<a name="configure-mqtt-port-443-installer"></a>

Vous pouvez configurer MQTT sur le port 443 lorsque vous installez le logiciel AWS IoT Greengrass Core sur un périphérique principal. Utilisez l'argument du `--init-config` programme d'installation pour configurer MQTT sur le port 443. Vous pouvez spécifier cet argument lors de l'installation à l'aide du [provisionnement manuel](manual-installation.md), du provisionnement du [parc ou du provisionnement](fleet-provisioning.md) [personnalisé](custom-provisioning.md).

### Configuration du protocole HTTPS sur le port 443
<a name="configure-https-port-443"></a>

Cette fonctionnalité nécessite la [Noyau de Greengrass](greengrass-nucleus-component.md) version 2.0.4 ou ultérieure.

Vous pouvez configurer le protocole HTTPS sur le port 443 sur les appareils principaux existants ou lorsque vous installez le logiciel AWS IoT Greengrass principal sur un nouveau périphérique principal.

**Topics**
+ [Configurer le protocole HTTPS sur le port 443 sur les appareils principaux existants](#configure-https-port-443-deployment)
+ [Configuration du protocole HTTPS sur le port 443 lors de l'installation](#configure-https-port-443-installer)

#### Configurer le protocole HTTPS sur le port 443 sur les appareils principaux existants
<a name="configure-https-port-443-deployment"></a>

Vous pouvez utiliser un déploiement pour configurer le protocole HTTPS sur le port 443 sur un périphérique central ou un groupe de périphériques principaux. Dans ce déploiement, vous mettez à jour la configuration des [composants du noyau](greengrass-nucleus-component.md).

Pour configurer le protocole HTTPS sur le port 443, [créez un déploiement](create-deployments.md) qui spécifie la mise à jour de configuration suivante pour le `aws.greengrass.Nucleus` composant.

```
{
  "greengrassDataPlanePort": 443
}
```

L'exemple suivant définit un déploiement qui configure le protocole HTTPS sur le port 443. La mise à jour `merge` de configuration nécessite un objet JSON sérialisé.

```
{
  "components": {
    "aws.greengrass.Nucleus": {
      "version": "2.16.1",
      "configurationUpdate": {
        "merge": "{\"greengrassDataPlanePort\":443}"
      }
    }
  }
}
```

#### Configuration du protocole HTTPS sur le port 443 lors de l'installation
<a name="configure-https-port-443-installer"></a>

Vous pouvez configurer le protocole HTTPS sur le port 443 lorsque vous installez le logiciel AWS IoT Greengrass Core sur un périphérique principal. Utilisez l'argument du `--init-config` programme d'installation pour configurer le protocole HTTPS sur le port 443. Vous pouvez spécifier cet argument lors de l'installation à l'aide du [provisionnement manuel](manual-installation.md), du provisionnement du [parc ou du provisionnement](fleet-provisioning.md) [personnalisé](custom-provisioning.md).

### Configuration d'un proxy réseau
<a name="configure-network-proxy"></a>

Suivez la procédure décrite dans cette section pour configurer les appareils principaux de Greengrass afin qu'ils se connectent à Internet via un proxy réseau HTTP ou HTTPS. Pour plus d'informations sur les points de terminaison et les ports utilisés par les appareils principaux, consultez[Autoriser le trafic des appareils via un proxy ou un pare-feu](allow-device-traffic.md).

**Important**  
Si votre appareil principal exécute une version du [noyau Greengrass](greengrass-nucleus-component.md) antérieure à la version 2.4.0, le rôle de votre appareil doit autoriser les autorisations suivantes pour utiliser un proxy réseau :  
`iot:Connect`
`iot:Publish`
`iot:Receive`
`iot:Subscribe`
Cela est nécessaire car le périphérique utilise les AWS informations d'identification du service d'échange de jetons pour authentifier les connexions MQTT auxquelles. AWS IoT L'appareil utilise MQTT pour recevoir et installer des déploiements depuis le AWS Cloud. Votre appareil ne fonctionnera donc pas si vous ne définissez pas ces autorisations sur son rôle. Les appareils utilisent généralement des certificats X.509 pour authentifier les connexions MQTT, mais ils ne peuvent pas le faire pour s'authentifier lorsqu'ils utilisent un proxy.  
Pour plus d'informations sur la façon de configurer le rôle de l'appareil, consultez[Autoriser les appareils principaux à interagir avec les AWS services](device-service-role.md).

**Topics**
+ [Configuration d'un proxy réseau sur les appareils principaux existants](#configure-network-proxy-deployment)
+ [Configuration d'un proxy réseau lors de l'installation](#configure-network-proxy-installer)
+ [Permettre au périphérique principal de faire confiance à un proxy HTTPS](#https-proxy-certificate-trust)
+ [L'objet NetworkProxy](#network-proxy-object)

#### Configuration d'un proxy réseau sur les appareils principaux existants
<a name="configure-network-proxy-deployment"></a>

Vous pouvez utiliser un déploiement pour configurer un proxy réseau sur un périphérique central unique ou un groupe de périphériques principaux. Dans ce déploiement, vous mettez à jour la configuration des [composants du noyau](greengrass-nucleus-component.md). Le noyau redémarre lorsque vous mettez à jour sa `networkProxy` configuration.

Pour configurer un proxy réseau, [créez un déploiement](create-deployments.md) pour le `aws.greengrass.Nucleus` composant qui fusionne la mise à jour de configuration suivante. Cette mise à jour de configuration contient l'objet [NetworkProxy](#network-proxy-object).

```
{
  "networkProxy": {
    "noProxyAddresses": "http://192.168.0.1,www.example.com",
    "proxy": {
      "url": "https://my-proxy-server:1100"
    }
  }
}
```

L'exemple suivant définit un déploiement qui configure un proxy réseau. La mise à jour `merge` de configuration nécessite un objet JSON sérialisé.

```
{
  "components": {
    "aws.greengrass.Nucleus": {
      "version": "2.16.1",
      "configurationUpdate": {
        "merge": "{\"networkProxy\":{\"noProxyAddresses\":\"http://192.168.0.1,www.example.com\",\"proxy\":{\"url\":\"https://my-proxy-server:1100\",\"username\":\"Mary_Major\",\"password\":\"pass@word1357\"}}}"
      }
    }
  }
}
```

#### Configuration d'un proxy réseau lors de l'installation
<a name="configure-network-proxy-installer"></a>

Vous pouvez configurer un proxy réseau lorsque vous installez le logiciel AWS IoT Greengrass Core sur un périphérique principal. Utilisez l'argument du programme d'`--init-config`installation pour configurer le proxy réseau. Vous pouvez spécifier cet argument lors de l'installation à l'aide du [provisionnement manuel](manual-installation.md), du provisionnement du [parc ou du provisionnement](fleet-provisioning.md) [personnalisé](custom-provisioning.md).

#### Permettre au périphérique principal de faire confiance à un proxy HTTPS
<a name="https-proxy-certificate-trust"></a>

Lorsque vous configurez un périphérique principal pour utiliser un proxy HTTPS, vous devez ajouter la chaîne de certificats du serveur proxy à celle du périphérique principal pour lui permettre de faire confiance au proxy HTTPS. Dans le cas contraire, le périphérique principal risque de rencontrer des erreurs lorsqu'il tente d'acheminer le trafic via le proxy. Ajoutez le certificat CA du serveur proxy au fichier de certificat CA racine Amazon de l'appareil principal.

**Pour permettre au périphérique principal de faire confiance au proxy HTTPS**

1. Recherchez le fichier de certificat Amazon Root CA sur l'appareil principal.
   + Si vous avez installé le logiciel AWS IoT Greengrass Core avec [provisionnement automatique](quick-installation.md), le fichier de certificat racine de l'autorité de certification Amazon existe à l'`/greengrass/v2/rootCA.pem`adresse.
   + Si vous avez installé le logiciel AWS IoT Greengrass Core avec un [provisionnement [manuel](manual-installation.md) ou par flotte](fleet-provisioning.md), le fichier de certificat racine de l'autorité de certification Amazon peut se trouver à `/greengrass/v2/AmazonRootCA1.pem` l'adresse.

   Si le certificat CA racine d'Amazon n'existe pas à ces emplacements, enregistrez l'`system.rootCaPath`établissement `/greengrass/v2/config/effectiveConfig.yaml` pour trouver son emplacement.

1. Ajoutez le contenu du fichier de certificat CA du serveur proxy au fichier de certificat CA racine d'Amazon.

   L'exemple suivant montre un certificat CA de serveur proxy ajouté au fichier de certificat CA racine d'Amazon.

   ```
   -----BEGIN CERTIFICATE-----
   MIIEFTCCAv2gAwIQWgIVAMHSAzWG/5YVRYtRQOxXUTEpHuEmApzGCSqGSIb3DQEK
   \nCwUAhuL9MQswCQwJVUzEPMAVUzEYMBYGA1UECgwP1hem9uLmNvbSBJbmMuMRww
   ... content of proxy CA certificate ...
   +vHIRlt0e5JAm5\noTIZGoFbK82A0/nO7f/t5PSIDAim9V3Gc3pSXxCCAQoFYnui
   GaPUlGk1gCE84a0X\n7Rp/lND/PuMZ/s8YjlkY2NmYmNjMCAXDTE5MTEyN2cM216
   gJMIADggEPADf2/m45hzEXAMPLE=
   -----END CERTIFICATE-----
   
   -----BEGIN CERTIFICATE-----
   MIIDQTCCAimgF6AwIBAgITBmyfz/5mjAo54vB4ikPmljZKyjANJmApzyMZFo6qBg
   ADA5MQswCQYDVQQGEwJVUzEPMA0tMVT8QtPHRh8jrdkGA1UEChMGDV3QQDExBBKW
   ... content of root CA certificate ...
   o/ufQJQWUCyziar1hem9uMRkwFwYVPSHCb2XV4cdFyQzR1KldZwgJcIQ6XUDgHaa
   5MsI+yMRQ+hDaXJiobldXgjUka642M4UwtBV8oK2xJNDd2ZhwLnoQdeXeGADKkpy
   rqXRfKoQnoZsG4q5WTP46EXAMPLE
   -----END CERTIFICATE-----
   ```

#### L'objet NetworkProxy
<a name="network-proxy-object"></a>

Utilisez l'objet `networkProxy` pour spécifier les informations sur le proxy réseau. Cet objet contient les informations suivantes :

`noProxyAddresses`  
(Facultatif) Liste séparée par des virgules d'adresses IP ou de noms d'hôtes exemptés du proxy.

`proxy`  
Le proxy auquel se connecter. Cet objet contient les informations suivantes :    
`url`  
URL du serveur proxy au format`scheme://userinfo@host:port`.  <a name="nucleus-component-configuration-proxy-url-segments"></a>
+ `scheme`— Le schéma, qui doit être `http` ou`https`.
**Important**  
<a name="https-proxy-greengrass-nucleus-requirement"></a>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](#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  
`username`  
(Facultatif) Le nom d'utilisateur qui authentifie le serveur proxy.  
`password`  
(Facultatif) Le mot de passe qui authentifie le serveur proxy.

## Utiliser un certificat d'appareil signé par une autorité de certification privée
<a name="configure-nucleus-private-ca"></a>

Si vous utilisez une autorité de certification privée (CA) personnalisée, vous devez définir le noyau **greengrassDataPlaneEndpoint** de Greengrass sur. **iotdata** Vous pouvez définir cette option lors du déploiement ou de l'installation à l'aide de l'[argument **--init-config** installer](configure-installer.md).

Vous pouvez personnaliser le point de terminaison du plan de données Greengrass auquel l'appareil se connecte. Vous pouvez définir cette option de configuration **iotdata** pour définir le point de terminaison du plan de données Greengrass sur le même point de terminaison que le point de terminaison de données IoT, que vous pouvez spécifier avec le. **iotDataEndpoint**

## Configurer les délais d'expiration et les paramètres de cache du MQTT
<a name="configure-mqtt"></a>

Dans l' AWS IoT Greengrass environnement, les composants peuvent utiliser MQTT pour communiquer avec AWS IoT Core. Le logiciel AWS IoT Greengrass Core gère les messages MQTT pour les composants. Lorsque le périphérique principal perd la connexion au AWS Cloud, le logiciel met en cache les messages MQTT pour réessayer ultérieurement lorsque la connexion sera rétablie. Vous pouvez configurer des paramètres tels que les délais d'expiration des messages et la taille du cache. Pour plus d'informations, consultez les paramètres de `mqtt.spooler` configuration `mqtt` et du composant [Greengrass nucleus](greengrass-nucleus-component.md).

AWS IoT Core impose des quotas de service à son courtier de messages MQTT. Ces quotas peuvent s'appliquer aux messages que vous envoyez entre des appareils principaux et AWS IoT Core. Pour plus d'informations, consultez la section sur les [quotas de service du courtier de AWS IoT Core messages](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#message-broker-limits) dans le *Références générales AWS*.

## Configurer Greengrass Nucleus sur le réseau IPv6
<a name="configure-ipv6"></a>

 [Greengrass Nucleus communique avec AWS IoT Core Greengrass. APIs](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html) APIs Support de Greengrass dans un environnement à IPv6 double pile.

Pour activer les points de terminaison à double pile pour : IPv6
+  Ajoutez les propriétés `aws.useDualstackEndpoint=true` du système et `java.net.preferIPv6Addresses=true` `jvmOptions` 
+  Définissez `s3EndpointType` sur `DUALSTACK` 

 Définissez cette option lors du [déploiement](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-deployments.html) ou configurez-la manuellement avec l'[argument du `--init-config` programme d'installation](https://docs.aws.amazon.com/greengrass/v2/developerguide/configure-installer.html). Consultez la section [Utilisation des points de terminaison à double pile Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/dual-stack-endpoints.html) pour plus de détails. 

**Example code pour le déploiement :**  

```
{
    "jvmOptions": "-Daws.useDualstackEndpoint=true",
    "s3EndpointType":"DUALSTACK"
}
```

**Example `config.yaml`par le biais d'un approvisionnement manuel :**  

```
---
system:
  ...
services:
  aws.greengrass.Nucleus:
    ...
    configuration:
      ...
      jvmOptions: "-Daws.useDualstackEndpoint=true -Djava.net.preferIPv6Addresses=true"
      s3EndpointType: "DUALSTACK"
```

# Mettre à jour le logiciel AWS IoT Greengrass principal (OTA)
<a name="update-greengrass-core-v2"></a>

Le logiciel de AWS IoT Greengrass base comprend le [composant Greengrass nucleus](greengrass-nucleus-component.md) et d'autres composants optionnels que vous pouvez déployer sur vos appareils pour effectuer des mises à jour over-the-air (OTA) du logiciel. Cette fonctionnalité est intégrée au logiciel de AWS IoT Greengrass base.

Les mises à jour OTA permettent de mieux :
+ Corriger les vulnérabilités de sécurité.
+ Prendre en charge des problèmes de stabilité logicielle.
+ Déployer de nouvelles fonctionnalités ou des fonctionnalités améliorées.

**Topics**
+ [Prérequis](#ota-update-requirements)
+ [Considérations relatives aux appareils principaux](#ota-update-considerations)
+ [Comportement de mise à jour du noyau Greengrass](#ota-update-behavior-nucleus)
+ [Effectuer une mise à jour OTA](#create-ota-update)

## Prérequis
<a name="ota-update-requirements"></a>

Les exigences suivantes s'appliquent au déploiement des mises à jour OTA du logiciel AWS IoT Greengrass principal :
+ L'appareil principal de Greengrass doit être connecté au pour AWS Cloud recevoir le déploiement.
+ L'appareil principal Greengrass doit être correctement configuré et doté de certificats et de clés pour l'authentification avec et. AWS IoT Core AWS IoT Greengrass
+ Le logiciel de AWS IoT Greengrass base doit être configuré et exécuté en tant que service système. Les mises à jour OTA ne fonctionnent pas si vous exécutez le noyau à partir du fichier JAR,`Greengrass.jar`. Pour de plus amples informations, veuillez consulter [Configurer le noyau Greengrass en tant que service système](configure-greengrass-core-v2.md#configure-system-service).

## Considérations relatives aux appareils principaux
<a name="ota-update-considerations"></a>

Avant d'effectuer une mise à jour OTA, soyez conscient de l'impact sur les principaux appareils que vous mettez à jour et sur leurs appareils clients connectés :
+ Le noyau de Greengrass s'arrête. 
+ Tous les composants exécutés sur le périphérique principal s'arrêtent également. Si ces composants écrivent dans des ressources locales, ils risquent de laisser ces ressources dans un état incorrect s'ils ne sont pas correctement arrêtés. Les composants peuvent utiliser [la communication entre processus](interprocess-communication.md) pour demander au composant du noyau de différer la mise à jour jusqu'à ce qu'ils aient nettoyé les ressources qu'ils utilisent.
+ Lorsque le composant du noyau est arrêté, le périphérique principal perd ses connexions avec les périphériques locaux AWS Cloud et les périphériques. L'appareil principal n'achemine pas les messages depuis les appareils clients lorsqu'il est éteint.
+ Les fonctions Lambda de longue durée qui s'exécutent en tant que composants perdent leurs informations d'état dynamique et abandonnent toutes les tâches en attente.

## Comportement de mise à jour du noyau Greengrass
<a name="ota-update-behavior-nucleus"></a>

<a name="component-patch-update"></a>Lorsque vous déployez un composant, AWS IoT Greengrass installe les dernières versions prises en charge de toutes les dépendances de ce composant. De ce fait, les nouvelles versions de correctif des composants publics AWS fournis peuvent être automatiquement déployées sur vos appareils principaux si vous ajoutez de nouveaux appareils à un groupe d'objets ou si vous mettez à jour le déploiement qui cible ces appareils. Certaines mises à jour automatiques, telles que la mise à jour du noyau, peuvent provoquer le redémarrage inattendu de vos appareils. 

Lorsque la version du [composant Greengrass nucleus](greengrass-nucleus-component.md) change, le logiciel AWS IoT Greengrass Core, qui inclut le noyau et tous les autres composants de votre appareil, redémarre pour appliquer les modifications. En raison de l'[impact sur les appareils principaux](#ota-update-considerations) lorsque le composant Nucleus est mis à jour, vous souhaiterez peut-être contrôler le moment où une nouvelle version du correctif Nucleus est déployée sur vos appareils. Pour ce faire, vous devez inclure directement le composant Greengrass nucleus dans votre déploiement. L'inclusion directe d'un composant signifie que vous incluez une version spécifique de ce composant dans votre configuration de déploiement et que vous ne comptez pas sur les dépendances des composants pour déployer ce composant sur vos appareils. Pour plus d'informations sur la définition des dépendances dans vos recettes de composants, consultez[Format de recette](component-recipe-reference.md#recipe-format).

Consultez le tableau suivant pour comprendre le comportement de mise à jour du composant Greengrass nucleus en fonction de vos actions et de vos configurations de déploiement.


| Action | Configuration de déploiement | Comportement de mise à jour | 
| --- | --- | --- | 
| Ajoutez de nouveaux appareils à un groupe d'objets ciblé par un déploiement existant sans modifier le déploiement. | Le déploiement n'inclut pas directement le noyau Greengrass.Le déploiement inclut directement au moins un composant AWS fourni, ou inclut un composant personnalisé qui dépend d'un composant AWS fourni ou du noyau Greengrass. | Sur les nouveaux appareils, installe la dernière version du correctif de Nucleus qui répond à toutes les exigences de dépendance des composants.Sur les appareils existants, ne met pas à jour la version installée du noyau. | 
| Ajoutez de nouveaux appareils à un groupe d'objets ciblé par un déploiement existant sans modifier le déploiement. |  Le déploiement inclut directement une version spécifique du noyau Greengrass.  | Sur les nouveaux appareils, installe la version de noyau spécifiée.Sur les appareils existants, ne met pas à jour la version installée du noyau. | 
| Créez un nouveau déploiement ou révisez un déploiement existant. | Le déploiement n'inclut pas directement le noyau Greengrass.Le déploiement inclut directement au moins un composant AWS fourni, ou inclut un composant personnalisé qui dépend d'un composant AWS fourni ou du noyau Greengrass. | Installe sur tous les appareils ciblés la dernière version du correctif du noyau qui répond à toutes les exigences de dépendance des composants, y compris sur tous les nouveaux appareils que vous ajoutez au groupe d'objets ciblé. | 
| Créez un nouveau déploiement ou révisez un déploiement existant. | Le déploiement inclut directement une version spécifique du noyau Greengrass. | Installe la version du noyau spécifiée sur tous les appareils ciblés, y compris les nouveaux appareils que vous ajoutez au groupe d'objets ciblé.  | 

## Effectuer une mise à jour OTA
<a name="create-ota-update"></a>

Pour effectuer une mise à jour OTA, [créez un déploiement](create-deployments.md) qui inclut le [composant Nucleus](greengrass-nucleus-component.md) et la version à installer.

# Désinstallez le logiciel AWS IoT Greengrass Core
<a name="uninstall-greengrass-core-v2"></a>

Vous pouvez désinstaller le logiciel AWS IoT Greengrass Core pour le supprimer d'un appareil que vous ne souhaitez pas utiliser comme appareil principal Greengrass. Vous pouvez également suivre ces étapes pour nettoyer une installation qui échoue.

**Pour désinstaller le logiciel AWS IoT Greengrass Core**

1. Si vous exécutez le logiciel en tant que service système, vous devez arrêter, désactiver et supprimer le service. Exécutez les commandes suivantes en fonction de votre système d'exploitation.

------
#### [ Linux ]

   1. Arrêtez le service .

      ```
      sudo systemctl stop greengrass.service
      ```

   1. Désactivez le service.

      ```
      sudo systemctl disable greengrass.service
      ```

   1. Supprimez le service.

      ```
      sudo rm /etc/systemd/system/greengrass.service
      ```

   1. Vérifiez que le service est supprimé.

      ```
      sudo systemctl daemon-reload && sudo systemctl reset-failed
      ```

------
#### [ Windows (Command Prompt) ]

**Note**  
Vous devez exécuter Command Prompt en tant qu'administrateur pour exécuter ces commandes.

   1. Arrêtez le service .

      ```
      sc stop "greengrass"
      ```

   1. Désactivez le service.

      ```
      sc config "greengrass" start=disabled
      ```

   1. Supprimez le service.

      ```
      sc delete "greengrass"
      ```

   1. Redémarrez le périphérique.

------
#### [ Windows (PowerShell) ]

**Note**  
Vous devez exécuter ces commandes en PowerShell tant qu'administrateur.

   1. Arrêtez le service .

      ```
      Stop-Service -Name "greengrass"
      ```

   1. Désactivez le service.

      ```
      Set-Service -Name "greengrass" -Status stopped -StartupType disabled
      ```

   1. Supprimez le service.
      + Pour la PowerShell version 6.0 et les versions ultérieures :

        ```
        Remove-Service -Name "greengrass" -Confirm:$false -Verbose
        ```
      + Pour PowerShell les versions antérieures à 6.0 :

        ```
        Get-Item HKLM:\SYSTEM\CurrentControlSet\Services\greengrass | Remove-Item -Force -Verbose
        ```

   1. Redémarrez le périphérique.

------

1. Supprimez le dossier racine de l'appareil. Remplacez `/greengrass/v2` ou *C:\$1greengrass\$1v2* par le chemin d'accès au dossier racine.

------
#### [ Linux ]

   ```
   sudo rm -rf /greengrass/v2
   ```

------
#### [ Windows (Command Prompt) ]

   ```
   rmdir /s /q C:\greengrass\v2
   ```

------
#### [ Windows (PowerShell) ]

   ```
   cmd.exe /c "rmdir /s /q C:\greengrass\v2"
   ```

------

1. Supprimez le périphérique principal du AWS IoT Greengrass service. Cette étape supprime les informations d'état du périphérique principal du AWS Cloud. Assurez-vous de terminer cette étape si vous prévoyez de réinstaller le logiciel AWS IoT Greengrass Core sur un périphérique principal portant le même nom.
   + Pour supprimer un périphérique principal de la AWS IoT Greengrass console, procédez comme suit :

     1. <a name="navigate-greengrass-console"></a>Accédez à la [console AWS IoT Greengrass](https://console.aws.amazon.com/greengrass).

     1. Choisissez les **appareils Core**.

     1. Choisissez le périphérique principal à supprimer.

     1. Sélectionnez **Delete (Supprimer)**.

     1. Dans le mode de confirmation, choisissez **Supprimer**.
   + Pour supprimer un périphérique principal doté du AWS Command Line Interface, utilisez l'[DeleteCoreDevice](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeleteCoreDevice.html)opération. Exécutez la commande suivante et *MyGreengrassCore* remplacez-la par le nom du périphérique principal.

     ```
     aws greengrassv2 delete-core-device --core-device-thing-name MyGreengrassCore
     ```