

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.

# Étape 5 : Créez votre composant dans le AWS IoT Greengrass service
<a name="upload-first-component"></a>

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)
<a name="upload-first-component-console"></a>

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. <a name="core-device-allow-s3-bucket-access-console"></a><a name="core-device-allow-s3-bucket-access-console-intro-1"></a>Autorisez le périphérique principal à accéder aux artefacts des composants dans le compartiment S3.

   <a name="core-device-allow-s3-bucket-access-console-intro-2"></a>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.

   <a name="core-device-allow-s3-bucket-access-console-intro-3"></a>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. <a name="core-device-allow-s3-bucket-access-console-step-1"></a>Dans le menu de navigation de [la console IAM](https://console.aws.amazon.com/iam), choisissez **Policies**, puis **Create policy**.

   1. <a name="core-device-allow-s3-bucket-access-console-step-2"></a>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. <a name="core-device-allow-s3-bucket-access-console-step-3"></a>Choisissez **Suivant**.

   1. <a name="core-device-allow-s3-bucket-access-console-step-4"></a>Dans la **section Détails de la politique**, pour **Nom**, entrez**MyGreengrassV2ComponentArtifactPolicy**.

   1. <a name="core-device-allow-s3-bucket-access-console-step-5"></a>Choisissez **Create Policy** (Créer une politique).

   1. <a name="core-device-allow-s3-bucket-access-console-step-6"></a>**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. <a name="core-device-allow-s3-bucket-access-console-step-7"></a>Sous **Autorisations**, choisissez **Ajouter des autorisations**, puis choisissez **Joindre des politiques**.

   1. <a name="core-device-allow-s3-bucket-access-console-step-8"></a>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)
<a name="upload-first-component-cli"></a>

**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. <a name="core-device-allow-s3-bucket-access-cli"></a>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.

   <a name="nano-command-intro"></a>Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.

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

   <a name="nano-command-intro"></a>Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.

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