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.
# Tutoriel : Débuter avec AWS IoT Greengrass V2
Vous pouvez suivre ce didacticiel de mise en route pour découvrir les fonctionnalités de base de AWS IoT Greengrass V2. Dans ce didacticiel, vous allez effectuer les opérations suivantes :
1. Installez et configurez le logiciel AWS IoT Greengrass Core sur un appareil Linux, tel qu'un Raspberry Pi ou un appareil Windows. Cet appareil est un appareil de base de Greengrass.
1. Développez un composant Hello World sur votre appareil principal Greengrass. Les composants sont des modules logiciels qui s'exécutent sur les appareils principaux de Greengrass.
1. Téléchargez ce composant AWS IoT Greengrass V2 dans le AWS Cloud.
1. Déployez ce composant depuis votre appareil principal Greengrass. AWS Cloud
**Note**
Ce didacticiel explique comment configurer un environnement de développement et explore les fonctionnalités de AWS IoT Greengrass. Pour plus d'informations sur l'installation et la configuration des appareils de production, consultez les rubriques suivantes :
[Configuration des appareils AWS IoT Greengrass principaux](setting-up.md)
[Installation du logiciel AWS IoT Greengrass de base](install-greengrass-core-v2.md)
Vous pouvez vous attendre à consacrer 20 à 30 minutes à ce didacticiel.
**Topics**
+ [Prérequis](getting-started-prerequisites.md)
+ [Étape 1 : créer un AWS compte](getting-started-set-up-aws-account.md)
+ [Étape 2 : Configuration de votre environnement](getting-started-set-up-environment.md)
+ [Étape 3 : Installation du logiciel AWS IoT Greengrass principal](install-greengrass-v2.md)
+ [Étape 4 : développer et tester un composant sur votre appareil](create-first-component.md)
+ [Étape 5 : Créez votre composant dans le AWS IoT Greengrass service](upload-first-component.md)
+ [Étape 6 : Déployez votre composant](deploy-first-component.md)
+ [Étapes suivantes](getting-started-next-steps.md)
# Prérequis
Pour suivre ce didacticiel de démarrage, vous avez besoin des éléments suivants :
+ Un Compte AWS. Si vous n'en avez pas, veuillez consulter [Étape 1 : créer un AWS compte](getting-started-set-up-aws-account.md).
+ L'utilisation d'un ventilateur [Région AWS](https://en.wikipedia.org/wiki/Amazon_Web_Services#Availability_and_topology)qui supporte AWS IoT Greengrass V2. Pour obtenir la liste des régions prises en charge, consultez [Points de terminaison et quotas AWS IoT Greengrass V2](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html) dans le *Références générales AWS*.
+ Un utilisateur Gestion des identités et des accès AWS (IAM) doté d'autorisations d'administrateur.
+ Un appareil à configurer en tant qu'appareil principal de Greengrass, tel qu'un Raspberry Pi avec le système d'[exploitation Raspberry Pi](https://www.raspberrypi.org/downloads/) (précédemment appelé Raspbian) ou un appareil Windows 10. Vous devez disposer d'autorisations d'administrateur sur cet appareil ou être en mesure d'acquérir des privilèges d'administrateur, par exemple via`sudo`. Cet appareil doit disposer d'une connexion Internet.
Vous pouvez également choisir d'utiliser un autre appareil répondant aux exigences d'installation et d'exécution du logiciel AWS IoT Greengrass Core.
Si votre ordinateur de développement répond à ces exigences, vous pouvez le configurer comme périphérique principal de Greengrass dans ce didacticiel.
+ [Python](https://www.python.org/downloads/) 3.5 ou version ultérieure installé pour tous les utilisateurs de l'appareil et ajouté à la variable d'`PATH`environnement. Sous Windows, le lanceur Python pour Windows doit également être installé pour tous les utilisateurs.
**Important**
Sous Windows, Python ne s'installe pas pour tous les utilisateurs par défaut. Lorsque vous installez Python, vous devez personnaliser l'installation pour la configurer afin que le logiciel AWS IoT Greengrass Core exécute des scripts Python. Par exemple, si vous utilisez le programme d'installation graphique Python, procédez comme suit :
Sélectionnez **Installer le lanceur pour tous les utilisateurs (recommandé).**
Choisissez **Customize installation**.
Choisissez **Next**.
Sélectionnez **Install for all users**.
Sélectionnez **Add Python to environment variables**.
Choisissez **Installer**.
Pour plus d'informations, consultez la section [Utilisation de Python sous Windows](https://docs.python.org/3/using/windows.html) dans la *documentation de Python 3*.
+ AWS Command Line Interface (AWS CLI) installé et configuré avec des informations d'identification sur votre ordinateur de développement et sur votre appareil. Assurez-vous de l'utiliser Région AWS pour configurer le AWS CLI sur votre ordinateur de développement et sur votre appareil. Pour l'utiliser AWS IoT Greengrass V2 avec le AWS CLI, vous devez disposer de l'une des versions suivantes ou d'une version ultérieure :
+ Version AWS CLI V1 minimale : v1.18.197
+ Version AWS CLI V2 minimale : v2.1.11
**Astuce**
Vous pouvez exécuter la commande suivante pour vérifier la version AWS CLI dont vous disposez.
```
aws --version
```
Pour plus d'informations, consultez les [sections Installation, mise à jour et désinstallation du AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) et [Configuration du AWS CLI dans le](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) *guide de l'AWS Command Line Interface utilisateur*.
**Note**
Si vous utilisez un appareil ARM 32 bits, tel qu'un Raspberry Pi avec un système d'exploitation 32 bits, installez AWS CLI la version 1. AWS CLI La V2 n'est pas disponible pour les appareils ARM 32 bits. Pour plus d'informations, voir [Installation, mise à jour et désinstallation de la AWS CLI version 1](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html).
# Étape 1 : créer un AWS compte
## Inscrivez-vous pour un Compte AWS
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).
AWS vous envoie un e-mail de confirmation une fois le processus d'inscription terminé. À tout moment, vous pouvez consulter l'activité actuelle de votre compte et gérer votre compte en accédant à [https://aws.amazon.com/](https://aws.amazon.com/)et en choisissant **Mon compte**.
## Création d’un utilisateur doté d’un accès administratif
Une fois que vous vous êtes inscrit à un utilisateur administratif Compte AWS, que vous Utilisateur racine d'un compte AWS l'avez sécurisé AWS IAM Identity Center, que vous l'avez activé et que vous en avez créé un, afin de ne pas utiliser l'utilisateur root pour les tâches quotidiennes.
**Sécurisez votre Utilisateur racine d'un compte AWS**
1. Connectez-vous en [AWS Management Console](https://console.aws.amazon.com/)tant que propriétaire du compte en choisissant **Utilisateur root** et en saisissant votre adresse Compte AWS e-mail. Sur la page suivante, saisissez votre mot de passe.
Pour obtenir de l’aide pour vous connecter en utilisant l’utilisateur racine, consultez [Connexion en tant qu’utilisateur racine](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) dans le *Guide de l’utilisateur Connexion à AWS *.
1. Activez l’authentification multifactorielle (MFA) pour votre utilisateur racine.
Pour obtenir des instructions, voir [Activer un périphérique MFA virtuel pour votre utilisateur Compte AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) dans le guide de l'utilisateur *IAM*.
**Création d’un utilisateur doté d’un accès administratif**
1. Activez IAM Identity Center.
Pour obtenir des instructions, consultez [Activation d’ AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
1. Dans IAM Identity Center, octroyez un accès administratif à un utilisateur.
Pour un didacticiel sur l'utilisation du Répertoire IAM Identity Center comme source d'identité, voir [Configurer l'accès utilisateur par défaut Répertoire IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) dans le *Guide de AWS IAM Identity Center l'utilisateur*.
**Connexion en tant qu’utilisateur doté d’un accès administratif**
+ Pour vous connecter avec votre utilisateur IAM Identity Center, utilisez l’URL de connexion qui a été envoyée à votre adresse e-mail lorsque vous avez créé l’utilisateur IAM Identity Center.
Pour obtenir de l'aide pour vous connecter en utilisant un utilisateur d'IAM Identity Center, consultez la section [Connexion au portail AWS d'accès](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) dans le *guide de l'Connexion à AWS utilisateur*.
**Attribution d’un accès à d’autres utilisateurs**
1. Dans IAM Identity Center, créez un ensemble d’autorisations qui respecte la bonne pratique consistant à appliquer les autorisations de moindre privilège.
Pour obtenir des instructions, consultez [Création d’un ensemble d’autorisations](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
1. Attribuez des utilisateurs à un groupe, puis attribuez un accès par authentification unique au groupe.
Pour obtenir des instructions, consultez [Ajout de groupes](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
# Étape 2 : Configuration de votre environnement
**Note**
Ces étapes ne s'appliquent pas à Nucleus Lite.
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 (Raspberry Pi)
Ces étapes supposent que vous utilisez un Raspberry Pi avec le système d'exploitation Raspberry Pi. Si vous utilisez un autre appareil ou un autre système d'exploitation, consultez la documentation correspondante à votre appareil.
**Pour configurer un Raspberry Pi pour AWS IoT Greengrass V2**
1. Activez SSH sur votre Raspberry Pi pour vous y connecter à distance. Pour plus d'informations, consultez [SSH (Secure Shell)](https://www.raspberrypi.com/documentation/computers/remote-access.html#ssh) dans la *documentation du Raspberry Pi*.
1. Trouvez l'adresse IP de votre Raspberry Pi pour vous y connecter via SSH. Pour ce faire, vous pouvez exécuter la commande suivante sur votre Raspberry Pi.
```
hostname -I
```
1. Connectez-vous à votre Raspberry Pi via SSH.
Sur votre ordinateur de développement, exécutez la commande suivante. Remplacez *username* par le nom de l'utilisateur auquel vous souhaitez vous connecter et *pi-ip-address* par l'adresse IP que vous avez trouvée à l'étape précédente.
```
ssh username@pi-ip-address
```
**Important**
Si votre ordinateur de développement utilise une version antérieure de Windows, il se peut que vous ne disposiez pas de cette `ssh` commande ou que vous `ssh` ne puissiez pas vous connecter à votre Raspberry Pi. Pour vous connecter à votre Raspberry Pi, vous pouvez installer et configurer [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html), un client SSH open source gratuit. Consultez la [documentation PuTTY](https://tartarus.org/~simon/putty-snapshots/htmldoc/Chapter2.html#gs) pour vous connecter à votre Raspberry Pi.
1. Installez le moteur d'exécution Java, dont le logiciel AWS IoT Greengrass Core a besoin pour fonctionner. Sur votre Raspberry Pi, utilisez les commandes suivantes pour installer Java 11.
```
sudo apt install default-jdk
```
Lorsque l'installation est terminée, exécutez la commande suivante pour vérifier que Java fonctionne sur votre Raspberry Pi.
```
java -version
```
La commande affiche la version de Java exécutée sur le périphérique. 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)
```
**Conseil : définissez les paramètres du noyau sur un Raspberry Pi**
Si votre appareil est un Raspberry Pi, vous pouvez suivre les étapes suivantes pour afficher et mettre à jour les paramètres de son noyau Linux :
Ouvrez le fichier `/boot/cmdline.txt`. Ce fichier indique les paramètres du noyau Linux à appliquer lors du démarrage du Raspberry Pi.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour ouvrir le fichier.
```
sudo nano /boot/cmdline.txt
```
Vérifiez que le `/boot/cmdline.txt` fichier contient les paramètres de noyau suivants. Le `systemd.unified_cgroup_hierarchy=0` paramètre indique d'utiliser cgroups v1 au lieu de cgroups v2.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Si le `/boot/cmdline.txt` fichier ne contient pas ces paramètres ou s'il contient des valeurs différentes, mettez-le à jour pour qu'il contienne ces paramètres et valeurs.
Si vous avez mis à jour le `/boot/cmdline.txt` fichier, redémarrez le Raspberry Pi pour appliquer les modifications.
```
sudo reboot
```
## Configuration d'un appareil Linux (autre)
**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
**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. Ouvrez l'invite de commande Windows (`cmd.exe`) en tant qu'administrateur.
1. Créez l'utilisateur par défaut dans le LocalSystem compte sur l'appareil Windows. *password*Remplacez-le par un mot de passe sécurisé.
```
net user /add ggc_user password
```
**Astuce**
En fonction de votre configuration Windows, le mot de passe de l'utilisateur peut être configuré pour expirer à une date ultérieure. Pour vous assurer que vos applications Greengrass continuent de fonctionner, suivez la date d'expiration du mot de passe et mettez-le à jour avant son expiration. Vous pouvez également définir le mot de passe de l'utilisateur pour qu'il n'expire jamais.
Pour vérifier la date d'expiration d'un utilisateur et de son mot de passe, exécutez la commande suivante.
```
net user ggc_user | findstr /C:expires
```
Pour définir le mot de passe d'un utilisateur afin qu'il n'expire jamais, exécutez la commande suivante.
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
Si vous utilisez Windows 10 ou une version ultérieure où la [`wmic`commande est obsolète](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), exécutez la commande suivante PowerShell .
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. Téléchargez et installez l'[PsExecutilitaire](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) de Microsoft sur l'appareil.
1. Utilisez l' PsExec utilitaire pour stocker le nom d'utilisateur et le mot de passe de l'utilisateur par défaut dans l'instance Credential Manager du LocalSystem compte. *password*Remplacez-le par le mot de passe utilisateur que vous avez défini précédemment.
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
S'il **PsExec License Agreement**s'ouvre, choisissez **Accept**d'accepter la licence et exécutez la commande.
**Note**
Sur les appareils Windows, le LocalSystem compte exécute le noyau Greengrass, et vous devez utiliser l' PsExec utilitaire pour stocker les informations utilisateur par défaut dans le LocalSystem compte. L'application Credential Manager stocke ces informations dans le compte Windows de l'utilisateur actuellement connecté, plutôt que dans le LocalSystem compte.
# Étape 3 : Installation du logiciel AWS IoT Greengrass principal
**Astuce**
Nous vous recommandons d'essayer le [pack contextuel AWS IoT Greengrass AI Agents](https://github.com/aws-greengrass/greengrass-agent-context-pack) pour configurer et expérimenter rapidement IoT AWS Greengrass. Le pack de contexte des agents permettra aux agents d'intelligence artificielle de configurer Greengrass Nucleus et Nucleus Lite, de déployer des composants et de résoudre les problèmes courants.
Suivez les étapes décrites dans cette section pour configurer votre Raspberry Pi en tant que périphérique AWS IoT Greengrass principal que vous pouvez utiliser pour le développement local. Dans cette section, vous allez télécharger et exécuter un programme d'installation qui effectue les opérations suivantes pour configurer le logiciel AWS IoT Greengrass Core pour votre appareil :
+ Installe le composant Greengrass nucleus. Le noyau est un composant obligatoire et constitue le minimum requis pour exécuter le logiciel AWS IoT Greengrass Core sur un appareil. Pour plus d'informations, consultez la section Composant du [noyau Greengrass](greengrass-nucleus-component.md).
+ Enregistre votre appareil en tant qu' AWS IoT objet et télécharge un certificat numérique qui permet à votre appareil de se connecter à AWS. Pour de plus amples informations, veuillez consulter [Authentification et autorisation de l'appareil pour AWS IoT Greengrass](device-auth.md).
+ Ajoute l' AWS IoT objet de l'appareil à un groupe d'objets, qui est un groupe ou un parc d' AWS IoT objets. Les groupes d'objets vous permettent de 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. Pour plus d'informations, consultez [la section Gestion des appareils AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-thing-management.html) dans le *Guide du AWS IoT Core développeur*.
+ Crée le rôle IAM qui permet à votre appareil principal Greengrass d'interagir avec AWS les services. Par défaut, ce rôle permet à votre appareil d'interagir avec Amazon Logs AWS IoT et de lui envoyer CloudWatch des journaux. Pour de plus amples informations, veuillez consulter [Autoriser les appareils principaux à interagir avec les AWS services](device-service-role.md).
+ Installe l'interface de ligne de AWS IoT Greengrass commande (`greengrass-cli`), que vous pouvez utiliser pour tester les composants personnalisés que vous développez sur le périphérique principal. Pour de plus amples informations, veuillez consulter [Interface de ligne de commande Greengrass](gg-cli.md).
# Installation du logiciel AWS IoT Greengrass Core (console)
1. Connectez-vous à la [console AWS IoT Greengrass](https://console.aws.amazon.com/greengrass).
1. Sous **Commencer avec Greengrass**, choisissez **Configurer l'appareil principal**.
1. Dans **Étape 1 : Enregistrer un appareil Greengrass Core**, dans le champ **Nom de l'appareil Core**, entrez le nom de l' AWS IoT appareil Greengrass Core. Si l'objet n'existe pas, le programme d'installation le crée.
1. Dans **Étape 2 : Ajouter à un groupe d'objets pour appliquer un déploiement continu**, pour le **groupe** d'objets, choisissez le AWS IoT groupe d'objets auquel vous souhaitez ajouter votre appareil principal.
+ Si vous sélectionnez **Entrez un nouveau nom de groupe**, dans **Nom du groupe** d'objets, entrez le nom du nouveau groupe à créer. Le programme d'installation crée le nouveau groupe pour vous.
+ Si vous sélectionnez **Sélectionner un groupe existant**, dans **Nom du groupe** d'objets, choisissez le groupe existant que vous souhaitez utiliser.
+ Si vous sélectionnez **Aucun groupe**, le programme d'installation n'ajoute pas le périphérique principal à un groupe d'objets.
1. Dans **Étape 3 : Installation du logiciel Greengrass Core, effectuez** les étapes suivantes.
------
#### [ Nucleus classic ]
1. Choisissez **Nucleus classic** comme moteur d'exécution du logiciel principal de votre appareil.
1. Choisissez le système d'exploitation de votre appareil principal : **Linux** ou **Windows**.
1. 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*.
1. Sous **Exécuter le programme d'installation**, effectuez les étapes suivantes.
1. Sous **Télécharger le programme d'installation**, choisissez **Copier** et exécutez la commande copiée sur votre appareil principal. Cette commande télécharge la dernière version du logiciel AWS IoT Greengrass Core et la décompresse sur votre appareil.
1. Sous **Exécuter le programme d'installation**, choisissez **Copier, puis** exécutez la commande copiée sur votre appareil principal. Cette commande utilise les AWS IoT noms d'objets et de groupes d'objets que vous avez spécifiés précédemment pour exécuter le programme d'installation du logiciel AWS IoT Greengrass Core et configurer les AWS ressources pour votre périphérique principal.
Cette commande effectue également les opérations suivantes :
+ Configurez le logiciel AWS IoT Greengrass Core en tant que service système qui s'exécute au démarrage. Sur les appareils Linux, cela nécessite le [système d'initialisation Systemd](https://en.wikipedia.org/wiki/Systemd).
**Important**
Sur les appareils Windows Core, vous devez configurer le logiciel AWS IoT Greengrass Core en tant que service système.
+ Déployez le [composant AWS IoT Greengrass CLI](gg-cli.md), qui est un outil de ligne de commande qui vous permet de développer des composants Greengrass personnalisés sur le périphérique principal.
+ Spécifiez l'utilisation de 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.
Lorsque vous exécutez cette commande, les messages suivants devraient s'afficher pour indiquer que le programme d'installation a réussi.
```
Successfully configured Nucleus with provisioned resource details!
Configured Nucleus to deploy aws.greengrass.Cli component
Successfully set up Nucleus as a system service
```
**Note**
Si vous possédez un appareil Linux et qu'il n'est pas doté de [systemd](https://en.wikipedia.org/wiki/Systemd), le programme d'installation ne configurera pas le logiciel en tant que service système et vous ne verrez pas le message de confirmation de configuration du noyau en tant que service système.
------
#### [ Nucleus lite ]
1. Choisissez **Nucleus lite** comme moteur d'exécution du logiciel principal de votre appareil.
1. Sélectionnez la méthode de configuration de votre appareil pour connecter votre appareil à un appareil Greengrass Core.
**Option 1 : configurer un appareil avec téléchargement du package (environ 1 Mo)**
1. Créez un AWS IoT objet et un rôle pour Greengrass.
1. Téléchargez le fichier zip contenant AWS IoT les ressources auxquelles votre appareil doit se connecter AWS IoT :
+ Un certificat et une clé privée générés à l'aide AWS IoT de l'autorité de certification.
+ Un fichier de schéma pour lancer l'installation de Greengrass sur votre appareil.
1. Téléchargez le package qui installera le dernier runtime Greengrass Nucleus lite sur votre Raspberry Pi.
1. Provisionnez votre appareil pour qu'il devienne un appareil AWS IoT Greengrass Core et connectez-le à AWS IoT :
1. a. Transférez le package Greengrass et le kit de connexion sur votre appareil à l'aide d'une clé USB, d'un SCP/FTP ou d'une carte SD.
1. b. Décompressez le fichier greengrass-package.zip dans le GreengrassInstaller répertoire/de l'appareil.
1. c. Décompressez le fichier zip du kit de connexion dans le répertoire /de l'appareil.
1. d. Exécutez la commande fournie sur le périphérique à installer AWS IoT Greengrass
1. Choisissez ensuite **Afficher les principaux appareils**.
**Option 2 : configurer un appareil avec un téléchargement d'exemple d'image préconfiguré sur l'ensemble du disque (environ 100 Mo)**
1. Créez un AWS IoT objet et un rôle pour Greengrass.
1. Téléchargez le fichier zip contenant AWS IoT les ressources auxquelles votre appareil doit se connecter AWS IoT :
+ Un certificat et une clé privée générés à l'aide AWS IoT de l'autorité de certification.
+ Un fichier de schéma pour lancer l'installation de Greengrass sur votre appareil.
1. Téléchargez l'image d'exemple de disque entier préconfigurée qui contient Greengrass et le système d'exploitation.
1. Pour transférer le kit de connexion et flasher l'image sur votre appareil, suivez le fichier readme téléchargé avec l'image.
1. Pour démarrer l'installation de Greengrass, allumez et démarrez l'appareil à partir de l'image clignotée
1. Choisissez ensuite **Afficher les principaux appareils**.
**Option 3 : configurer un appareil avec votre propre version personnalisée**
1. Créez un AWS IoT objet et un rôle pour Greengrass.
1. Téléchargez le fichier zip contenant AWS IoT les ressources auxquelles votre appareil doit se connecter AWS IoT :
+ Un certificat et une clé privée générés à l'aide AWS IoT de l'autorité de certification.
+ Un fichier de schéma pour lancer l'installation de Greengrass sur votre appareil.
1. Pour personnaliser et créer votre propre image à l'aide de Yocto à partir du code source, puis utiliser le kit de connexion pour installer Nucleus Lite, suivez les instructions ci-dessous. GitHub
1. Choisissez ensuite **Afficher les principaux appareils**.
------
# Installation du logiciel AWS IoT Greengrass principal (CLI)
**Note**
Ces étapes ne s'appliquent pas à Nucleus Lite.
**Pour installer et configurer le logiciel AWS IoT Greengrass Core**
1. Sur votre appareil principal Greengrass, exécutez la commande suivante pour accéder au répertoire de base.
------
#### [ Linux or Unix ]
```
cd ~
```
------
#### [ Windows Command Prompt (CMD) ]
```
cd %USERPROFILE%
```
------
#### [ PowerShell ]
```
cd ~
```
------
1. Sur votre appareil principal, téléchargez le logiciel AWS IoT Greengrass Core dans un fichier nommé`greengrass-nucleus-latest.zip`.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
Si vous téléchargez ce logiciel, vous acceptez le [contrat de licence du logiciel Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
1. 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. Exécutez la commande suivante pour lancer le programme d'installation du logiciel AWS IoT Greengrass Core. Cette commande exécute les opérations suivantes :
+ Créez les AWS ressources dont le périphérique principal a besoin pour fonctionner.
+ Configurez le logiciel AWS IoT Greengrass Core en tant que service système qui s'exécute au démarrage. Sur les appareils Linux, cela nécessite le [système d'initialisation Systemd](https://en.wikipedia.org/wiki/Systemd).
**Important**
Sur les appareils Windows Core, vous devez configurer le logiciel AWS IoT Greengrass Core en tant que service système.
+ Déployez le [composant AWS IoT Greengrass CLI](gg-cli.md), qui est un outil de ligne de commande qui vous permet de développer des composants Greengrass personnalisés sur le périphérique principal.
+ 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.
Remplacez les valeurs des arguments dans votre commande comme suit.
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**
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**
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 \
--deploy-dev-tools 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 ^
--deploy-dev-tools 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 `
--deploy-dev-tools true
```
------
**Note**
Si vous utilisez AWS IoT Greengrass un appareil dont la mémoire est limitée, vous pouvez contrôler la quantité de mémoire utilisée par le logiciel AWS IoT Greengrass Core. Pour contrôler l'allocation de mémoire, vous pouvez définir les options de taille de segment de mémoire JVM dans le paramètre de `jvmOptions` configuration de votre composant Nucleus. Pour de plus amples informations, veuillez consulter [Contrôlez l'allocation de mémoire grâce aux options JVM](configure-greengrass-core-v2.md#jvm-tuning).
Lorsque vous exécutez cette commande, les messages suivants devraient s'afficher pour indiquer que le programme d'installation a réussi.
```
Successfully configured Nucleus with provisioned resource details!
Configured Nucleus to deploy aws.greengrass.Cli component
Successfully set up Nucleus as a system service
```
**Note**
Si vous possédez un appareil Linux et qu'il n'est pas doté de [systemd](https://en.wikipedia.org/wiki/Systemd), le programme d'installation ne configurera pas le logiciel en tant que service système et vous ne verrez pas le message de confirmation de configuration du noyau en tant que service système.
# (Facultatif) Exécutez le logiciel Greengrass (Linux)
**Note**
Ces étapes ne s'appliquent pas à Nucleus Lite.
Si vous avez installé le logiciel 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. Pour savoir si le programme d'installation a configuré le logiciel en tant que service système, recherchez la ligne suivante dans le résultat du programme d'installation.
```
Successfully set up Nucleus as a system service
```
Si ce message ne s'affiche pas, procédez comme suit pour exécuter le logiciel :
1. Exécutez la commande suivante pour exécuter le logiciel.
```
sudo /greengrass/v2/alts/current/distro/bin/loader
```
Le logiciel imprime le message suivant s'il démarre correctement.
```
Launched Nucleus successfully.
```
1. Vous devez laisser l'interface de commande actuelle ouverte pour que le logiciel AWS IoT Greengrass Core continue de fonctionner. Si vous utilisez SSH pour vous connecter au périphérique principal, exécutez la commande suivante sur votre ordinateur de développement pour ouvrir une deuxième session SSH que vous pouvez utiliser pour exécuter des commandes supplémentaires sur le périphérique principal. Remplacez *username* par le nom de l'utilisateur auquel vous souhaitez vous connecter et *pi-ip-address* par l'adresse IP de l'appareil.
```
ssh username@pi-ip-address
```
Pour plus d'informations sur la manière d'interagir avec le service système Greengrass, consultez. [Configurer le noyau Greengrass en tant que service système](configure-greengrass-core-v2.md#configure-system-service)
# Vérifiez l'installation de Greengrass CLI sur l'appareil
**Note**
Ces étapes ne s'appliquent pas à Nucleus Lite.
Le déploiement de la CLI Greengrass peut prendre jusqu'à une minute. Exécutez la commande suivante pour vérifier l'état du déploiement. Remplacez *MyGreengrassCore* par le nom de votre appareil principal.
```
aws greengrassv2 list-effective-deployments --core-device-thing-name MyGreengrassCore
```
`coreDeviceExecutionStatus`Indique l'état du déploiement sur le périphérique principal. Lorsque le statut est défini`SUCCEEDED`, exécutez la commande suivante pour vérifier que la CLI Greengrass est installée et fonctionne. Remplacez `/greengrass/v2` par le chemin d'accès au dossier racine.
------
#### [ Linux or Unix ]
```
/greengrass/v2/bin/greengrass-cli help
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli help
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli help
```
------
La commande génère des informations d'aide pour la CLI Greengrass. S'il `greengrass-cli` n'est pas trouvé, le déploiement n'a peut-être pas réussi à installer la CLI Greengrass. Pour de plus amples informations, veuillez consulter [Résolution des problèmes AWS IoT Greengrass V2](troubleshooting.md).
Vous pouvez également exécuter la commande suivante pour déployer manuellement la AWS IoT Greengrass CLI sur votre appareil.
+ *region*Remplacez-le par Région AWS celui que vous utilisez. Assurez-vous d'utiliser le même Région AWS que celui que vous avez utilisé pour configurer le AWS CLI sur votre appareil.
+ *account-id*Remplacez-le par votre Compte AWS identifiant.
+ Remplacez *MyGreengrassCore* par le nom de votre appareil principal.
------
#### [ Linux, macOS, or Unix ]
```
aws greengrassv2 create-deployment \
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \
--components '{
"aws.greengrass.Cli": {
"componentVersion": "2.16.1"
}
}'
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws greengrassv2 create-deployment ^
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^
--components "{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}"
```
------
#### [ PowerShell ]
```
aws greengrassv2 create-deployment `
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" `
--components '{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}'
```
------
**Astuce**
Vous pouvez ajouter `/greengrass/v2/bin` (Linux) ou `C:\greengrass\v2\bin` (Windows) à votre variable d'`PATH`environnement pour qu'elle s'exécute `greengrass-cli` sans son chemin absolu.
Le logiciel AWS IoT Greengrass principal et les outils de développement local s'exécutent sur votre appareil. Vous pouvez ensuite développer un AWS IoT Greengrass composant Hello World sur votre appareil.
# Étape 4 : développer et tester un composant sur votre appareil
Un composant est un module logiciel qui s'exécute sur les appareils AWS IoT Greengrass principaux. Les composants vous permettent de créer et de gérer des applications complexes sous forme de composants distincts que vous pouvez réutiliser d'un appareil principal de Greengrass à un autre. Chaque composant est composé d'une *recette* et d'*artefacts*.
+ **Recettes**
Chaque composant contient un fichier de recette qui définit ses métadonnées. La recette spécifie également les paramètres de configuration, les dépendances des composants, le cycle de vie et la compatibilité de la plate-forme du composant. Le cycle de vie du composant définit les commandes qui installent, exécutent et arrêtent le composant. Pour de plus amples informations, veuillez consulter [AWS IoT Greengrass référence de recette de composant](component-recipe-reference.md).
Vous pouvez définir des recettes au format [JSON](https://en.wikipedia.org/wiki/JSON) ou [YAML.](https://en.wikipedia.org/wiki/YAML)
+ **Artefacts**
Les composants peuvent avoir un nombre illimité d'artefacts, qui sont des binaires de composants. Les artefacts peuvent inclure des scripts, du code compilé, des ressources statiques et tout autre fichier consommé par un composant. Les composants peuvent également consommer des artefacts issus de leurs dépendances.
Avec AWS IoT Greengrass, vous pouvez utiliser la CLI Greengrass pour développer et tester des composants localement sur un appareil principal de Greengrass sans interaction avec le Cloud. AWS Lorsque vous avez terminé votre composant local, vous pouvez utiliser la recette et les artefacts du composant pour créer ce composant dans le AWS IoT Greengrass service dans le AWS Cloud, puis le déployer sur tous vos appareils principaux Greengrass. Pour plus d'informations sur les composants, consultez[Développer des AWS IoT Greengrass composants](develop-greengrass-components.md).
Dans cette section, vous apprendrez à créer et à exécuter un composant Hello World de base en local sur votre appareil principal.
**Pour développer un composant Hello World sur votre appareil**
1. Créez un dossier pour vos composants avec des sous-dossiers pour les recettes et les artefacts. Exécutez les commandes suivantes sur votre appareil principal Greengrass pour créer ces dossiers et accéder au dossier des composants. Remplacez *\$1/greengrassv2* ou *%USERPROFILE%\$1greengrassv2* par le chemin d'accès au dossier à utiliser pour le développement local.
------
#### [ Linux or Unix ]
```
mkdir -p ~/greengrassv2/{recipes,artifacts}
cd ~/greengrassv2
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir %USERPROFILE%\greengrassv2\\recipes, %USERPROFILE%\greengrassv2\\artifacts
cd %USERPROFILE%\greengrassv2
```
------
#### [ PowerShell ]
```
mkdir ~/greengrassv2/recipes, ~/greengrassv2/artifacts
cd ~/greengrassv2
```
------
1. Utilisez un éditeur de texte pour créer un fichier de recette qui définit les métadonnées, les paramètres, les dépendances, le cycle de vie et les capacités de la plateforme de votre composant. Incluez la version du composant dans le nom du fichier de recette afin de pouvoir identifier quelle recette reflète quelle version de composant. Vous pouvez choisir le format YAML ou JSON pour votre recette.
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.
------
#### [ JSON ]
```
nano recipes/com.example.HelloWorld-1.0.0.json
```
------
#### [ YAML ]
```
nano recipes/com.example.HelloWorld-1.0.0.yaml
```
------
**Note**
AWS IoT Greengrass utilise des versions sémantiques pour les composants. Les versions sémantiques suivent une *majeure*. *mineur*. système de numéro de *patch*. Par exemple, la version `1.0.0` représente la première version majeure d'un composant. Pour plus d'informations, consultez la [spécification de version sémantique](https://semver.org/).
1. Collez la recette suivante dans le fichier.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
- Platform:
os: windows
Lifecycle:
run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
```
------
La `ComponentConfiguration` section de cette recette définit un paramètre`Message`, dont la valeur par défaut est. `world` La `Manifests` section définit un *manifeste*, qui est un ensemble d'instructions de cycle de vie et d'artefacts pour une plate-forme. Vous pouvez définir plusieurs manifestes pour spécifier différentes instructions d'installation pour différentes plateformes, par exemple. Dans le manifeste, la `Lifecycle` section indique au périphérique principal de Greengrass d'exécuter le script Hello World avec `Message` la valeur du paramètre comme argument.
1. Exécutez la commande suivante pour créer un dossier pour les artefacts du composant.
------
#### [ Linux or Unix ]
```
mkdir -p artifacts/com.example.HelloWorld/1.0.0
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir artifacts\com.example.HelloWorld\1.0.0
```
------
#### [ PowerShell ]
```
mkdir artifacts\com.example.HelloWorld\1.0.0
```
------
**Important**
Vous devez utiliser le format suivant pour le chemin du dossier d'artefacts. Incluez le nom et la version du composant que vous spécifiez dans la recette.
```
artifacts/componentName/componentVersion/
```
1. Utilisez un éditeur de texte pour créer un fichier d'artefact de script Python pour votre composant Hello World.
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 artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Copiez et collez le script Python suivant dans le fichier.
```
import sys
message = "Hello, %s!" % sys.argv[1]
# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```
1. Utilisez la AWS IoT Greengrass CLI locale pour gérer les composants de votre appareil principal Greengrass.
Exécutez la commande suivante pour déployer le composant sur le AWS IoT Greengrass noyau. Remplacez `/greengrass/v2` ou *C:\$1greengrass\$1v2* par votre dossier AWS IoT Greengrass V2 racine, et remplacez *\$1/greengrassv2* ou *%USERPROFILE%\$1greengrassv2* par le dossier de développement de vos composants.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--recipeDir ~/greengrassv2/recipes \
--artifactDir ~/greengrassv2/artifacts \
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--recipeDir %USERPROFILE%\greengrassv2\recipes ^
--artifactDir %USERPROFILE%\greengrassv2\artifacts ^
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--recipeDir ~/greengrassv2/recipes `
--artifactDir ~/greengrassv2/artifacts `
--merge "com.example.HelloWorld=1.0.0"
```
------
Cette commande ajoute le composant qui utilise la recette dans `recipes` et le script Python dans`artifacts`. L'`--merge`option ajoute ou met à jour le composant et la version que vous spécifiez.
1. Le logiciel AWS IoT Greengrass Core enregistre la sortie standard du processus du composant dans les fichiers journaux du `logs` dossier. Exécutez la commande suivante pour vérifier que le composant Hello World s'exécute et imprime les messages.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
La `type` commande écrit le contenu du fichier sur le terminal. Exécutez cette commande plusieurs fois pour observer les modifications apportées au fichier.
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Vous devriez voir des messages similaires à ceux de l'exemple suivant.
```
Hello, world!
```
**Note**
Si le fichier n'existe pas, le déploiement local n'est peut-être pas encore terminé. Si le fichier n'existe pas dans les 15 secondes, le déploiement a probablement échoué. Cela peut se produire si votre recette n'est pas valide, par exemple. Exécutez la commande suivante pour afficher le fichier journal AWS IoT Greengrass principal. Ce fichier inclut les journaux du service de déploiement de l'appareil principal Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
```
type C:\greengrass\v2\logs\greengrass.log
```
La `type` commande écrit le contenu du fichier sur le terminal. Exécutez cette commande plusieurs fois pour observer les modifications apportées au fichier.
```
gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
```
1. Modifiez le composant local pour itérer et tester votre code. Ouvrez `hello_world.py` dans un éditeur de texte et ajoutez le code suivant à la ligne 4 pour modifier le message enregistré par le AWS IoT Greengrass noyau.
```
message += " Greetings from your first Greengrass component."
```
Le `hello_world.py` script doit maintenant avoir le contenu suivant.
```
import sys
message = "Hello, %s!" % sys.argv[1]
message += " Greetings from your first Greengrass component."
# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```
1. Exécutez la commande suivante pour mettre à jour le composant avec vos modifications.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--recipeDir ~/greengrassv2/recipes \
--artifactDir ~/greengrassv2/artifacts \
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--recipeDir %USERPROFILE%\greengrassv2\recipes ^
--artifactDir %USERPROFILE%\greengrassv2\artifacts ^
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--recipeDir ~/greengrassv2/recipes `
--artifactDir ~/greengrassv2/artifacts `
--merge "com.example.HelloWorld=1.0.0"
```
------
Cette commande met à jour le `com.example.HelloWorld` composant avec le dernier artefact Hello World.
1. Exécutez la commande suivante pour redémarrer le composant. Lorsque vous redémarrez un composant, le périphérique principal utilise les dernières modifications.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli component restart \
--names "com.example.HelloWorld"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli component restart ^
--names "com.example.HelloWorld"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli component restart `
--names "com.example.HelloWorld"
```
------
1. Consultez à nouveau le journal pour vérifier que le composant Hello World imprime le nouveau message.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
La `type` commande écrit le contenu du fichier sur le terminal. Exécutez cette commande plusieurs fois pour observer les modifications apportées au fichier.
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Vous devriez voir des messages similaires à ceux de l'exemple suivant.
```
Hello, world! Greetings from your first Greengrass component.
```
1. Vous pouvez mettre à jour les paramètres de configuration du composant pour tester différentes configurations. Lorsque vous déployez un composant, vous pouvez spécifier une *mise à jour de configuration*, qui définit comment modifier la configuration du composant sur le périphérique principal. Vous pouvez spécifier les valeurs de configuration à rétablir aux valeurs par défaut et les nouvelles valeurs de configuration à fusionner sur le périphérique principal. Pour de plus amples informations, veuillez consulter [Mettre à jour les configurations des composants](update-component-configurations.md).
Procédez comme suit :
1. Utilisez un éditeur de texte pour créer un fichier appelé `hello-world-config-update.json` pour contenir la mise à jour de configuration
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 hello-world-config-update.json
```
1. Copiez et collez l'objet JSON suivant dans le fichier. Cet objet JSON définit une mise à jour de configuration qui fusionne la valeur `friend` avec le `Message` paramètre pour mettre à jour sa valeur. Cette mise à jour de configuration ne spécifie aucune valeur à réinitialiser. Il n'est pas nécessaire de réinitialiser le `Message` paramètre car la mise à jour de fusion remplace la valeur existante.
```
{
"com.example.HelloWorld": {
"MERGE": {
"Message": "friend"
}
}
}
```
1. Exécutez la commande suivante pour déployer la mise à jour de configuration sur le composant Hello World.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--merge "com.example.HelloWorld=1.0.0" \
--update-config hello-world-config-update.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--merge "com.example.HelloWorld=1.0.0" ^
--update-config hello-world-config-update.json
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--merge "com.example.HelloWorld=1.0.0" `
--update-config hello-world-config-update.json
```
------
1. Consultez à nouveau le journal pour vérifier que le composant Hello World produit le nouveau message.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
La `type` commande écrit le contenu du fichier sur le terminal. Exécutez cette commande plusieurs fois pour observer les modifications apportées au fichier.
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Vous devriez voir des messages similaires à ceux de l'exemple suivant.
```
Hello, friend! Greetings from your first Greengrass component.
```
1. Une fois que vous avez terminé de tester votre composant, supprimez-le de votre appareil principal. Exécutez la commande suivante.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create --remove="com.example.HelloWorld"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld"
```
------
**Important**
Cette étape est nécessaire pour que vous puissiez redéployer le composant sur le périphérique principal après l'avoir chargé sur AWS IoT Greengrass. Dans le cas contraire, le déploiement échoue avec une erreur de compatibilité de version car le déploiement local spécifie une version différente du composant.
Exécutez la commande suivante et vérifiez que le `com.example.HelloWorld` composant n'apparaît pas dans la liste des composants de votre appareil.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli component list
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli component list
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli component list
```
------
Votre composant Hello World est terminé et vous pouvez désormais le télécharger sur le service AWS IoT Greengrass cloud. Vous pouvez ensuite déployer le composant sur les appareils principaux de Greengrass.
# Étape 5 : Créez votre composant dans le AWS IoT Greengrass service
Lorsque vous avez terminé de développer un composant sur votre appareil principal, vous pouvez le télécharger vers le AWS IoT Greengrass service dans le AWS Cloud. Vous pouvez également créer le composant directement dans la [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass). AWS IoT Greengrass fournit un service de gestion des composants qui héberge vos composants afin que vous puissiez les déployer sur des appareils individuels ou des flottes d'appareils. Pour télécharger un composant vers le AWS IoT Greengrass service, vous devez suivre les étapes suivantes :
+ Téléchargez les artefacts des composants dans un compartiment S3.
+ Ajoutez l'URI Amazon Simple Storage Service (Amazon S3) de chaque artefact à la recette du composant.
+ Créez un composant à AWS IoT Greengrass partir de la recette du composant.
Dans cette section, vous devez effectuer ces étapes sur votre appareil principal Greengrass pour télécharger votre composant Hello World sur le AWS IoT Greengrass service.
## Créez votre composant dans AWS IoT Greengrass (console)
1. Utilisez un compartiment S3 dans votre AWS compte pour héberger les artefacts des AWS IoT Greengrass composants. Lorsque vous déployez le composant sur un périphérique principal, celui-ci télécharge les artefacts du composant depuis le compartiment.
Vous pouvez utiliser un compartiment S3 existant ou en créer un nouveau.
1. Dans la [console Amazon S3](https://console.aws.amazon.com/s3), sous **Buckets**, choisissez **Create bucket**.
1. Pour **Nom du compartiment**, entrez un nom de compartiment unique. Par exemple, vous pouvez utiliser **greengrass-component-artifacts-*region*-*123456789012***. *123456789012*Remplacez-le par votre identifiant de AWS compte et *region* par celui Région AWS que vous utilisez pour ce didacticiel.
1. Pour **AWS la région**, sélectionnez la AWS région que vous utilisez pour ce didacticiel.
1. Choisissez **Créer un compartiment**.
1. Sous **Buckets**, choisissez le bucket que vous avez créé, téléchargez le `hello_world.py` script dans le `artifacts/com.example.HelloWorld/1.0.0` dossier du bucket. Pour plus d'informations sur le téléchargement d'objets vers des compartiments S3, consultez la section [Chargement d'objets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) dans le guide de l'utilisateur d'*Amazon Simple Storage Service*.
1. Copiez l'URI S3 de l'`hello_world.py`objet dans le compartiment S3. Cette URI doit ressembler à l'exemple suivant. Remplacez amzn-s3-demo-bucket par le nom du compartiment S3.
```
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
1. Autorisez le périphérique principal à accéder aux artefacts des composants dans le compartiment S3.
Chaque appareil principal possède un [rôle IAM principal](device-service-role.md) qui lui permet d'interagir avec le AWS cloud AWS IoT et d'envoyer des journaux vers celui-ci. Ce rôle de périphérique n'autorise pas l'accès aux compartiments S3 par défaut. Vous devez donc créer et associer une politique permettant au périphérique principal de récupérer les artefacts des composants du compartiment S3.
Si le rôle de votre appareil autorise déjà l'accès au compartiment S3, vous pouvez ignorer cette étape. Sinon, créez une politique IAM autorisant l'accès et associez-la au rôle, comme suit :
1. Dans le menu de navigation de [la console IAM](https://console.aws.amazon.com/iam), choisissez **Policies**, puis **Create policy**.
1. Sur l'onglet **JSON**, remplacez le contenu de l'espace réservé par la stratégie suivante. Remplacez amzn-s3-demo-bucket par le nom du compartiment S3 contenant les artefacts des composants à télécharger par le périphérique principal.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
1. Choisissez **Suivant**.
1. Dans la **section Détails de la politique**, pour **Nom**, entrez**MyGreengrassV2ComponentArtifactPolicy**.
1. Choisissez **Create Policy** (Créer une politique).
1. **Dans le menu de navigation de [la console IAM](https://console.aws.amazon.com/iam), choisissez Role, puis choisissez le nom du rôle pour le périphérique principal.** Vous avez spécifié ce nom de rôle lors de l'installation du logiciel AWS IoT Greengrass Core. Si vous n'avez pas spécifié de nom, le nom par défaut est`GreengrassV2TokenExchangeRole`.
1. Sous **Autorisations**, choisissez **Ajouter des autorisations**, puis choisissez **Joindre des politiques**.
1. Sur la page **Ajouter des autorisations**, cochez la case à côté de la `MyGreengrassV2ComponentArtifactPolicy` politique que vous avez créée, puis choisissez **Ajouter des autorisations**.
1. Utilisez la recette du composant pour créer un composant dans la [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass).
1. Dans le menu de navigation de la [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass), choisissez **Composants**, puis sélectionnez **Créer un composant**.
1. Sous **Informations sur le composant**, choisissez **Enter recipe as JSON**. La recette de remplacement doit ressembler à l'exemple suivant.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
}
]
}
```
1. Remplacez l'URI de remplacement dans chaque `Artifacts` section par l'URI S3 de votre `hello_world.py` objet.
1. Choisissez **Créer un composant**.
1. Sur le **com.example. HelloWorld**page du composant, vérifiez que l'**état** du composant est **déployable**.
## Créez votre composant dans AWS IoT Greengrass (AWS CLI)
**Pour télécharger votre composant Hello World**
1. Utilisez un compartiment S3 dans votre compartiment Compte AWS pour héberger les artefacts des AWS IoT Greengrass composants. Lorsque vous déployez le composant sur un périphérique principal, celui-ci télécharge les artefacts du composant depuis le compartiment.
Vous pouvez utiliser un compartiment S3 existant ou exécuter la commande suivante pour créer un compartiment. Cette commande crée un compartiment avec votre Compte AWS identifiant et Région AWS pour former un nom de compartiment unique. *123456789012*Remplacez-le par votre Compte AWS identifiant et *region* par celui Région AWS que vous avez utilisé pour ce didacticiel.
```
aws s3 mb s3://greengrass-component-artifacts-123456789012-region
```
La commande affiche les informations suivantes si la demande aboutit.
```
make_bucket: greengrass-component-artifacts-123456789012-region
```
1. Autorisez le périphérique principal à accéder aux artefacts des composants dans le compartiment S3.
Chaque appareil principal possède un [rôle IAM principal](device-service-role.md) qui lui permet AWS IoT d'interagir avec le AWS Cloud. Ce rôle de périphérique n'autorise pas l'accès aux compartiments S3 par défaut. Vous devez donc créer et associer une politique permettant au périphérique principal de récupérer les artefacts des composants du compartiment S3.
Si le rôle du périphérique principal autorise déjà l'accès au compartiment S3, vous pouvez ignorer cette étape. Sinon, créez une politique IAM autorisant l'accès et associez-la au rôle, comme suit :
1. Créez un fichier appelé `component-artifact-policy.json` et copiez-y le code JSON suivant. Cette politique permet d'accéder à tous les fichiers d'un compartiment S3. Remplacez amzn-s3-demo-bucket par le nom du compartiment S3.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
1. Exécutez la commande suivante pour créer la politique à partir du document de stratégie dans`component-artifact-policy.json`.
------
#### [ Linux or Unix ]
```
aws iam create-policy \\
--policy-name MyGreengrassV2ComponentArtifactPolicy \\
--policy-document file://component-artifact-policy.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iam create-policy ^
--policy-name MyGreengrassV2ComponentArtifactPolicy ^
--policy-document file://component-artifact-policy.json
```
------
#### [ PowerShell ]
```
aws iam create-policy `
--policy-name MyGreengrassV2ComponentArtifactPolicy `
--policy-document file://component-artifact-policy.json
```
------
Copiez le nom Amazon Resource Name (ARN) de la politique à partir des métadonnées de la politique dans la sortie. Vous utilisez cet ARN pour associer cette politique au rôle principal de l'appareil à l'étape suivante.
1. Exécutez la commande suivante pour associer la politique au rôle principal de l'appareil. Remplacez *GreengrassV2TokenExchangeRole* par le nom du rôle du périphérique principal. Vous avez spécifié ce nom de rôle lors de l'installation du logiciel AWS IoT Greengrass Core. Remplacez l'ARN de la politique par l'ARN de l'étape précédente.
------
#### [ Linux or Unix ]
```
aws iam attach-role-policy \\
--role-name GreengrassV2TokenExchangeRole \\
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iam attach-role-policy ^
--role-name GreengrassV2TokenExchangeRole ^
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
#### [ PowerShell ]
```
aws iam attach-role-policy `
--role-name GreengrassV2TokenExchangeRole `
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
Si la commande n'a aucune sortie, elle a réussi. Le périphérique principal peut désormais accéder aux artefacts que vous téléchargez dans ce compartiment S3.
1. Téléchargez l'artefact du script Python Hello World dans le compartiment S3.
Exécutez la commande suivante pour télécharger le script sur le même chemin dans le compartiment où le script existe sur votre AWS IoT Greengrass cœur. Remplacez amzn-s3-demo-bucket par le nom du compartiment S3.
------
#### [ Linux or Unix ]
```
aws s3 cp \
artifacts/com.example.HelloWorld/1.0.0/hello_world.py \
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws s3 cp ^
artifacts/com.example.HelloWorld/1.0.0/hello_world.py ^
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
#### [ PowerShell ]
```
aws s3 cp `
artifacts/com.example.HelloWorld/1.0.0/hello_world.py `
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
La commande affiche une ligne qui commence par `upload:` si la demande aboutit.
1. Ajoutez l'URI Amazon S3 de l'artefact à la recette du composant.
L'URI Amazon S3 est composé du nom du compartiment et du chemin d'accès à l'objet artefact contenu dans le compartiment. L'URI Amazon S3 de votre artefact de script est l'URI vers lequel vous avez chargé l'artefact à l'étape précédente. Cette URI doit ressembler à l'exemple suivant. Remplacez amzn-s3-demo-bucket par le nom du compartiment S3.
```
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Pour ajouter l'artefact à la recette, ajoutez une liste `Artifacts` contenant une structure avec l'URI Amazon S3.
------
#### [ JSON ]
```
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
```
Ouvrez le fichier de recette dans un éditeur de texte.
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 recipes/com.example.HelloWorld-1.0.0.json
```
Ajoutez l'artefact à la recette. Votre fichier de recette doit ressembler à l'exemple suivant.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
}
]
}
```
------
#### [ YAML ]
```
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Ouvrez le fichier de recette dans un éditeur de texte.
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 recipes/com.example.HelloWorld-1.0.0.yaml
```
Ajoutez l'artefact à la recette. Votre fichier de recette doit ressembler à l'exemple suivant.
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
Run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
- Platform:
os: windows
Lifecycle:
Run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
1. Créez une ressource de composant à AWS IoT Greengrass partir de la recette. Exécutez la commande suivante pour créer le composant à partir de la recette, que vous fournissez sous forme de fichier binaire.
------
#### [ JSON ]
```
aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.json
```
------
#### [ YAML ]
```
aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.yaml
```
------
La réponse ressemble à l'exemple suivant si la demande aboutit.
```
{
"arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0",
"componentName": "com.example.HelloWorld",
"componentVersion": "1.0.0",
"creationTimestamp": "Mon Nov 30 09:04:05 UTC 2020",
"status": {
"componentState": "REQUESTED",
"message": "NONE",
"errors": {}
}
}
```
Copiez le `arn` depuis la sortie pour vérifier l'état du composant à l'étape suivante.
**Note**
Vous pouvez également voir votre composant Hello World dans la [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass) sur la page **Composants**.
1. Vérifiez que le composant est créé et qu'il est prêt à être déployé. Lorsque vous créez un composant, son état est`REQUESTED`. AWS IoT Greengrass Vérifie ensuite que le composant est déployable. Vous pouvez exécuter la commande suivante pour connaître l'état du composant et vérifier que celui-ci est déployable. Remplacez le `arn` par l'ARN de l'étape précédente.
```
aws greengrassv2 describe-component --arn "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0"
```
Si le composant est validé, la réponse indique que l'état du composant est`DEPLOYABLE`.
```
{
"arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0",
"componentName": "com.example.HelloWorld",
"componentVersion": "1.0.0",
"creationTimestamp": "2020-11-30T18:04:05.823Z",
"publisher": "Amazon",
"description": "My first Greengrass component.",
"status": {
"componentState": "DEPLOYABLE",
"message": "NONE",
"errors": {}
},
"platforms": [
{
"os": "linux",
"architecture": "all"
}
]
}
```
Votre composant Hello World est désormais disponible en AWS IoT Greengrass. Vous pouvez le redéployer sur cet appareil principal de Greengrass ou sur d'autres appareils principaux.
# Étape 6 : Déployez votre composant
Avec AWS IoT Greengrass, vous pouvez déployer des composants sur des appareils individuels ou des groupes d'appareils. Lorsque vous déployez un composant, il AWS IoT Greengrass installe et exécute le logiciel de ce composant sur chaque machine cible. Vous spécifiez les composants à déployer et la mise à jour de configuration à déployer pour chaque composant. Vous pouvez également contrôler la manière dont le déploiement est déployé sur les appareils ciblés par le déploiement. Pour de plus amples informations, veuillez consulter [Déployer AWS IoT Greengrass des composants sur des appareils](manage-deployments.md).
Dans cette section, vous allez redéployer votre composant Hello World sur votre appareil principal Greengrass.
## Déployez votre composant (console)
1. Dans le menu de navigation de la [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass), sélectionnez **Composants**.
1. Sur la page **Composants**, sous l'onglet **Mes composants**, choisissez **com.example.HelloWorld**.
1. Dans la page **com.example.HelloWorld**page, choisissez **Déployer**.
1. Dans **Ajouter au déploiement**, choisissez **Créer un nouveau déploiement**, puis **Suivant**.
1. Sur la page **Specify target (Spécifier une cible)**, procédez comme suit :
1. Dans la case **Nom**, saisissez **Deployment for MyGreengrassCore**.
1. Pour **Cible de déploiement**, choisissez l'**appareil principal** et le nom de l' AWS IoT appareil principal. La valeur par défaut de ce didacticiel est*MyGreengrassCore*.
1. Choisissez **Suivant**.
1. Sur la page **Sélectionner les composants**, sous **Mes composants**, vérifiez que **com.example.HelloWorld**le composant est sélectionné, puis choisissez **Next**.
1. Sur la page **Configurer les composants**, sélectionnez **com.example.HelloWorld**, puis procédez comme suit :
1. Choisissez **Configure component (Configurer un composant)**.
1. Sous **Configuration update (Mise à jour de la configuration)**, dans **Configuration to merge (Configuration à fusionner)**, saisissez la configuration suivante.
```
{
"Message": "universe"
}
```
Cette mise à jour de configuration définit le `Message` paramètre Hello World sur `universe` pour l'appareil dans ce déploiement.
1. Choisissez **Confirmer**.
1. Choisissez **Suivant**.
1. Sur la page **Configure advanced settings (Configurer les paramètres avancés)**, conservez les paramètres de configuration par défaut et choisissez **Next (Suivant)**.
1. Sur la page **Review (Révision)**, choisissez **Deploy (Déployer)**.
1. Vérifiez que le déploiement est terminé correctement. L'exécution du déploiement peut prendre plusieurs minutes. Consultez le journal Hello World pour vérifier la modification. Exécutez la commande suivante sur votre appareil principal Greengrass.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\\logs\\com.example.HelloWorld.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Vous devriez voir des messages similaires à ceux de l'exemple suivant.
```
Hello, universe! Greetings from your first Greengrass component.
```
**Note**
Si les messages du journal ne changent pas, le déploiement a échoué ou n'a pas atteint le périphérique principal. Cela peut se produire si votre appareil principal n'est pas connecté à Internet ou n'est pas autorisé à récupérer des artefacts de votre compartiment S3. Exécutez la commande suivante sur votre appareil principal pour afficher le fichier journal du logiciel AWS IoT Greengrass Core. Ce fichier inclut les journaux du service de déploiement de l'appareil principal Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
```
type C:\greengrass\v2\\logs\\greengrass.log
```
La `type` commande écrit le contenu du fichier sur le terminal. Exécutez cette commande plusieurs fois pour observer les modifications apportées au fichier.
```
gc C:\greengrass\v2\\logs\\greengrass.log -Tail 10 -Wait
```
Pour de plus amples informations, veuillez consulter [Résolution des problèmes AWS IoT Greengrass V2](troubleshooting.md).
## Déployez votre composant (AWS CLI)
**Pour déployer votre composant Hello World**
1. Sur votre ordinateur de développement, créez un fichier appelé `hello-world-deployment.json` et copiez-y le code JSON suivant. Ce fichier définit les composants et les configurations à déployer.
```
{
"components": {
"com.example.HelloWorld": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"merge": "{\"Message\":\"universe\"}"
}
}
}
}
```
Ce fichier de configuration indique de déployer la version `1.0.0` du composant Hello World que vous avez développée et publiée lors de la procédure précédente. `configurationUpdate`Spécifie de fusionner la configuration du composant dans une chaîne codée en JSON. Cette mise à jour de configuration définit le `Message` paramètre Hello World sur `universe` pour l'appareil dans ce déploiement.
1. Exécutez la commande suivante pour déployer le composant sur votre appareil principal Greengrass. Vous pouvez effectuer un déploiement sur des objets, qui sont des appareils individuels, ou sur des groupes d'objets, qui sont des groupes d'appareils. *MyGreengrassCore*Remplacez-le par le nom de l' AWS IoT objet correspondant à votre appareil principal.
------
#### [ Linux or Unix ]
```
aws greengrassv2 create-deployment \
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \
--cli-input-json file://hello-world-deployment.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws greengrassv2 create-deployment ^
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^
--cli-input-json file://hello-world-deployment.json
```
------
#### [ PowerShell ]
```
aws greengrassv2 create-deployment `
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" `
--cli-input-json file://hello-world-deployment.json
```
------
La commande produit une réponse similaire à l'exemple suivant.
```
{
"deploymentId": "deb69c37-314a-4369-a6a1-3dff9fce73a9",
"iotJobId": "b5d92151-6348-4941-8603-bdbfb3e02b75",
"iotJobArn": "arn:aws:iot:region:account-id:job/b5d92151-6348-4941-8603-bdbfb3e02b75"
}
```
1. Vérifiez que le déploiement est terminé correctement. L'exécution du déploiement peut prendre plusieurs minutes. Consultez le journal Hello World pour vérifier la modification. Exécutez la commande suivante sur votre appareil principal Greengrass.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\\logs\\com.example.HelloWorld.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Vous devriez voir des messages similaires à ceux de l'exemple suivant.
```
Hello, universe! Greetings from your first Greengrass component.
```
**Note**
Si les messages du journal ne changent pas, le déploiement a échoué ou n'a pas atteint le périphérique principal. Cela peut se produire si votre appareil principal n'est pas connecté à Internet ou n'est pas autorisé à récupérer des artefacts de votre compartiment S3. Exécutez la commande suivante sur votre appareil principal pour afficher le fichier journal du logiciel AWS IoT Greengrass Core. Ce fichier inclut les journaux du service de déploiement de l'appareil principal Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
```
type C:\greengrass\v2\\logs\\greengrass.log
```
La `type` commande écrit le contenu du fichier sur le terminal. Exécutez cette commande plusieurs fois pour observer les modifications apportées au fichier.
```
gc C:\greengrass\v2\\logs\\greengrass.log -Tail 10 -Wait
```
Pour de plus amples informations, veuillez consulter [Résolution des problèmes AWS IoT Greengrass V2](troubleshooting.md).
# Étapes suivantes
Vous avez terminé ce didacticiel. Le logiciel AWS IoT Greengrass principal et votre composant Hello World s'exécutent sur votre appareil. Votre composant Hello World est également disponible dans le service AWS IoT Greengrass cloud pour être déployé sur d'autres appareils. Pour plus d'informations sur les sujets abordés dans ce didacticiel, consultez les rubriques suivantes :
+ [Création de AWS IoT Greengrass composants](create-components.md)
+ [Publiez des composants à déployer sur vos appareils principaux](publish-components.md)
+ [Déployer AWS IoT Greengrass des composants sur des appareils](manage-deployments.md)