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

Vous pouvez définir des recettes au format JSON ou 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, consultezDévelopper des AWS IoT Greengrass composants.

Dans cette section, vous allez apprendre à 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

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 ~/greengrassv2 ou %USERPROFILE% \ greengrassv2 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
```
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.

Collez la recette suivante dans le fichier.

La ComponentConfiguration section de cette recette définit un paramètreMessage, 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.

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/
```
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)
```
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 C:\greengrass\v2 par votre dossier AWS IoT Greengrass V2 racine, et remplacez ~/greengrassv2 ou %USERPROFILE% \ greengrassv2 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 dansartifacts. L'--mergeoption ajoute ou met à jour le composant et la version que vous spécifiez.
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.
Linux or Unix

sudo tail -f /greengrass/v2/logs/greengrass.log

Windows Command Prompt (CMD)

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.

PowerShell

gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
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)
```

Exécutez la commande suivante pour mettre à jour le composant avec vos modifications.

Cette commande met à jour le com.example.HelloWorld composant avec le dernier artefact Hello World.

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.

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

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
```
2. 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"
    }
  }
}
```
3. 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
4. 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.
```
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.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Vérifiez l'installation de Greengrass CLI sur l'appareil

Étape 5 : Créez votre composant dans le AWS IoT Greengrass service

Étape 4 : développer et tester un composant sur votre appareil

Pour développer un composant Hello World sur votre appareil

Note

Important

Note

Important