Avis de fin de support : le 7 octobre 2026, AWS le support de. AWS IoT Greengrass Version 1 Après le 7 octobre 2026, vous ne pourrez plus accéder aux AWS IoT Greengrass V1 ressources. Pour plus d'informations, rendez-vous sur [Migrer depuis AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).
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.
# Module 1 : Configuration de l'environnement pour Greengrass
Ce module vous montre comment obtenir un out-of-the-box Raspberry Pi, une EC2 instance Amazon ou un autre appareil prêt à être utilisé AWS IoT Greengrass comme appareil AWS IoT Greengrass principal.
**Astuce**
Ou, pour utiliser un script qui configure votre appareil principal à votre place, veuillez consulter [Démarrage rapide : Configuration de l'appareil Greengrass](quick-start.md).
Le module dure approximativement 30 minutes.
Avant de commencer, lisez les [conditions requises](gg-gs.md#gg-requirements) pour ce didacticiel. Ensuite, suivez les instructions de configuration dans l'une des rubriques suivantes. Choisissez uniquement la rubrique qui s'applique à votre type d'appareil principal.
**Topics**
+ [Configuration d'une carte Raspberry Pi](setup-filter.rpi.md)
+ [Configuration d'une EC2 instance Amazon](setup-filter.ec2.md)
+ [Configuration d'autres appareils](setup-filter.other.md)
**Note**
Pour savoir comment utiliser l' AWS IoT Greengrass exécution dans un conteneur Docker prédéfini, consultez. [Exécution AWS IoT Greengrass dans un conteneur Docker](run-gg-in-docker-container.md)
# Configuration d'une carte Raspberry Pi
Suivez les étapes décrites dans cette rubrique pour configurer un Raspberry Pi afin de l'utiliser comme AWS IoT Greengrass cœur.
**Astuce**
AWS IoT Greengrass fournit également d'autres options pour installer le logiciel AWS IoT Greengrass Core. Par exemple, vous pouvez utiliser la [configuration de l'appareil Greengrass](quick-start.md) pour configurer votre environnement et installer la dernière version du logiciel AWS IoT Greengrass Core. Ou, sur les plateformes Debian prises en charge, vous pouvez utiliser le [gestionnaire de paquets APT](install-ggc.md#ggc-package-manager) pour installer ou mettre à jour le logiciel AWS IoT Greengrass principal. Pour de plus amples informations, veuillez consulter [Installation du logiciel AWS IoT Greengrass Core](install-ggc.md).
Si vous configurez une carte Raspberry Pi pour la première fois, vous devez suivre toutes ces étapes. Sinon, vous pouvez passer à l'[étape 9](#add-ggc-user-ggc-group). Toutefois, nous vous recommandons de recréer une image de votre carte Raspberry Pi avec le système d'exploitation, comme recommandé à l'étape 2.
1. Téléchargez et installez un formateur de carte SD tel que le formateur de [carte mémoire SD](https://www.sdcard.org/downloads/formatter/). Insérez la carte SD dans votre ordinateur. Démarrez le programme et choisissez le lecteur où vous avez inséré votre carte SD. Vous pouvez effectuer un formatage rapide de la carte SD.
1. Téléchargez le système d'exploitation [Raspbian Buster](https://downloads.raspberrypi.org/raspbian/images/raspbian-2020-02-14/) sous la forme d'un fichier `zip`.
1. Lors de l'utilisation d'un outil d'écriture sur carte SD (par exemple, [Etcher](https://etcher.io/)), suivez les instructions de l'outil pour flasher le fichier `zip` téléchargé sur la carte SD. Comme l'image du système d'exploitation est volumineuse, cette étape peut prendre un peu de temps. Ejectez votre carte SD de votre ordinateur et insérez la carte microSD dans votre Raspberry Pi.
1. Pour le premier démarrage, nous vous recommandons de connecter la carte Raspberry Pi à un moniteur (via HDMI), un clavier et une souris. Connectez ensuite votre carte Pi à une source d'alimentation micro USB et le système d'exploitation Raspbian doit démarrer.
1. Vous pouvez également configurer la disposition du clavier de l'appareil Pi avant de continuer. Pour ce faire, cliquez sur l'icône Raspberry dans l'angle supérieur droit, choisissez **Preferences**, puis **Mouse and Keyboard Settings**. Choisissez ensuite l'onglet **Keyboard** et **Keyboard Layout**, puis sélectionnez une variante de clavier appropriée.
1. Puis [connectez votre Raspberry Pi à Internet via un réseau Wi-Fi](https://www.raspberrypi.org/documentation/configuration/wireless/desktop.md) ou un câble Ethernet.
**Note**
Connectez votre Raspberry Pi au *même* réseau que votre ordinateur et assurez-vous que votre ordinateur et votre Raspberry Pi ont tous deux accès à Internet avant de continuer. Si vous vous trouvez dans un environnement de travail ou derrière un pare-feu, vous devrez peut-être connecter votre Pi et votre ordinateur au réseau invité afin que les deux appareils soient sur le même réseau. Cette approche risque néanmoins de déconnecter votre ordinateur de certaines ressources du réseau local, comme l'intranet. Une solution possible consiste à connecter le Pi ainsi que votre ordinateur au réseau Wi-Fi invité *et* de relier votre ordinateur au réseau local via un câble Ethernet. Avec cette configuration, votre ordinateur devrait pouvoir se connecter à la carte Raspberry Pi via le réseau Wi-Fi invité et aux ressources de votre réseau local grâce au câble Ethernet.
1. Vous devez configurer [SSH](https://en.wikipedia.org/wiki/Secure_Shell) sur votre carte Pi pour pouvoir vous y connecter à distance. Sur votre Raspberry Pi, ouvrez une [fenêtre de terminal](https://www.raspberrypi.org/documentation/usage/terminal/) et exécutez la commande suivante :
```
sudo raspi-config
```
Vous devez voir ce qui suit :
![\[Capture d'écran de l'outil de configuration du logiciel Raspberry Pi (raspi-config).\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/gg-get-started-001.png)
Faites défiler la page vers le bas et choisissez **Interfacing Options**, puis **P2 SSH**. À l'invite, choisissez **Oui**. (Utilisez la clé Tab suivie de Enter). SSH doit maintenant être activé. Choisissez **OK**. Utilisez la clé Tab pour choisir **Terminer**, puis appuyez sur Enter. Si le Raspberry Pi ne redémarre pas automatiquement, exécutez la commande suivante :
```
sudo reboot
```
1. Sur votre Raspberry Pi, dans la fenêtre de terminal, exécutez la commande suivante :
```
hostname -I
```
Cela renvoie l'adresse IP de votre Raspberry Pi.
**Note**
Pour les éléments suivants, si vous recevez un message concernant l'empreinte digitale de la clé ECDSA (`Are you sure you want to continue connecting (yes/no)?`), indiquez `yes`. Le mot de passe par défaut pour le Raspberry Pi est **raspberry**.
Si vous utilisez macOS, ouvrez une fenêtre Terminal et tapez ce qui suit :
```
ssh pi@IP-address
```
*IP-address*est l'adresse IP de votre Raspberry Pi que vous avez obtenue à l'aide de la `hostname -I` commande.
Si vous utilisez Windows, vous devez installer et configurer [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html). Développez **Connection**, puis choisissez **Data** et assurez-vous que **Prompt** est sélectionné :
![\[Fenêtre PuTTY avec l'option Prompt sélectionnée.\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/gg-get-started-001.4.png)
Choisissez ensuite **Session**, saisissez l'adresse IP du Raspberry Pi, puis sélectionnez **Open** en utilisant les paramètres par défaut.
![\[Fenêtre PuTTY avec l'adresse IP dans le champ « Host Name (or IP address) ».\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/gg-get-started-001.5.png)
Si une alerte de sécurité PuTTY s'affiche, choisissez **Yes**.
L'ID de connexion et le mot de passe par défaut de la carte Raspberry Pi sont **pi** et **raspberry**, respectivement.
![\[Fenêtre de terminal PuTTY initiale.\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/gg-get-started-001.6.png)
**Note**
Si votre ordinateur est connecté à un réseau à distance à l'aide de VPN (par exemple, un réseau professionnel), vous pouvez rencontrer des difficultés pour vous connecter au Raspberry Pi à partir de l'ordinateur à l'aide de SSH.
1. Vous êtes maintenant prêt à configurer le Raspberry Pi pour AWS IoT Greengrass. Tout d'abord, exécutez les commandes suivantes à partir d'une fenêtre de terminal Raspberry Pi locale ou d'une fenêtre de terminal SSH :
**Astuce**
AWS IoT Greengrass fournit également d'autres options pour installer le logiciel AWS IoT Greengrass Core. Par exemple, vous pouvez utiliser la [configuration de l'appareil Greengrass](quick-start.md) pour configurer votre environnement et installer la dernière version du logiciel AWS IoT Greengrass Core. Ou, sur les plateformes Debian prises en charge, vous pouvez utiliser le [gestionnaire de paquets APT](install-ggc.md#ggc-package-manager) pour installer ou mettre à jour le logiciel AWS IoT Greengrass principal. Pour de plus amples informations, veuillez consulter [Installation du logiciel AWS IoT Greengrass Core](install-ggc.md).
```
sudo adduser --system ggc_user
sudo addgroup --system ggc_group
```
1. Pour améliorer la sécurité sur l'appareil Pi, activez les protections hardlink et softlink (symlink) au démarrage du système d'exploitation.
1. Accédez au fichier `98-rpi.conf`.
```
cd /etc/sysctl.d
ls
```
**Note**
Si vous ne voyez pas le fichier `98-rpi.conf`, suivez les instructions fournies dans le fichier `README.sysctl`.
1. Utilisez un éditeur de texte (tel que Leafpad, GNU nano ou vi) pour ajouter les deux lignes suivantes à la fin du fichier. Vous devrez peut-être utiliser la commande `sudo` pour modifier en tant qu'utilisateur racine (par exemple, `sudo nano 98-rpi.conf`).
```
fs.protected_hardlinks = 1
fs.protected_symlinks = 1
```
1. Redémarrez le Pi.
```
sudo reboot
```
Après environ une minute, connectez-vous au Pi à l'aide de SSH, puis exécutez la commande suivante pour confirmer la modification :
```
sudo sysctl -a 2> /dev/null | grep fs.protected
```
Vous devez voir `fs.protected_hardlinks = 1` et `fs.protected_symlinks = 1`.
1. Modifiez votre fichier de démarrage de ligne de commande de manière à activer et monter les cgroups de mémoire. Cela permet AWS IoT Greengrass de définir la limite de mémoire pour les fonctions Lambda. Les groupes C doivent également s'exécuter AWS IoT Greengrass dans le mode de [conteneurisation](lambda-group-config.md#lambda-containerization-considerations) par défaut.
1. Accédez à votre répertoire `boot`.
```
cd /boot/
```
1. Utilisez un éditeur de texte pour ouvrir `cmdline.txt`. Ajoutez les éléments suivants à la fin de la ligne existante, et non en tant que nouvelle ligne. Vous devrez peut-être utiliser la commande `sudo` pour modifier en tant qu'utilisateur racine (par exemple, `sudo nano cmdline.txt`).
```
cgroup_enable=memory cgroup_memory=1
```
1. Maintenant, redémarrez le Pi.
```
sudo reboot
```
Votre Raspberry Pi doit maintenant être prêt pour AWS IoT Greengrass.
1. Facultatif. Installez l'environnement d'exécution Java 8, qui est requis par le [gestionnaire de flux](stream-manager.md). Ce didacticiel n'utilise pas le gestionnaire de flux, mais il utilise le flux de travail **Default Group creation (Création du groupe par défaut)** qui active le gestionnaire de flux par défaut. Utilisez les commandes suivantes pour installer l'environnement d'exécution Java 8 sur l'appareil principal, ou désactivez le gestionnaire de flux avant de déployer votre groupe. Les instructions permettant de désactiver le gestionnaire de flux sont fournies dans le module 3.
```
sudo apt install openjdk-8-jdk
```
1. Pour vous assurer que vous disposez de toutes les dépendances requises, téléchargez et exécutez le vérificateur de dépendances Greengrass depuis le référentiel [AWS IoT Greengrass Samples](https://github.com/aws-samples/aws-greengrass-samples). GitHub Ces commandes décompressent et exécutent le script de vérification des dépendances dans le `Downloads` répertoire.
**Note**
Le vérificateur de dépendance peut échouer si vous utilisez la version 5.4.51 du noyau Raspbian. Cette version ne monte pas correctement les cgroups de mémoire. Cela peut entraîner l'échec des fonctions Lambda exécutées en mode conteneur.
Pour plus d'informations sur la mise à jour de votre noyau, consultez les [groupes C non chargés après la mise à niveau du noyau](https://www.raspberrypi.org/forums/viewtopic.php?t=280656) sur les forums du Raspberry Pi.
```
cd /home/pi/Downloads
mkdir greengrass-dependency-checker-GGCv1.11.x
cd greengrass-dependency-checker-GGCv1.11.x
wget https://github.com/aws-samples/aws-greengrass-samples/raw/master/greengrass-dependency-checker-GGCv1.11.x.zip
unzip greengrass-dependency-checker-GGCv1.11.x.zip
cd greengrass-dependency-checker-GGCv1.11.x
sudo modprobe configs
sudo ./check_ggc_dependencies | more
```
Là où `more` s'affiche, appuyez sur la touche Spacebar pour afficher un autre écran de texte.
**Important**
Ce didacticiel nécessite le moteur d'exécution Python 3.7 pour exécuter les fonctions Lambda locales. Lorsque le gestionnaire de flux est activé, il a également besoin de l'environnement d'exécution Java 8. Si le script `check_ggc_dependencies` génère des avertissements concernant des environnements d'exécution prérequis manquants, veillez à installer ces environnements d'exécution avant de continuer. Vous pouvez ignorer les avertissements concernant d'autres environnements d'exécution facultatifs manquants.
Pour en savoir plus sur la commande **modprobe**, exécutez **man modprobe** dans le terminal.
Votre configuration Raspberry Pi est terminée. Passez au [Module 2 : Installation du logiciel AWS IoT Greengrass de base](module2.md).
# Configuration d'une EC2 instance Amazon
Suivez les étapes décrites dans cette rubrique pour configurer une EC2 instance Amazon à utiliser comme instance AWS IoT Greengrass principale.
**Astuce**
Ou, pour utiliser un script qui configure votre environnement et installe le logiciel AWS IoT Greengrass Core pour vous, voir[Démarrage rapide : Configuration de l'appareil Greengrass](quick-start.md).
Bien que vous puissiez suivre ce didacticiel à l'aide d'une EC2 instance Amazon, AWS IoT Greengrass il doit idéalement être utilisé avec du matériel physique. Nous vous recommandons de [configurer un Raspberry Pi](setup-filter.rpi.md) au lieu d'utiliser une EC2 instance Amazon lorsque cela est possible. Si vous utilisez un Raspberry Pi, vous n'avez pas besoin de suivre les étapes de cette rubrique.
1. Connectez-vous à l' EC2 instance Amazon [AWS Management Console](https://console.aws.amazon.com/)et lancez-la à l'aide d'une AMI Amazon Linux. Pour plus d'informations sur EC2 les instances Amazon, consultez le [guide de EC2 démarrage Amazon](https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/).
1. Une fois que votre EC2 instance Amazon est en cours d'exécution, activez le port 8883 pour autoriser les communications MQTT entrantes afin que d'autres appareils puissent se connecter au AWS IoT Greengrass cœur.
1. Dans le volet de navigation de la EC2 console Amazon, sélectionnez **Security Groups**.
![\[Volet de navigation avec groupes de sécurité surlignés.\]](http://docs.aws.amazon.com/fr_fr/greengrass/v1/developerguide/images/gg-get-started-002.6.1.png)
1. Sélectionnez le groupe de sécurité pour l'instance que vous venez de lancer, puis cliquez sur l'onglet **Règles d'entrée**.
1. Choisissez **Modifier les règles entrantes**.
Pour activer le port 8883, vous devez ajouter une règle TCP personnalisée au groupe de sécurité. Pour plus d'informations, consultez la section [Ajouter des règles à un groupe de sécurité](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule) dans le *guide de EC2 l'utilisateur Amazon*.
1. Sur la page **Modifier les règles entrantes**, choisissez **Ajouter une règle**, entrez les paramètres suivants, puis sélectionnez **Enregistrer**.
+ Pour **Type**, choisissez **Règle TCP personnalisée**.
+ Dans **Portée de ports**, entrez**8883**.
+ Pour **Source**, choisissez **N'importe où**.
+ Pour **Description**, saisissez **MQTT Communications**.
1. Connectez-vous à votre EC2 instance Amazon.
1. Dans le panneau de navigation, choisissez **Instances**, puis sélectionnez votre instance et choisissez **Connexion**.
1. Suivez les instructions de la page **Connectez-vous à votre instance** pour vous connecter à votre instance [ l'aide de SSH](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html) et de votre fichier de clé privée.
Vous pouvez utiliser [PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html) pour Windows ou Terminal pour macOS. Pour plus d'informations, consultez [Connect to your Linux instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) dans le *guide de EC2 l'utilisateur Amazon*.
Vous êtes maintenant prêt à configurer votre EC2 instance Amazon pour AWS IoT Greengrass.
1. Une fois connecté à votre EC2 instance Amazon, créez les `ggc_group` comptes `ggc_user` et :
```
sudo adduser --system ggc_user
sudo groupadd --system ggc_group
```
**Note**
Si la commande `adduser` n'est pas disponible sur votre système, utilisez la commande suivante.
```
sudo useradd --system ggc_user
```
1. Pour améliorer la sécurité, assurez-vous que les protections des liens physiques et des liens souples (liens symboliques) sont activées sur le système d'exploitation de l' EC2 instance Amazon au démarrage.
**Note**
Les étapes permettant d'activer les protections hardlink et softlink varient selon le système d'exploitation. Consultez la documentation de votre distribution.
1. Exécutez la commande suivante pour vérifier si les protections hardlink et softlink sont activées :
```
sudo sysctl -a | grep fs.protected
```
Si les protections hardlink et softlinks sont définies sur `1`, vos protections sont correctement activées. Passez à l'étape 6.
**Note**
Les protections softlink sont représentées par `fs.protected_symlinks`.
1. Si les protections hardlink et softlink ne sont pas définies sur `1`, activez ces protections. Accédez au fichier de configuration du système.
```
cd /etc/sysctl.d
ls
```
1. À l'aide de l'éditeur de texte de votre choix (tel que Leafpad, GNU nano ou vi), ajoutez les deux lignes suivantes à la fin du fichier de configuration du système. Sur Amazon Linux 1, il s'agit du fichier `00-defaults.conf`. Sur Amazon Linux 2, il s'agit du fichier `99-amazon.conf`. Vous devrez peut-être modifier les autorisations du fichier (à l'aide de la commande `chmod`) afin de pouvoir écrire sur ce fichier, ou utiliser la commande `sudo` pour le modifier en tant qu'utilisateur racine (par exemple, `sudo nano 00-defaults.conf`).
```
fs.protected_hardlinks = 1
fs.protected_symlinks = 1
```
1. Redémarrez l' EC2 instance Amazon.
```
sudo reboot
```
Après quelques minutes, connectez-vous à votre instance à l'aide de SSH, puis exécutez la commande suivante pour confirmer la modification.
```
sudo sysctl -a | grep fs.protected
```
Vous devriez voir que les protections hardlink et softlink sont définies avec la valeur 1.
1. Extrayez et exécutez le script suivant pour monter les [groupes de contrôle Linux](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/resource_management_guide/ch01) (cgroups). Cela permet AWS IoT Greengrass de définir la limite de mémoire pour les fonctions Lambda. Les groupes C doivent également s'exécuter AWS IoT Greengrass dans le mode de [conteneurisation](lambda-group-config.md#lambda-containerization-considerations) par défaut.
```
curl https://raw.githubusercontent.com/tianon/cgroupfs-mount/951c38ee8d802330454bdede20d85ec1c0f8d312/cgroupfs-mount > cgroupfs-mount.sh
chmod +x cgroupfs-mount.sh
sudo bash ./cgroupfs-mount.sh
```
Votre EC2 instance Amazon devrait maintenant être prête pour AWS IoT Greengrass.
1. Facultatif. Installez l'environnement d'exécution Java 8, qui est requis par le [gestionnaire de flux](stream-manager.md). Ce didacticiel n'utilise pas le gestionnaire de flux, mais il utilise le flux de travail **Default Group creation (Création du groupe par défaut)** qui active le gestionnaire de flux par défaut. Utilisez les commandes suivantes pour installer l'environnement d'exécution Java 8 sur l'appareil principal, ou désactivez le gestionnaire de flux avant de déployer votre groupe. Les instructions permettant de désactiver le gestionnaire de flux sont fournies dans le module 3.
+ Pour les distributions basées sur Debian :
```
sudo apt install openjdk-8-jdk
```
+ Pour les distributions basées sur Red Hat :
```
sudo yum install java-1.8.0-openjdk
```
1. Pour vous assurer que vous disposez de toutes les dépendances requises, téléchargez et exécutez le vérificateur de dépendances Greengrass depuis le référentiel [AWS IoT Greengrass Samples](https://github.com/aws-samples/aws-greengrass-samples). GitHub Ces commandes téléchargent, décompressent et exécutent le script de vérification des dépendances dans votre instance Amazon EC2 .
```
mkdir greengrass-dependency-checker-GGCv1.11.x
cd greengrass-dependency-checker-GGCv1.11.x
wget https://github.com/aws-samples/aws-greengrass-samples/raw/master/greengrass-dependency-checker-GGCv1.11.x.zip
unzip greengrass-dependency-checker-GGCv1.11.x.zip
cd greengrass-dependency-checker-GGCv1.11.x
sudo ./check_ggc_dependencies | more
```
**Important**
Ce didacticiel nécessite le moteur d'exécution Python 3.7 pour exécuter les fonctions Lambda locales. Lorsque le gestionnaire de flux est activé, il a également besoin de l'environnement d'exécution Java 8. Si le script `check_ggc_dependencies` génère des avertissements concernant des environnements d'exécution prérequis manquants, veillez à installer ces environnements d'exécution avant de continuer. Vous pouvez ignorer les avertissements concernant d'autres environnements d'exécution facultatifs manquants.
La configuration de votre EC2 instance Amazon est terminée. Passez au [Module 2 : Installation du logiciel AWS IoT Greengrass de base](module2.md).
# Configuration d'autres appareils
Suivez les étapes décrites dans cette rubrique pour configurer un appareil (autre qu'un Raspberry Pi) à utiliser comme périphérique AWS IoT Greengrass principal.
**Astuce**
Ou, pour utiliser un script qui configure votre environnement et installe le logiciel AWS IoT Greengrass Core pour vous, voir[Démarrage rapide : Configuration de l'appareil Greengrass](quick-start.md).
Si vous êtes nouveau dans ce AWS IoT Greengrass domaine, nous vous recommandons d'utiliser un Raspberry Pi ou une EC2 instance Amazon comme appareil principal et de suivre les [étapes de configuration](module1.md) adaptées à votre appareil.
Si vous envisagez de créer un système personnalisé basé sur Linux à l'aide du projet Yocto, vous pouvez utiliser la recette AWS IoT Greengrass Bitbake du projet. `meta-aws` Cette recette vous aide également à développer une plate-forme logicielle qui prend en charge les logiciels de AWS pointe pour les applications intégrées. La version Bitbake installe, configure et exécute automatiquement le logiciel AWS IoT Greengrass Core sur votre appareil.
Projet Yocto
Un projet de collaboration open source qui vous aide à créer des systèmes Linux personnalisés pour les applications intégrées, quelle que soit l'architecture matérielle. Pour plus d'informations, consultez le projet [Yocto](https://www.yoctoproject.org/).
`meta-aws`
Un projet AWS géré qui fournit des recettes de Yocto. Vous pouvez utiliser les recettes pour développer des logiciels de AWS pointe dans des systèmes basés sur Linux construits avec [OpenEmbedded](https://www.openembedded.org/wiki/Main_Page)Yocto Project. Pour plus d'informations sur cette fonctionnalité prise en charge par la communauté, consultez le [https://github.com/aws/meta-aws](https://github.com/aws/meta-aws)projet sur GitHub.
`meta-aws-demos`
Un projet AWS géré qui contient des démonstrations du `meta-aws` projet. Pour plus d'exemples sur le processus d'intégration, consultez le [https://github.com/aws-samples/meta-aws-demos](https://github.com/aws-samples/meta-aws-demos)projet sur GitHub.
Pour utiliser un autre appareil ou une autre [plateforme prise en charge](what-is-gg.md#gg-platforms), suivez les étapes de cette rubrique.
1. Si votre appareil principal est un appareil NVIDIA Jetson, vous devez d'abord flasher le microprogramme avec le programme d'installation JetPack 4.3. Si vous configurez un appareil différent, passez à l'étape 2.
**Note**
JetPack La version du programme d'installation que vous utilisez est basée sur votre version cible du CUDA Toolkit. Les instructions suivantes utilisent la JetPack version 4.3 et la version 10.0 de CUDA Toolkit. Pour de plus amples informations sur l'utilisation des versions appropriées pour votre appareil, veuillez consulter [How to Install Jetpack](https://docs.nvidia.com/jetson/jetpack/install-jetpack/index.html) dans la documentation NVIDIA.
1. Sur un poste de travail physique qui exécute Ubuntu 16.04 ou version ultérieure, flashez le microprogramme avec le programme d'installation JetPack 4.3, comme décrit dans la section [Télécharger et installer JetPack](https://docs.nvidia.com/jetson/archives/jetpack-archived/jetpack-33/index.html#jetpack/3.3/install.htm%3FTocPath%3D_____3) (4.3) de la documentation NVIDIA.
Suivez les instructions affichées dans le programme d'installation pour installer tous les packages et toutes les dépendances sur la carte Jetson connectée à l'ordinateur de bureau à l'aide d'un câble Micro-B.
1. Redémarrez votre carte en mode normal, puis connectez un écran à la carte.
**Note**
Lorsque vous utilisez SSH pour vous connecter à la carte Jetson, utilisez le nom d'utilisateur par défaut (**nvidia**) et le mot de passe par défaut (**nvidia**).
1. Exécutez les commandes suivantes pour créer l'utilisateur `ggc_user` et le groupe `ggc_group`. Les commandes que vous exécutez varient en fonction de la distribution installée sur votre appareil principal.
+ Si votre appareil principal est en cours d'exécution OpenWrt, exécutez les commandes suivantes :
```
opkg install shadow-useradd
opkg install shadow-groupadd
useradd --system ggc_user
groupadd --system ggc_group
```
+ Dans le cas contraire, exécutez les commandes suivantes :
```
sudo adduser --system ggc_user
sudo addgroup --system ggc_group
```
**Note**
Si la commande `addgroup` n'est pas disponible sur votre système, utilisez la commande suivante.
```
sudo groupadd --system ggc_group
```
1. Facultatif. Installez l'environnement d'exécution Java 8, qui est requis par le [gestionnaire de flux](stream-manager.md). Ce didacticiel n'utilise pas le gestionnaire de flux, mais il utilise le flux de travail **Default Group creation (Création du groupe par défaut)** qui active le gestionnaire de flux par défaut. Utilisez les commandes suivantes pour installer l'environnement d'exécution Java 8 sur l'appareil principal, ou désactivez le gestionnaire de flux avant de déployer votre groupe. Les instructions permettant de désactiver le gestionnaire de flux sont fournies dans le module 3.
+ Pour les distributions basées sur Debian ou Ubuntu :
```
sudo apt install openjdk-8-jdk
```
+ Pour les distributions basées sur Red Hat :
```
sudo yum install java-1.8.0-openjdk
```
1. Pour vous assurer que vous disposez de toutes les dépendances requises, téléchargez et exécutez le vérificateur de dépendances Greengrass depuis le référentiel [AWS IoT Greengrass Samples](https://github.com/aws-samples/aws-greengrass-samples). GitHub Ces commandes décompressent et exécutent le script de vérification des dépendances.
```
mkdir greengrass-dependency-checker-GGCv1.11.x
cd greengrass-dependency-checker-GGCv1.11.x
wget https://github.com/aws-samples/aws-greengrass-samples/raw/master/greengrass-dependency-checker-GGCv1.11.x.zip
unzip greengrass-dependency-checker-GGCv1.11.x.zip
cd greengrass-dependency-checker-GGCv1.11.x
sudo ./check_ggc_dependencies | more
```
**Note**
Le `check_ggc_dependencies` script s'exécute sur les plateformes AWS IoT Greengrass prises en charge et nécessite des commandes système Linux spécifiques. Pour plus d'informations, consultez le fichier [Readme](https://github.com/aws-samples/aws-greengrass-samples/blob/master/greengrass-dependency-checker-GGCv1.11.x/README.md) du vérificateur de dépendance.
1. Installez toutes les dépendances requises sur votre appareil, comme indiqué par la sortie du vérificateur de dépendance. S'il manque des dépendances au niveau du noyau, il se peut que vous ayez besoin de recompiler votre noyau. Pour monter les groupes de contrôle Linux (`cgroups`), vous pouvez exécuter le script [cgroupfs-mount](https://raw.githubusercontent.com/tianon/cgroupfs-mount/master/cgroupfs-mount). Cela permet AWS IoT Greengrass de définir la limite de mémoire pour les fonctions Lambda. Les groupes C doivent également s'exécuter AWS IoT Greengrass dans le mode de [conteneurisation](lambda-group-config.md#lambda-containerization-considerations) par défaut.
Si aucune erreur n'apparaît dans la sortie, elle AWS IoT Greengrass devrait pouvoir fonctionner correctement sur votre appareil.
**Important**
Ce didacticiel nécessite le runtime Python 3.7 pour exécuter les fonctions Lambda locales. Lorsque le gestionnaire de flux est activé, il a également besoin de l'environnement d'exécution Java 8. Si le script `check_ggc_dependencies` génère des avertissements concernant des environnements d'exécution prérequis manquants, veillez à installer ces environnements d'exécution avant de continuer. Vous pouvez ignorer les avertissements concernant d'autres environnements d'exécution facultatifs manquants.
Pour la liste des AWS IoT Greengrass exigences et des dépendances, voir[Exigences et plateformes prises en charge](what-is-gg.md#gg-platforms).