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.

# Utilisez le Kit SDK des appareils AWS IoT pour communiquer avec le noyau de Greengrass, les autres composants et AWS IoT Core
<a name="interprocess-communication"></a>

Les composants exécutés sur votre appareil principal peuvent utiliser la bibliothèque de communication interprocessus (IPC) du AWS IoT Greengrass Core Kit SDK des appareils AWS IoT pour communiquer avec le AWS IoT Greengrass noyau et les autres composants de Greengrass. Pour développer et exécuter des composants personnalisés utilisant IPC, vous devez utiliser le Kit SDK des appareils AWS IoT pour vous connecter au service IPC AWS IoT Greengrass principal et effectuer des opérations IPC.

L'interface IPC prend en charge deux types d'opérations :
+ **Demande/réponse**

  Les composants envoient une demande au service IPC et reçoivent une réponse contenant le résultat de la demande.
+ **Abonnement**

  Les composants envoient une demande d'abonnement au service IPC et attendent un flux de messages d'événements en réponse. Les composants fournissent un gestionnaire d'abonnement qui gère les messages d'événements, les erreurs et les fermetures de flux. Kit SDK des appareils AWS IoT Il inclut une interface de gestion avec les types de réponse et d'événement appropriés pour chaque opération IPC. Pour de plus amples informations, veuillez consulter [Abonnez-vous aux diffusions d'événements IPC](#ipc-subscribe-operations).

**Topics**
+ [Versions du client IPC](#ipc-client-versions)
+ [Pris en charge SDKs pour la communication interprocessus](#ipc-requirements)
+ [Connectez-vous au service AWS IoT Greengrass Core IPC](#ipc-service-connect)
+ [Autoriser les composants à effectuer des opérations IPC](#ipc-authorization-policies)
+ [Abonnez-vous aux diffusions d'événements IPC](#ipc-subscribe-operations)
+ [Bonnes pratiques en matière d'IPC](#ipc-best-practices)
+ [Publier/souscrire des messages locaux](ipc-publish-subscribe.md)
+ [Publier/souscrire AWS IoT Core des messages MQTT](ipc-iot-core-mqtt.md)
+ [Interagir avec le cycle de vie des composants](ipc-component-lifecycle.md)
+ [Interagir avec la configuration des composants](ipc-component-configuration.md)
+ [Récupérez les valeurs secrètes](ipc-secret-manager.md)
+ [Interagissez avec les ombres locales](ipc-local-shadows.md)
+ [Gérez les déploiements et les composants locaux](ipc-local-deployments-components.md)
+ [Authentifier et autoriser les appareils clients](ipc-client-device-auth.md)

## Versions du client IPC
<a name="ipc-client-versions"></a>

Dans les versions ultérieures de Java et Python SDKs, AWS IoT Greengrass fournit une version améliorée du client IPC, appelée client IPC V2. Client IPC V2 :
+ Réduit la quantité de code que vous devez écrire pour utiliser les opérations IPC et permet d'éviter les erreurs courantes susceptibles de se produire avec le client IPC V1.
+ Appelle les rappels du gestionnaire d'abonnement dans un thread séparé. Vous pouvez donc désormais exécuter du code de blocage, y compris des appels de fonction IPC supplémentaires, dans les rappels du gestionnaire d'abonnement. Le client IPC V1 utilise le même thread pour communiquer avec le serveur IPC et appeler les rappels du gestionnaire d'abonnement.
+ Permet d'appeler des opérations d'abonnement à l'aide d'expressions Lambda (Java) ou de fonctions (Python). Le client IPC V1 vous oblige à définir des classes de gestionnaires d'abonnement.
+ Fournit des versions synchrones et asynchrones de chaque opération IPC. Le client IPC V1 fournit uniquement des versions asynchrones de chaque opération.

Nous vous recommandons d'utiliser le client IPC V2 pour tirer parti de ces améliorations. Cependant, de nombreux exemples présentés dans cette documentation et dans certains contenus en ligne montrent uniquement comment utiliser le client IPC V1. Vous pouvez utiliser les exemples et didacticiels suivants pour découvrir des exemples de composants utilisant le client IPC V2 :
+ [PublishToTopicexemples](ipc-publish-subscribe.md#ipc-operation-publishtotopic-examples)
+ [SubscribeToTopicexemples](ipc-publish-subscribe.md#ipc-operation-subscribetotopic-examples)
+ [Tutoriel : Développement d'un composant Greengrass qui reporte les mises à jour des composants](defer-component-updates-tutorial.md)
+ [Tutoriel : Interagissez avec des appareils IoT locaux via MQTT](client-devices-tutorial.md)

Actuellement, le Kit SDK des appareils AWS IoT for C\$1\$1 v2 ne prend en charge que le client IPC V1.

## Pris en charge SDKs pour la communication interprocessus
<a name="ipc-requirements"></a>

Les bibliothèques AWS IoT Greengrass Core IPC sont incluses dans les Kit SDK des appareils AWS IoT versions suivantes.


| Kit SDK | Version minimale | Usage | 
| --- | --- | --- | 
|  [Kit SDK des appareils AWS IoT pour Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.6.0  |  Consultez [Utilisation Kit SDK des appareils AWS IoT pour Java v2 (client IPC V2)](#ipc-java-v2)  | 
|  [Kit SDK des appareils AWS IoT pour Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.9.0  |  Consultez [Utilisation Kit SDK des appareils AWS IoT pour Python v2 (client IPC V2)](#ipc-python-v2)  | 
|  [Kit SDK des appareils AWS IoT pour C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  |  Consultez [Utilisation Kit SDK des appareils AWS IoT pour C\$1\$1 v2](#ipc-cpp)  | 
|  [Kit SDK des appareils AWS IoT pour JavaScript v2](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  |  Consultez [Utilisation Kit SDK des appareils AWS IoT pour la JavaScript version 2 (client IPC V1)](#ipc-nodejs)  | 

## Connectez-vous au service AWS IoT Greengrass Core IPC
<a name="ipc-service-connect"></a>

Pour utiliser la communication interprocessus dans votre composant personnalisé, vous devez créer une connexion à un socket de serveur IPC exécuté par le logiciel AWS IoT Greengrass Core. Effectuez les tâches suivantes pour télécharger et utiliser le Kit SDK des appareils AWS IoT dans la langue de votre choix. 

### Utilisation Kit SDK des appareils AWS IoT pour Java v2 (client IPC V2)
<a name="ipc-java-v2"></a>

**Pour utiliser le Kit SDK des appareils AWS IoT pour Java v2 (client IPC V2)**

1. Téléchargez le [Kit SDK des appareils AWS IoT pour Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2) (v1.6.0 ou version ultérieure).

1. <a name="use-ipc-java-component-install-step"></a>Procédez de l'une des manières suivantes pour exécuter votre code personnalisé dans votre composant :
   + Créez votre composant sous la forme d'un fichier JAR qui inclut le Kit SDK des appareils AWS IoT, et exécutez ce fichier JAR dans votre recette de composant.
   + Définissez le Kit SDK des appareils AWS IoT JAR en tant qu'artefact de composant et ajoutez cet artefact au chemin de classe lorsque vous exécutez votre application dans votre recette de composant.

1. Utilisez le code suivant pour créer le client IPC.

   ```
   try (GreengrassCoreIPCClientV2 ipcClient = GreengrassCoreIPCClientV2.builder().build()) {
       // Use client.
   } catch (Exception e) {
       LOGGER.log(Level.SEVERE, "Exception occurred when using IPC.", e);
       System.exit(1);
   }
   ```

### Utilisation Kit SDK des appareils AWS IoT pour Python v2 (client IPC V2)
<a name="ipc-python-v2"></a>

**Pour utiliser le Kit SDK des appareils AWS IoT for Python v2 (client IPC V2)**

1. Téléchargez le [Kit SDK des appareils AWS IoT pour Python](https://github.com/aws/aws-iot-device-sdk-python-v2) (v1.9.0 ou version ultérieure).

1. <a name="use-ipc-python-component-install-step"></a>Ajoutez les [étapes d'installation](https://github.com/aws/aws-iot-device-sdk-python-v2#installation) du SDK au cycle de vie d'installation dans la recette de votre composant.

1. Créez une connexion au service AWS IoT Greengrass Core IPC. Utilisez le code suivant pour créer le client IPC.

   ```
   from awsiot.greengrasscoreipc.clientv2 import GreengrassCoreIPCClientV2
   
   try:
       ipc_client = GreengrassCoreIPCClientV2()
       # Use IPC client.
   except Exception:
       print('Exception occurred when using IPC.', file=sys.stderr)
       traceback.print_exc()
       exit(1)
   ```

### Utilisation Kit SDK des appareils AWS IoT pour C\$1\$1 v2
<a name="ipc-cpp"></a>

<a name="iot-device-sdk-cpp-v2-build-requirements-intro"></a>Pour créer la Kit SDK des appareils AWS IoT version 2 pour C\$1\$1, un périphérique doit disposer des outils suivants :<a name="iot-device-sdk-cpp-v2-build-requirements"></a>
+ C\$1\$1 11 ou version ultérieure
+ CMake 3.1 ou version ultérieure
+ L'un des compilateurs suivants :
  + GCC 4.8 ou version ultérieure
  + Clang 3.9 ou version ultérieure
  + MSVC 2015 ou version ultérieure

**Pour utiliser le Kit SDK des appareils AWS IoT pour C\$1\$1 v2**

1. Téléchargez le [Kit SDK des appareils AWS IoT pour C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2) (v1.17.0 ou version ultérieure).

1. Suivez les [instructions d'installation du fichier README](https://github.com/aws/aws-iot-device-sdk-cpp-v2#Installation) pour créer le Kit SDK des appareils AWS IoT pour C\$1\$1 v2 à partir des sources.

1. Dans votre outil de génération C\$1\$1, liez la bibliothèque IPC Greengrass que vous avez créée à l'étape précédente. `AWS::GreengrassIpc-cpp` L'`CMakeLists.txt`exemple suivant lie la bibliothèque IPC Greengrass à un projet avec lequel vous créez. CMake

   ```
   cmake_minimum_required(VERSION 3.1)
   project (greengrassv2_pubsub_subscriber)
   
   file(GLOB MAIN_SRC
           "*.h"
           "*.cpp"
           )
   add_executable(${PROJECT_NAME} ${MAIN_SRC})
   
   set_target_properties(${PROJECT_NAME} PROPERTIES
           LINKER_LANGUAGE CXX
           CXX_STANDARD 11)
   find_package(aws-crt-cpp PATHS ~/sdk-cpp-workspace/build)
   find_package(EventstreamRpc-cpp PATHS ~/sdk-cpp-workspace/build)
   find_package(GreengrassIpc-cpp PATHS ~/sdk-cpp-workspace/build)
   target_link_libraries(${PROJECT_NAME} AWS::GreengrassIpc-cpp)
   ```

1. Dans le code de votre composant, créez une connexion au service AWS IoT Greengrass Core IPC pour créer un client IPC ()`Aws::Greengrass::GreengrassCoreIpcClient`. Vous devez définir un gestionnaire du cycle de vie des connexions IPC qui gère les événements de connexion, de déconnexion et d'erreur IPC. L'exemple suivant crée un client IPC et un gestionnaire de cycle de vie des connexions IPC qui imprime lorsque le client IPC se connecte, se déconnecte et rencontre des erreurs.

   ```
   #include <iostream>
   
   #include <aws/crt/Api.h>
   #include <aws/greengrass/GreengrassCoreIpcClient.h>
   
   using namespace Aws::Crt;
   using namespace Aws::Greengrass;
   
   class IpcClientLifecycleHandler : public ConnectionLifecycleHandler {
       void OnConnectCallback() override {
           std::cout << "OnConnectCallback" << std::endl;
       }
   
       void OnDisconnectCallback(RpcError error) override {
           std::cout << "OnDisconnectCallback: " << error.StatusToString() << std::endl;
           exit(-1);
       }
   
       bool OnErrorCallback(RpcError error) override {
           std::cout << "OnErrorCallback: " << error.StatusToString() << std::endl;
           return true;
       }
   };
   
   int main() {
       // Create the IPC client.
       ApiHandle apiHandle(g_allocator);
       Io::EventLoopGroup eventLoopGroup(1);
       Io::DefaultHostResolver socketResolver(eventLoopGroup, 64, 30);
       Io::ClientBootstrap bootstrap(eventLoopGroup, socketResolver);
       IpcClientLifecycleHandler ipcLifecycleHandler;
       GreengrassCoreIpcClient ipcClient(bootstrap);
       auto connectionStatus = ipcClient.Connect(ipcLifecycleHandler).get();
       if (!connectionStatus) {
           std::cerr << "Failed to establish IPC connection: " << connectionStatus.StatusToString() << std::endl;
           exit(-1);
       }
       
       // Use the IPC client to create an operation request.
       
       // Activate the operation request.
       auto activate = operation.Activate(request, nullptr);
       activate.wait();
   
       // Wait for Greengrass Core to respond to the request.
       auto responseFuture = operation.GetResult();
       if (responseFuture.wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout) {
           std::cerr << "Operation timed out while waiting for response from Greengrass Core." << std::endl;
           exit(-1);
       }
   
       // Check the result of the request.
       auto response = responseFuture.get();
       if (response) {
           std::cout << "Successfully published to topic: " << topic << std::endl;
       } else {
           // An error occurred.
           std::cout << "Failed to publish to topic: " << topic << std::endl;
           auto errorType = response.GetResultType();
           if (errorType == OPERATION_ERROR) {
               auto *error = response.GetOperationError();
               std::cout << "Operation error: " << error->GetMessage().value() << std::endl;
           } else {
               std::cout << "RPC error: " << response.GetRpcError() << std::endl;
           }
           exit(-1);
       }
       
       return 0;
   }
   ```

1. Pour exécuter votre code personnalisé dans votre composant, créez votre code sous forme d'artefact binaire et exécutez l'artefact binaire dans la recette de votre composant. Définissez l'`Execute`autorisation de l'artefact pour `OWNER` permettre au logiciel AWS IoT Greengrass Core d'exécuter l'artefact binaire.

   La `Manifests` section de la recette de votre composant peut ressembler à l'exemple suivant.

------
#### [ JSON ]

   ```
   {
     ...
     "Manifests": [
       {
         "Lifecycle": {
           "Run": "{artifacts:path}/greengrassv2_pubsub_subscriber"
         },
         "Artifacts": [
           {
             "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.PubSubSubscriberCpp/1.0.0/greengrassv2_pubsub_subscriber",
             "Permission": {
               "Execute": "OWNER"
             }
           }
         ]
       }
     ]
   }
   ```

------
#### [ YAML ]

   ```
   ...
   Manifests:
     - Lifecycle:
         Run: {artifacts:path}/greengrassv2_pubsub_subscriber
       Artifacts:
         - URI: s3://amzn-s3-demo-bucket/artifacts/com.example.PubSubSubscriberCpp/1.0.0/greengrassv2_pubsub_subscriber
           Permission:
             Execute: OWNER
   ```

------

### Utilisation Kit SDK des appareils AWS IoT pour la JavaScript version 2 (client IPC V1)
<a name="ipc-nodejs"></a>

<a name="iot-device-sdk-nodejs-build-requirements-intro"></a>Pour créer le Kit SDK des appareils AWS IoT for JavaScript v2 à utiliser avec NodeJS, un appareil doit disposer des outils suivants :<a name="iot-device-sdk-nodejs-build-requirements"></a>
+ NodeJS 10.0 ou version ultérieure
  + Exécutez `node -v` pour vérifier la version du nœud.
+ CMake 3.1 ou version ultérieure

**Pour utiliser le Kit SDK des appareils AWS IoT for JavaScript v2 (client IPC V1)**

1. Téléchargez le [Kit SDK des appareils AWS IoT pour la version JavaScript 2](https://github.com/aws/aws-iot-device-sdk-js-v2) (v1.12.10 ou version ultérieure).

1. Suivez les [instructions d'installation du fichier README](https://github.com/aws/aws-iot-device-sdk-js-v2/tree/v1.12.1#installation) pour créer le Kit SDK des appareils AWS IoT for JavaScript v2 à partir des sources.

1. Créez une connexion au service AWS IoT Greengrass Core IPC. Procédez comme suit pour créer le client IPC et établir une connexion.

1. Utilisez le code suivant pour créer le client IPC.

   ```
   import * as greengrascoreipc from 'aws-iot-device-sdk-v2';
   
   let client = greengrascoreipc.createClient();
   ```

1. Utilisez le code suivant pour établir une connexion entre votre composant et le noyau de Greengrass.

   ```
   await client.connect();
   ```

## Autoriser les composants à effectuer des opérations IPC
<a name="ipc-authorization-policies"></a>

Pour permettre à vos composants personnalisés d'utiliser certaines opérations IPC, vous devez définir des *politiques d'autorisation* qui permettent au composant d'effectuer l'opération sur certaines ressources. Chaque politique d'autorisation définit une liste d'opérations et une liste de ressources autorisées par la politique. Par exemple, le service de publish/subscribe messagerie IPC définit les opérations de publication et d'abonnement pour les ressources thématiques. Vous pouvez utiliser le `*` caractère générique pour autoriser l'accès à toutes les opérations ou à toutes les ressources.

Vous définissez les politiques d'autorisation à l'aide du paramètre de `accessControl` configuration, que vous pouvez définir dans la recette du composant ou lorsque vous déployez le composant. L'`accessControl`objet associe les identifiants de service IPC à des listes de politiques d'autorisation. Vous pouvez définir plusieurs politiques d'autorisation pour chaque service IPC afin de contrôler l'accès. Chaque politique d'autorisation possède un identifiant de politique, qui doit être unique parmi tous les composants.

**Astuce**  
Pour créer une politique unique IDs, vous pouvez combiner le nom du composant, le nom du service IPC et un compteur. Par exemple, un composant nommé `com.example.HelloWorld` peut définir deux politiques publish/subscribe d'autorisation avec les éléments suivants IDs :  
`com.example.HelloWorld:pubsub:1`
`com.example.HelloWorld:pubsub:2`

Les politiques d'autorisation utilisent le format suivant. Cet objet est le paramètre `accessControl` de configuration.

------
#### [ JSON ]

```
{
  "IPC service identifier": {
    "policyId": {
      "policyDescription": "description",
      "operations": [
        "operation1",
        "operation2"
      ],
      "resources": [
        "resource1",
        "resource2"
      ]
    }
  }
}
```

------
#### [ YAML ]

```
IPC service identifier:
  policyId:
    policyDescription: description
    operations:
      - operation1
      - operation2
    resources:
      - resource1
      - resource2
```

------

### Des caractères génériques dans les politiques d'autorisation
<a name="ipc-authorization-policy-wildcards"></a>

Vous pouvez utiliser le `*` caractère générique dans l'`resources`élément des politiques d'autorisation IPC pour autoriser l'accès à plusieurs ressources dans le cadre d'une seule politique d'autorisation.
+ Dans toutes les versions du [noyau Greengrass](greengrass-nucleus-component.md), vous pouvez spécifier un seul `*` personnage comme ressource pour autoriser l'accès à toutes les ressources.
+ Dans [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 et versions ultérieures, vous pouvez spécifier le `*` personnage d'une ressource pour qu'il corresponde à n'importe quelle combinaison de caractères. Par exemple, vous pouvez spécifier `factory/1/devices/Thermostat*/status` d'autoriser l'accès à une rubrique d'état pour tous les thermostats d'une usine, où le nom de chaque appareil commence par`Thermostat`.

Lorsque vous définissez des politiques d'autorisation pour le service AWS IoT Core MQTT IPC, vous pouvez également utiliser des caractères génériques MQTT (`+`et`#`) pour associer plusieurs ressources. Pour plus d'informations, voir les [caractères génériques MQTT dans les politiques d'autorisation AWS IoT Core MQTT IPC](ipc-iot-core-mqtt.md#ipc-iot-core-mqtt-authorization-mqtt-wildcards).

### Variables de recette dans les politiques d'autorisation
<a name="ipc-authorization-policy-recipe-variables"></a>

[Si vous utilisez [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 ou version ultérieure et que vous définissez l'option de [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)configuration du noyau Greengrass sur, vous pouvez utiliser la variable de recette dans les `true` politiques d'autorisation. `{iot:thingName}`](component-recipe-reference.md#recipe-variables) Lorsque vous avez besoin d'une politique d'autorisation incluant le nom du périphérique principal, par exemple pour les sujets MQTT ou les ombres d'appareils, vous pouvez utiliser cette variable de recette pour configurer une politique d'autorisation unique pour un groupe de périphériques principaux. Par exemple, vous pouvez autoriser un composant à accéder à la ressource suivante pour les opérations IPC parallèles.

```
$aws/things/{iot:thingName}/shadow/
```

### Caractères spéciaux dans les politiques d'autorisation
<a name="ipc-authorization-policy-special-characters"></a>

Pour spécifier un littéral `*` ou un `?` caractère dans une politique d'autorisation, vous devez utiliser une séquence d'échappement. Les séquences d'échappement suivantes indiquent au logiciel AWS IoT Greengrass Core d'utiliser la valeur littérale au lieu de la signification particulière du caractère. Par exemple, le `*` caractère est un [joker](#ipc-authorization-policy-wildcards) qui correspond à n'importe quelle combinaison de caractères.


| Caractère littéral | Séquence d'échappement | Remarques | 
| --- | --- | --- | 
|  `*`  |  `${*}`  |  | 
|  `?`  |  `${?}`  |  AWS IoT Greengrass ne prend actuellement pas en charge le `?` joker, qui correspond à n'importe quel caractère.  | 
|  `$`  |  `${$}`  |  Utilisez cette séquence d'échappement pour faire correspondre une ressource contenant`${`. Par exemple, pour faire correspondre une ressource nommée`${resourceName}`, vous devez spécifier`${$}{resourceName}`. Sinon, pour faire correspondre une ressource contenant`$`, vous pouvez utiliser un littéral`$`, par exemple pour autoriser l'accès à une rubrique commençant `$aws` par.  | 

### Exemples de politiques d'autorisation
<a name="ipc-authorization-policy-examples"></a>

Vous pouvez consulter les exemples de politiques d'autorisation suivants pour vous aider à configurer les politiques d'autorisation pour vos composants.

**Example Exemple de recette de composant avec une politique d'autorisation**  
L'exemple de recette de composant suivant inclut un `accessControl` objet qui définit une politique d'autorisation. Cette politique autorise le `com.example.HelloWorld` composant à publier dans le `test/topic` sujet.  

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.HelloWorld",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that publishes messages.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.HelloWorld:pubsub:1": {
            "policyDescription": "Allows access to publish to test/topic.",
            "operations": [
              "aws.greengrass#PublishToTopic"
            ],
            "resources": [
              "test/topic"
            ]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Lifecycle": {
        "Run": "java -jar {artifacts:path}/HelloWorld.jar"
      }
    }
  ]
}
```

```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: A component that publishes messages.
ComponentPublisher: Amazon
ComponentConfiguration:
  DefaultConfiguration:
    accessControl:
      aws.greengrass.ipc.pubsub:
        "com.example.HelloWorld:pubsub:1":
          policyDescription: Allows access to publish to test/topic.
          operations:
            - "aws.greengrass#PublishToTopic"
          resources:
            - "test/topic"
Manifests:
  - Lifecycle:
      Run: |-
        java -jar {artifacts:path}/HelloWorld.jar
```

**Example Exemple de mise à jour de configuration de composant avec une politique d'autorisation**  
L'exemple de mise à jour de configuration suivant dans un déploiement indique de configurer un composant avec un `accessControl` objet qui définit une politique d'autorisation. Cette politique autorise le `com.example.HelloWorld` composant à publier dans le `test/topic` sujet.    
**Configuration à fusionner**  

```
{
  "accessControl": {
    "aws.greengrass.ipc.pubsub": {
      "com.example.HelloWorld:pubsub:1": {
        "policyDescription": "Allows access to publish to test/topic.",
        "operations": [
          "aws.greengrass#PublishToTopic"
        ],
        "resources": [
          "test/topic"
        ]
      }
    }
  }
}
```
La commande suivante crée un déploiement sur un périphérique principal.  

```
aws greengrassv2 create-deployment --cli-input-json file://hello-world-deployment.json
```
Le `hello-world-deployment.json` fichier contient le document JSON suivant.  

```
{
  "targetArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
  "deploymentName": "Deployment for MyGreengrassCore",
  "components": {
    "com.example.HelloWorld": {
      "componentVersion": "1.0.0",
      "configurationUpdate": {
        "merge": "{\"accessControl\":{\"aws.greengrass.ipc.pubsub\":{\"com.example.HelloWorld:pubsub:1\":{\"policyDescription\":\"Allows access to publish to test/topic.\",\"operations\":[\"aws.greengrass#PublishToTopic\"],\"resources\":[\"test/topic\"]}}}}"
      }
    }
  }
}
```
La commande [Greengrass CLI](greengrass-cli-component.md) suivante crée un déploiement local sur un périphérique principal.  

```
sudo greengrass-cli deployment create \
  --recipeDir recipes \
  --artifactDir artifacts \
  --merge "com.example.HelloWorld=1.0.0" \
  --update-config hello-world-configuration.json
```
Le `hello-world-configuration.json` fichier contient le document JSON suivant.  

```
{
  "com.example.HelloWorld": {
    "MERGE": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.HelloWorld:pubsub:1": {
            "policyDescription": "Allows access to publish to test/topic.",
            "operations": [
              "aws.greengrass#PublishToTopic"
            ],
            "resources": [
              "test/topic"
            ]
          }
        }
      }
    }
  }
}
```

## Abonnez-vous aux diffusions d'événements IPC
<a name="ipc-subscribe-operations"></a>

Vous pouvez utiliser les opérations IPC pour vous abonner à des flux d'événements sur un appareil principal de Greengrass. Pour utiliser une opération d'abonnement, définissez un *gestionnaire d'abonnement* et créez une demande auprès du service IPC. Ensuite, le client IPC exécute les fonctions du gestionnaire d'abonnement chaque fois que le périphérique principal transmet un message d'événement à votre composant.

Vous pouvez fermer un abonnement pour arrêter le traitement des messages relatifs aux événements. Pour ce faire, appelez `closeStream()` (Java), `close()` (Python) ou `Close()` (C\$1\$1) sur l'objet d'opération d'abonnement que vous avez utilisé pour ouvrir l'abonnement.

Le service AWS IoT Greengrass Core IPC prend en charge les opérations d'abonnement suivantes :
+ [SubscribeToTopic](ipc-publish-subscribe.md#ipc-operation-subscribetotopic)
+ [SubscribeToIoTCore](ipc-iot-core-mqtt.md#ipc-operation-subscribetoiotcore)
+ [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)
+ [SubscribeToConfigurationUpdate](ipc-component-configuration.md#ipc-operation-subscribetoconfigurationupdate)
+ [SubscribeToValidateConfigurationUpdates](ipc-component-configuration.md#ipc-operation-subscribetovalidateconfigurationupdates)

**Topics**
+ [Définition des gestionnaires d'abonnements](#ipc-define-subscription-handlers)
+ [Exemples de gestionnaires d'abonnements](#ipc-subscription-handler-examples)

### Définition des gestionnaires d'abonnements
<a name="ipc-define-subscription-handlers"></a>

Pour définir un gestionnaire d'abonnement, définissez des fonctions de rappel qui gèrent les messages d'événements, les erreurs et les fermetures de flux. Si vous utilisez le client IPC V1, vous devez définir ces fonctions dans une classe. Si vous utilisez le client IPC V2, disponible dans les versions ultérieures de Java et Python SDKs, vous pouvez définir ces fonctions sans créer de classe de gestionnaire d'abonnement.

------
#### [ Java ]

Si vous utilisez le client IPC V1, vous devez implémenter l'`software.amazon.awssdk.eventstreamrpc.StreamResponseHandler<StreamEventType>`interface générique. *StreamEventType*est le type de message d'événement pour l'opération d'abonnement. Définissez les fonctions suivantes pour gérer les messages d'événements, les erreurs et les fermetures de flux.

Si vous utilisez le client IPC V2, vous pouvez définir ces fonctions en dehors d'une classe de gestionnaire d'abonnement ou utiliser des expressions [lambda](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html).

`void onStreamEvent(StreamEventType event)`  
Le rappel que le client IPC appelle lorsqu'il reçoit un message d'événement, tel qu'un message MQTT ou une notification de mise à jour de composant.

`boolean onStreamError(Throwable error)`  
Le rappel que le client IPC appelle lorsqu'une erreur de flux se produit.  
<a name="ipc-subscription-handler-on-stream-error-return-value"></a>Renvoie true pour fermer le stream d'abonnement suite à l'erreur, ou renvoie false pour garder le stream ouvert.

`void onStreamClosed()`  
Le rappel que le client IPC appelle lorsque le flux se ferme.

------
#### [ Python ]

Si vous utilisez le client IPC V1, vous devez étendre la classe du gestionnaire de réponse aux flux correspondant à l'opération d'abonnement. Kit SDK des appareils AWS IoT Il inclut une classe de gestionnaire d'abonnement pour chaque opération d'abonnement. *StreamEventType*est le type de message d'événement pour l'opération d'abonnement. Définissez les fonctions suivantes pour gérer les messages d'événements, les erreurs et les fermetures de flux.

Si vous utilisez le client IPC V2, vous pouvez définir ces fonctions en dehors d'une classe de gestionnaire d'abonnement ou utiliser des expressions [lambda](https://docs.python.org/3/tutorial/controlflow.html#lambda-expressions).

`def on_stream_event(self, event: StreamEventType) -> None`  
Le rappel que le client IPC appelle lorsqu'il reçoit un message d'événement, tel qu'un message MQTT ou une notification de mise à jour de composant.

`def on_stream_error(self, error: Exception) -> bool`  
Le rappel que le client IPC appelle lorsqu'une erreur de flux se produit.  
<a name="ipc-subscription-handler-on-stream-error-return-value"></a>Renvoie true pour fermer le stream d'abonnement suite à l'erreur, ou renvoie false pour garder le stream ouvert.

`def on_stream_closed(self) -> None`  
Le rappel que le client IPC appelle lorsque le flux se ferme.

------
#### [ C\$1\$1 (IPC client V1) ]

Implémentez une classe dérivée de la classe du gestionnaire de réponse au flux correspondant à l'opération d'abonnement. Kit SDK des appareils AWS IoT Il inclut une classe de base de gestionnaire d'abonnement pour chaque opération d'abonnement. *StreamEventType*est le type de message d'événement pour l'opération d'abonnement. Définissez les fonctions suivantes pour gérer les messages d'événements, les erreurs et les fermetures de flux.

`void OnStreamEvent(StreamEventType *event)`  
Le rappel que le client IPC appelle lorsqu'il reçoit un message d'événement, tel qu'un message MQTT ou une notification de mise à jour de composant.

`bool OnStreamError(OperationError *error)`  
Le rappel que le client IPC appelle lorsqu'une erreur de flux se produit.  
<a name="ipc-subscription-handler-on-stream-error-return-value"></a>Renvoie true pour fermer le stream d'abonnement suite à l'erreur, ou renvoie false pour garder le stream ouvert.

`void OnStreamClosed()`  
Le rappel que le client IPC appelle lorsque le flux se ferme.

------
#### [ JavaScript ]

Implémentez une classe dérivée de la classe du gestionnaire de réponse au flux correspondant à l'opération d'abonnement. Kit SDK des appareils AWS IoT Il inclut une classe de base de gestionnaire d'abonnement pour chaque opération d'abonnement. *StreamEventType*est le type de message d'événement pour l'opération d'abonnement. Définissez les fonctions suivantes pour gérer les messages d'événements, les erreurs et les fermetures de flux.

`on(event: 'ended', listener: StreamingOperationEndedListener)`  
Le rappel que le client IPC appelle lorsque le flux se ferme.

`on(event: 'streamError', listener: StreamingRpcErrorListener)`  
Le rappel que le client IPC appelle lorsqu'une erreur de flux se produit.  
<a name="ipc-subscription-handler-on-stream-error-return-value"></a>Renvoie true pour fermer le stream d'abonnement suite à l'erreur, ou renvoie false pour garder le stream ouvert.

`on(event: 'message', listener: (message: InboundMessageType) => void)`  
Le rappel que le client IPC appelle lorsqu'il reçoit un message d'événement, tel qu'un message MQTT ou une notification de mise à jour de composant.

------

### Exemples de gestionnaires d'abonnements
<a name="ipc-subscription-handler-examples"></a>

L'exemple suivant montre comment utiliser l'[SubscribeToTopic](ipc-publish-subscribe.md#ipc-operation-subscribetotopic)opération et un gestionnaire d'abonnement pour s'abonner à des messages de publication/d'abonnement locaux.

------
#### [ Java (IPC client V2) ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  <a name="ipc-operation-subscribetotopic-example-java-v2"></a>

```
package com.aws.greengrass.docs.samples.ipc;

import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClientV2;
import software.amazon.awssdk.aws.greengrass.SubscribeToTopicResponseHandler;
import software.amazon.awssdk.aws.greengrass.model.*;

import java.nio.charset.StandardCharsets;
import java.util.Optional;

public class SubscribeToTopicV2 {

    public static void main(String[] args) {
        String topic = args[0];
        try (GreengrassCoreIPCClientV2 ipcClient = GreengrassCoreIPCClientV2.builder().build()) {
            SubscribeToTopicRequest request = new SubscribeToTopicRequest().withTopic(topic);
            GreengrassCoreIPCClientV2.StreamingResponse<SubscribeToTopicResponse,
                    SubscribeToTopicResponseHandler> response =
                    ipcClient.subscribeToTopic(request, SubscribeToTopicV2::onStreamEvent,
                            Optional.of(SubscribeToTopicV2::onStreamError),
                            Optional.of(SubscribeToTopicV2::onStreamClosed));
            SubscribeToTopicResponseHandler responseHandler = response.getHandler();
            System.out.println("Successfully subscribed to topic: " + topic);

            // Keep the main thread alive, or the process will exit.
            try {
                while (true) {
                    Thread.sleep(10000);
                }
            } catch (InterruptedException e) {
                System.out.println("Subscribe interrupted.");
            }

            // To stop subscribing, close the stream.
            responseHandler.closeStream();
        } catch (Exception e) {
            if (e.getCause() instanceof UnauthorizedError) {
                System.err.println("Unauthorized error while publishing to topic: " + topic);
            } else {
                System.err.println("Exception occurred when using IPC.");
            }
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static void onStreamEvent(SubscriptionResponseMessage subscriptionResponseMessage) {
        try {
            BinaryMessage binaryMessage = subscriptionResponseMessage.getBinaryMessage();
            String message = new String(binaryMessage.getMessage(), StandardCharsets.UTF_8);
            String topic = binaryMessage.getContext().getTopic();
            System.out.printf("Received new message on topic %s: %s%n", topic, message);
        } catch (Exception e) {
            System.err.println("Exception occurred while processing subscription response " +
                    "message.");
            e.printStackTrace();
        }
    }

    public static boolean onStreamError(Throwable error) {
        System.err.println("Received a stream error.");
        error.printStackTrace();
        return false; // Return true to close stream, false to keep stream open.
    }

    public static void onStreamClosed() {
        System.out.println("Subscribe to topic stream closed.");
    }
}
```

------
#### [ Python (IPC client V2) ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  <a name="ipc-operation-subscribetotopic-example-python-v2"></a>

```
import sys
import time
import traceback

from awsiot.greengrasscoreipc.clientv2 import GreengrassCoreIPCClientV2
from awsiot.greengrasscoreipc.model import (
    SubscriptionResponseMessage,
    UnauthorizedError
)


def main():
    args = sys.argv[1:]
    topic = args[0]

    try:
        ipc_client = GreengrassCoreIPCClientV2()
        # Subscription operations return a tuple with the response and the operation.
        _, operation = ipc_client.subscribe_to_topic(topic=topic, on_stream_event=on_stream_event,
                                                     on_stream_error=on_stream_error, on_stream_closed=on_stream_closed)
        print('Successfully subscribed to topic: ' + topic)

        # Keep the main thread alive, or the process will exit.
        try:
            while True:
                time.sleep(10)
        except InterruptedError:
            print('Subscribe interrupted.')

        # To stop subscribing, close the stream.
        operation.close()
    except UnauthorizedError:
        print('Unauthorized error while subscribing to topic: ' +
              topic, file=sys.stderr)
        traceback.print_exc()
        exit(1)
    except Exception:
        print('Exception occurred', file=sys.stderr)
        traceback.print_exc()
        exit(1)


def on_stream_event(event: SubscriptionResponseMessage) -> None:
    try:
        message = str(event.binary_message.message, 'utf-8')
        topic = event.binary_message.context.topic
        print('Received new message on topic %s: %s' % (topic, message))
    except:
        traceback.print_exc()


def on_stream_error(error: Exception) -> bool:
    print('Received a stream error.', file=sys.stderr)
    traceback.print_exc()
    return False  # Return True to close stream, False to keep stream open.


def on_stream_closed() -> None:
    print('Subscribe to topic stream closed.')


if __name__ == '__main__':
    main()
```

------
#### [ C\$1\$1 (IPC client V1) ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  <a name="ipc-operation-subscribetotopic-example-cpp"></a>

```
#include <iostream>

#include </crt/Api.h>
#include <aws/greengrass/GreengrassCoreIpcClient.h>

using namespace Aws::Crt;
using namespace Aws::Greengrass;

class SubscribeResponseHandler : public SubscribeToTopicStreamHandler {
    public:
        virtual ~SubscribeResponseHandler() {}

    private:
        void OnStreamEvent(SubscriptionResponseMessage *response) override {
            auto jsonMessage = response->GetJsonMessage();
            if (jsonMessage.has_value() && jsonMessage.value().GetMessage().has_value()) {
                auto messageString = jsonMessage.value().GetMessage().value().View().WriteReadable();
                // Handle JSON message.
            } else {
                auto binaryMessage = response->GetBinaryMessage();
                if (binaryMessage.has_value() && binaryMessage.value().GetMessage().has_value()) {
                    auto messageBytes = binaryMessage.value().GetMessage().value();
                    std::string messageString(messageBytes.begin(), messageBytes.end());
                    // Handle binary message.
                }
            }
        }

        bool OnStreamError(OperationError *error) override {
            // Handle error.
            return false; // Return true to close stream, false to keep stream open.
        }

        void OnStreamClosed() override {
            // Handle close.
        }
};

class IpcClientLifecycleHandler : public ConnectionLifecycleHandler {
    void OnConnectCallback() override {
        // Handle connection to IPC service.
    }

    void OnDisconnectCallback(RpcError error) override {
        // Handle disconnection from IPC service.
    }

    bool OnErrorCallback(RpcError error) override {
        // Handle IPC service connection error.
        return true;
    }
};

int main() {
    ApiHandle apiHandle(g_allocator);
    Io::EventLoopGroup eventLoopGroup(1);
    Io::DefaultHostResolver socketResolver(eventLoopGroup, 64, 30);
    Io::ClientBootstrap bootstrap(eventLoopGroup, socketResolver);
    IpcClientLifecycleHandler ipcLifecycleHandler;
    GreengrassCoreIpcClient ipcClient(bootstrap);
    auto connectionStatus = ipcClient.Connect(ipcLifecycleHandler).get();
    if (!connectionStatus) {
        std::cerr << "Failed to establish IPC connection: " << connectionStatus.StatusToString() << std::endl;
        exit(-1);
    }

    String topic("my/topic");
    int timeout = 10;

    SubscribeToTopicRequest request;
    request.SetTopic(topic);

    //SubscribeResponseHandler streamHandler;
    auto streamHandler = MakeShared<SubscribeResponseHandler>(DefaultAllocator());
    auto operation = ipcClient.NewSubscribeToTopic(streamHandler);
    auto activate = operation->Activate(request, nullptr);
    activate.wait();

    auto responseFuture = operation->GetResult();
    if (responseFuture.wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout) {
        std::cerr << "Operation timed out while waiting for response from Greengrass Core." << std::endl;
        exit(-1);
    }

    auto response = responseFuture.get();
    if (!response) {
        // Handle error.
        auto errorType = response.GetResultType();
        if (errorType == OPERATION_ERROR) {
            auto *error = response.GetOperationError();
            (void)error;
            // Handle operation error.
        } else {
            // Handle RPC error.
        }
        exit(-1);
    }

    // Keep the main thread alive, or the process will exit.
    while (true) {
        std::this_thread::sleep_for(std::chrono::seconds(10));
    }

    operation->Close();
    return 0;
}
```

------
#### [ JavaScript ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  <a name="ipc-operation-subscribetotopic-example-nodejs"></a>

```
import * as greengrasscoreipc from "aws-iot-device-sdk-v2/dist/greengrasscoreipc";
import {SubscribeToTopicRequest, SubscriptionResponseMessage} from "aws-iot-device-sdk-v2/dist/greengrasscoreipc/model";
import {RpcError} from "aws-iot-device-sdk-v2/dist/eventstream_rpc";
 
class SubscribeToTopic {
    private ipcClient : greengrasscoreipc.Client
    private readonly topic : string;
 
    constructor() {
        // define your own constructor, e.g.
        this.topic = "<define_your_topic>";
        this.subscribeToTopic().then(r => console.log("Started workflow"));
    }
 
    private async subscribeToTopic() {
        try {
            this.ipcClient = await getIpcClient();
 
            const subscribeToTopicRequest : SubscribeToTopicRequest = {
                topic: this.topic,
            }
 
            const streamingOperation = this.ipcClient.subscribeToTopic(subscribeToTopicRequest, undefined); // conditionally apply options
 
            streamingOperation.on("message", (message: SubscriptionResponseMessage) => {
                // parse the message depending on your use cases, e.g.
                if(message.binaryMessage && message.binaryMessage.message) {
                    const receivedMessage = message.binaryMessage?.message.toString();
                }
            });
 
            streamingOperation.on("streamError", (error : RpcError) => {
                // define your own error handling logic
            })
 
            streamingOperation.on("ended", () => {
                // define your own logic
            })
 
            await streamingOperation.activate();
 
            // Keep the main thread alive, or the process will exit.
            await new Promise((resolve) => setTimeout(resolve, 10000))
        } catch (e) {
            // parse the error depending on your use cases
            throw e
        }
    }
}
 
export async function getIpcClient(){
    try {
        const ipcClient = greengrasscoreipc.createClient();
        await ipcClient.connect()
            .catch(error => {
                // parse the error depending on your use cases
                throw error;
            });
        return ipcClient
    } catch (err) {
        // parse the error depending on your use cases
        throw err
    }
}
 
// starting point
const subscribeToTopic = new SubscribeToTopic();
```

------
#### [ Rust ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  

```
use gg_sdk::{Sdk, SubscribeToTopicPayload};
use std::{thread, time::Duration};

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    let topic = "my/topic";

    let callback = |topic: &str, payload: SubscribeToTopicPayload| match payload
    {
        SubscribeToTopicPayload::Binary(message) => {
            let message = String::from_utf8_lossy(message);
            println!("Received new message on topic {topic}: {message}");
        }
        SubscribeToTopicPayload::Json(_) => {
            println!("Received new message on topic {topic}: (JSON message)");
        }
    };

    let _sub = sdk
        .subscribe_to_topic(topic, &callback)
        .expect("Failed to subscribe to topic");

    println!("Successfully subscribed to topic: {topic}");

    // Keep the main thread alive, or the process will exit.
    loop {
        thread::sleep(Duration::from_secs(10));
    }
}
```

------
#### [ C ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  

```
#include <assert.h>
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/object.h>
#include <gg/sdk.h>
#include <gg/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

static void on_subscription_response(
    void *ctx, GgBuffer topic, GgObject payload, GgIpcSubscriptionHandle handle
) {
    (void) ctx;
    (void) handle;

    if (gg_obj_type(payload) == GG_TYPE_BUF) {
        GgBuffer message = gg_obj_into_buf(payload);
        printf(
            "Received new message on topic %.*s: %.*s\n",
            (int) topic.len,
            topic.data,
            (int) message.len,
            message.data
        );
    } else {
        assert(gg_obj_type(payload) == GG_TYPE_MAP);
        printf(
            "Received new message on topic %.*s: (JSON message)\n",
            (int) topic.len,
            topic.data
        );
    }
}

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    GgBuffer topic = GG_STR("my/topic");

    GgIpcSubscriptionHandle handle;
    err = ggipc_subscribe_to_topic(
        topic, on_subscription_response, NULL, &handle
    );
    if (err != GG_ERR_OK) {
        fprintf(
            stderr,
            "Failed to subscribe to topic: %.*s\n",
            (int) topic.len,
            topic.data
        );
        exit(-1);
    }

    printf(
        "Successfully subscribed to topic: %.*s\n", (int) topic.len, topic.data
    );

    // Keep the main thread alive, or the process will exit.
    while (1) {
        sleep(10);
    }

    // To stop subscribing, close the stream.
    ggipc_close_subscription(handle);
}
```

------
#### [ C\$1\$1 (Component SDK) ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  

```
#include <gg/ipc/client.hpp>
#include <gg/object.hpp>
#include <unistd.h>
#include <cassert>
#include <iostream>

class ResponseHandler : public gg::ipc::LocalTopicCallback {
    void operator()(
        std::string_view topic,
        gg::Object payload,
        gg::ipc::Subscription &handle
    ) override {
        (void) handle;
        if (payload.index() == GG_TYPE_BUF) {
            std::cout << "Received new message on topic " << topic << ": "
                      << get<gg::Buffer>(payload) << "\n";
        } else {
            assert(payload.index() == GG_TYPE_MAP);
            std::cout << "Received new message on topic " << topic
                      << ": (JSON message)\n";
        }
    }
};

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    std::string_view topic = "my/topic";

    static ResponseHandler handler;
    error = client.subscribe_to_topic(topic, handler);
    if (error) {
        std::cerr << "Failed to subscribe to topic: " << topic << "\n";
        exit(-1);
    }

    std::cout << "Successfully subscribed to topic: " << topic << "\n";

    // Keep the main thread alive, or the process will exit.
    while (1) {
        sleep(10);
    }
}
```

------

## Bonnes pratiques en matière d'IPC
<a name="ipc-best-practices"></a>

Les meilleures pratiques d'utilisation d'IPC dans des composants personnalisés diffèrent entre le client IPC V1 et le client IPC V2. Suivez les meilleures pratiques pour la version du client IPC que vous utilisez.

------
#### [ IPC client V2 ]

Le client IPC V2 exécute les fonctions de rappel dans un thread séparé. Par conséquent, par rapport au client IPC V1, vous devez suivre moins de directives lorsque vous utilisez IPC et écrivez des fonctions de gestion d'abonnement.
+ <a name="ipc-best-practice-reuse-one-client"></a>**Réutiliser un client IPC**

  Après avoir créé un client IPC, gardez-le ouvert et réutilisez-le pour toutes les opérations IPC. La création de plusieurs clients utilise des ressources supplémentaires et peut entraîner des fuites de ressources.
+ **Gérer les exceptions**

  Le client IPC V2 enregistre les exceptions non détectées dans les fonctions du gestionnaire d'abonnement. Vous devez intercepter les exceptions dans les fonctions de votre gestionnaire pour gérer les erreurs qui se produisent dans votre code.

------
#### [ IPC client V1 ]

Le client IPC V1 utilise un seul thread qui communique avec le serveur IPC et appelle les gestionnaires d'abonnement. Vous devez tenir compte de ce comportement synchrone lorsque vous écrivez des fonctions de gestion d'abonnement.
+ <a name="ipc-best-practice-reuse-one-client"></a>**Réutiliser un client IPC**

  Après avoir créé un client IPC, gardez-le ouvert et réutilisez-le pour toutes les opérations IPC. La création de plusieurs clients utilise des ressources supplémentaires et peut entraîner des fuites de ressources.
+ **Exécuter le code de blocage de manière asynchrone**

  Le client IPC V1 ne peut pas envoyer de nouvelles demandes ou traiter de nouveaux messages d'événements lorsque le thread est bloqué. Vous devez exécuter le code de blocage dans un thread distinct que vous exécutez à partir de la fonction de gestion. Le code de blocage inclut `sleep` les appels, les boucles qui s'exécutent en continu et les I/O demandes synchrones dont le traitement prend du temps.
+ **Envoyer de nouvelles demandes IPC de manière asynchrone**

  Le client IPC V1 ne peut pas envoyer de nouvelle demande depuis les fonctions du gestionnaire d'abonnement, car la demande bloque la fonction du gestionnaire si vous attendez une réponse. Vous devez envoyer les requêtes IPC dans un thread distinct que vous exécutez à partir de la fonction de gestion.
+ **Gérer les exceptions**

  Le client IPC V1 ne gère pas les exceptions non détectées dans les fonctions du gestionnaire d'abonnement. Si votre fonction de gestion génère une exception, l'abonnement prend fin et l'exception n'apparaît pas dans les journaux de vos composants. Vous devez détecter les exceptions dans les fonctions de votre gestionnaire afin de maintenir l'abonnement ouvert et de consigner les erreurs qui se produisent dans votre code.

------

# Publier/souscrire des messages locaux
<a name="ipc-publish-subscribe"></a>

La messagerie Publish/subscribe (pubsub) vous permet d'envoyer et de recevoir des messages relatifs à des sujets. Les composants peuvent publier des messages dans des rubriques pour envoyer des messages à d'autres composants. Les composants abonnés à cette rubrique peuvent ensuite agir sur les messages qu'ils reçoivent.

**Note**  
Vous ne pouvez pas utiliser ce service publish/subscribe IPC pour publier ou vous abonner à AWS IoT Core MQTT. Pour plus d'informations sur l'échange de messages avec AWS IoT Core MQTT, consultez[Publier/souscrire AWS IoT Core des messages MQTT](ipc-iot-core-mqtt.md).

**Topics**
+ [Versions minimales du SDK](#ipc-publish-subscribe-sdk-versions)
+ [Autorisation](#ipc-publish-subscribe-authorization)
+ [PublishToTopic](#ipc-operation-publishtotopic)
+ [SubscribeToTopic](#ipc-operation-subscribetotopic)
+ [Exemples](#ipc-publish-subscribe-examples)

## Versions minimales du SDK
<a name="ipc-publish-subscribe-sdk-versions"></a>

Le tableau suivant répertorie les versions minimales Kit SDK des appareils AWS IoT que vous devez utiliser pour publier et vous abonner à des messages à destination et en provenance de sujets locaux.


| Kit SDK | Version minimale | 
| --- | --- | 
|  [Kit SDK des appareils AWS IoT pour Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.2.10  | 
|  [Kit SDK des appareils AWS IoT pour Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.5.3  | 
|  [Kit SDK des appareils AWS IoT pour C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [Kit SDK des appareils AWS IoT pour JavaScript  ](https://github.com/aws/aws-iot-device-sdk-js-v2) v2  |  v1.12.0  | 

## Autorisation
<a name="ipc-publish-subscribe-authorization"></a>

Pour utiliser la publish/subscribe messagerie locale dans un composant personnalisé, vous devez définir des politiques d'autorisation qui permettent à votre composant d'envoyer et de recevoir des messages aux rubriques. Pour plus d'informations sur la définition des politiques d'autorisation, consultez[Autoriser les composants à effectuer des opérations IPC](interprocess-communication.md#ipc-authorization-policies).

Les politiques d'autorisation pour la publish/subscribe messagerie présentent les propriétés suivantes.

**Identifiant du service IPC :** `aws.greengrass.ipc.pubsub`


| Opération | Description | Ressources | 
| --- | --- | --- | 
|  `aws.greengrass#PublishToTopic`  |  Permet à un composant de publier des messages dans les rubriques que vous spécifiez.  |  Une chaîne de rubrique, telle que`test/topic`. Utilisez an `*` pour correspondre à n'importe quelle combinaison de caractères dans une rubrique. Cette chaîne de rubrique ne prend pas en charge les caractères génériques de rubrique MQTT (`#`et`+`).  | 
|  `aws.greengrass#SubscribeToTopic`  |  Permet à un composant de s'abonner à des messages pour les sujets que vous spécifiez.  |  Une chaîne de rubrique, telle que`test/topic`. Utilisez an `*` pour correspondre à n'importe quelle combinaison de caractères dans une rubrique. <a name="ipc-local-publish-subscribe-authorization-mqtt-wildcards"></a>Dans [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 et versions ultérieures, vous pouvez vous abonner à des sujets contenant des caractères génériques MQTT (et). `#` `+` Cette chaîne de rubrique prend en charge les caractères génériques des rubriques MQTT sous forme de caractères littéraux. Par exemple, si la politique d'autorisation d'un composant accorde l'accès à `test/topic/#``test/topic/#`, le composant peut s'abonner, mais pas`test/topic/filter`.  | 
|  `*`  |  Permet à un composant de publier des messages et de s'y abonner pour les sujets que vous spécifiez.  |  Une chaîne de rubrique, telle que`test/topic`. Utilisez an `*` pour correspondre à n'importe quelle combinaison de caractères dans une rubrique. <a name="ipc-local-publish-subscribe-authorization-mqtt-wildcards"></a>Dans [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 et versions ultérieures, vous pouvez vous abonner à des sujets contenant des caractères génériques MQTT (et). `#` `+` Cette chaîne de rubrique prend en charge les caractères génériques des rubriques MQTT sous forme de caractères littéraux. Par exemple, si la politique d'autorisation d'un composant accorde l'accès à `test/topic/#``test/topic/#`, le composant peut s'abonner, mais pas`test/topic/filter`.  | 

### Exemples de politiques d'autorisation
<a name="ipc-publish-subscribe-authorization-policy-examples"></a>

Vous pouvez vous référer à l'exemple de politique d'autorisation suivant pour vous aider à configurer les politiques d'autorisation pour vos composants.

**Example Exemple de politique d'autorisation**  
L'exemple de politique d'autorisation suivant permet à un composant de publier et de s'abonner à toutes les rubriques.  

```
{
  "accessControl": {
    "aws.greengrass.ipc.pubsub": {
      "com.example.MyLocalPubSubComponent:pubsub:1": {
        "policyDescription": "Allows access to publish/subscribe to all topics.",
        "operations": [
          "aws.greengrass#PublishToTopic",
          "aws.greengrass#SubscribeToTopic"
        ],
        "resources": [
          "*"
        ]
      }
    }
  }
}
```

## PublishToTopic
<a name="ipc-operation-publishtotopic"></a>

Publier un message dans une rubrique

### Demande
<a name="ipc-operation-publishtotopic-request"></a>

La demande de cette opération comporte les paramètres suivants :

`topic`  
Sujet dans lequel le message doit être publié.

`publishMessage`(Python :`publish_message`)  
Le message à publier. Cet objet contient `PublishMessage` les informations suivantes. Vous devez spécifier l'une des options suivantes : `jsonMessage` et`binaryMessage`.  <a name="ipc-publish-subscribe-message-shape"></a>  
`jsonMessage`(Python :`json_message`)  
(Facultatif) Un message JSON. Cet objet contient `JsonMessage` les informations suivantes :    
`message`  
Le message JSON en tant qu'objet.  
`context`  <a name="ipc-publish-subscribe-message-context-variable"></a>
Le contexte du message, tel que le sujet dans lequel le message a été publié.  
Cette fonctionnalité est disponible pour les versions 2.6.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. Le tableau suivant répertorie les versions minimales du Kit SDK des appareils AWS IoT que vous devez utiliser pour accéder au contexte du message.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/ipc-publish-subscribe.html)
Le logiciel AWS IoT Greengrass Core utilise les mêmes objets de message dans les `SubscribeToTopic` opérations `PublishToTopic` et. Le logiciel AWS IoT Greengrass Core définit cet objet de contexte dans les messages lorsque vous vous abonnez et ignore cet objet de contexte dans les messages que vous publiez.
Cet objet contient `MessageContext` les informations suivantes :    
`topic`  
Sujet dans lequel le message a été publié.  
`binaryMessage`(Python :`binary_message`)  
(Facultatif) Un message binaire. Cet objet contient `BinaryMessage` les informations suivantes :    
`message`  
Le message binaire sous forme de blob.  
`context`  <a name="ipc-publish-subscribe-message-context-variable"></a>
Le contexte du message, tel que le sujet dans lequel le message a été publié.  
Cette fonctionnalité est disponible pour les versions 2.6.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. Le tableau suivant répertorie les versions minimales du Kit SDK des appareils AWS IoT que vous devez utiliser pour accéder au contexte du message.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/ipc-publish-subscribe.html)
Le logiciel AWS IoT Greengrass Core utilise les mêmes objets de message dans les `SubscribeToTopic` opérations `PublishToTopic` et. Le logiciel AWS IoT Greengrass Core définit cet objet de contexte dans les messages lorsque vous vous abonnez et ignore cet objet de contexte dans les messages que vous publiez.
Cet objet contient `MessageContext` les informations suivantes :    
`topic`  
Sujet dans lequel le message a été publié.

### Réponse
<a name="ipc-operation-publishtotopic-response"></a>

Cette opération ne fournit aucune information dans sa réponse.

### Exemples
<a name="ipc-operation-publishtotopic-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Java (IPC client V2) ]

**Example Exemple : publier un message binaire**  

```
package com.aws.greengrass.docs.samples.ipc;

import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClientV2;
import software.amazon.awssdk.aws.greengrass.model.BinaryMessage;
import software.amazon.awssdk.aws.greengrass.model.PublishMessage;
import software.amazon.awssdk.aws.greengrass.model.PublishToTopicRequest;
import software.amazon.awssdk.aws.greengrass.model.PublishToTopicResponse;
import software.amazon.awssdk.aws.greengrass.model.UnauthorizedError;

import java.nio.charset.StandardCharsets;

public class PublishToTopicV2 {

    public static void main(String[] args) {
        String topic = args[0];
        String message = args[1];
        try (GreengrassCoreIPCClientV2 ipcClient = GreengrassCoreIPCClientV2.builder().build()) {
            PublishToTopicV2.publishBinaryMessageToTopic(ipcClient, topic, message);
            System.out.println("Successfully published to topic: " + topic);
        } catch (Exception e) {
            if (e.getCause() instanceof UnauthorizedError) {
                System.err.println("Unauthorized error while publishing to topic: " + topic);
            } else {
                System.err.println("Exception occurred when using IPC.");
            }
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static PublishToTopicResponse publishBinaryMessageToTopic(
            GreengrassCoreIPCClientV2 ipcClient, String topic, String message) throws InterruptedException {
        BinaryMessage binaryMessage =
                new BinaryMessage().withMessage(message.getBytes(StandardCharsets.UTF_8));
        PublishMessage publishMessage = new PublishMessage().withBinaryMessage(binaryMessage);
        PublishToTopicRequest publishToTopicRequest =
                new PublishToTopicRequest().withTopic(topic).withPublishMessage(publishMessage);
        return ipcClient.publishToTopic(publishToTopicRequest);
    }
}
```

------
#### [ Python (IPC client V2) ]

**Example Exemple : publier un message binaire**  

```
import sys
import traceback

from awsiot.greengrasscoreipc.clientv2 import GreengrassCoreIPCClientV2
from awsiot.greengrasscoreipc.model import (
    PublishMessage,
    BinaryMessage
)


def main():
    args = sys.argv[1:]
    topic = args[0]
    message = args[1]

    try:
        ipc_client = GreengrassCoreIPCClientV2()
        publish_binary_message_to_topic(ipc_client, topic, message)
        print('Successfully published to topic: ' + topic)
    except Exception:
        print('Exception occurred', file=sys.stderr)
        traceback.print_exc()
        exit(1)


def publish_binary_message_to_topic(ipc_client, topic, message):
    binary_message = BinaryMessage(message=bytes(message, 'utf-8'))
    publish_message = PublishMessage(binary_message=binary_message)
    return ipc_client.publish_to_topic(topic=topic, publish_message=publish_message)


if __name__ == '__main__':
    main()
```

------
#### [ C\$1\$1 (IPC client V1) ]

**Example Exemple : publier un message binaire**  

```
#include <iostream>

#include <aws/crt/Api.h>
#include <aws/greengrass/GreengrassCoreIpcClient.h>

using namespace Aws::Crt;
using namespace Aws::Greengrass;

class IpcClientLifecycleHandler : public ConnectionLifecycleHandler {
    void OnConnectCallback() override {
        // Handle connection to IPC service.
    }

    void OnDisconnectCallback(RpcError error) override {
        // Handle disconnection from IPC service.
    }

    bool OnErrorCallback(RpcError error) override {
        // Handle IPC service connection error.
        return true;
    }
};

int main() {
    ApiHandle apiHandle(g_allocator);
    Io::EventLoopGroup eventLoopGroup(1);
    Io::DefaultHostResolver socketResolver(eventLoopGroup, 64, 30);
    Io::ClientBootstrap bootstrap(eventLoopGroup, socketResolver);
    IpcClientLifecycleHandler ipcLifecycleHandler;
    GreengrassCoreIpcClient ipcClient(bootstrap);
    auto connectionStatus = ipcClient.Connect(ipcLifecycleHandler).get();
    if (!connectionStatus) {
        std::cerr << "Failed to establish IPC connection: " << connectionStatus.StatusToString() << std::endl;
        exit(-1);
    }

    String topic("my/topic");
    String message("Hello, World!");
    int timeout = 10;

    PublishToTopicRequest request;
    Vector<uint8_t> messageData({message.begin(), message.end()});
    BinaryMessage binaryMessage;
    binaryMessage.SetMessage(messageData);
    PublishMessage publishMessage;
    publishMessage.SetBinaryMessage(binaryMessage);
    request.SetTopic(topic);
    request.SetPublishMessage(publishMessage);

    auto operation = ipcClient.NewPublishToTopic();
    auto activate = operation->Activate(request, nullptr);
    activate.wait();

    auto responseFuture = operation->GetResult();
    if (responseFuture.wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout) {
        std::cerr << "Operation timed out while waiting for response from Greengrass Core." << std::endl;
        exit(-1);
    }

    auto response = responseFuture.get();
    if (!response) {
        // Handle error.
        auto errorType = response.GetResultType();
        if (errorType == OPERATION_ERROR) {
            auto *error = response.GetOperationError();
            (void)error;
            // Handle operation error.
        } else {
            // Handle RPC error.
        }
    }
    return 0;
}
```

------
#### [ JavaScript ]

**Example Exemple : publier un message binaire**  

```
    
import * as greengrasscoreipc from "aws-iot-device-sdk-v2/dist/greengrasscoreipc";
import {BinaryMessage, PublishMessage, PublishToTopicRequest} from "aws-iot-device-sdk-v2/dist/greengrasscoreipc/model";
 
class PublishToTopic {
    private ipcClient : greengrasscoreipc.Client
    private readonly topic : string;
    private readonly messageString : string;
 
    constructor() {
        // define your own constructor, e.g.
        this.topic = "<define_your_topic>";
        this.messageString = "<define_your_message_string>";
        this.publishToTopic().then(r => console.log("Started workflow"));
    }
 
    private async publishToTopic() {
        try {
            this.ipcClient = await getIpcClient();
 
            const binaryMessage : BinaryMessage = {
                message: this.messageString
            }
 
            const publishMessage : PublishMessage = {
                binaryMessage: binaryMessage
            }
 
            const request : PublishToTopicRequest = {
                topic: this.topic,
                publishMessage: publishMessage
            }
 
            this.ipcClient.publishToTopic(request).finally(() => console.log(`Published message ${publishMessage.binaryMessage?.message} to topic`))
 
        } catch (e) {
            // parse the error depending on your use cases
            throw e
        }
    }
}
 
 
export async function getIpcClient(){
    try {
        const ipcClient = greengrasscoreipc.createClient();
        await ipcClient.connect()
            .catch(error => {
                // parse the error depending on your use cases
                throw error;
            });
        return ipcClient
    } catch (err) {
        // parse the error depending on your use cases
        throw err
    }
}
 
// starting point
const publishToTopic = new PublishToTopic();
```

------
#### [ Rust ]

**Example Exemple : publier un message binaire**  

```
use gg_sdk::Sdk;

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    let message = b"Hello, World";
    let topic = "my/topic";

    sdk.publish_to_topic_binary(topic, message)
        .expect("Failed to publish to topic");

    println!("Successfully published to topic: {topic}");
}
```

------
#### [ C ]

**Example Exemple : publier un message binaire**  

```
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/sdk.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    GgBuffer message = GG_STR("Hello, World");
    GgBuffer topic = GG_STR("my/topic");

    err = ggipc_publish_to_topic_binary(topic, message);
    if (err != GG_ERR_OK) {
        fprintf(
            stderr,
            "Failed to publish to topic: %.*s\n",
            (int) topic.len,
            topic.data
        );
        exit(-1);
    }

    printf(
        "Successfully published to topic: %.*s\n", (int) topic.len, topic.data
    );
}
```

------
#### [ C\$1\$1 (Component SDK) ]

**Example Exemple : publier un message binaire**  

```
#include <gg/ipc/client.hpp>
#include <iostream>

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    std::string_view message = "Hello, World";
    std::string_view topic = "my/topic";

    error = client.publish_to_topic(topic, message);
    if (error) {
        std::cerr << "Failed to publish to topic: " << topic << "\n";
        exit(-1);
    }

    std::cout << "Successfully published to topic: " << topic << "\n";
}
```

------

## SubscribeToTopic
<a name="ipc-operation-subscribetotopic"></a>

Abonnez-vous aux messages sur un sujet.

<a name="ipc-subscribe-operation-note"></a>Il s'agit d'une opération d'abonnement dans le cadre de laquelle vous vous abonnez à un flux de messages d'événements. Pour utiliser cette opération, définissez un gestionnaire de réponse au flux avec des fonctions qui gèrent les messages d'événements, les erreurs et la fermeture du flux. Pour de plus amples informations, veuillez consulter [Abonnez-vous aux diffusions d'événements IPC](interprocess-communication.md#ipc-subscribe-operations).

**Type de message d'événement :** `SubscriptionResponseMessage`

### Demande
<a name="ipc-operation-subscribetotopic-request"></a>

La demande de cette opération comporte les paramètres suivants :

`topic`  
Rubrique à laquelle vous souhaitez vous abonner.  
Dans [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 et versions ultérieures, cette rubrique prend en charge les caractères génériques du thème MQTT (et). `#` `+`

`receiveMode`(Python :`receive_mode`)  
(Facultatif) Comportement qui indique si le composant reçoit des messages de lui-même. Vous pouvez modifier ce comportement pour permettre à un composant d'agir sur ses propres messages. Le comportement par défaut dépend de la présence ou non d'un caractère générique MQTT dans le sujet. Sélectionnez l’une des options suivantes :  
+ `RECEIVE_ALL_MESSAGES`— Recevez tous les messages correspondant au sujet, y compris les messages du composant abonné.

  Ce mode est l'option par défaut lorsque vous vous abonnez à un sujet qui ne contient pas de joker MQTT.
+ `RECEIVE_MESSAGES_FROM_OTHERS`— Recevez tous les messages correspondant au sujet, à l'exception des messages du composant abonné.

  Ce mode est l'option par défaut lorsque vous vous abonnez à un sujet contenant un caractère générique MQTT.
Cette fonctionnalité est disponible pour les versions 2.6.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. Le tableau suivant répertorie les versions minimales Kit SDK des appareils AWS IoT que vous devez utiliser pour définir le mode de réception.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/ipc-publish-subscribe.html)

### Réponse
<a name="ipc-operation-subscribetotopic-response"></a>

La réponse de cette opération contient les informations suivantes :

`messages`  
Le flux de messages. Cet objet contient `SubscriptionResponseMessage` les informations suivantes. Chaque message contient `jsonMessage` ou`binaryMessage`.  <a name="ipc-publish-subscribe-message-shape"></a>  
`jsonMessage`(Python :`json_message`)  
(Facultatif) Un message JSON. Cet objet contient `JsonMessage` les informations suivantes :    
`message`  
Le message JSON en tant qu'objet.  
`context`  <a name="ipc-publish-subscribe-message-context-variable"></a>
Le contexte du message, tel que le sujet dans lequel le message a été publié.  
Cette fonctionnalité est disponible pour les versions 2.6.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. Le tableau suivant répertorie les versions minimales du Kit SDK des appareils AWS IoT que vous devez utiliser pour accéder au contexte du message.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/ipc-publish-subscribe.html)
Le logiciel AWS IoT Greengrass Core utilise les mêmes objets de message dans les `SubscribeToTopic` opérations `PublishToTopic` et. Le logiciel AWS IoT Greengrass Core définit cet objet de contexte dans les messages lorsque vous vous abonnez et ignore cet objet de contexte dans les messages que vous publiez.
Cet objet contient `MessageContext` les informations suivantes :    
`topic`  
Sujet dans lequel le message a été publié.  
`binaryMessage`(Python :`binary_message`)  
(Facultatif) Un message binaire. Cet objet contient `BinaryMessage` les informations suivantes :    
`message`  
Le message binaire sous forme de blob.  
`context`  <a name="ipc-publish-subscribe-message-context-variable"></a>
Le contexte du message, tel que le sujet dans lequel le message a été publié.  
Cette fonctionnalité est disponible pour les versions 2.6.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. Le tableau suivant répertorie les versions minimales du Kit SDK des appareils AWS IoT que vous devez utiliser pour accéder au contexte du message.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/ipc-publish-subscribe.html)
Le logiciel AWS IoT Greengrass Core utilise les mêmes objets de message dans les `SubscribeToTopic` opérations `PublishToTopic` et. Le logiciel AWS IoT Greengrass Core définit cet objet de contexte dans les messages lorsque vous vous abonnez et ignore cet objet de contexte dans les messages que vous publiez.
Cet objet contient `MessageContext` les informations suivantes :    
`topic`  
Sujet dans lequel le message a été publié.

`topicName`(Python :`topic_name`)  
Sujet dans lequel le message a été publié.  
Cette propriété n'est pas utilisée actuellement. Dans [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 et versions ultérieures, vous pouvez obtenir la `(jsonMessage|binaryMessage).context.topic` valeur de a `SubscriptionResponseMessage` pour obtenir le sujet dans lequel le message a été publié.

### Exemples
<a name="ipc-operation-subscribetotopic-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Java (IPC client V2) ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  <a name="ipc-operation-subscribetotopic-example-java-v2"></a>

```
package com.aws.greengrass.docs.samples.ipc;

import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClientV2;
import software.amazon.awssdk.aws.greengrass.SubscribeToTopicResponseHandler;
import software.amazon.awssdk.aws.greengrass.model.*;

import java.nio.charset.StandardCharsets;
import java.util.Optional;

public class SubscribeToTopicV2 {

    public static void main(String[] args) {
        String topic = args[0];
        try (GreengrassCoreIPCClientV2 ipcClient = GreengrassCoreIPCClientV2.builder().build()) {
            SubscribeToTopicRequest request = new SubscribeToTopicRequest().withTopic(topic);
            GreengrassCoreIPCClientV2.StreamingResponse<SubscribeToTopicResponse,
                    SubscribeToTopicResponseHandler> response =
                    ipcClient.subscribeToTopic(request, SubscribeToTopicV2::onStreamEvent,
                            Optional.of(SubscribeToTopicV2::onStreamError),
                            Optional.of(SubscribeToTopicV2::onStreamClosed));
            SubscribeToTopicResponseHandler responseHandler = response.getHandler();
            System.out.println("Successfully subscribed to topic: " + topic);

            // Keep the main thread alive, or the process will exit.
            try {
                while (true) {
                    Thread.sleep(10000);
                }
            } catch (InterruptedException e) {
                System.out.println("Subscribe interrupted.");
            }

            // To stop subscribing, close the stream.
            responseHandler.closeStream();
        } catch (Exception e) {
            if (e.getCause() instanceof UnauthorizedError) {
                System.err.println("Unauthorized error while publishing to topic: " + topic);
            } else {
                System.err.println("Exception occurred when using IPC.");
            }
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static void onStreamEvent(SubscriptionResponseMessage subscriptionResponseMessage) {
        try {
            BinaryMessage binaryMessage = subscriptionResponseMessage.getBinaryMessage();
            String message = new String(binaryMessage.getMessage(), StandardCharsets.UTF_8);
            String topic = binaryMessage.getContext().getTopic();
            System.out.printf("Received new message on topic %s: %s%n", topic, message);
        } catch (Exception e) {
            System.err.println("Exception occurred while processing subscription response " +
                    "message.");
            e.printStackTrace();
        }
    }

    public static boolean onStreamError(Throwable error) {
        System.err.println("Received a stream error.");
        error.printStackTrace();
        return false; // Return true to close stream, false to keep stream open.
    }

    public static void onStreamClosed() {
        System.out.println("Subscribe to topic stream closed.");
    }
}
```

------
#### [ Python (IPC client V2) ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  <a name="ipc-operation-subscribetotopic-example-python-v2"></a>

```
import sys
import time
import traceback

from awsiot.greengrasscoreipc.clientv2 import GreengrassCoreIPCClientV2
from awsiot.greengrasscoreipc.model import (
    SubscriptionResponseMessage,
    UnauthorizedError
)


def main():
    args = sys.argv[1:]
    topic = args[0]

    try:
        ipc_client = GreengrassCoreIPCClientV2()
        # Subscription operations return a tuple with the response and the operation.
        _, operation = ipc_client.subscribe_to_topic(topic=topic, on_stream_event=on_stream_event,
                                                     on_stream_error=on_stream_error, on_stream_closed=on_stream_closed)
        print('Successfully subscribed to topic: ' + topic)

        # Keep the main thread alive, or the process will exit.
        try:
            while True:
                time.sleep(10)
        except InterruptedError:
            print('Subscribe interrupted.')

        # To stop subscribing, close the stream.
        operation.close()
    except UnauthorizedError:
        print('Unauthorized error while subscribing to topic: ' +
              topic, file=sys.stderr)
        traceback.print_exc()
        exit(1)
    except Exception:
        print('Exception occurred', file=sys.stderr)
        traceback.print_exc()
        exit(1)


def on_stream_event(event: SubscriptionResponseMessage) -> None:
    try:
        message = str(event.binary_message.message, 'utf-8')
        topic = event.binary_message.context.topic
        print('Received new message on topic %s: %s' % (topic, message))
    except:
        traceback.print_exc()


def on_stream_error(error: Exception) -> bool:
    print('Received a stream error.', file=sys.stderr)
    traceback.print_exc()
    return False  # Return True to close stream, False to keep stream open.


def on_stream_closed() -> None:
    print('Subscribe to topic stream closed.')


if __name__ == '__main__':
    main()
```

------
#### [ C\$1\$1 (IPC client V1) ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  <a name="ipc-operation-subscribetotopic-example-cpp"></a>

```
#include <iostream>

#include </crt/Api.h>
#include <aws/greengrass/GreengrassCoreIpcClient.h>

using namespace Aws::Crt;
using namespace Aws::Greengrass;

class SubscribeResponseHandler : public SubscribeToTopicStreamHandler {
    public:
        virtual ~SubscribeResponseHandler() {}

    private:
        void OnStreamEvent(SubscriptionResponseMessage *response) override {
            auto jsonMessage = response->GetJsonMessage();
            if (jsonMessage.has_value() && jsonMessage.value().GetMessage().has_value()) {
                auto messageString = jsonMessage.value().GetMessage().value().View().WriteReadable();
                // Handle JSON message.
            } else {
                auto binaryMessage = response->GetBinaryMessage();
                if (binaryMessage.has_value() && binaryMessage.value().GetMessage().has_value()) {
                    auto messageBytes = binaryMessage.value().GetMessage().value();
                    std::string messageString(messageBytes.begin(), messageBytes.end());
                    // Handle binary message.
                }
            }
        }

        bool OnStreamError(OperationError *error) override {
            // Handle error.
            return false; // Return true to close stream, false to keep stream open.
        }

        void OnStreamClosed() override {
            // Handle close.
        }
};

class IpcClientLifecycleHandler : public ConnectionLifecycleHandler {
    void OnConnectCallback() override {
        // Handle connection to IPC service.
    }

    void OnDisconnectCallback(RpcError error) override {
        // Handle disconnection from IPC service.
    }

    bool OnErrorCallback(RpcError error) override {
        // Handle IPC service connection error.
        return true;
    }
};

int main() {
    ApiHandle apiHandle(g_allocator);
    Io::EventLoopGroup eventLoopGroup(1);
    Io::DefaultHostResolver socketResolver(eventLoopGroup, 64, 30);
    Io::ClientBootstrap bootstrap(eventLoopGroup, socketResolver);
    IpcClientLifecycleHandler ipcLifecycleHandler;
    GreengrassCoreIpcClient ipcClient(bootstrap);
    auto connectionStatus = ipcClient.Connect(ipcLifecycleHandler).get();
    if (!connectionStatus) {
        std::cerr << "Failed to establish IPC connection: " << connectionStatus.StatusToString() << std::endl;
        exit(-1);
    }

    String topic("my/topic");
    int timeout = 10;

    SubscribeToTopicRequest request;
    request.SetTopic(topic);

    //SubscribeResponseHandler streamHandler;
    auto streamHandler = MakeShared<SubscribeResponseHandler>(DefaultAllocator());
    auto operation = ipcClient.NewSubscribeToTopic(streamHandler);
    auto activate = operation->Activate(request, nullptr);
    activate.wait();

    auto responseFuture = operation->GetResult();
    if (responseFuture.wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout) {
        std::cerr << "Operation timed out while waiting for response from Greengrass Core." << std::endl;
        exit(-1);
    }

    auto response = responseFuture.get();
    if (!response) {
        // Handle error.
        auto errorType = response.GetResultType();
        if (errorType == OPERATION_ERROR) {
            auto *error = response.GetOperationError();
            (void)error;
            // Handle operation error.
        } else {
            // Handle RPC error.
        }
        exit(-1);
    }

    // Keep the main thread alive, or the process will exit.
    while (true) {
        std::this_thread::sleep_for(std::chrono::seconds(10));
    }

    operation->Close();
    return 0;
}
```

------
#### [ JavaScript ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  <a name="ipc-operation-subscribetotopic-example-nodejs"></a>

```
import * as greengrasscoreipc from "aws-iot-device-sdk-v2/dist/greengrasscoreipc";
import {SubscribeToTopicRequest, SubscriptionResponseMessage} from "aws-iot-device-sdk-v2/dist/greengrasscoreipc/model";
import {RpcError} from "aws-iot-device-sdk-v2/dist/eventstream_rpc";
 
class SubscribeToTopic {
    private ipcClient : greengrasscoreipc.Client
    private readonly topic : string;
 
    constructor() {
        // define your own constructor, e.g.
        this.topic = "<define_your_topic>";
        this.subscribeToTopic().then(r => console.log("Started workflow"));
    }
 
    private async subscribeToTopic() {
        try {
            this.ipcClient = await getIpcClient();
 
            const subscribeToTopicRequest : SubscribeToTopicRequest = {
                topic: this.topic,
            }
 
            const streamingOperation = this.ipcClient.subscribeToTopic(subscribeToTopicRequest, undefined); // conditionally apply options
 
            streamingOperation.on("message", (message: SubscriptionResponseMessage) => {
                // parse the message depending on your use cases, e.g.
                if(message.binaryMessage && message.binaryMessage.message) {
                    const receivedMessage = message.binaryMessage?.message.toString();
                }
            });
 
            streamingOperation.on("streamError", (error : RpcError) => {
                // define your own error handling logic
            })
 
            streamingOperation.on("ended", () => {
                // define your own logic
            })
 
            await streamingOperation.activate();
 
            // Keep the main thread alive, or the process will exit.
            await new Promise((resolve) => setTimeout(resolve, 10000))
        } catch (e) {
            // parse the error depending on your use cases
            throw e
        }
    }
}
 
export async function getIpcClient(){
    try {
        const ipcClient = greengrasscoreipc.createClient();
        await ipcClient.connect()
            .catch(error => {
                // parse the error depending on your use cases
                throw error;
            });
        return ipcClient
    } catch (err) {
        // parse the error depending on your use cases
        throw err
    }
}
 
// starting point
const subscribeToTopic = new SubscribeToTopic();
```

------
#### [ Rust ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  

```
use gg_sdk::{Sdk, SubscribeToTopicPayload};
use std::{thread, time::Duration};

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    let topic = "my/topic";

    let callback = |topic: &str, payload: SubscribeToTopicPayload| match payload
    {
        SubscribeToTopicPayload::Binary(message) => {
            let message = String::from_utf8_lossy(message);
            println!("Received new message on topic {topic}: {message}");
        }
        SubscribeToTopicPayload::Json(_) => {
            println!("Received new message on topic {topic}: (JSON message)");
        }
    };

    let _sub = sdk
        .subscribe_to_topic(topic, &callback)
        .expect("Failed to subscribe to topic");

    println!("Successfully subscribed to topic: {topic}");

    // Keep the main thread alive, or the process will exit.
    loop {
        thread::sleep(Duration::from_secs(10));
    }
}
```

------
#### [ C ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  

```
#include <assert.h>
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/object.h>
#include <gg/sdk.h>
#include <gg/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

static void on_subscription_response(
    void *ctx, GgBuffer topic, GgObject payload, GgIpcSubscriptionHandle handle
) {
    (void) ctx;
    (void) handle;

    if (gg_obj_type(payload) == GG_TYPE_BUF) {
        GgBuffer message = gg_obj_into_buf(payload);
        printf(
            "Received new message on topic %.*s: %.*s\n",
            (int) topic.len,
            topic.data,
            (int) message.len,
            message.data
        );
    } else {
        assert(gg_obj_type(payload) == GG_TYPE_MAP);
        printf(
            "Received new message on topic %.*s: (JSON message)\n",
            (int) topic.len,
            topic.data
        );
    }
}

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    GgBuffer topic = GG_STR("my/topic");

    GgIpcSubscriptionHandle handle;
    err = ggipc_subscribe_to_topic(
        topic, on_subscription_response, NULL, &handle
    );
    if (err != GG_ERR_OK) {
        fprintf(
            stderr,
            "Failed to subscribe to topic: %.*s\n",
            (int) topic.len,
            topic.data
        );
        exit(-1);
    }

    printf(
        "Successfully subscribed to topic: %.*s\n", (int) topic.len, topic.data
    );

    // Keep the main thread alive, or the process will exit.
    while (1) {
        sleep(10);
    }

    // To stop subscribing, close the stream.
    ggipc_close_subscription(handle);
}
```

------
#### [ C\$1\$1 (Component SDK) ]

**Example Exemple : s'abonner à des publish/subscribe messages locaux**  

```
#include <gg/ipc/client.hpp>
#include <gg/object.hpp>
#include <unistd.h>
#include <cassert>
#include <iostream>

class ResponseHandler : public gg::ipc::LocalTopicCallback {
    void operator()(
        std::string_view topic,
        gg::Object payload,
        gg::ipc::Subscription &handle
    ) override {
        (void) handle;
        if (payload.index() == GG_TYPE_BUF) {
            std::cout << "Received new message on topic " << topic << ": "
                      << get<gg::Buffer>(payload) << "\n";
        } else {
            assert(payload.index() == GG_TYPE_MAP);
            std::cout << "Received new message on topic " << topic
                      << ": (JSON message)\n";
        }
    }
};

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    std::string_view topic = "my/topic";

    static ResponseHandler handler;
    error = client.subscribe_to_topic(topic, handler);
    if (error) {
        std::cerr << "Failed to subscribe to topic: " << topic << "\n";
        exit(-1);
    }

    std::cout << "Successfully subscribed to topic: " << topic << "\n";

    // Keep the main thread alive, or the process will exit.
    while (1) {
        sleep(10);
    }
}
```

------

## Exemples
<a name="ipc-publish-subscribe-examples"></a>

Utilisez les exemples suivants pour savoir comment utiliser le service publish/subscribe IPC dans vos composants.

### Exemple d' publish/subscribe éditeur (Java, client IPC V1)
<a name="ipc-publish-subscribe-example-publisher-java"></a>

L'exemple de recette suivant permet au composant de publier dans toutes les rubriques.

------
#### [ JSON ]

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PubSubPublisherJava",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that publishes messages.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.PubSubPublisherJava:pubsub:1": {
            "policyDescription": "Allows access to publish to all topics.",
            "operations": [
              "aws.greengrass#PublishToTopic"
            ],
            "resources": [
              "*"
            ]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Lifecycle": {
        "Run": "java -jar {artifacts:path}/PubSubPublisher.jar"
      }
    }
  ]
}
```

------
#### [ YAML ]

```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.PubSubPublisherJava
ComponentVersion: '1.0.0'
ComponentDescription: A component that publishes messages.
ComponentPublisher: Amazon
ComponentConfiguration:
  DefaultConfiguration:
    accessControl:
      aws.greengrass.ipc.pubsub:
        'com.example.PubSubPublisherJava:pubsub:1':
          policyDescription: Allows access to publish to all topics.
          operations:
            - 'aws.greengrass#PublishToTopic'
          resources:
            - '*'
Manifests:
  - Lifecycle:
      Run: |-
        java -jar {artifacts:path}/PubSubPublisher.jar
```

------

L'exemple d'application Java suivant montre comment utiliser le service IPC de publication/abonnement pour publier des messages destinés à d'autres composants.

```
/* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0 */

package com.example.ipc.pubsub;

import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClient;
import software.amazon.awssdk.aws.greengrass.model.*;
import software.amazon.awssdk.eventstreamrpc.EventStreamRPCConnection;

import java.nio.charset.StandardCharsets;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class PubSubPublisher {

    public static void main(String[] args) {
        String message = "Hello from the pub/sub publisher (Java).";
        String topic = "test/topic/java";

        try (EventStreamRPCConnection eventStreamRPCConnection = IPCUtils.getEventStreamRpcConnection()) {
            GreengrassCoreIPCClient ipcClient = new GreengrassCoreIPCClient(eventStreamRPCConnection);

            while (true) {
                PublishToTopicRequest publishRequest = new PublishToTopicRequest();
                PublishMessage publishMessage = new PublishMessage();
                BinaryMessage binaryMessage = new BinaryMessage();
                binaryMessage.setMessage(message.getBytes(StandardCharsets.UTF_8));
                publishMessage.setBinaryMessage(binaryMessage);
                publishRequest.setPublishMessage(publishMessage);
                publishRequest.setTopic(topic);
                CompletableFuture<PublishToTopicResponse> futureResponse = ipcClient
                        .publishToTopic(publishRequest, Optional.empty()).getResponse();

                try {
                    futureResponse.get(10, TimeUnit.SECONDS);
                    System.out.println("Successfully published to topic: " + topic);
                } catch (TimeoutException e) {
                    System.err.println("Timeout occurred while publishing to topic: " + topic);
                } catch (ExecutionException e) {
                    if (e.getCause() instanceof UnauthorizedError) {
                        System.err.println("Unauthorized error while publishing to topic: " + topic);
                    } else {
                        System.err.println("Execution exception while publishing to topic: " + topic);
                    }
                    throw e;
                }
                Thread.sleep(5000);
            }
        } catch (InterruptedException e) {
            System.out.println("Publisher interrupted.");
        } catch (Exception e) {
            System.err.println("Exception occurred when using IPC.");
            e.printStackTrace();
            System.exit(1);
        }
    }
}
```

### Exemple publish/subscribe d'abonné (Java, client IPC V1)
<a name="ipc-publish-subscribe-example-subscriber-java"></a>

L'exemple de recette suivant permet au composant de s'abonner à toutes les rubriques.

------
#### [ JSON ]

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PubSubSubscriberJava",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that subscribes to messages.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.PubSubSubscriberJava:pubsub:1": {
            "policyDescription": "Allows access to subscribe to all topics.",
            "operations": [
              "aws.greengrass#SubscribeToTopic"
            ],
            "resources": [
              "*"
            ]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Lifecycle": {
        "Run": "java -jar {artifacts:path}/PubSubSubscriber.jar"
      }
    }
  ]
}
```

------
#### [ YAML ]

```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.PubSubSubscriberJava
ComponentVersion: '1.0.0'
ComponentDescription: A component that subscribes to messages.
ComponentPublisher: Amazon
ComponentConfiguration:
  DefaultConfiguration:
    accessControl:
      aws.greengrass.ipc.pubsub:
        'com.example.PubSubSubscriberJava:pubsub:1':
          policyDescription: Allows access to subscribe to all topics.
          operations:
            - 'aws.greengrass#SubscribeToTopic'
          resources:
            - '*'
Manifests:
  - Lifecycle:
      Run: |-
        java -jar {artifacts:path}/PubSubSubscriber.jar
```

------

L'exemple d'application Java suivant montre comment utiliser le service IPC de publication/abonnement pour s'abonner à des messages envoyés à d'autres composants.

```
/* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0 */

package com.example.ipc.pubsub;

import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClient;
import software.amazon.awssdk.aws.greengrass.SubscribeToTopicResponseHandler;
import software.amazon.awssdk.aws.greengrass.model.SubscribeToTopicRequest;
import software.amazon.awssdk.aws.greengrass.model.SubscribeToTopicResponse;
import software.amazon.awssdk.aws.greengrass.model.SubscriptionResponseMessage;
import software.amazon.awssdk.aws.greengrass.model.UnauthorizedError;
import software.amazon.awssdk.eventstreamrpc.EventStreamRPCConnection;
import software.amazon.awssdk.eventstreamrpc.StreamResponseHandler;

import java.nio.charset.StandardCharsets;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class PubSubSubscriber {

    public static void main(String[] args) {
        String topic = "test/topic/java";

        try (EventStreamRPCConnection eventStreamRPCConnection = IPCUtils.getEventStreamRpcConnection()) {
            GreengrassCoreIPCClient ipcClient = new GreengrassCoreIPCClient(eventStreamRPCConnection);

            SubscribeToTopicRequest subscribeRequest = new SubscribeToTopicRequest();
            subscribeRequest.setTopic(topic);
            SubscribeToTopicResponseHandler operationResponseHandler = ipcClient
                    .subscribeToTopic(subscribeRequest, Optional.of(new SubscribeResponseHandler()));
            CompletableFuture<SubscribeToTopicResponse> futureResponse = operationResponseHandler.getResponse();

            try {
                futureResponse.get(10, TimeUnit.SECONDS);
                System.out.println("Successfully subscribed to topic: " + topic);
            } catch (TimeoutException e) {
                System.err.println("Timeout occurred while subscribing to topic: " + topic);
                throw e;
            } catch (ExecutionException e) {
                if (e.getCause() instanceof UnauthorizedError) {
                    System.err.println("Unauthorized error while subscribing to topic: " + topic);
                } else {
                    System.err.println("Execution exception while subscribing to topic: " + topic);
                }
                throw e;
            }

            // Keep the main thread alive, or the process will exit.
            try {
                while (true) {
                    Thread.sleep(10000);
                }
            } catch (InterruptedException e) {
                System.out.println("Subscribe interrupted.");
            }
        } catch (Exception e) {
            System.err.println("Exception occurred when using IPC.");
            e.printStackTrace();
            System.exit(1);
        }
    }

    private static class SubscribeResponseHandler implements StreamResponseHandler<SubscriptionResponseMessage> {

        @Override
        public void onStreamEvent(SubscriptionResponseMessage subscriptionResponseMessage) {
            try {
                String message = new String(subscriptionResponseMessage.getBinaryMessage()
                        .getMessage(), StandardCharsets.UTF_8);
                System.out.println("Received new message: " + message);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        @Override
        public boolean onStreamError(Throwable error) {
            System.err.println("Received a stream error.");
            error.printStackTrace();
            return false; // Return true to close stream, false to keep stream open.
        }

        @Override
        public void onStreamClosed() {
            System.out.println("Subscribe to topic stream closed.");
        }
    }
}
```

### Exemple d' publish/subscribe éditeur (Python, client IPC V1)
<a name="ipc-publish-subscribe-example-publisher-python"></a>

L'exemple de recette suivant permet au composant de publier dans toutes les rubriques.

------
#### [ JSON ]

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PubSubPublisherPython",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that publishes messages.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.PubSubPublisherPython:pubsub:1": {
            "policyDescription": "Allows access to publish to all topics.",
            "operations": [
              "aws.greengrass#PublishToTopic"
            ],
            "resources": [
              "*"
            ]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": "python3 -m pip install --user awsiotsdk",
        "Run": "python3 -u {artifacts:path}/pubsub_publisher.py"
      }
    },
    {
      "Platform": {
        "os": "windows"
      },
      "Lifecycle": {
        "install": "py -3 -m pip install --user awsiotsdk",
        "Run": "py -3 -u {artifacts:path}/pubsub_publisher.py"
      }
    }
  ]
}
```

------
#### [ YAML ]

```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.PubSubPublisherPython
ComponentVersion: 1.0.0
ComponentDescription: A component that publishes messages.
ComponentPublisher: Amazon
ComponentConfiguration:
  DefaultConfiguration:
    accessControl:
      aws.greengrass.ipc.pubsub:
        com.example.PubSubPublisherPython:pubsub:1:
          policyDescription: Allows access to publish to all topics.
          operations:
            - aws.greengrass#PublishToTopic
          resources:
            - "*"
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install: python3 -m pip install --user awsiotsdk
      Run: python3 -u {artifacts:path}/pubsub_publisher.py
  - Platform:
      os: windows
    Lifecycle:
      install: py -3 -m pip install --user awsiotsdk
      Run: py -3 -u {artifacts:path}/pubsub_publisher.py
```

------

L'exemple d'application Python suivant montre comment utiliser le service IPC publish/subscribe pour publier des messages destinés à d'autres composants.

```
import concurrent.futures
import sys
import time
import traceback

import awsiot.greengrasscoreipc
from awsiot.greengrasscoreipc.model import (
    PublishToTopicRequest,
    PublishMessage,
    BinaryMessage,
    UnauthorizedError
)

                    
topic = "test/topic/python"
message = "Hello from the pub/sub publisher (Python)."
TIMEOUT = 10

try:
    ipc_client = awsiot.greengrasscoreipc.connect()

    while True:
        request = PublishToTopicRequest()
        request.topic = topic
        publish_message = PublishMessage()
        publish_message.binary_message = BinaryMessage()
        publish_message.binary_message.message = bytes(message, "utf-8")
        request.publish_message = publish_message
        operation = ipc_client.new_publish_to_topic()
        operation.activate(request)
        future_response = operation.get_response()

        try:
            future_response.result(TIMEOUT)
            print('Successfully published to topic: ' + topic)
        except concurrent.futures.TimeoutError:
            print('Timeout occurred while publishing to topic: ' + topic, file=sys.stderr)
        except UnauthorizedError as e:
            print('Unauthorized error while publishing to topic: ' + topic, file=sys.stderr)
            raise e
        except Exception as e:
            print('Exception while publishing to topic: ' + topic, file=sys.stderr)
            raise e
        time.sleep(5)
except InterruptedError:
    print('Publisher interrupted.')
except Exception:
    print('Exception occurred when using IPC.', file=sys.stderr)
    traceback.print_exc()
    exit(1)
```

### Exemple publish/subscribe d'abonné (Python, client IPC V1)
<a name="ipc-publish-subscribe-example-subscriber-python"></a>

L'exemple de recette suivant permet au composant de s'abonner à toutes les rubriques.

------
#### [ JSON ]

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PubSubSubscriberPython",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that subscribes to messages.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.PubSubSubscriberPython:pubsub:1": {
            "policyDescription": "Allows access to subscribe to all topics.",
            "operations": [
              "aws.greengrass#SubscribeToTopic"
            ],
            "resources": [
              "*"
            ]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": "python3 -m pip install --user awsiotsdk",
        "Run": "python3 -u {artifacts:path}/pubsub_subscriber.py"
      }
    },
    {
      "Platform": {
        "os": "windows"
      },
      "Lifecycle": {
        "install": "py -3 -m pip install --user awsiotsdk",
        "Run": "py -3 -u {artifacts:path}/pubsub_subscriber.py"
      }
    }
  ]
}
```

------
#### [ YAML ]

```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.PubSubSubscriberPython
ComponentVersion: 1.0.0
ComponentDescription: A component that subscribes to messages.
ComponentPublisher: Amazon
ComponentConfiguration:
  DefaultConfiguration:
    accessControl:
      aws.greengrass.ipc.pubsub:
        com.example.PubSubSubscriberPython:pubsub:1:
          policyDescription: Allows access to subscribe to all topics.
          operations:
            - aws.greengrass#SubscribeToTopic
          resources:
            - "*"
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install: python3 -m pip install --user awsiotsdk
      Run: python3 -u {artifacts:path}/pubsub_subscriber.py
  - Platform:
      os: windows
    Lifecycle:
      install: py -3 -m pip install --user awsiotsdk
      Run: py -3 -u {artifacts:path}/pubsub_subscriber.py
```

------

L'exemple d'application Python suivant montre comment utiliser le service IPC publish/subscribe pour s'abonner à des messages envoyés à d'autres composants.

```
import concurrent.futures
import sys
import time
import traceback

import awsiot.greengrasscoreipc
import awsiot.greengrasscoreipc.client as client
from awsiot.greengrasscoreipc.model import (
    SubscribeToTopicRequest,
    SubscriptionResponseMessage,
    UnauthorizedError
)

topic = "test/topic/python"
TIMEOUT = 10

                    
class StreamHandler(client.SubscribeToTopicStreamHandler):
    def __init__(self):
        super().__init__()

    def on_stream_event(self, event: SubscriptionResponseMessage) -> None:
        try:
            message = str(event.binary_message.message, "utf-8")
            print("Received new message: " + message)
        except:
            traceback.print_exc()

    def on_stream_error(self, error: Exception) -> bool:
        print("Received a stream error.", file=sys.stderr)
        traceback.print_exc()
        return False  # Return True to close stream, False to keep stream open.

    def on_stream_closed(self) -> None:
        print('Subscribe to topic stream closed.')


try:
    ipc_client = awsiot.greengrasscoreipc.connect()

    request = SubscribeToTopicRequest()
    request.topic = topic
    handler = StreamHandler()
    operation = ipc_client.new_subscribe_to_topic(handler)
    operation.activate(request)
    future_response = operation.get_response()
    
    try:
        future_response.result(TIMEOUT)
        print('Successfully subscribed to topic: ' + topic)
    except concurrent.futures.TimeoutError as e:
        print('Timeout occurred while subscribing to topic: ' + topic, file=sys.stderr)
        raise e
    except UnauthorizedError as e:
        print('Unauthorized error while subscribing to topic: ' + topic, file=sys.stderr)
        raise e
    except Exception as e:
        print('Exception while subscribing to topic: ' + topic, file=sys.stderr)
        raise e

    # Keep the main thread alive, or the process will exit.
    try:
        while True:
            time.sleep(10)
    except InterruptedError:
        print('Subscribe interrupted.')
except Exception:
    print('Exception occurred when using IPC.', file=sys.stderr)
    traceback.print_exc()
    exit(1)
```

### Exemple d' publish/subscribe éditeur (C\$1\$1, client IPC V1)
<a name="ipc-publish-subscribe-example-publisher-cpp"></a>

L'exemple de recette suivant permet au composant de publier dans toutes les rubriques.

------
#### [ JSON ]

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PubSubPublisherCpp",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that publishes messages.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.PubSubPublisherCpp:pubsub:1": {
            "policyDescription": "Allows access to publish to all topics.",
            "operations": [
              "aws.greengrass#PublishToTopic"
            ],
            "resources": [
              "*"
            ]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Lifecycle": {
        "Run": "{artifacts:path}/greengrassv2_pubsub_publisher"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.PubSubPublisherCpp/1.0.0/greengrassv2_pubsub_publisher",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

------
#### [ YAML ]

```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.PubSubPublisherCpp
ComponentVersion: 1.0.0
ComponentDescription: A component that publishes messages.
ComponentPublisher: Amazon
ComponentConfiguration:
  DefaultConfiguration:
    accessControl:
      aws.greengrass.ipc.pubsub:
        com.example.PubSubPublisherCpp:pubsub:1:
          policyDescription: Allows access to publish to all topics.
          operations:
            - aws.greengrass#PublishToTopic
          resources:
            - "*"
Manifests:
  - Lifecycle:
      Run: "{artifacts:path}/greengrassv2_pubsub_publisher"
    Artifacts:
      - URI: s3://amzn-s3-demo-bucket/artifacts/com.example.PubSubPublisherCpp/1.0.0/greengrassv2_pubsub_publisher
        Permission:
          Execute: OWNER
```

------

L'exemple d'application C\$1\$1 suivant montre comment utiliser le service IPC de publication/abonnement pour publier des messages destinés à d'autres composants.

```
#include <iostream>

#include <aws/crt/Api.h>
#include <aws/greengrass/GreengrassCoreIpcClient.h>

using namespace Aws::Crt;
using namespace Aws::Greengrass;

class IpcClientLifecycleHandler : public ConnectionLifecycleHandler {
    void OnConnectCallback() override {
        std::cout << "OnConnectCallback" << std::endl;
    }

    void OnDisconnectCallback(RpcError error) override {
        std::cout << "OnDisconnectCallback: " << error.StatusToString() << std::endl;
        exit(-1);
    }

    bool OnErrorCallback(RpcError error) override {
        std::cout << "OnErrorCallback: " << error.StatusToString() << std::endl;
        return true;
    }
};

int main() {
    String message("Hello from the pub/sub publisher (C++).");
    String topic("test/topic/cpp");
    int timeout = 10;

    ApiHandle apiHandle(g_allocator);
    Io::EventLoopGroup eventLoopGroup(1);
    Io::DefaultHostResolver socketResolver(eventLoopGroup, 64, 30);
    Io::ClientBootstrap bootstrap(eventLoopGroup, socketResolver);
    IpcClientLifecycleHandler ipcLifecycleHandler;
    GreengrassCoreIpcClient ipcClient(bootstrap);
    auto connectionStatus = ipcClient.Connect(ipcLifecycleHandler).get();
    if (!connectionStatus) {
        std::cerr << "Failed to establish IPC connection: " << connectionStatus.StatusToString() << std::endl;
        exit(-1);
    }

    while (true) {
        PublishToTopicRequest request;
        Vector<uint8_t> messageData({message.begin(), message.end()});
        BinaryMessage binaryMessage;
        binaryMessage.SetMessage(messageData);
        PublishMessage publishMessage;
        publishMessage.SetBinaryMessage(binaryMessage);
        request.SetTopic(topic);
        request.SetPublishMessage(publishMessage);

        auto operation = ipcClient.NewPublishToTopic();
        auto activate = operation->Activate(request, nullptr);
        activate.wait();

        auto responseFuture = operation->GetResult();
        if (responseFuture.wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout) {
            std::cerr << "Operation timed out while waiting for response from Greengrass Core." << std::endl;
            exit(-1);
        }

        auto response = responseFuture.get();
        if (response) {
            std::cout << "Successfully published to topic: " << topic << std::endl;
        } else {
            // An error occurred.
            std::cout << "Failed to publish to topic: " << topic << std::endl;
            auto errorType = response.GetResultType();
            if (errorType == OPERATION_ERROR) {
                auto *error = response.GetOperationError();
                std::cout << "Operation error: " << error->GetMessage().value() << std::endl;
            } else {
                std::cout << "RPC error: " << response.GetRpcError() << std::endl;
            }
            exit(-1);
        }

        std::this_thread::sleep_for(std::chrono::seconds(5));
    }

    return 0;
}
```

### Exemple publish/subscribe d'abonné (C\$1\$1, client IPC V1)
<a name="ipc-publish-subscribe-example-subscriber-cpp"></a>

L'exemple de recette suivant permet au composant de s'abonner à toutes les rubriques.

------
#### [ JSON ]

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PubSubSubscriberCpp",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that subscribes to messages.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.PubSubSubscriberCpp:pubsub:1": {
            "policyDescription": "Allows access to subscribe to all topics.",
            "operations": [
              "aws.greengrass#SubscribeToTopic"
            ],
            "resources": [
              "*"
            ]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Lifecycle": {
        "Run": "{artifacts:path}/greengrassv2_pub_sub_subscriber"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.PubSubSubscriberCpp/1.0.0/greengrassv2_pub_sub_subscriber",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

------
#### [ YAML ]

```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.PubSubSubscriberCpp
ComponentVersion: 1.0.0
ComponentDescription: A component that subscribes to messages.
ComponentPublisher: Amazon
ComponentConfiguration:
  DefaultConfiguration:
    accessControl:
      aws.greengrass.ipc.pubsub:
        com.example.PubSubSubscriberCpp:pubsub:1:
          policyDescription: Allows access to subscribe to all topics.
          operations:
            - aws.greengrass#SubscribeToTopic
          resources:
            - "*"
Manifests:
  - Lifecycle:
      Run: "{artifacts:path}/greengrassv2_pub_sub_subscriber"
    Artifacts:
      - URI: s3://amzn-s3-demo-bucket/artifacts/com.example.PubSubSubscriberCpp/1.0.0/greengrassv2_pub_sub_subscriber
        Permission:
          Execute: OWNER
```

------

L'exemple d'application C\$1\$1 suivant montre comment utiliser le service IPC de publication/abonnement pour s'abonner à des messages envoyés à d'autres composants.

```
#include <iostream>

#include <aws/crt/Api.h>
#include <aws/greengrass/GreengrassCoreIpcClient.h>

using namespace Aws::Crt;
using namespace Aws::Greengrass;

class SubscribeResponseHandler : public SubscribeToTopicStreamHandler {
    public:
        virtual ~SubscribeResponseHandler() {}

    private:
        void OnStreamEvent(SubscriptionResponseMessage *response) override {
            auto jsonMessage = response->GetJsonMessage();
            if (jsonMessage.has_value() && jsonMessage.value().GetMessage().has_value()) {
                auto messageString = jsonMessage.value().GetMessage().value().View().WriteReadable();
                std::cout << "Received new message: " << messageString << std::endl;
            } else {
                auto binaryMessage = response->GetBinaryMessage();
                if (binaryMessage.has_value() && binaryMessage.value().GetMessage().has_value()) {
                    auto messageBytes = binaryMessage.value().GetMessage().value();
                    std::string messageString(messageBytes.begin(), messageBytes.end());
                    std::cout << "Received new message: " << messageString << std::endl;
                }
            }
        }

        bool OnStreamError(OperationError *error) override {
            std::cout << "Received an operation error: ";
            if (error->GetMessage().has_value()) {
                std::cout << error->GetMessage().value();
            }
            std::cout << std::endl;
            return false; // Return true to close stream, false to keep stream open.
        }

        void OnStreamClosed() override {
            std::cout << "Subscribe to topic stream closed." << std::endl;
        }
};

class IpcClientLifecycleHandler : public ConnectionLifecycleHandler {
    void OnConnectCallback() override {
        std::cout << "OnConnectCallback" << std::endl;
    }

    void OnDisconnectCallback(RpcError error) override {
        std::cout << "OnDisconnectCallback: " << error.StatusToString() << std::endl;
        exit(-1);
    }

    bool OnErrorCallback(RpcError error) override {
        std::cout << "OnErrorCallback: " << error.StatusToString() << std::endl;
        return true;
    }
};

int main() {
    String topic("test/topic/cpp");
    int timeout = 10;

    ApiHandle apiHandle(g_allocator);
    Io::EventLoopGroup eventLoopGroup(1);
    Io::DefaultHostResolver socketResolver(eventLoopGroup, 64, 30);
    Io::ClientBootstrap bootstrap(eventLoopGroup, socketResolver);
    IpcClientLifecycleHandler ipcLifecycleHandler;
    GreengrassCoreIpcClient ipcClient(bootstrap);
    auto connectionStatus = ipcClient.Connect(ipcLifecycleHandler).get();
    if (!connectionStatus) {
        std::cerr << "Failed to establish IPC connection: " << connectionStatus.StatusToString() << std::endl;
        exit(-1);
    }

    SubscribeToTopicRequest request;
    request.SetTopic(topic);
    auto streamHandler = MakeShared<SubscribeResponseHandler>(DefaultAllocator());
    auto operation = ipcClient.NewSubscribeToTopic(streamHandler);
    auto activate = operation->Activate(request, nullptr);
    activate.wait();

    auto responseFuture = operation->GetResult();
    if (responseFuture.wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout) {
        std::cerr << "Operation timed out while waiting for response from Greengrass Core." << std::endl;
        exit(-1);
    }

    auto response = responseFuture.get();
    if (response) {
        std::cout << "Successfully subscribed to topic: " << topic << std::endl;
    } else {
        // An error occurred.
        std::cout << "Failed to subscribe to topic: " << topic << std::endl;
        auto errorType = response.GetResultType();
        if (errorType == OPERATION_ERROR) {
            auto *error = response.GetOperationError();
            std::cout << "Operation error: " << error->GetMessage().value() << std::endl;
        } else {
            std::cout << "RPC error: " << response.GetRpcError() << std::endl;
        }
        exit(-1);
    }

    // Keep the main thread alive, or the process will exit.
    while (true) {
        std::this_thread::sleep_for(std::chrono::seconds(10));
    }

    operation->Close();
    return 0;
}
```

### Exemple d' publish/subscribe éditeur (Rust)
<a name="ipc-publish-subscribe-example-publisher-rust"></a>

L'exemple de recette suivant permet au composant de publier dans toutes les rubriques.

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PubSubPublisherRust",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that publishes messages.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.PubSubPublisherRust:pubsub:1": {
            "policyDescription": "Allows access to publish to all topics.",
            "operations": ["aws.greengrass#PublishToTopic"],
            "resources": ["*"]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux",
        "runtime": "*"
      },
      "Lifecycle": {
        "run": "{artifacts:path}/publish_to_topic"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.PubSubPublisherRust/1.0.0/publish_to_topic",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

L'exemple d'application Rust suivant montre comment utiliser le service IPC de publication/abonnement pour publier des messages vers d'autres composants.

```
use gg_sdk::Sdk;

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    let message = b"Hello, World";
    let topic = "my/topic";

    sdk.publish_to_topic_binary(topic, message)
        .expect("Failed to publish to topic");

    println!("Successfully published to topic: {topic}");
}
```

### Exemple publish/subscribe d'abonné (Rust)
<a name="ipc-publish-subscribe-example-subscriber-rust"></a>

L'exemple de recette suivant permet au composant de s'abonner à toutes les rubriques.

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PubSubSubscriberRust",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that subscribes to messages.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.PubSubSubscriberRust:pubsub:1": {
            "policyDescription": "Allows access to subscribe to all topics.",
            "operations": ["aws.greengrass#SubscribeToTopic"],
            "resources": ["*"]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux",
        "runtime": "*"
      },
      "Lifecycle": {
        "run": "{artifacts:path}/subscribe_to_topic"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.PubSubSubscriberRust/1.0.0/subscribe_to_topic",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

L'exemple d'application Rust suivant montre comment utiliser le service IPC publish/subscribe pour s'abonner à des messages provenant d'autres composants.

```
use gg_sdk::{Sdk, SubscribeToTopicPayload};
use std::{thread, time::Duration};

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    let topic = "my/topic";

    let callback = |topic: &str, payload: SubscribeToTopicPayload| match payload
    {
        SubscribeToTopicPayload::Binary(message) => {
            let message = String::from_utf8_lossy(message);
            println!("Received new message on topic {topic}: {message}");
        }
        SubscribeToTopicPayload::Json(_) => {
            println!("Received new message on topic {topic}: (JSON message)");
        }
    };

    let _sub = sdk
        .subscribe_to_topic(topic, &callback)
        .expect("Failed to subscribe to topic");

    println!("Successfully subscribed to topic: {topic}");

    // Keep the main thread alive, or the process will exit.
    loop {
        thread::sleep(Duration::from_secs(10));
    }
}
```

### Exemple d' publish/subscribe éditeur (C)
<a name="ipc-publish-subscribe-example-publisher-c"></a>

L'exemple de recette suivant permet au composant de publier dans toutes les rubriques.

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PubSubPublisherC",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that publishes messages.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.PubSubPublisherC:pubsub:1": {
            "policyDescription": "Allows access to publish to all topics.",
            "operations": ["aws.greengrass#PublishToTopic"],
            "resources": ["*"]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux",
        "runtime": "*"
      },
      "Lifecycle": {
        "run": "{artifacts:path}/sample_publish_to_topic"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.PubSubPublisherC/1.0.0/sample_publish_to_topic",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

L'exemple d'application C suivant montre comment utiliser le service IPC de publication/abonnement pour publier des messages destinés à d'autres composants.

```
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/sdk.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    GgBuffer message = GG_STR("Hello, World");
    GgBuffer topic = GG_STR("my/topic");

    err = ggipc_publish_to_topic_binary(topic, message);
    if (err != GG_ERR_OK) {
        fprintf(
            stderr,
            "Failed to publish to topic: %.*s\n",
            (int) topic.len,
            topic.data
        );
        exit(-1);
    }

    printf(
        "Successfully published to topic: %.*s\n", (int) topic.len, topic.data
    );
}
```

### Exemple publish/subscribe d'abonné (C)
<a name="ipc-publish-subscribe-example-subscriber-c"></a>

L'exemple de recette suivant permet au composant de s'abonner à toutes les rubriques.

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PubSubSubscriberC",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that subscribes to messages.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.PubSubSubscriberC:pubsub:1": {
            "policyDescription": "Allows access to subscribe to all topics.",
            "operations": ["aws.greengrass#SubscribeToTopic"],
            "resources": ["*"]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux",
        "runtime": "*"
      },
      "Lifecycle": {
        "run": "{artifacts:path}/sample_subscribe_to_topic"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.PubSubSubscriberC/1.0.0/sample_subscribe_to_topic",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

L'exemple d'application C suivant montre comment utiliser le service IPC de publication/abonnement pour s'abonner à des messages provenant d'autres composants.

```
#include <assert.h>
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/object.h>
#include <gg/sdk.h>
#include <gg/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

static void on_subscription_response(
    void *ctx, GgBuffer topic, GgObject payload, GgIpcSubscriptionHandle handle
) {
    (void) ctx;
    (void) handle;

    if (gg_obj_type(payload) == GG_TYPE_BUF) {
        GgBuffer message = gg_obj_into_buf(payload);
        printf(
            "Received new message on topic %.*s: %.*s\n",
            (int) topic.len,
            topic.data,
            (int) message.len,
            message.data
        );
    } else {
        assert(gg_obj_type(payload) == GG_TYPE_MAP);
        printf(
            "Received new message on topic %.*s: (JSON message)\n",
            (int) topic.len,
            topic.data
        );
    }
}

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    GgBuffer topic = GG_STR("my/topic");

    GgIpcSubscriptionHandle handle;
    err = ggipc_subscribe_to_topic(
        topic, on_subscription_response, NULL, &handle
    );
    if (err != GG_ERR_OK) {
        fprintf(
            stderr,
            "Failed to subscribe to topic: %.*s\n",
            (int) topic.len,
            topic.data
        );
        exit(-1);
    }

    printf(
        "Successfully subscribed to topic: %.*s\n", (int) topic.len, topic.data
    );

    // Keep the main thread alive, or the process will exit.
    while (1) {
        sleep(10);
    }

    // To stop subscribing, close the stream.
    ggipc_close_subscription(handle);
}
```

### Exemple d' publish/subscribe éditeur (C\$1\$1, SDK de composants)
<a name="ipc-publish-subscribe-example-publisher-cpp-component-sdk"></a>

L'exemple de recette suivant permet au composant de publier dans toutes les rubriques.

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PubSubPublisherCpp",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that publishes messages.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.PubSubPublisherCpp:pubsub:1": {
            "policyDescription": "Allows access to publish to all topics.",
            "operations": ["aws.greengrass#PublishToTopic"],
            "resources": ["*"]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux",
        "runtime": "*"
      },
      "Lifecycle": {
        "run": "{artifacts:path}/sample_cpp_publish_to_topic"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.PubSubPublisherCpp/1.0.0/sample_cpp_publish_to_topic",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

L'exemple d'application C\$1\$1 suivant montre comment utiliser le service IPC de publication/abonnement pour publier des messages destinés à d'autres composants.

```
#include <gg/ipc/client.hpp>
#include <iostream>

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    std::string_view message = "Hello, World";
    std::string_view topic = "my/topic";

    error = client.publish_to_topic(topic, message);
    if (error) {
        std::cerr << "Failed to publish to topic: " << topic << "\n";
        exit(-1);
    }

    std::cout << "Successfully published to topic: " << topic << "\n";
}
```

### Exemple publish/subscribe d'abonné (C\$1\$1, SDK de composants)
<a name="ipc-publish-subscribe-example-subscriber-cpp-component-sdk"></a>

L'exemple de recette suivant permet au composant de s'abonner à toutes les rubriques.

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PubSubSubscriberCpp",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that subscribes to messages.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.pubsub": {
          "com.example.PubSubSubscriberCpp:pubsub:1": {
            "policyDescription": "Allows access to subscribe to all topics.",
            "operations": ["aws.greengrass#SubscribeToTopic"],
            "resources": ["*"]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux",
        "runtime": "*"
      },
      "Lifecycle": {
        "run": "{artifacts:path}/sample_cpp_subscribe_to_topic"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.PubSubSubscriberCpp/1.0.0/sample_cpp_subscribe_to_topic",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

L'exemple d'application C\$1\$1 suivant montre comment utiliser le service IPC de publication/abonnement pour s'abonner à des messages provenant d'autres composants.

```
#include <gg/ipc/client.hpp>
#include <gg/object.hpp>
#include <unistd.h>
#include <cassert>
#include <iostream>

class ResponseHandler : public gg::ipc::LocalTopicCallback {
    void operator()(
        std::string_view topic,
        gg::Object payload,
        gg::ipc::Subscription &handle
    ) override {
        (void) handle;
        if (payload.index() == GG_TYPE_BUF) {
            std::cout << "Received new message on topic " << topic << ": "
                      << get<gg::Buffer>(payload) << "\n";
        } else {
            assert(payload.index() == GG_TYPE_MAP);
            std::cout << "Received new message on topic " << topic
                      << ": (JSON message)\n";
        }
    }
};

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    std::string_view topic = "my/topic";

    static ResponseHandler handler;
    error = client.subscribe_to_topic(topic, handler);
    if (error) {
        std::cerr << "Failed to subscribe to topic: " << topic << "\n";
        exit(-1);
    }

    std::cout << "Successfully subscribed to topic: " << topic << "\n";

    // Keep the main thread alive, or the process will exit.
    while (1) {
        sleep(10);
    }
}
```

# Publier/souscrire AWS IoT Core des messages MQTT
<a name="ipc-iot-core-mqtt"></a>

Le service IPC de messagerie AWS IoT Core MQTT vous permet d'envoyer et de recevoir des messages MQTT depuis et vers. AWS IoT Core Les composants peuvent publier des messages AWS IoT Core et s'abonner à des sujets pour agir sur les messages MQTT provenant d'autres sources. Pour plus d'informations sur l' AWS IoT Core implémentation de MQTT, consultez [MQTT](https://docs.aws.amazon.com/iot/latest/developerguide/mqtt.html) dans le Guide du *AWS IoT Core développeur*.

**Note**  
Ce service IPC de messagerie MQTT vous permet d'échanger des messages avec. AWS IoT Core Pour plus d'informations sur l'échange de messages entre composants, consultez[Publier/souscrire des messages locaux](ipc-publish-subscribe.md).

**Topics**
+ [Versions minimales du SDK](#ipc-iot-core-mqtt-sdk-versions)
+ [Autorisation](#ipc-iot-core-mqtt-authorization)
+ [PublishToIoTCore](#ipc-operation-publishtoiotcore)
+ [SubscribeToIoTCore](#ipc-operation-subscribetoiotcore)
+ [Exemples](#ipc-iot-core-mqtt-examples)

## Versions minimales du SDK
<a name="ipc-iot-core-mqtt-sdk-versions"></a>

Le tableau suivant répertorie les versions minimales Kit SDK des appareils AWS IoT que vous devez utiliser pour publier et vous abonner à des messages MQTT en provenance AWS IoT Core et à destination.


| Kit SDK | Version minimale | 
| --- | --- | 
|  [Kit SDK des appareils AWS IoT pour Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.2.10  | 
|  [Kit SDK des appareils AWS IoT pour Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.5.3  | 
|  [Kit SDK des appareils AWS IoT pour C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [Kit SDK des appareils AWS IoT pour JavaScript v2](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

## Autorisation
<a name="ipc-iot-core-mqtt-authorization"></a>

Pour utiliser la messagerie AWS IoT Core MQTT dans un composant personnalisé, vous devez définir des politiques d'autorisation qui permettent à votre composant d'envoyer et de recevoir des messages sur des sujets. Pour plus d'informations sur la définition des politiques d'autorisation, consultez[Autoriser les composants à effectuer des opérations IPC](interprocess-communication.md#ipc-authorization-policies).

Les politiques d'autorisation pour AWS IoT Core la messagerie MQTT présentent les propriétés suivantes.

**Identifiant du service IPC :** `aws.greengrass.ipc.mqttproxy`


| Opération | Description | Ressources | 
| --- | --- | --- | 
|  `aws.greengrass#PublishToIoTCore`  |  Permet à un composant de publier des messages AWS IoT Core sur les sujets MQTT que vous spécifiez.  |  Chaîne de rubrique, telle que`test/topic`, ou `*` pour autoriser l'accès à toutes les rubriques. Vous pouvez utiliser les caractères génériques des rubriques MQTT (`#`et`+`) pour associer plusieurs ressources.  | 
|  `aws.greengrass#SubscribeToIoTCore`  |  Permet à un composant de s'abonner à des messages provenant AWS IoT Core des sujets que vous spécifiez.  |  Chaîne de rubrique, telle que`test/topic`, ou `*` pour autoriser l'accès à toutes les rubriques. Vous pouvez utiliser les caractères génériques des rubriques MQTT (`#`et`+`) pour associer plusieurs ressources.  | 
|  `*`  |  Permet à un composant de publier des messages AWS IoT Core MQTT et de s'y abonner pour les sujets que vous spécifiez.  |  Chaîne de rubrique, telle que`test/topic`, ou `*` pour autoriser l'accès à toutes les rubriques. Vous pouvez utiliser les caractères génériques des rubriques MQTT (`#`et`+`) pour associer plusieurs ressources.  | 

### Caractères génériques MQTT dans les politiques d'autorisation AWS IoT Core MQTT
<a name="ipc-iot-core-mqtt-authorization-mqtt-wildcards"></a>

Vous pouvez utiliser des caractères génériques MQTT dans les politiques d'autorisation AWS IoT Core MQTT IPC. Les composants peuvent publier et s'abonner à des rubriques qui correspondent au filtre de rubrique que vous autorisez dans une politique d'autorisation. Par exemple, si la politique d'autorisation d'un composant accorde l'accès à`test/topic/#`, le composant peut s'abonner à`test/topic/#`, publier et s'abonner à`test/topic/filter`.

### Variables de recette dans les AWS IoT Core politiques d'autorisation MQTT
<a name="ipc-iot-core-mqtt-authorization-recipe-variables"></a>

Si vous utilisez la version 2.6.0 ou ultérieure du [noyau](greengrass-nucleus-component.md) Greengrass, vous pouvez utiliser la variable de `{iot:thingName}` recette dans les politiques d'autorisation. Cette fonctionnalité vous permet de configurer une politique d'autorisation unique pour un groupe de périphériques principaux, chaque périphérique principal ne pouvant accéder qu'aux rubriques contenant son propre nom. Par exemple, vous pouvez autoriser un composant à accéder à la ressource thématique suivante.

```
devices/{iot:thingName}/messages
```

Pour plus d’informations, consultez [Variables de recette](component-recipe-reference.md#recipe-variables) et [Utiliser des variables de recette dans les mises à jour de fusion](update-component-configurations.md#merge-configuration-update-recipe-variables).

### Exemples de politiques d'autorisation
<a name="ipc-iot-core-mqtt-authorization-policy-examples"></a>

Vous pouvez vous référer aux exemples de politiques d'autorisation suivants pour vous aider à configurer les politiques d'autorisation pour vos composants.

**Example Exemple de politique d'autorisation avec accès illimité**  
L'exemple de politique d'autorisation suivant permet à un composant de publier et de s'abonner à toutes les rubriques.  

```
{
  "accessControl": {
    "aws.greengrass.ipc.mqttproxy": {
      "com.example.MyIoTCorePubSubComponent:mqttproxy:1": {
        "policyDescription": "Allows access to publish/subscribe to all topics.",
        "operations": [
          "aws.greengrass#PublishToIoTCore",
          "aws.greengrass#SubscribeToIoTCore"
        ],
        "resources": [
          "*"
        ]
      }
    }
  }
}
```

```
---
accessControl:
  aws.greengrass.ipc.mqttproxy:
    com.example.MyIoTCorePubSubComponent:mqttproxy:1:
      policyDescription: Allows access to publish/subscribe to all topics.
      operations:
        - aws.greengrass#PublishToIoTCore
        - aws.greengrass#SubscribeToIoTCore
      resources:
        - "*"
```

**Example Exemple de politique d'autorisation avec accès limité**  
L'exemple de politique d'autorisation suivant permet à un composant de publier et de s'abonner à deux rubriques nommées `factory/1/events` et`factory/1/actions`.  

```
{
  "accessControl": {
    "aws.greengrass.ipc.mqttproxy": {
      "com.example.MyIoTCorePubSubComponent:mqttproxy:1": {
        "policyDescription": "Allows access to publish/subscribe to factory 1 topics.",
        "operations": [
          "aws.greengrass#PublishToIoTCore",
          "aws.greengrass#SubscribeToIoTCore"
        ],
        "resources": [
          "factory/1/actions",
          "factory/1/events"
        ]
      }
    }
  }
}
```

```
---
accessControl:
  aws.greengrass.ipc.mqttproxy:
    "com.example.MyIoTCorePubSubComponent:mqttproxy:1":
      policyDescription: Allows access to publish/subscribe to factory 1 topics.
      operations:
        - aws.greengrass#PublishToIoTCore
        - aws.greengrass#SubscribeToIoTCore
      resources:
        - factory/1/actions
        - factory/1/events
```

**Example Exemple de politique d'autorisation pour un groupe de périphériques principaux**  
Cet exemple utilise une fonctionnalité disponible pour les versions 2.6.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. Greengrass nucleus v2.6.0 ajoute la prise en charge de la plupart des [variables de recette](component-recipe-reference.md#recipe-variables), notamment dans les configurations de composants`{iot:thingName}`.
L'exemple de politique d'autorisation suivant permet à un composant de publier et de s'abonner à une rubrique contenant le nom du périphérique principal qui exécute le composant.  

```
{
  "accessControl": {
    "aws.greengrass.ipc.mqttproxy": {
      "com.example.MyIoTCorePubSubComponent:mqttproxy:1": {
        "policyDescription": "Allows access to publish/subscribe to all topics.",
        "operations": [
          "aws.greengrass#PublishToIoTCore",
          "aws.greengrass#SubscribeToIoTCore"
        ],
        "resources": [
          "factory/1/devices/{iot:thingName}/controls"
        ]
      }
    }
  }
}
```

```
---
accessControl:
  aws.greengrass.ipc.mqttproxy:
    "com.example.MyIoTCorePubSubComponent:mqttproxy:1":
      policyDescription: Allows access to publish/subscribe to all topics.
      operations:
        - aws.greengrass#PublishToIoTCore
        - aws.greengrass#SubscribeToIoTCore
      resources:
        - factory/1/devices/{iot:thingName}/controls
```

## PublishToIoTCore
<a name="ipc-operation-publishtoiotcore"></a>

Publie un message MQTT AWS IoT Core sur un sujet.

Lorsque vous publiez des messages MQTT sur AWS IoT Core, il existe un quota de 100 transactions par seconde. Si vous dépassez ce quota, les messages sont mis en file d'attente pour traitement sur l'appareil Greengrass. Il existe également un quota de 512 Ko de données par seconde et un quota de 20 000 publications par seconde à l'échelle du compte (2 000 dans certains Régions AWS cas). Pour plus d'informations sur les limites du courtier de messages MQTT dans AWS IoT Core, consultez les sections [Limites et quotas du courtier de AWS IoT Core messages et du protocole](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#message-broker-limits). 

Si vous dépassez ces quotas, l'appareil Greengrass limite la publication de messages à. AWS IoT Core Les messages sont stockés dans un spouleur en mémoire. Par défaut, la mémoire allouée au spouleur est de 2,5 Mo. Si le spouleur se remplit, les nouveaux messages sont rejetés. Vous pouvez augmenter la taille du spouleur. Pour plus d'informations, consultez la section [Configuration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration)dans la documentation [Noyau de Greengrass](greengrass-nucleus-component.md). Pour éviter de remplir le spouleur et d'avoir à augmenter la mémoire allouée, limitez les demandes de publication à un maximum de 100 demandes par seconde.

Lorsque votre application doit envoyer des messages à un débit plus élevé ou des messages plus volumineux, pensez à utiliser le [Gestionnaire de flux](stream-manager-component.md) pour envoyer des messages à Kinesis Data Streams. Le composant du gestionnaire de flux est conçu pour transférer de gros volumes de données vers le AWS Cloud. Pour de plus amples informations, veuillez consulter [Gérez les flux de données sur les appareils principaux de Greengrass](manage-data-streams.md).

### Demande
<a name="ipc-operation-publishtoiotcore-request"></a>

La demande de cette opération comporte les paramètres suivants :

`topicName`(Python :`topic_name`)  
Rubrique dans laquelle le message doit être publié.

`qos`  <a name="ipc-iot-core-mqtt-qos"></a>
Les QoS MQTT à utiliser. Cette énumération possède `QOS` les valeurs suivantes :  
+ `AT_MOST_ONCE`— QoS 0. Le message MQTT est délivré au plus une fois.
+ `AT_LEAST_ONCE`— QoS 1. Le message MQTT est délivré au moins une fois.

`payload`  
(Facultatif) La charge utile du message sous forme de blob.

Les fonctionnalités suivantes sont disponibles pour la version 2.10.0 et les versions ultérieures [Noyau de Greengrass](greengrass-nucleus-component.md) lors de l'utilisation de MQTT 5. Ces fonctionnalités sont ignorées lorsque vous utilisez MQTT 3.1.1. Le tableau suivant répertorie la version minimale du SDK de l' AWS IoT appareil que vous devez utiliser pour accéder à ces fonctionnalités.


| Kit SDK | Version minimale | 
| --- | --- | 
| [Kit SDK des appareils AWS IoT pour Python](https://github.com/aws/aws-iot-device-sdk-python-v2) v2 | v1.15.0 | 
| [Kit SDK des appareils AWS IoT pour Java](https://github.com/aws/aws-iot-device-sdk-java-v2) v2 | v1.13.0 | 
| [Kit SDK des appareils AWS IoT pour C\$1\$1](https://github.com/aws/aws-iot-device-sdk-cpp-v2) v2 | v1.24.0 | 
| [Kit SDK des appareils AWS IoT pour JavaScript  ](https://github.com/aws/aws-iot-device-sdk-js-v2) v2  | v1.13.0 | 

`payloadFormat`  
(Facultatif) Format de la charge utile du message. Si vous ne définissez pas le`payloadFormat`, le type est supposé être`BYTES`. L'enum possède les valeurs suivantes :   
+ `BYTES`— Le contenu de la charge utile est un blob binaire.
+ `UTF8`— Le contenu de la charge utile est une UTF8 chaîne de caractères.

`retain`  
(Facultatif) Indique s'il faut définir l'option de conservation MQTT sur `true` lors de la publication.

`userProperties`  
(Facultatif) Liste des `UserProperty` objets spécifiques à l'application à envoyer. L'`UserProperty`objet est défini comme suit :  

```
UserProperty:
  key: string
  value: string
```

`messageExpiryIntervalSeconds`  
(Facultatif) Nombre de secondes avant que le message n'expire et ne soit supprimé par le serveur. Si cette valeur n'est pas définie, le message n'expire pas.

`correlationData`  
(Facultatif) Informations ajoutées à la demande qui peuvent être utilisées pour associer une demande à une réponse.

`responseTopic`  
(Facultatif) Rubrique à utiliser pour le message de réponse.

`contentType`  
(Facultatif) Identifiant spécifique à l'application du type de contenu du message.

### Réponse
<a name="ipc-operation-publishtoiotcore-response"></a>

Cette opération ne fournit aucune information dans sa réponse.

### Exemples
<a name="ipc-operation-publishtoiotcore-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Java (IPC client V2) ]

**Example Exemple : publier un message**  

```
package com.aws.greengrass.docs.samples.ipc;

import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClientV2;
import software.amazon.awssdk.aws.greengrass.model.PublishToIoTCoreRequest;
import software.amazon.awssdk.aws.greengrass.model.QOS;
import java.nio.charset.StandardCharsets;

public class PublishToIoTCore {

    public static void main(String[] args) {
        String topic = args[0];
        String message = args[1];
        QOS qos = QOS.get(args[2]);

        try (GreengrassCoreIPCClientV2 ipcClientV2 = GreengrassCoreIPCClientV2.builder().build()) {
            ipcClientV2.publishToIoTCore(new PublishToIoTCoreRequest()
                    .withTopicName(topic)
                    .withPayload(message.getBytes(StandardCharsets.UTF_8))
                    .withQos(qos));
            System.out.println("Successfully published to topic: " + topic);
        } catch (Exception e) {
            System.err.println("Exception occurred.");
            e.printStackTrace();
            System.exit(1);
        }
    }
}
```

------
#### [ Python (IPC client V2) ]

**Example Exemple : publier un message**  
Cet exemple suppose que vous utilisez la version 1.5.4 ou ultérieure de Kit SDK des appareils AWS IoT for Python v2. 

```
import awsiot.greengrasscoreipc.clientv2 as clientV2
                    
topic = 'my/topic'
qos = '1'
payload = 'Hello, World'

ipc_client = clientV2.GreengrassCoreIPCClientV2()
resp = ipc_client.publish_to_iot_core(topic_name=topic, qos=qos, payload=payload)
ipc_client.close()
```

------
#### [ Java (IPC client V1) ]

**Example Exemple : publier un message**  
Cet exemple utilise une `IPCUtils` classe pour créer une connexion au service AWS IoT Greengrass Core IPC. Pour de plus amples informations, veuillez consulter [Connectez-vous au service AWS IoT Greengrass Core IPC](interprocess-communication.md#ipc-service-connect).

```
package com.aws.greengrass.docs.samples.ipc;

import com.aws.greengrass.docs.samples.ipc.util.IPCUtils;
import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClient;
import software.amazon.awssdk.aws.greengrass.PublishToIoTCoreResponseHandler;
import software.amazon.awssdk.aws.greengrass.model.PublishToIoTCoreRequest;
import software.amazon.awssdk.aws.greengrass.model.PublishToIoTCoreResponse;
import software.amazon.awssdk.aws.greengrass.model.QOS;
import software.amazon.awssdk.aws.greengrass.model.UnauthorizedError;
import software.amazon.awssdk.eventstreamrpc.EventStreamRPCConnection;

import java.nio.charset.StandardCharsets;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class PublishToIoTCore {

    public static final int TIMEOUT_SECONDS = 10;

    public static void main(String[] args) {
        String topic = args[0];
        String message = args[1];
        QOS qos = QOS.get(args[2]);
        try (EventStreamRPCConnection eventStreamRPCConnection =
                     IPCUtils.getEventStreamRpcConnection()) {
            GreengrassCoreIPCClient ipcClient =
                    new GreengrassCoreIPCClient(eventStreamRPCConnection);
            PublishToIoTCoreResponseHandler responseHandler =
                    PublishToIoTCore.publishBinaryMessageToTopic(ipcClient, topic, message, qos);
            CompletableFuture<PublishToIoTCoreResponse> futureResponse =
                    responseHandler.getResponse();
            try {
                futureResponse.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
                System.out.println("Successfully published to topic: " + topic);
            } catch (TimeoutException e) {
                System.err.println("Timeout occurred while publishing to topic: " + topic);
            } catch (ExecutionException e) {
                if (e.getCause() instanceof UnauthorizedError) {
                    System.err.println("Unauthorized error while publishing to topic: " + topic);
                } else {
                    throw e;
                }
            }
        } catch (InterruptedException e) {
            System.out.println("IPC interrupted.");
        } catch (ExecutionException e) {
            System.err.println("Exception occurred when using IPC.");
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static PublishToIoTCoreResponseHandler publishBinaryMessageToTopic(GreengrassCoreIPCClient greengrassCoreIPCClient, String topic, String message, QOS qos) {
        PublishToIoTCoreRequest publishToIoTCoreRequest = new PublishToIoTCoreRequest();
        publishToIoTCoreRequest.setTopicName(topic);
        publishToIoTCoreRequest.setPayload(message.getBytes(StandardCharsets.UTF_8));
        publishToIoTCoreRequest.setQos(qos);
        return greengrassCoreIPCClient.publishToIoTCore(publishToIoTCoreRequest, Optional.empty());
    }
}
```

------
#### [ Python (IPC client V1) ]

**Example Exemple : publier un message**  
Cet exemple suppose que vous utilisez la version 1.5.4 ou ultérieure de Kit SDK des appareils AWS IoT for Python v2. 

```
import awsiot.greengrasscoreipc
import awsiot.greengrasscoreipc.client as client
from awsiot.greengrasscoreipc.model import (
    QOS,
    PublishToIoTCoreRequest
)

TIMEOUT = 10

ipc_client = awsiot.greengrasscoreipc.connect()
                    
topic = "my/topic"
message = "Hello, World"
qos = QOS.AT_LEAST_ONCE

request = PublishToIoTCoreRequest()
request.topic_name = topic
request.payload = bytes(message, "utf-8")
request.qos = qos
operation = ipc_client.new_publish_to_iot_core()
operation.activate(request)
future_response = operation.get_response()
future_response.result(TIMEOUT)
```

------
#### [ C\$1\$1 (IPC client V1) ]

**Example Exemple : publier un message**  

```
#include <iostream>

#include <aws/crt/Api.h>
#include <aws/greengrass/GreengrassCoreIpcClient.h>

using namespace Aws::Crt;
using namespace Aws::Greengrass;

class IpcClientLifecycleHandler : public ConnectionLifecycleHandler {
    void OnConnectCallback() override {
        // Handle connection to IPC service.
    }

    void OnDisconnectCallback(RpcError error) override {
        // Handle disconnection from IPC service.
    }

    bool OnErrorCallback(RpcError error) override {
        // Handle IPC service connection error.
        return true;
    }
};

int main() {
    ApiHandle apiHandle(g_allocator);
    Io::EventLoopGroup eventLoopGroup(1);
    Io::DefaultHostResolver socketResolver(eventLoopGroup, 64, 30);
    Io::ClientBootstrap bootstrap(eventLoopGroup, socketResolver);
    IpcClientLifecycleHandler ipcLifecycleHandler;
    GreengrassCoreIpcClient ipcClient(bootstrap);
    auto connectionStatus = ipcClient.Connect(ipcLifecycleHandler).get();
    if (!connectionStatus) {
        std::cerr << "Failed to establish IPC connection: " << connectionStatus.StatusToString() << std::endl;
        exit(-1);
    }

    String message("Hello, World!");
    String topic("my/topic");
    QOS qos = QOS_AT_MOST_ONCE;
    int timeout = 10;

    PublishToIoTCoreRequest request;
    Vector<uint8_t> messageData({message.begin(), message.end()});
    request.SetTopicName(topic);
    request.SetPayload(messageData);
    request.SetQos(qos);

    auto operation = ipcClient.NewPublishToIoTCore();
    auto activate = operation->Activate(request, nullptr);
    activate.wait();

    auto responseFuture = operation->GetResult();
    if (responseFuture.wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout) {
        std::cerr << "Operation timed out while waiting for response from Greengrass Core." << std::endl;
        exit(-1);
    }

    auto response = responseFuture.get();
    if (!response) {
        // Handle error.
        auto errorType = response.GetResultType();
        if (errorType == OPERATION_ERROR) {
            auto *error = response.GetOperationError();
            (void)error;
            // Handle operation error.
        } else {
            // Handle RPC error.
        }
    }

    return 0;
}
```

------
#### [ JavaScript ]

**Example Exemple : publier un message**  

```
    
import * as greengrasscoreipc from "aws-iot-device-sdk-v2/dist/greengrasscoreipc";
import {QOS, PublishToIoTCoreRequest} from "aws-iot-device-sdk-v2/dist/greengrasscoreipc/model";
 
class PublishToIoTCore {
    private ipcClient: greengrasscoreipc.Client
    private readonly topic: string;
 
    constructor() {
        // define your own constructor, e.g.
        this.topic = "<define_your_topic>";
        this.publishToIoTCore().then(r => console.log("Started workflow"));
    }
 
    private async publishToIoTCore() {
        try {
            const request: PublishToIoTCoreRequest = {
                topicName: this.topic,
                qos: QOS.AT_LEAST_ONCE, // you can change this depending on your use case
            }
 
            this.ipcClient = await getIpcClient();
 
            await this.ipcClient.publishToIoTCore(request);
        } catch (e) {
            // parse the error depending on your use cases
            throw e
        }
    }
}
 
 
export async function getIpcClient(){
    try {
        const ipcClient = greengrasscoreipc.createClient();
        await ipcClient.connect()
            .catch(error => {
                // parse the error depending on your use cases
                throw error;
            });
        return ipcClient
    } catch (err) {
        // parse the error depending on your use cases
        throw err
    }
}
 
// starting point
const publishToIoTCore = new PublishToIoTCore();
```

------
#### [ Rust ]

**Example Exemple : publier un message**  

```
use gg_sdk::{Qos, Sdk};

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    let message = b"Hello, World";
    let topic = "my/topic";
    let qos = Qos::AtLeastOnce;

    sdk.publish_to_iot_core(topic, message, qos)
        .expect("Failed to publish to topic");

    println!("Successfully published to topic: {topic}");
}
```

------
#### [ C ]

**Example Exemple : publier un message**  

```
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/sdk.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    GgBuffer message = GG_STR("Hello, World");
    GgBuffer topic = GG_STR("my/topic");
    uint8_t qos = 1;

    err = ggipc_publish_to_iot_core(topic, message, qos);
    if (err != GG_ERR_OK) {
        fprintf(
            stderr,
            "Failed to publish to topic: %.*s\n",
            (int) topic.len,
            topic.data
        );
        exit(-1);
    }

    printf(
        "Successfully published to topic: %.*s\n", (int) topic.len, topic.data
    );
}
```

------
#### [ C\$1\$1 (Component SDK) ]

**Example Exemple : publier un message**  

```
#include <gg/ipc/client.hpp>
#include <iostream>

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    std::string_view message = "Hello, World";
    std::string_view topic = "my/topic";
    uint8_t qos = 1;

    error = client.publish_to_iot_core(topic, message, qos);
    if (error) {
        std::cerr << "Failed to publish to topic: " << topic << "\n";
        exit(-1);
    }

    std::cout << "Successfully published to topic: " << topic << "\n";
}
```

------

## SubscribeToIoTCore
<a name="ipc-operation-subscribetoiotcore"></a>

Abonnez-vous aux messages MQTT à partir d'un AWS IoT Core sujet ou d'un filtre de sujet. Le logiciel de AWS IoT Greengrass base supprime les abonnements lorsque le composant atteint la fin de son cycle de vie.

<a name="ipc-subscribe-operation-note"></a>Il s'agit d'une opération d'abonnement dans le cadre de laquelle vous vous abonnez à un flux de messages d'événements. Pour utiliser cette opération, définissez un gestionnaire de réponse au flux avec des fonctions qui gèrent les messages d'événements, les erreurs et la fermeture du flux. Pour de plus amples informations, veuillez consulter [Abonnez-vous aux diffusions d'événements IPC](interprocess-communication.md#ipc-subscribe-operations).

**Type de message d'événement :** `IoTCoreMessage`

### Demande
<a name="ipc-operation-subscribetoiotcore-request"></a>

La demande de cette opération comporte les paramètres suivants :

`topicName`(Python :`topic_name`)  
Rubrique à laquelle vous souhaitez vous abonner. Vous pouvez utiliser les caractères génériques des rubriques MQTT (`#`et`+`) pour vous abonner à plusieurs rubriques.

`qos`  <a name="ipc-iot-core-mqtt-qos"></a>
Les QoS MQTT à utiliser. Cette énumération possède `QOS` les valeurs suivantes :  
+ `AT_MOST_ONCE`— QoS 0. Le message MQTT est délivré au plus une fois.
+ `AT_LEAST_ONCE`— QoS 1. Le message MQTT est délivré au moins une fois.

### Réponse
<a name="ipc-operation-subscribetoiotcore-response"></a>

La réponse de cette opération contient les informations suivantes :

`messages`  
Le flux de messages MQTT. Cet objet contient `IoTCoreMessage` les informations suivantes :    
`message`  
Le message MQTT. Cet objet contient `MQTTMessage` les informations suivantes :    
`topicName`(Python :`topic_name`)  
Sujet dans lequel le message a été publié.  
`payload`  
(Facultatif) La charge utile du message sous forme de blob.
Les fonctionnalités suivantes sont disponibles pour la version 2.10.0 et les versions ultérieures [Noyau de Greengrass](greengrass-nucleus-component.md) lors de l'utilisation de MQTT 5. Ces fonctionnalités sont ignorées lorsque vous utilisez MQTT 3.1.1. Le tableau suivant répertorie la version minimale du SDK de l' AWS IoT appareil que vous devez utiliser pour accéder à ces fonctionnalités.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/ipc-iot-core-mqtt.html)  
`payloadFormat`  
(Facultatif) Format de la charge utile du message. Si vous ne définissez pas le`payloadFormat`, le type est supposé être`BYTES`. L'enum possède les valeurs suivantes :   
+ `BYTES`— Le contenu de la charge utile est un blob binaire.
+ `UTF8`— Le contenu de la charge utile est une UTF8 chaîne de caractères.  
`retain`  
(Facultatif) Indique s'il faut définir l'option de conservation MQTT sur `true` lors de la publication.  
`userProperties`  
(Facultatif) Liste des `UserProperty` objets spécifiques à l'application à envoyer. L'`UserProperty`objet est défini comme suit :  

```
UserProperty:
  key: string
  value: string
```  
`messageExpiryIntervalSeconds`  
(Facultatif) Nombre de secondes avant que le message n'expire et ne soit supprimé par le serveur. Si cette valeur n'est pas définie, le message n'expire pas.  
`correlationData`  
(Facultatif) Informations ajoutées à la demande qui peuvent être utilisées pour associer une demande à une réponse.  
`responseTopic`  
(Facultatif) Rubrique à utiliser pour le message de réponse.  
`contentType`  
(Facultatif) Identifiant spécifique à l'application du type de contenu du message.

### Exemples
<a name="ipc-operation-subscribetoiotcore-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Java (IPC client V2) ]

**Example Exemple : s'abonner à des messages**  

```
package com.aws.greengrass.docs.samples.ipc;

import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClientV2;
import software.amazon.awssdk.aws.greengrass.SubscribeToIoTCoreResponseHandler;
import software.amazon.awssdk.aws.greengrass.model.QOS;
import software.amazon.awssdk.aws.greengrass.model.IoTCoreMessage;
import software.amazon.awssdk.aws.greengrass.model.SubscribeToIoTCoreRequest;
import software.amazon.awssdk.aws.greengrass.model.SubscribeToIoTCoreResponse;

import java.nio.charset.StandardCharsets;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;


public class SubscribeToIoTCore {

    public static void main(String[] args) {
        String topic = args[0];
        QOS qos = QOS.get(args[1]);

        Consumer<IoTCoreMessage> onStreamEvent = ioTCoreMessage ->
                System.out.printf("Received new message on topic %s: %s%n",
                        ioTCoreMessage.getMessage().getTopicName(),
                        new String(ioTCoreMessage.getMessage().getPayload(), StandardCharsets.UTF_8));

        Optional<Function<Throwable, Boolean>> onStreamError =
                Optional.of(e -> {
                    System.err.println("Received a stream error.");
                    e.printStackTrace();
                    return false;
                });

        Optional<Runnable> onStreamClosed = Optional.of(() ->
                System.out.println("Subscribe to IoT Core stream closed."));

        try (GreengrassCoreIPCClientV2 ipcClientV2 = GreengrassCoreIPCClientV2.builder().build()) {
            SubscribeToIoTCoreRequest request = new SubscribeToIoTCoreRequest()
                    .withTopicName(topic)
                    .withQos(qos);

            GreengrassCoreIPCClientV2.StreamingResponse<SubscribeToIoTCoreResponse, SubscribeToIoTCoreResponseHandler>
                    streamingResponse = ipcClientV2.subscribeToIoTCore(request, onStreamEvent, onStreamError, onStreamClosed);

            streamingResponse.getResponse();
            System.out.println("Successfully subscribed to topic: " + topic);

            // Keep the main thread alive, or the process will exit.
            while (true) {
                Thread.sleep(10000);
            }

            // To stop subscribing, close the stream.
            streamingResponse.getHandler().closeStream();
        } catch (InterruptedException e) {
            System.out.println("Subscribe interrupted.");
        } catch (Exception e) {
            System.err.println("Exception occurred.");
            e.printStackTrace();
            System.exit(1);
        }
    }
}
```

------
#### [ Python (IPC client V2) ]

**Example Exemple : s'abonner à des messages**  
Cet exemple suppose que vous utilisez la version 1.5.4 ou ultérieure de Kit SDK des appareils AWS IoT for Python v2. 

```
import threading
import traceback

import awsiot.greengrasscoreipc.clientv2 as clientV2
                    
topic = 'my/topic'
qos = '1'

def on_stream_event(event):
    try:
        topic_name = event.message.topic_name
        message = str(event.message.payload, 'utf-8')
        print(f'Received new message on topic {topic_name}:  {message}')
    except:
        traceback.print_exc()

def on_stream_error(error):
    # Return True to close stream, False to keep stream open.
    return True  

def on_stream_closed():
    pass

ipc_client = clientV2.GreengrassCoreIPCClientV2()
resp, operation = ipc_client.subscribe_to_iot_core(
    topic_name=topic,
    qos=qos, 
    on_stream_event=on_stream_event,
    on_stream_error=on_stream_error,
    on_stream_closed=on_stream_closed
)

# Keep the main thread alive, or the process will exit.
event = threading.Event()
event.wait()

# To stop subscribing, close the operation stream.
operation.close()
ipc_client.close()
```

------
#### [ Java (IPC client V1) ]

**Example Exemple : s'abonner à des messages**  
Cet exemple utilise une `IPCUtils` classe pour créer une connexion au service AWS IoT Greengrass Core IPC. Pour de plus amples informations, veuillez consulter [Connectez-vous au service AWS IoT Greengrass Core IPC](interprocess-communication.md#ipc-service-connect).

```
package com.aws.greengrass.docs.samples.ipc;

import com.aws.greengrass.docs.samples.ipc.util.IPCUtils;
import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClient;
import software.amazon.awssdk.aws.greengrass.SubscribeToIoTCoreResponseHandler;
import software.amazon.awssdk.aws.greengrass.model.*;
import software.amazon.awssdk.eventstreamrpc.EventStreamRPCConnection;
import software.amazon.awssdk.eventstreamrpc.StreamResponseHandler;

import java.nio.charset.StandardCharsets;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class SubscribeToIoTCore {

    public static final int TIMEOUT_SECONDS = 10;

    public static void main(String[] args) {
        String topic = args[0];
        QOS qos = QOS.get(args[1]);
        try (EventStreamRPCConnection eventStreamRPCConnection =
                     IPCUtils.getEventStreamRpcConnection()) {
            GreengrassCoreIPCClient ipcClient =
                    new GreengrassCoreIPCClient(eventStreamRPCConnection);
            StreamResponseHandler<IoTCoreMessage> streamResponseHandler =
                    new SubscriptionResponseHandler();
            SubscribeToIoTCoreResponseHandler responseHandler =
                    SubscribeToIoTCore.subscribeToIoTCore(ipcClient, topic, qos,
                            streamResponseHandler);
            CompletableFuture<SubscribeToIoTCoreResponse> futureResponse =
                    responseHandler.getResponse();
            try {
                futureResponse.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
                System.out.println("Successfully subscribed to topic: " + topic);
            } catch (TimeoutException e) {
                System.err.println("Timeout occurred while subscribing to topic: " + topic);
            } catch (ExecutionException e) {
                if (e.getCause() instanceof UnauthorizedError) {
                    System.err.println("Unauthorized error while subscribing to topic: " + topic);
                } else {
                    throw e;
                }
            }

            // Keep the main thread alive, or the process will exit.
            try {
                while (true) {
                    Thread.sleep(10000);
                }
            } catch (InterruptedException e) {
                System.out.println("Subscribe interrupted.");
            }

            // To stop subscribing, close the stream.
            responseHandler.closeStream();
        } catch (InterruptedException e) {
            System.out.println("IPC interrupted.");
        } catch (ExecutionException e) {
            System.err.println("Exception occurred when using IPC.");
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static SubscribeToIoTCoreResponseHandler subscribeToIoTCore(GreengrassCoreIPCClient greengrassCoreIPCClient, String topic, QOS qos, StreamResponseHandler<IoTCoreMessage> streamResponseHandler) {
        SubscribeToIoTCoreRequest subscribeToIoTCoreRequest = new SubscribeToIoTCoreRequest();
        subscribeToIoTCoreRequest.setTopicName(topic);
        subscribeToIoTCoreRequest.setQos(qos);
        return greengrassCoreIPCClient.subscribeToIoTCore(subscribeToIoTCoreRequest,
                Optional.of(streamResponseHandler));
    }

    public static class SubscriptionResponseHandler implements StreamResponseHandler<IoTCoreMessage> {

        @Override
        public void onStreamEvent(IoTCoreMessage ioTCoreMessage) {
            try {
                String topic = ioTCoreMessage.getMessage().getTopicName();
                String message = new String(ioTCoreMessage.getMessage().getPayload(),
                        StandardCharsets.UTF_8);
                System.out.printf("Received new message on topic %s: %s%n", topic, message);
            } catch (Exception e) {
                System.err.println("Exception occurred while processing subscription response " +
                        "message.");
                e.printStackTrace();
            }
        }

        @Override
        public boolean onStreamError(Throwable error) {
            System.err.println("Received a stream error.");
            error.printStackTrace();
            return false;
        }

        @Override
        public void onStreamClosed() {
            System.out.println("Subscribe to IoT Core stream closed.");
        }
    }
}
```

------
#### [ Python (IPC client V1) ]

**Example Exemple : s'abonner à des messages**  
Cet exemple suppose que vous utilisez la version 1.5.4 ou ultérieure de Kit SDK des appareils AWS IoT for Python v2. 

```
import time
import traceback

import awsiot.greengrasscoreipc
import awsiot.greengrasscoreipc.client as client
from awsiot.greengrasscoreipc.model import (
    IoTCoreMessage,
    QOS,
    SubscribeToIoTCoreRequest
)

TIMEOUT = 10

ipc_client = awsiot.greengrasscoreipc.connect()

class StreamHandler(client.SubscribeToIoTCoreStreamHandler):
    def __init__(self):
        super().__init__()

    def on_stream_event(self, event: IoTCoreMessage) -> None:
        try:
            message = str(event.message.payload, "utf-8")
            topic_name = event.message.topic_name
            # Handle message.
        except:
            traceback.print_exc()

    def on_stream_error(self, error: Exception) -> bool:
        # Handle error.
        return True  # Return True to close stream, False to keep stream open.

    def on_stream_closed(self) -> None:
        # Handle close.
        pass


topic = "my/topic"
qos = QOS.AT_MOST_ONCE

request = SubscribeToIoTCoreRequest()
request.topic_name = topic
request.qos = qos
handler = StreamHandler()
operation = ipc_client.new_subscribe_to_iot_core(handler)
operation.activate(request)
future_response = operation.get_response() 
future_response.result(TIMEOUT)

# Keep the main thread alive, or the process will exit.
while True:
    time.sleep(10)
                  
# To stop subscribing, close the operation stream.
operation.close()
```

------
#### [ C\$1\$1 (IPC client V1) ]

**Example Exemple : s'abonner à des messages**  

```
#include <iostream>

#include <aws/crt/Api.h>
#include <aws/greengrass/GreengrassCoreIpcClient.h>

using namespace Aws::Crt;
using namespace Aws::Greengrass;

class IoTCoreResponseHandler : public SubscribeToIoTCoreStreamHandler {

    public:
        virtual ~IoTCoreResponseHandler() {}

    private:
        void OnStreamEvent(IoTCoreMessage *response) override {
            auto message = response->GetMessage();
            if (message.has_value() && message.value().GetPayload().has_value()) {
                auto messageBytes = message.value().GetPayload().value();
                std::string messageString(messageBytes.begin(), messageBytes.end());
                std::string topicName = message.value().GetTopicName().value().c_str();
                // Handle message.
            }
        }

        bool OnStreamError(OperationError *error) override {
            // Handle error.
            return false; // Return true to close stream, false to keep stream open.
        }

        void OnStreamClosed() override {
            // Handle close.
        }
};

class IpcClientLifecycleHandler : public ConnectionLifecycleHandler {
    void OnConnectCallback() override {
        // Handle connection to IPC service.
    }

    void OnDisconnectCallback(RpcError error) override {
        // Handle disconnection from IPC service.
    }

    bool OnErrorCallback(RpcError error) override {
        // Handle IPC service connection error.
        return true;
    }
};

int main() {
    ApiHandle apiHandle(g_allocator);
    Io::EventLoopGroup eventLoopGroup(1);
    Io::DefaultHostResolver socketResolver(eventLoopGroup, 64, 30);
    Io::ClientBootstrap bootstrap(eventLoopGroup, socketResolver);
    IpcClientLifecycleHandler ipcLifecycleHandler;
    GreengrassCoreIpcClient ipcClient(bootstrap);
    auto connectionStatus = ipcClient.Connect(ipcLifecycleHandler).get();
    if (!connectionStatus) {
        std::cerr << "Failed to establish IPC connection: " << connectionStatus.StatusToString() << std::endl;
        exit(-1);
    }

    String topic("my/topic");
    QOS qos = QOS_AT_MOST_ONCE;
    int timeout = 10;

    SubscribeToIoTCoreRequest request;
    request.SetTopicName(topic);
    request.SetQos(qos);
    auto streamHandler = MakeShared<IoTCoreResponseHandler>(DefaultAllocator());
    auto operation = ipcClient.NewSubscribeToIoTCore(streamHandler);
    auto activate = operation->Activate(request, nullptr);
    activate.wait();

    auto responseFuture = operation->GetResult();
    if (responseFuture.wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout) {
        std::cerr << "Operation timed out while waiting for response from Greengrass Core." << std::endl;
        exit(-1);
    }

    auto response = responseFuture.get();
    if (!response) {
        // Handle error.
        auto errorType = response.GetResultType();
        if (errorType == OPERATION_ERROR) {
            auto *error = response.GetOperationError();
            (void)error;
            // Handle operation error.
        } else {
            // Handle RPC error.
        }
        exit(-1);
    }

    // Keep the main thread alive, or the process will exit.
    while (true) {
        std::this_thread::sleep_for(std::chrono::seconds(10));
    }

    operation->Close();
    return 0;
}
```

------
#### [ JavaScript ]

**Example Exemple : s'abonner à des messages**  

```
import * as greengrasscoreipc from "aws-iot-device-sdk-v2/dist/greengrasscoreipc";
import {IoTCoreMessage, QOS, SubscribeToIoTCoreRequest} from "aws-iot-device-sdk-v2/dist/greengrasscoreipc/model";
import {RpcError} from "aws-iot-device-sdk-v2/dist/eventstream_rpc";
 
class SubscribeToIoTCore {
    private ipcClient: greengrasscoreipc.Client
    private readonly topic: string;
 
    constructor() {
        // define your own constructor, e.g.
        this.topic = "<define_your_topic>";
        this.subscribeToIoTCore().then(r => console.log("Started workflow"));
    }
 
    private async subscribeToIoTCore() {
        try {
            const request: SubscribeToIoTCoreRequest = {
                topicName: this.topic,
                qos: QOS.AT_LEAST_ONCE, // you can change this depending on your use case
            }
 
            this.ipcClient = await getIpcClient();
 
            const streamingOperation = this.ipcClient.subscribeToIoTCore(request);
 
            streamingOperation.on('message', (message: IoTCoreMessage) => {
                // parse the message depending on your use cases, e.g.
                if (message.message && message.message.payload) {
                    const receivedMessage = message.message.payload.toString();
                }
            });
 
            streamingOperation.on('streamError', (error : RpcError) => {
                // define your own error handling logic
            });
 
            streamingOperation.on('ended', () => {
                // define your own logic
            });
 
            await streamingOperation.activate();
 
            // Keep the main thread alive, or the process will exit.
            await new Promise((resolve) => setTimeout(resolve, 10000))
        } catch (e) {
            // parse the error depending on your use cases
            throw e
        }
    }
}
 
export async function getIpcClient(){
    try {
        const ipcClient = greengrasscoreipc.createClient();
        await ipcClient.connect()
            .catch(error => {
                // parse the error depending on your use cases
                throw error;
            });
        return ipcClient
    } catch (err) {
        // parse the error depending on your use cases
        throw err
    }
}
 
// starting point
const subscribeToIoTCore = new SubscribeToIoTCore();
```

------
#### [ Rust ]

**Example Exemple : s'abonner à des messages**  

```
use gg_sdk::{Qos, Sdk};
use std::{thread, time::Duration};

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    let topic = "my/topic";
    let qos = Qos::AtLeastOnce;

    let callback = |topic: &str, payload: &[u8]| {
        let message = String::from_utf8_lossy(payload);
        println!("Received new message on topic {topic}: {message}");
    };

    let _sub = sdk
        .subscribe_to_iot_core(topic, qos, &callback)
        .expect("Failed to subscribe to topic");

    println!("Successfully subscribed to topic: {topic}");

    // Keep the main thread alive, or the process will exit.
    loop {
        thread::sleep(Duration::from_secs(10));
    }
}
```

------
#### [ C ]

**Example Exemple : s'abonner à des messages**  

```
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/sdk.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

static void on_subscription_response(
    void *ctx, GgBuffer topic, GgBuffer payload, GgIpcSubscriptionHandle handle
) {
    (void) ctx;
    (void) handle;

    printf(
        "Received new message on topic %.*s: %.*s\n",
        (int) topic.len,
        topic.data,
        (int) payload.len,
        payload.data
    );
}

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    GgBuffer topic = GG_STR("my/topic");
    uint8_t qos = 1;

    GgIpcSubscriptionHandle handle;
    err = ggipc_subscribe_to_iot_core(
        topic, qos, on_subscription_response, NULL, &handle
    );
    if (err != GG_ERR_OK) {
        fprintf(
            stderr,
            "Failed to subscribe to topic: %.*s\n",
            (int) topic.len,
            topic.data
        );
        exit(-1);
    }

    printf(
        "Successfully subscribed to topic: %.*s\n", (int) topic.len, topic.data
    );

    // Keep the main thread alive, or the process will exit.
    while (1) {
        sleep(10);
    }

    // To stop subscribing, close the subscription handle.
    ggipc_close_subscription(handle);
}
```

------
#### [ C\$1\$1 (Component SDK) ]

**Example Exemple : s'abonner à des messages**  

```
#include <gg/ipc/client.hpp>
#include <unistd.h>
#include <iostream>

class ResponseHandler : public gg::ipc::IotTopicCallback {
    void operator()(
        std::string_view topic,
        gg::Buffer payload,
        gg::ipc::Subscription &handle
    ) override {
        (void) handle;
        std::cout << "Received new message on topic " << topic << ": "
                  << payload << "\n";
    }
};

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    std::string_view topic = "my/topic";
    uint8_t qos = 1;

    static ResponseHandler handler;
    error = client.subscribe_to_iot_core(topic, qos, handler);
    if (error) {
        std::cerr << "Failed to subscribe to topic: " << topic << "\n";
        exit(-1);
    }

    std::cout << "Successfully subscribed to topic: " << topic << "\n";

    // Keep the main thread alive, or the process will exit.
    while (1) {
        sleep(10);
    }
}
```

------

## Exemples
<a name="ipc-iot-core-mqtt-examples"></a>

Utilisez les exemples suivants pour apprendre à utiliser le service AWS IoT Core MQTT IPC dans vos composants.

### Exemple d'éditeur AWS IoT Core MQTT (C\$1\$1, client IPC V1)
<a name="ipc-iot-core-mqtt-example-publisher-cpp"></a>

L'exemple de recette suivant permet au composant de publier dans toutes les rubriques.

------
#### [ JSON ]

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.IoTCorePublisherCpp",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that publishes MQTT messages to IoT Core.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.mqttproxy": {
          "com.example.IoTCorePublisherCpp:mqttproxy:1": {
            "policyDescription": "Allows access to publish to all topics.",
            "operations": [
              "aws.greengrass#PublishToIoTCore"
            ],
            "resources": [
              "*"
            ]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Lifecycle": {
        "Run": "{artifacts:path}/greengrassv2_iotcore_publisher"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.IoTCorePublisherCpp/1.0.0/greengrassv2_iotcore_publisher",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

------
#### [ YAML ]

```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.IoTCorePublisherCpp
ComponentVersion: 1.0.0
ComponentDescription: A component that publishes MQTT messages to IoT Core.
ComponentPublisher: Amazon
ComponentConfiguration:
  DefaultConfiguration:
    accessControl:
      aws.greengrass.ipc.mqttproxy:
        com.example.IoTCorePublisherCpp:mqttproxy:1:
          policyDescription: Allows access to publish to all topics.
          operations:
            - aws.greengrass#PublishToIoTCore
          resources:
            - "*"
Manifests:
  - Lifecycle:
      Run: "{artifacts:path}/greengrassv2_iotcore_publisher"
    Artifacts:
      - URI: s3://amzn-s3-demo-bucket/artifacts/com.example.IoTCorePublisherCpp/1.0.0/greengrassv2_iotcore_publisher
        Permission:
          Execute: OWNER
```

------

L'exemple d'application C\$1\$1 suivant montre comment utiliser le service AWS IoT Core MQTT IPC pour publier des messages sur. AWS IoT Core

```
#include <iostream>

#include <aws/crt/Api.h>
#include <aws/greengrass/GreengrassCoreIpcClient.h>

using namespace Aws::Crt;
using namespace Aws::Greengrass;

class IpcClientLifecycleHandler : public ConnectionLifecycleHandler {
    void OnConnectCallback() override {
        std::cout << "OnConnectCallback" << std::endl;
    }

    void OnDisconnectCallback(RpcError error) override {
        std::cout << "OnDisconnectCallback: " << error.StatusToString() << std::endl;
        exit(-1);
    }

    bool OnErrorCallback(RpcError error) override {
        std::cout << "OnErrorCallback: " << error.StatusToString() << std::endl;
        return true;
    }
};

int main() {
    String message("Hello from the Greengrass IPC MQTT publisher (C++).");
    String topic("test/topic/cpp");
    QOS qos = QOS_AT_LEAST_ONCE;
    int timeout = 10;

    ApiHandle apiHandle(g_allocator);
    Io::EventLoopGroup eventLoopGroup(1);
    Io::DefaultHostResolver socketResolver(eventLoopGroup, 64, 30);
    Io::ClientBootstrap bootstrap(eventLoopGroup, socketResolver);
    IpcClientLifecycleHandler ipcLifecycleHandler;
    GreengrassCoreIpcClient ipcClient(bootstrap);
    auto connectionStatus = ipcClient.Connect(ipcLifecycleHandler).get();
    if (!connectionStatus) {
        std::cerr << "Failed to establish IPC connection: " << connectionStatus.StatusToString() << std::endl;
        exit(-1);
    }

    while (true) {
        PublishToIoTCoreRequest request;
        Vector<uint8_t> messageData({message.begin(), message.end()});
        request.SetTopicName(topic);
        request.SetPayload(messageData);
        request.SetQos(qos);

        auto operation = ipcClient.NewPublishToIoTCore();
        auto activate = operation->Activate(request, nullptr);
        activate.wait();

        auto responseFuture = operation->GetResult();
        if (responseFuture.wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout) {
            std::cerr << "Operation timed out while waiting for response from Greengrass Core." << std::endl;
            exit(-1);
        }

        auto response = responseFuture.get();
        if (response) {
            std::cout << "Successfully published to topic: " << topic << std::endl;
        } else {
            // An error occurred.
            std::cout << "Failed to publish to topic: " << topic << std::endl;
            auto errorType = response.GetResultType();
            if (errorType == OPERATION_ERROR) {
                auto *error = response.GetOperationError();
                std::cout << "Operation error: " << error->GetMessage().value() << std::endl;
            } else {
                std::cout << "RPC error: " << response.GetRpcError() << std::endl;
            }
            exit(-1);
        }

        std::this_thread::sleep_for(std::chrono::seconds(5));
    }

    return 0;
}
```

### Exemple d'abonné AWS IoT Core MQTT (C\$1\$1, client IPC V1)
<a name="ipc-iot-core-mqtt-example-subscriber-cpp"></a>

L'exemple de recette suivant permet au composant de s'abonner à toutes les rubriques.

------
#### [ JSON ]

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.IoTCoreSubscriberCpp",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that subscribes to MQTT messages from IoT Core.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.mqttproxy": {
          "com.example.IoTCoreSubscriberCpp:mqttproxy:1": {
            "policyDescription": "Allows access to subscribe to all topics.",
            "operations": [
              "aws.greengrass#SubscribeToIoTCore"
            ],
            "resources": [
              "*"
            ]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Lifecycle": {
        "Run": "{artifacts:path}/greengrassv2_iotcore_subscriber"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.IoTCoreSubscriberCpp/1.0.0/greengrassv2_iotcore_subscriber",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

------
#### [ YAML ]

```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.IoTCoreSubscriberCpp
ComponentVersion: 1.0.0
ComponentDescription: A component that subscribes to MQTT messages from IoT Core.
ComponentPublisher: Amazon
ComponentConfiguration:
  DefaultConfiguration:
    accessControl:
      aws.greengrass.ipc.mqttproxy:
        com.example.IoTCoreSubscriberCpp:mqttproxy:1:
          policyDescription: Allows access to subscribe to all topics.
          operations:
            - aws.greengrass#SubscribeToIoTCore
          resources:
            - "*"
Manifests:
  - Lifecycle:
      Run: "{artifacts:path}/greengrassv2_iotcore_subscriber"
    Artifacts:
      - URI: s3://amzn-s3-demo-bucket/artifacts/com.example.IoTCoreSubscriberCpp/1.0.0/greengrassv2_iotcore_subscriber
        Permission:
          Execute: OWNER
```

------

L'exemple d'application C\$1\$1 suivant montre comment utiliser le service AWS IoT Core MQTT IPC pour s'abonner à des messages provenant de. AWS IoT Core

```
#include <iostream>

#include <aws/crt/Api.h>
#include <aws/greengrass/GreengrassCoreIpcClient.h>

using namespace Aws::Crt;
using namespace Aws::Greengrass;

class IoTCoreResponseHandler : public SubscribeToIoTCoreStreamHandler {

    public:
        virtual ~IoTCoreResponseHandler() {}

    private:

        void OnStreamEvent(IoTCoreMessage *response) override {
            auto message = response->GetMessage();
            if (message.has_value() && message.value().GetPayload().has_value()) {
                auto messageBytes = message.value().GetPayload().value();
                std::string messageString(messageBytes.begin(), messageBytes.end());
                std::string messageTopic = message.value().GetTopicName().value().c_str();
                std::cout << "Received new message on topic: " << messageTopic << std::endl;
                std::cout << "Message: " << messageString << std::endl;
            }
        }

        bool OnStreamError(OperationError *error) override {
            std::cout << "Received an operation error: ";
            if (error->GetMessage().has_value()) {
                std::cout << error->GetMessage().value();
            }
            std::cout << std::endl;
            return false; // Return true to close stream, false to keep stream open.
        }

        void OnStreamClosed() override {
            std::cout << "Subscribe to IoT Core stream closed." << std::endl;
        }
};

class IpcClientLifecycleHandler : public ConnectionLifecycleHandler {
    void OnConnectCallback() override {
        std::cout << "OnConnectCallback" << std::endl;
    }

    void OnDisconnectCallback(RpcError error) override {
        std::cout << "OnDisconnectCallback: " << error.StatusToString() << std::endl;
        exit(-1);
    }

    bool OnErrorCallback(RpcError error) override {
        std::cout << "OnErrorCallback: " << error.StatusToString() << std::endl;
        return true;
    }
};

int main() {
    String topic("test/topic/cpp");
    QOS qos = QOS_AT_LEAST_ONCE;
    int timeout = 10;

    ApiHandle apiHandle(g_allocator);
    Io::EventLoopGroup eventLoopGroup(1);
    Io::DefaultHostResolver socketResolver(eventLoopGroup, 64, 30);
    Io::ClientBootstrap bootstrap(eventLoopGroup, socketResolver);
    IpcClientLifecycleHandler ipcLifecycleHandler;
    GreengrassCoreIpcClient ipcClient(bootstrap);
    auto connectionStatus = ipcClient.Connect(ipcLifecycleHandler).get();
    if (!connectionStatus) {
        std::cerr << "Failed to establish IPC connection: " << connectionStatus.StatusToString() << std::endl;
        exit(-1);
    }

    SubscribeToIoTCoreRequest request;
    request.SetTopicName(topic);
    request.SetQos(qos);
    auto streamHandler = MakeShared<IoTCoreResponseHandler>(DefaultAllocator());
    auto operation = ipcClient.NewSubscribeToIoTCore(streamHandler);
    auto activate = operation->Activate(request, nullptr);
    activate.wait();

    auto responseFuture = operation->GetResult();
    if (responseFuture.wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout) {
        std::cerr << "Operation timed out while waiting for response from Greengrass Core." << std::endl;
        exit(-1);
    }

    auto response = responseFuture.get();
    if (response) {
        std::cout << "Successfully subscribed to topic: " << topic << std::endl;
    } else {
        // An error occurred.
        std::cout << "Failed to subscribe to topic: " << topic << std::endl;
        auto errorType = response.GetResultType();
        if (errorType == OPERATION_ERROR) {
            auto *error = response.GetOperationError();
            std::cout << "Operation error: " << error->GetMessage().value() << std::endl;
        } else {
            std::cout << "RPC error: " << response.GetRpcError() << std::endl;
        }
        exit(-1);
    }

    // Keep the main thread alive, or the process will exit.
    while (true) {
        std::this_thread::sleep_for(std::chrono::seconds(10));
    }

    operation->Close();
    return 0;
}
```

### Exemple d'éditeur AWS IoT Core MQTT (Rust)
<a name="ipc-iot-core-mqtt-example-publisher-rust"></a>

L'exemple de recette suivant permet au composant de publier dans toutes les rubriques.

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.IoTCorePublisherRust",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that publishes MQTT messages to IoT Core.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.mqttproxy": {
          "com.example.IoTCorePublisherRust:mqttproxy:1": {
            "policyDescription": "Allows access to publish to all topics.",
            "operations": ["aws.greengrass#PublishToIoTCore"],
            "resources": ["*"]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux",
        "runtime": "*"
      },
      "Lifecycle": {
        "run": "{artifacts:path}/publish_to_iot_core"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.IoTCorePublisherRust/1.0.0/publish_to_iot_core",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

L'exemple d'application Rust suivant montre comment utiliser le service AWS IoT Core MQTT IPC pour publier des messages. AWS IoT Core

```
use gg_sdk::{Qos, Sdk};

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    let message = b"Hello, World";
    let topic = "my/topic";
    let qos = Qos::AtLeastOnce;

    sdk.publish_to_iot_core(topic, message, qos)
        .expect("Failed to publish to topic");

    println!("Successfully published to topic: {topic}");
}
```

### Exemple d'abonné AWS IoT Core MQTT (Rust)
<a name="ipc-iot-core-mqtt-example-subscriber-rust"></a>

L'exemple de recette suivant permet au composant de s'abonner à toutes les rubriques.

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.IoTCoreSubscriberRust",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that subscribes to MQTT messages from IoT Core.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.mqttproxy": {
          "com.example.IoTCoreSubscriberRust:mqttproxy:1": {
            "policyDescription": "Allows access to subscribe to all topics.",
            "operations": ["aws.greengrass#SubscribeToIoTCore"],
            "resources": ["*"]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux",
        "runtime": "*"
      },
      "Lifecycle": {
        "run": "{artifacts:path}/subscribe_to_iot_core"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.IoTCoreSubscriberRust/1.0.0/subscribe_to_iot_core",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

L'exemple d'application Rust suivant montre comment utiliser le service AWS IoT Core MQTT IPC pour s'abonner aux messages de. AWS IoT Core

```
use gg_sdk::{Qos, Sdk};
use std::{thread, time::Duration};

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    let topic = "my/topic";
    let qos = Qos::AtLeastOnce;

    let callback = |topic: &str, payload: &[u8]| {
        let message = String::from_utf8_lossy(payload);
        println!("Received new message on topic {topic}: {message}");
    };

    let _sub = sdk
        .subscribe_to_iot_core(topic, qos, &callback)
        .expect("Failed to subscribe to topic");

    println!("Successfully subscribed to topic: {topic}");

    // Keep the main thread alive, or the process will exit.
    loop {
        thread::sleep(Duration::from_secs(10));
    }
}
```

### Exemple d'éditeur AWS IoT Core MQTT (C)
<a name="ipc-iot-core-mqtt-example-publisher-c"></a>

L'exemple de recette suivant permet au composant de publier dans toutes les rubriques.

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.IoTCorePublisherC",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that publishes MQTT messages to IoT Core.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.mqttproxy": {
          "com.example.IoTCorePublisherC:mqttproxy:1": {
            "policyDescription": "Allows access to publish to all topics.",
            "operations": ["aws.greengrass#PublishToIoTCore"],
            "resources": ["*"]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux",
        "runtime": "*"
      },
      "Lifecycle": {
        "run": "{artifacts:path}/sample_publish_to_iot_core"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.IoTCorePublisherC/1.0.0/sample_publish_to_iot_core",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

L'exemple d'application C suivant montre comment utiliser le service AWS IoT Core MQTT IPC pour publier des messages sur. AWS IoT Core

```
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/sdk.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    GgBuffer message = GG_STR("Hello, World");
    GgBuffer topic = GG_STR("my/topic");
    uint8_t qos = 1;

    err = ggipc_publish_to_iot_core(topic, message, qos);
    if (err != GG_ERR_OK) {
        fprintf(
            stderr,
            "Failed to publish to topic: %.*s\n",
            (int) topic.len,
            topic.data
        );
        exit(-1);
    }

    printf(
        "Successfully published to topic: %.*s\n", (int) topic.len, topic.data
    );
}
```

### Exemple d'abonné AWS IoT Core MQTT (C)
<a name="ipc-iot-core-mqtt-example-subscriber-c"></a>

L'exemple de recette suivant permet au composant de s'abonner à toutes les rubriques.

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.IoTCoreSubscriberC",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that subscribes to MQTT messages from IoT Core.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.mqttproxy": {
          "com.example.IoTCoreSubscriberC:mqttproxy:1": {
            "policyDescription": "Allows access to subscribe to all topics.",
            "operations": ["aws.greengrass#SubscribeToIoTCore"],
            "resources": ["*"]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux",
        "runtime": "*"
      },
      "Lifecycle": {
        "run": "{artifacts:path}/sample_subscribe_to_iot_core"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.IoTCoreSubscriberC/1.0.0/sample_subscribe_to_iot_core",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

L'exemple d'application C suivant montre comment utiliser le service AWS IoT Core MQTT IPC pour s'abonner à des messages provenant de. AWS IoT Core

```
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/sdk.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

static void on_subscription_response(
    void *ctx, GgBuffer topic, GgBuffer payload, GgIpcSubscriptionHandle handle
) {
    (void) ctx;
    (void) handle;

    printf(
        "Received new message on topic %.*s: %.*s\n",
        (int) topic.len,
        topic.data,
        (int) payload.len,
        payload.data
    );
}

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    GgBuffer topic = GG_STR("my/topic");
    uint8_t qos = 1;

    GgIpcSubscriptionHandle handle;
    err = ggipc_subscribe_to_iot_core(
        topic, qos, on_subscription_response, NULL, &handle
    );
    if (err != GG_ERR_OK) {
        fprintf(
            stderr,
            "Failed to subscribe to topic: %.*s\n",
            (int) topic.len,
            topic.data
        );
        exit(-1);
    }

    printf(
        "Successfully subscribed to topic: %.*s\n", (int) topic.len, topic.data
    );

    // Keep the main thread alive, or the process will exit.
    while (1) {
        sleep(10);
    }

    // To stop subscribing, close the subscription handle.
    ggipc_close_subscription(handle);
}
```

### Exemple d'éditeur AWS IoT Core MQTT (C\$1\$1, SDK de composants)
<a name="ipc-iot-core-mqtt-example-publisher-cpp-component-sdk"></a>

L'exemple de recette suivant permet au composant de publier dans toutes les rubriques.

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.IoTCorePublisherCpp",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that publishes MQTT messages to IoT Core.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.mqttproxy": {
          "com.example.IoTCorePublisherCpp:mqttproxy:1": {
            "policyDescription": "Allows access to publish to all topics.",
            "operations": ["aws.greengrass#PublishToIoTCore"],
            "resources": ["*"]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux",
        "runtime": "*"
      },
      "Lifecycle": {
        "run": "{artifacts:path}/sample_cpp_publish_to_iot_core"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.IoTCorePublisherCpp/1.0.0/sample_cpp_publish_to_iot_core",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

L'exemple d'application C\$1\$1 suivant montre comment utiliser le service AWS IoT Core MQTT IPC pour publier des messages sur. AWS IoT Core

```
#include <gg/ipc/client.hpp>
#include <iostream>

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    std::string_view message = "Hello, World";
    std::string_view topic = "my/topic";
    uint8_t qos = 1;

    error = client.publish_to_iot_core(topic, message, qos);
    if (error) {
        std::cerr << "Failed to publish to topic: " << topic << "\n";
        exit(-1);
    }

    std::cout << "Successfully published to topic: " << topic << "\n";
}
```

### Exemple d'abonné AWS IoT Core MQTT (C\$1\$1, SDK de composants)
<a name="ipc-iot-core-mqtt-example-subscriber-cpp-component-sdk"></a>

L'exemple de recette suivant permet au composant de s'abonner à toutes les rubriques.

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.IoTCoreSubscriberCpp",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that subscribes to MQTT messages from IoT Core.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "accessControl": {
        "aws.greengrass.ipc.mqttproxy": {
          "com.example.IoTCoreSubscriberCpp:mqttproxy:1": {
            "policyDescription": "Allows access to subscribe to all topics.",
            "operations": ["aws.greengrass#SubscribeToIoTCore"],
            "resources": ["*"]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux",
        "runtime": "*"
      },
      "Lifecycle": {
        "run": "{artifacts:path}/sample_cpp_subscribe_to_iot_core"
      },
      "Artifacts": [
        {
          "URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.IoTCoreSubscriberCpp/1.0.0/sample_cpp_subscribe_to_iot_core",
          "Permission": {
            "Execute": "OWNER"
          }
        }
      ]
    }
  ]
}
```

L'exemple d'application C\$1\$1 suivant montre comment utiliser le service AWS IoT Core MQTT IPC pour s'abonner à des messages provenant de. AWS IoT Core

```
#include <gg/ipc/client.hpp>
#include <unistd.h>
#include <iostream>

class ResponseHandler : public gg::ipc::IotTopicCallback {
    void operator()(
        std::string_view topic,
        gg::Buffer payload,
        gg::ipc::Subscription &handle
    ) override {
        (void) handle;
        std::cout << "Received new message on topic " << topic << ": "
                  << payload << "\n";
    }
};

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    std::string_view topic = "my/topic";
    uint8_t qos = 1;

    static ResponseHandler handler;
    error = client.subscribe_to_iot_core(topic, qos, handler);
    if (error) {
        std::cerr << "Failed to subscribe to topic: " << topic << "\n";
        exit(-1);
    }

    std::cout << "Successfully subscribed to topic: " << topic << "\n";

    // Keep the main thread alive, or the process will exit.
    while (1) {
        sleep(10);
    }
}
```

# Interagir avec le cycle de vie des composants
<a name="ipc-component-lifecycle"></a>

Utilisez le service IPC du cycle de vie des composants pour :
+ Mettez à jour l'état du composant sur le périphérique principal.
+ Abonnez-vous aux mises à jour de l'état des composants.
+ Empêchez le noyau d'arrêter le composant pour appliquer une mise à jour lors d'un déploiement.
+ Suspendez et reprenez les processus relatifs aux composants.

**Topics**
+ [Versions minimales du SDK](#ipc-component-lifecycle-sdk-versions)
+ [Autorisation](#ipc-component-lifecycle-authorization)
+ [UpdateState](#ipc-operation-updatestate)
+ [SubscribeToComponentUpdates](#ipc-operation-subscribetocomponentupdates)
+ [DeferComponentUpdate](#ipc-operation-defercomponentupdate)
+ [PauseComponent](#ipc-operation-pausecomponent)
+ [ResumeComponent](#ipc-operation-resumecomponent)

## Versions minimales du SDK
<a name="ipc-component-lifecycle-sdk-versions"></a>

Le tableau suivant répertorie les versions minimales Kit SDK des appareils AWS IoT que vous devez utiliser pour interagir avec le cycle de vie des composants.


| Kit SDK | Version minimale | 
| --- | --- | 
|  [Kit SDK des appareils AWS IoT pour Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.2.10  | 
|  [Kit SDK des appareils AWS IoT pour Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.5.3  | 
|  [Kit SDK des appareils AWS IoT pour C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [Kit SDK des appareils AWS IoT pour JavaScript v2](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

## Autorisation
<a name="ipc-component-lifecycle-authorization"></a>

Pour suspendre ou reprendre d'autres composants d'un composant personnalisé, vous devez définir des politiques d'autorisation qui permettent à votre composant de gérer d'autres composants. Pour plus d'informations sur la définition des politiques d'autorisation, consultez[Autoriser les composants à effectuer des opérations IPC](interprocess-communication.md#ipc-authorization-policies).

Les politiques d'autorisation pour la gestion du cycle de vie des composants présentent les propriétés suivantes.

**Identifiant du service IPC :** `aws.greengrass.ipc.lifecycle`


| Opération | Description | Ressources | 
| --- | --- | --- | 
|  `aws.greengrass#PauseComponent`  |  Permet à un composant de suspendre les composants que vous spécifiez.  |  Un nom de composant, ou `*` pour autoriser l'accès à tous les composants.  | 
|  `aws.greengrass#ResumeComponent`  |  Permet à un composant de reprendre les composants que vous spécifiez.  |  Un nom de composant, ou `*` pour autoriser l'accès à tous les composants.  | 
|  `*`  |  Permet à un composant de suspendre et de reprendre les composants que vous spécifiez.  |  Un nom de composant, ou `*` pour autoriser l'accès à tous les composants.  | 

### Exemples de politiques d'autorisation
<a name="ipc-component-lifecycle-authorization-policy-examples"></a>

Vous pouvez vous référer à l'exemple de politique d'autorisation suivant pour vous aider à configurer les politiques d'autorisation pour vos composants.

**Example Exemple de politique d'autorisation**  
L'exemple de politique d'autorisation suivant permet à un composant de suspendre et de reprendre tous les composants.  

```
{
  "accessControl": {
    "aws.greengrass.ipc.lifecycle": {
      "com.example.MyLocalLifecycleComponent:lifecycle:1": {
        "policyDescription": "Allows access to pause/resume all components.",
        "operations": [
          "aws.greengrass#PauseComponent",
          "aws.greengrass#ResumeComponent"
        ],
        "resources": [
          "*"
        ]
      }
    }
  }
}
```

## UpdateState
<a name="ipc-operation-updatestate"></a>

Mettez à jour l'état du composant sur le périphérique principal.

### Demande
<a name="ipc-operation-updatestate-request"></a>

La demande de cette opération comporte les paramètres suivants :

`state`  
État à définir. Cette énumération possède `LifecycleState` les valeurs suivantes :  
+ `RUNNING`
+ `ERRORED`

### Réponse
<a name="ipc-operation-updatestate-response"></a>

Cette opération ne fournit aucune information dans sa réponse.

### Exemples
<a name="ipc-operation-updatestate-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Rust ]

**Example Exemple : état de mise à jour**  

```
use gg_sdk::{ComponentState, Sdk};

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    // Update component state to RUNNING
    sdk.update_state(ComponentState::Running)
        .expect("Failed to update component state");

    println!("Successfully updated component state to RUNNING.");
}
```

------
#### [ C ]

**Example Exemple : état de mise à jour**  

```
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/sdk.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    // Update component state to RUNNING
    err = ggipc_update_state(GG_COMPONENT_STATE_RUNNING);
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to update component state.\n");
        exit(-1);
    }

    printf("Successfully updated component state to RUNNING.\n");
}
```

------
#### [ C\$1\$1 (Component SDK) ]

**Example Exemple : état de mise à jour**  

```
#include <gg/ipc/client.hpp>
#include <iostream>

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    // Update component state to RUNNING
    error = client.update_component_state(GG_COMPONENT_STATE_RUNNING);
    if (error) {
        std::cerr << "Failed to update component state.\n";
        exit(-1);
    }

    std::cout << "Successfully updated component state to RUNNING.\n";
}
```

------

## SubscribeToComponentUpdates
<a name="ipc-operation-subscribetocomponentupdates"></a>

Abonnez-vous pour recevoir des notifications avant que le logiciel AWS IoT Greengrass Core ne mette à jour un composant. La notification indique si le noyau redémarrera ou non dans le cadre de la mise à jour.

Le noyau envoie des notifications de mise à jour uniquement si la politique de mise à jour des composants du déploiement indique de notifier les composants. Le comportement par défaut consiste à notifier les composants. Pour plus d'informations, reportez-vous à la section [Créer des déploiements](create-deployments.md) et à l'[DeploymentComponentUpdatePolicy](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeploymentComponentUpdatePolicy.html)objet que vous pouvez fournir lorsque vous appelez l'[CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html)opération.

**Important**  
Les déploiements locaux ne notifient pas les composants avant les mises à jour.

<a name="ipc-subscribe-operation-note"></a>Il s'agit d'une opération d'abonnement dans le cadre de laquelle vous vous abonnez à un flux de messages d'événements. Pour utiliser cette opération, définissez un gestionnaire de réponse au flux avec des fonctions qui gèrent les messages d'événements, les erreurs et la fermeture du flux. Pour de plus amples informations, veuillez consulter [Abonnez-vous aux diffusions d'événements IPC](interprocess-communication.md#ipc-subscribe-operations).

**Type de message d'événement :** `ComponentUpdatePolicyEvents`

**Astuce**  
Vous pouvez suivre un didacticiel pour apprendre à développer un composant qui reporte de manière conditionnelle les mises à jour des composants. Pour de plus amples informations, veuillez consulter [Tutoriel : Développement d'un composant Greengrass qui reporte les mises à jour des composants](defer-component-updates-tutorial.md).

### Demande
<a name="ipc-operation-subscribetocomponentupdates-request"></a>

La demande de cette opération ne comporte aucun paramètre.

### Réponse
<a name="ipc-operation-subscribetocomponentupdates-response"></a>

La réponse de cette opération contient les informations suivantes :

`messages`  
Le flux de messages de notification. Cet objet contient `ComponentUpdatePolicyEvents` les informations suivantes :    
`preUpdateEvent`(Python :`pre_update_event`)  
(Facultatif) Evénement indiquant que le noyau souhaite mettre à jour un composant. Vous pouvez répondre par une [DeferComponentUpdate](#ipc-operation-defercomponentupdate) opération visant à accuser réception ou à différer la mise à jour jusqu'à ce que le composant soit prêt à redémarrer. Cet objet contient `PreComponentUpdateEvent` les informations suivantes :    
`deploymentId`(Python :`deployment_id`)  
ID du AWS IoT Greengrass déploiement qui met à jour le composant.  
`isGgcRestarting`(Python :`is_ggc_restarting`)  
Si le noyau doit ou non redémarrer pour appliquer la mise à jour.  
`postUpdateEvent`(Python :`post_update_event`)  
(Facultatif) Evénement indiquant que le noyau a mis à jour un composant. Cet objet contient `PostComponentUpdateEvent` les informations suivantes :    
`deploymentId`(Python :`deployment_id`)  
ID du AWS IoT Greengrass déploiement qui a mis à jour le composant.  
Cette fonctionnalité nécessite la version 2.7.0 ou ultérieure du composant Greengrass nucleus.

## DeferComponentUpdate
<a name="ipc-operation-defercomponentupdate"></a>

Reconnaissez ou reportez une mise à jour d'un composant que vous découvrez avec[SubscribeToComponentUpdates](#ipc-operation-subscribetocomponentupdates). Vous spécifiez le délai d'attente avant que le noyau vérifie à nouveau si votre composant est prêt à être mis à jour. Vous pouvez également utiliser cette opération pour indiquer au noyau que votre composant est prêt pour la mise à jour.

Si un composant ne répond pas à la notification de mise à jour du composant, le noyau attend le délai que vous spécifiez dans la politique de mise à jour des composants du déploiement. Après ce délai, le noyau procède au déploiement. Le délai de mise à jour des composants par défaut est de 60 secondes. Pour plus d'informations, reportez-vous à la section [Créer des déploiements](create-deployments.md) et à l'[DeploymentComponentUpdatePolicy](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeploymentComponentUpdatePolicy.html)objet que vous pouvez fournir lorsque vous appelez l'[CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html)opération.

**Astuce**  
Vous pouvez suivre un didacticiel pour apprendre à développer un composant qui reporte de manière conditionnelle les mises à jour des composants. Pour de plus amples informations, veuillez consulter [Tutoriel : Développement d'un composant Greengrass qui reporte les mises à jour des composants](defer-component-updates-tutorial.md).

### Demande
<a name="ipc-operation-defercomponentupdate-request"></a>

La demande de cette opération comporte les paramètres suivants :

`deploymentId`(Python :`deployment_id`)  
ID du AWS IoT Greengrass déploiement à reporter.

`message`  
(Facultatif) Nom du composant dont les mises à jour doivent être différées.  
La valeur par défaut est le nom du composant qui fait la demande.

`recheckAfterMs`(Python :`recheck_after_ms`)  
Durée en millisecondes pendant laquelle la mise à jour doit être différée. Le noyau attend ce laps de temps puis en envoie un autre avec `PreComponentUpdateEvent` [SubscribeToComponentUpdates](#ipc-operation-subscribetocomponentupdates) lequel vous pouvez le découvrir.  
Spécifiez `0` pour accuser réception de la mise à jour. Cela indique au noyau que votre composant est prêt pour la mise à jour.  
La valeur par défaut est zéro milliseconde, ce qui signifie que la mise à jour est confirmée.

### Réponse
<a name="ipc-operation-defercomponentupdate-response"></a>

Cette opération ne fournit aucune information dans sa réponse.

## PauseComponent
<a name="ipc-operation-pausecomponent"></a>

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

Suspend les processus d'un composant sur le périphérique principal. Pour reprendre un composant, utilisez l'[ResumeComponent](#ipc-operation-resumecomponent)opération.

Vous ne pouvez suspendre que les composants génériques. Si vous essayez de suspendre un autre type de composant, cette opération génère un`InvalidRequestError`.

**Note**  
Cette opération ne peut pas suspendre les processus conteneurisés, tels que les conteneurs Docker. Pour suspendre et reprendre un conteneur Docker, vous pouvez utiliser les commandes [docker pause et [docker](https://docs.docker.com/engine/reference/commandline/unpause/)](https://docs.docker.com/engine/reference/commandline/pause/) unpause.

Cette opération ne met pas en pause les dépendances des composants ni les composants qui dépendent du composant que vous interrompez. Tenez compte de ce comportement lorsque vous suspendez un composant dépendant d'un autre composant, car le composant dépendant peut rencontrer des problèmes lorsque sa dépendance est suspendue.

Lorsque vous redémarrez ou arrêtez un composant suspendu, par exemple lors d'un déploiement, le noyau Greengrass reprend le composant et exécute son cycle de vie d'arrêt. Pour plus d'informations sur le redémarrage d'un composant, consultez[RestartComponent](ipc-local-deployments-components.md#ipc-operation-restartcomponent).

**Important**  
Pour utiliser cette opération, vous devez définir une politique d'autorisation qui accorde l'autorisation d'utiliser cette opération. Pour de plus amples informations, veuillez consulter [Autorisation](#ipc-component-lifecycle-authorization).

### Versions minimales du SDK
<a name="ipc-operation-pausecomponent-sdk-versions"></a>

Le tableau suivant répertorie les versions minimales Kit SDK des appareils AWS IoT que vous devez utiliser pour suspendre et reprendre les composants.


| Kit SDK | Version minimale | 
| --- | --- | 
|  [Kit SDK des appareils AWS IoT pour Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.4.3  | 
|  [Kit SDK des appareils AWS IoT pour Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.6.2  | 
|  [Kit SDK des appareils AWS IoT pour C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.13.1  | 
|  [Kit SDK des appareils AWS IoT pour JavaScript v2](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

### Demande
<a name="ipc-operation-defercomponentupdate-request"></a>

La demande de cette opération comporte les paramètres suivants :

`componentName`(Python :`component_name`)  
Nom du composant à suspendre, qui doit être un composant générique. Pour de plus amples informations, veuillez consulter [Types de composants](develop-greengrass-components.md#component-types).

### Réponse
<a name="ipc-operation-defercomponentupdate-response"></a>

Cette opération ne fournit aucune information dans sa réponse.

## ResumeComponent
<a name="ipc-operation-resumecomponent"></a>

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

Reprend les processus d'un composant sur le périphérique principal. Pour suspendre un composant, utilisez l'[PauseComponent](#ipc-operation-pausecomponent)opération.

Vous ne pouvez reprendre que les composants en pause. Si vous essayez de reprendre un composant qui n'est pas en pause, cette opération lance un`InvalidRequestError`.

**Important**  
Pour utiliser cette opération, vous devez définir une politique d'autorisation qui accorde l'autorisation de le faire. Pour de plus amples informations, veuillez consulter [Autorisation](#ipc-component-lifecycle-authorization).

### Versions minimales du SDK
<a name="ipc-operation-resumecomponent-sdk-versions"></a>

Le tableau suivant répertorie les versions minimales Kit SDK des appareils AWS IoT que vous devez utiliser pour suspendre et reprendre les composants.


| Kit SDK | Version minimale | 
| --- | --- | 
|  [Kit SDK des appareils AWS IoT pour Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.4.3  | 
|  [Kit SDK des appareils AWS IoT pour Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.6.2  | 
|  [Kit SDK des appareils AWS IoT pour C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.13.1  | 
|  [Kit SDK des appareils AWS IoT pour JavaScript v2](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

### Demande
<a name="ipc-operation-defercomponentupdate-request"></a>

La demande de cette opération comporte les paramètres suivants :

`componentName`(Python :`component_name`)  
Nom du composant à reprendre.

### Réponse
<a name="ipc-operation-defercomponentupdate-response"></a>

Cette opération ne fournit aucune information dans sa réponse.

# Interagir avec la configuration des composants
<a name="ipc-component-configuration"></a>

Le service IPC de configuration des composants vous permet d'effectuer les opérations suivantes :
+ Obtenez et définissez les paramètres de configuration des composants.
+ Abonnez-vous aux mises à jour de configuration des composants.
+ Validez les mises à jour de configuration des composants avant que le noyau ne les applique.

**Topics**
+ [Versions minimales du SDK](#ipc-component-configuration-sdk-versions)
+ [GetConfiguration](#ipc-operation-getconfiguration)
+ [UpdateConfiguration](#ipc-operation-updateconfiguration)
+ [SubscribeToConfigurationUpdate](#ipc-operation-subscribetoconfigurationupdate)
+ [SubscribeToValidateConfigurationUpdates](#ipc-operation-subscribetovalidateconfigurationupdates)
+ [SendConfigurationValidityReport](#ipc-operation-sendconfigurationvalidityreport)

## Versions minimales du SDK
<a name="ipc-component-configuration-sdk-versions"></a>

Le tableau suivant répertorie les versions minimales Kit SDK des appareils AWS IoT que vous devez utiliser pour interagir avec la configuration des composants.


| Kit SDK | Version minimale | 
| --- | --- | 
|  [Kit SDK des appareils AWS IoT pour Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.2.10  | 
|  [Kit SDK des appareils AWS IoT pour Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.5.3  | 
|  [Kit SDK des appareils AWS IoT pour C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [Kit SDK des appareils AWS IoT pour JavaScript v2](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

## GetConfiguration
<a name="ipc-operation-getconfiguration"></a>

Obtient une valeur de configuration pour un composant sur le périphérique principal. Vous spécifiez le chemin clé pour lequel vous souhaitez obtenir une valeur de configuration.

### Demande
<a name="ipc-operation-getconfiguration-request"></a>

La demande de cette opération comporte les paramètres suivants :

`componentName`(Python :`component_name`)  <a name="ipc-configuration-request-component-name"></a>
(Facultatif) Le nom du composant.  
La valeur par défaut est le nom du composant qui fait la demande.

`keyPath`(Python :`key_path`)  
Le chemin clé vers la valeur de configuration. Spécifiez une liste dans laquelle chaque entrée est la clé d'un seul niveau de l'objet de configuration. Par exemple, spécifiez `["mqtt", "port"]` d'obtenir la valeur de `port` dans la configuration suivante.  

```
{
  "mqtt": {
    "port": 443
  }
}
```
Pour obtenir la configuration complète du composant, spécifiez une liste vide.

### Réponse
<a name="ipc-operation-getconfiguration-response"></a>

La réponse de cette opération contient les informations suivantes :

`componentName`(Python :`component_name`)  <a name="ipc-configuration-response-component-name"></a>
Le nom du composant.

`value`  
La configuration demandée sous forme d'objet.

### Exemples
<a name="ipc-operation-getconfiguration-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Rust ]

**Example Exemple : Obtenir la configuration**  

```
use core::mem::MaybeUninit;
use gg_sdk::{Sdk, UnpackedObject};

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    // Get a configuration value at key path ["mqtt", "port"]
    let mut buf = [MaybeUninit::uninit(); 1024];

    let value = sdk
        .get_config(&["mqtt", "port"], None, &mut buf)
        .expect("Failed to get configuration");

    if let UnpackedObject::I64(port) = value.unpack() {
        println!("Configuration value: {port}");
    }
}
```

------
#### [ C ]

**Example Exemple : Obtenir la configuration**  

```
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/object.h>
#include <gg/sdk.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    // Get a configuration value at key path ["mqtt", "port"]
    uint8_t response_mem[1024];
    GgObject value;

    err = ggipc_get_config(
        GG_BUF_LIST(GG_STR("mqtt"), GG_STR("port")),
        NULL, // component_name (NULL = current component)
        GG_BUF(response_mem),
        &value
    );
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to get configuration.\n");
        exit(-1);
    }

    if (gg_obj_type(value) == GG_TYPE_I64) {
        printf("Configuration value: %" PRId64 "\n", gg_obj_into_i64(value));
    } else if (gg_obj_type(value) == GG_TYPE_BUF) {
        GgBuffer buf = gg_obj_into_buf(value);
        printf("Configuration value: %.*s\n", (int) buf.len, buf.data);
    } else {
        printf("Configuration value is of unexpected type.\n");
    }
}
```

------
#### [ C\$1\$1 (Component SDK) ]

**Example Exemple : Obtenir la configuration**  

```
#include <gg/ipc/client.hpp>
#include <iostream>

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    // Get a configuration value at key path ["mqtt", "port"]
    std::array key_path = { gg::Buffer { "mqtt" }, gg::Buffer { "port" } };
    int64_t value = 0;

    error = client.get_config(key_path, std::nullopt, value);
    if (error) {
        std::cerr << "Failed to get configuration.\n";
        exit(-1);
    }

    std::cout << "Configuration value: " << value << "\n";
}
```

------

## UpdateConfiguration
<a name="ipc-operation-updateconfiguration"></a>

Met à jour une valeur de configuration pour ce composant sur le périphérique principal.

### Demande
<a name="ipc-operation-updateconfiguration-request"></a>

La demande de cette opération comporte les paramètres suivants :

`keyPath`(Python :`key_path`)  
(Facultatif) Le chemin clé vers le nœud de conteneur (l'objet) à mettre à jour. Spécifiez une liste dans laquelle chaque entrée est la clé d'un seul niveau de l'objet de configuration. Par exemple, spécifiez le chemin clé `["mqtt"]` et la valeur de fusion `{ "port": 443 }` dont vous souhaitez définir la valeur `port` dans la configuration suivante.  

```
{
  "mqtt": {
    "port": 443
  }
}
```
Le chemin clé doit spécifier un nœud de conteneur (un objet) dans la configuration. Si le nœud n'existe pas dans la configuration du composant, cette opération le crée et attribue sa valeur à l'objet dans`valueToMerge`.  
La valeur par défaut est la racine de l'objet de configuration.

`timestamp`  
Durée actuelle de l'époque Unix en millisecondes. Cette opération utilise cet horodatage pour résoudre les mises à jour simultanées de la clé. Si la clé de la configuration du composant possède un horodatage supérieur à celui de la demande, la demande échoue.

`valueToMerge`(Python :`value_to_merge`)  
L'objet de configuration à fusionner à l'emplacement que vous spécifiez`keyPath`. Pour de plus amples informations, veuillez consulter [Mettre à jour les configurations des composants](update-component-configurations.md).

### Réponse
<a name="ipc-operation-updateconfiguration-response"></a>

Cette opération ne fournit aucune information dans sa réponse.

### Exemples
<a name="ipc-operation-updateconfiguration-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Rust ]

**Example Exemple : mise à jour de la configuration**  

```
use gg_sdk::Sdk;

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    // Update configuration value at key path ["mqtt", "port"] to 443
    sdk.update_config(&["mqtt", "port"], None, 443)
        .expect("Failed to update configuration");

    println!("Successfully updated configuration.");
}
```

------
#### [ C ]

**Example Exemple : mise à jour de la configuration**  

```
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/object.h>
#include <gg/sdk.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    // Update configuration value at key path ["mqtt", "port"] to 443
    err = ggipc_update_config(
        GG_BUF_LIST(GG_STR("mqtt"), GG_STR("port")),
        NULL, // timestamp (NULL = current time)
        gg_obj_i64(443)
    );
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to update configuration.\n");
        exit(-1);
    }

    printf("Successfully updated configuration.\n");
}
```

------
#### [ C\$1\$1 (Component SDK) ]

**Example Exemple : mise à jour de la configuration**  

```
#include <gg/ipc/client.hpp>
#include <iostream>

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    // Update configuration value at key path ["mqtt", "port"] to 443
    std::array key_path = { gg::Buffer { "mqtt" }, gg::Buffer { "port" } };

    error = client.update_config(key_path, 443);
    if (error) {
        std::cerr << "Failed to update configuration.\n";
        exit(-1);
    }

    std::cout << "Successfully updated configuration.\n";
}
```

------

## SubscribeToConfigurationUpdate
<a name="ipc-operation-subscribetoconfigurationupdate"></a>

Abonnez-vous pour recevoir des notifications lorsque la configuration d'un composant est mise à jour. Lorsque vous vous abonnez à une clé, vous recevez une notification lorsqu'un enfant porteur de cette clé est mis à jour.

<a name="ipc-subscribe-operation-note"></a>Il s'agit d'une opération d'abonnement dans le cadre de laquelle vous vous abonnez à un flux de messages d'événements. Pour utiliser cette opération, définissez un gestionnaire de réponse au flux avec des fonctions qui gèrent les messages d'événements, les erreurs et la fermeture du flux. Pour de plus amples informations, veuillez consulter [Abonnez-vous aux diffusions d'événements IPC](interprocess-communication.md#ipc-subscribe-operations).

**Type de message d'événement :** `ConfigurationUpdateEvents`

### Demande
<a name="ipc-operation-subscribetoconfigurationupdate-request"></a>

La demande de cette opération comporte les paramètres suivants :

`componentName`(Python :`component_name`)  <a name="ipc-configuration-request-component-name"></a>
(Facultatif) Le nom du composant.  
La valeur par défaut est le nom du composant qui fait la demande.

`keyPath`(Python :`key_path`)  
Le chemin clé vers la valeur de configuration à laquelle vous souhaitez vous abonner. Spécifiez une liste dans laquelle chaque entrée est la clé d'un seul niveau de l'objet de configuration. Par exemple, spécifiez `["mqtt", "port"]` d'obtenir la valeur de `port` dans la configuration suivante.  

```
{
  "mqtt": {
    "port": 443
  }
}
```
Pour vous abonner aux mises à jour pour toutes les valeurs de la configuration du composant, spécifiez une liste vide.

### Réponse
<a name="ipc-operation-subscribetoconfigurationupdate-response"></a>

La réponse de cette opération contient les informations suivantes :

`messages`  
Le flux de messages de notification. Cet objet contient `ConfigurationUpdateEvents` les informations suivantes :    
`configurationUpdateEvent`(Python :`configuration_update_event`)  
L'événement de mise à jour de configuration. Cet objet contient `ConfigurationUpdateEvent` les informations suivantes :    
`componentName`(Python :`component_name`)  <a name="ipc-configuration-response-component-name"></a>
Le nom du composant.  
`keyPath`(Python :`key_path`)  
Le chemin clé vers la valeur de configuration mise à jour.

### Exemples
<a name="ipc-operation-subscribetoconfigurationupdate-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Rust ]

**Example Exemple : s'abonner aux mises à jour de configuration**  

```
use gg_sdk::Sdk;
use std::{thread, time::Duration};

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    // Subscribe to configuration updates for key path ["mqtt"]
    let callback = |component_name: &str, key_path: &[&str]| {
        println!(
            "Received configuration update for component: {component_name}"
        );
        println!("Key path: {key_path:?}");
    };

    let _sub = sdk
        .subscribe_to_configuration_update(None, &["mqtt"], &callback)
        .expect("Failed to subscribe to configuration updates");

    println!("Successfully subscribed to configuration updates.");

    // Keep the main thread alive, or the process will exit.
    loop {
        thread::sleep(Duration::from_secs(10));
    }
}
```

------
#### [ C ]

**Example Exemple : s'abonner aux mises à jour de configuration**  

```
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/object.h>
#include <gg/sdk.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

static void on_subscription_response(
    void *ctx,
    GgBuffer component_name,
    GgList key_path,
    GgIpcSubscriptionHandle handle
) {
    (void) ctx;
    (void) handle;

    printf(
        "Received configuration update for component: %.*s\n",
        (int) component_name.len,
        component_name.data
    );

    printf("Key path: [");
    for (size_t i = 0; i < key_path.len; i++) {
        if (i > 0) {
            printf(", ");
        }
        GgObject *obj = &key_path.items[i];
        if (gg_obj_type(*obj) == GG_TYPE_BUF) {
            GgBuffer key = gg_obj_into_buf(*obj);
            printf("\"%.*s\"", (int) key.len, key.data);
        }
    }
    printf("]\n");
}

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    // Subscribe to configuration updates for key path ["mqtt"]
    GgIpcSubscriptionHandle handle;
    err = ggipc_subscribe_to_configuration_update(
        NULL, // component_name (NULL = current component)
        GG_BUF_LIST(GG_STR("mqtt")),
        on_subscription_response,
        NULL,
        &handle
    );
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to subscribe to configuration updates.\n");
        exit(-1);
    }

    printf("Successfully subscribed to configuration updates.\n");

    // Keep the main thread alive, or the process will exit.
    while (1) {
        sleep(10);
    }

    // To stop subscribing, close the stream.
    ggipc_close_subscription(handle);
}
```

------
#### [ C\$1\$1 (Component SDK) ]

**Example Exemple : s'abonner aux mises à jour de configuration**  

```
#include <gg/ipc/client.hpp>
#include <unistd.h>
#include <iostream>

class ResponseHandler : public gg::ipc::ConfigurationUpdateCallback {
    void operator()(
        std::string_view component_name,
        gg::List key_path,
        gg::ipc::Subscription &handle
    ) override {
        (void) handle;
        std::cout << "Received configuration update for component: "
                  << component_name << "\n";
        std::cout << "Key path: [";
        for (size_t i = 0; i < key_path.size(); i++) {
            if (i > 0) {
                std::cout << ", ";
            }
            std::cout << "\"" << get<gg::Buffer>(key_path[i]) << "\"";
        }
        std::cout << "]\n";
    }
};

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    // Subscribe to configuration updates for key path ["mqtt"]
    std::array key_path = { gg::Buffer { "mqtt" } };

    static ResponseHandler handler;
    error = client.subscribe_to_configuration_update(
        key_path, std::nullopt, handler
    );
    if (error) {
        std::cerr << "Failed to subscribe to configuration updates.\n";
        exit(-1);
    }

    std::cout << "Successfully subscribed to configuration updates.\n";

    // Keep the main thread alive, or the process will exit.
    while (1) {
        sleep(10);
    }
}
```

------

## SubscribeToValidateConfigurationUpdates
<a name="ipc-operation-subscribetovalidateconfigurationupdates"></a>

Abonnez-vous pour recevoir des notifications avant les mises à jour de configuration de ce composant. Cela permet aux composants de valider les mises à jour de leur propre configuration. Utilisez cette [SendConfigurationValidityReport](#ipc-operation-sendconfigurationvalidityreport) opération pour indiquer au noyau si la configuration est valide ou non.

**Important**  
Les déploiements locaux n'informent pas les composants des mises à jour.

<a name="ipc-subscribe-operation-note"></a>Il s'agit d'une opération d'abonnement dans le cadre de laquelle vous vous abonnez à un flux de messages d'événements. Pour utiliser cette opération, définissez un gestionnaire de réponse au flux avec des fonctions qui gèrent les messages d'événements, les erreurs et la fermeture du flux. Pour de plus amples informations, veuillez consulter [Abonnez-vous aux diffusions d'événements IPC](interprocess-communication.md#ipc-subscribe-operations).

**Type de message d'événement :** `ValidateConfigurationUpdateEvents`

### Demande
<a name="ipc-operation-subscribetovalidateconfigurationupdates-request"></a>

La demande de cette opération ne comporte aucun paramètre.

### Réponse
<a name="ipc-operation-subscribetovalidateconfigurationupdates-response"></a>

La réponse de cette opération contient les informations suivantes :

`messages`  
Le flux de messages de notification. Cet objet contient `ValidateConfigurationUpdateEvents` les informations suivantes :    
`validateConfigurationUpdateEvent`(Python :`validate_configuration_update_event`)  
L'événement de mise à jour de configuration. Cet objet contient `ValidateConfigurationUpdateEvent` les informations suivantes :    
`deploymentId`(Python :`deployment_id`)  
ID du AWS IoT Greengrass déploiement qui met à jour le composant.  
`configuration`  
Objet contenant la nouvelle configuration.

## SendConfigurationValidityReport
<a name="ipc-operation-sendconfigurationvalidityreport"></a>

Indiquez au noyau si une mise à jour de configuration de ce composant est valide ou non. Le déploiement échoue si vous indiquez au noyau que la nouvelle configuration n'est pas valide. Utilisez l'[SubscribeToValidateConfigurationUpdates](#ipc-operation-subscribetovalidateconfigurationupdates)opération pour vous abonner afin de valider les mises à jour de configuration.

Si un composant ne répond pas à une notification de mise à jour de configuration validée, le noyau attend le délai que vous spécifiez dans la politique de validation de configuration du déploiement. Après ce délai, le noyau procède au déploiement. Le délai de validation du composant par défaut est de 20 secondes. Pour plus d'informations, reportez-vous à la section [Créer des déploiements](create-deployments.md) et à l'[DeploymentConfigurationValidationPolicy](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeploymentConfigurationValidationPolicy.html)objet que vous pouvez fournir lorsque vous appelez l'[CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html)opération.

### Demande
<a name="ipc-operation-sendconfigurationvalidityreport-request"></a>

La demande de cette opération comporte les paramètres suivants :

`configurationValidityReport`(Python :`configuration_validity_report`)  
Le rapport qui indique au noyau si la mise à jour de configuration est valide ou non. Cet objet contient `ConfigurationValidityReport` les informations suivantes :    
`status`  
Le statut de validité. Cette énumération possède `ConfigurationValidityStatus` les valeurs suivantes :  
+ `ACCEPTED`— La configuration est valide et le noyau peut l'appliquer à ce composant.
+ `REJECTED`— La configuration n'est pas valide et le déploiement échoue.  
`deploymentId`(Python :`deployment_id`)  
ID du AWS IoT Greengrass déploiement qui a demandé la mise à jour de configuration.  
`message`  
(Facultatif) Message indiquant pourquoi la configuration n'est pas valide.

### Réponse
<a name="ipc-operation-sendconfigurationvalidityreport-response"></a>

Cette opération ne fournit aucune information dans sa réponse.

# Récupérez les valeurs secrètes
<a name="ipc-secret-manager"></a>

Utilisez le service IPC du gestionnaire de secrets pour récupérer les valeurs secrètes des secrets du périphérique principal. Vous utilisez le [composant gestionnaire de secrets](secret-manager-component.md) pour déployer des secrets chiffrés sur les appareils principaux. Vous pouvez ensuite utiliser une opération IPC pour déchiffrer le secret et utiliser sa valeur dans vos composants personnalisés.

**Topics**
+ [Versions minimales du SDK](#ipc-secret-manager-sdk-versions)
+ [Autorisation](#ipc-secret-manager-authorization)
+ [GetSecretValue](#ipc-operation-getsecretvalue)
+ [Exemples](#ipc-secret-manager-examples)

## Versions minimales du SDK
<a name="ipc-secret-manager-sdk-versions"></a>

Le tableau suivant répertorie les versions minimales Kit SDK des appareils AWS IoT que vous devez utiliser pour récupérer des valeurs secrètes à partir de secrets sur le périphérique principal.


| Kit SDK | Version minimale | 
| --- | --- | 
|  [Kit SDK des appareils AWS IoT pour Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.2.10  | 
|  [Kit SDK des appareils AWS IoT pour Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.5.3  | 
|  [Kit SDK des appareils AWS IoT pour C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [Kit SDK des appareils AWS IoT pour JavaScript v2](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

## Autorisation
<a name="ipc-secret-manager-authorization"></a>

Pour utiliser le gestionnaire de secrets dans un composant personnalisé, vous devez définir des politiques d'autorisation qui permettent à votre composant d'obtenir la valeur des secrets que vous stockez sur le périphérique principal. Pour plus d'informations sur la définition des politiques d'autorisation, consultez[Autoriser les composants à effectuer des opérations IPC](interprocess-communication.md#ipc-authorization-policies).

Les politiques d'autorisation pour Secret Manager possèdent les propriétés suivantes.

**Identifiant du service IPC :** `aws.greengrass.SecretManager`


| Opération | Description | Ressources | 
| --- | --- | --- | 
|  `aws.greengrass#GetSecretValue` ou `*`  |  Permet à un composant d'obtenir la valeur des secrets chiffrés sur le périphérique principal.  |  Un ARN secret du Secrets Manager, ou `*` pour autoriser l'accès à tous les secrets.  | 

### Exemples de politiques d'autorisation
<a name="ipc-secret-manager-authorization-policy-examples"></a>

Vous pouvez vous référer à l'exemple de politique d'autorisation suivant pour vous aider à configurer les politiques d'autorisation pour vos composants.

**Example Exemple de politique d'autorisation**  
L'exemple de politique d'autorisation suivant permet à un composant d'obtenir la valeur de n'importe quel secret sur le périphérique principal.  
Dans un environnement de production, nous vous recommandons de réduire la portée de la politique d'autorisation afin que le composant ne récupère que les secrets qu'il utilise. Vous pouvez remplacer le `*` caractère générique par une liste de secrets ARNs lorsque vous déployez le composant.

```
{
  "accessControl": {
    "aws.greengrass.SecretManager": {
      "com.example.MySecretComponent:secrets:1": {
        "policyDescription": "Allows access to a secret.",
        "operations": [
          "aws.greengrass#GetSecretValue"
        ],
        "resources": [
          "*"
        ]
      }
    }
  }
}
```

## GetSecretValue
<a name="ipc-operation-getsecretvalue"></a>

Obtient la valeur d'un secret que vous stockez sur le périphérique principal.

Cette opération est similaire à l'opération Secrets Manager que vous pouvez utiliser pour obtenir la valeur d'un secret dans le AWS Cloud. Pour plus d’informations, consultez [GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html) dans la *Référence d’API AWS Secrets Manager *.

### Demande
<a name="ipc-operation-getsecretvalue-request"></a>

La demande de cette opération comporte les paramètres suivants :

`refresh`(Python :`refresh`)  
(facultatif) : s'il faut synchroniser le secret demandé avec sa dernière valeur du AWS Secrets Manager service.  
Lorsqu'il est défini sur true, le gestionnaire de secrets demande au AWS Secrets Manager service la dernière valeur de l'étiquette secrète spécifiée et renvoie cette valeur en réponse. Dans le cas contraire, la valeur secrète stockée localement sera renvoyée.  
 Ce paramètre ne fonctionnera pas conjointement avec le `versionId` paramètre de la demande. Ce paramètre fonctionne lorsqu'il est utilisé conjointement avec Nucleus 2.13.0 et versions ultérieures.

`secretId`(Python :`secret_id`)  
Le nom du secret à obtenir. Vous pouvez spécifier l'Amazon Resource Name (ARN) ou le nom convivial du secret.

`versionId`(Python :`version_id`)  
(Facultatif) L'ID de la version à obtenir.  
Vous pouvez spécifier `versionId` ou `versionStage`.  
Si vous ne spécifiez pas `versionId` ou`versionStage`, cette opération utilise par défaut la version avec l'`AWSCURRENT`étiquette.

`versionStage`(Python :`version_stage`)  
(Facultatif) L'étiquette de mise en scène de la version à obtenir.  
Vous pouvez spécifier `versionId` ou `versionStage`.  
Si vous ne spécifiez pas `versionId` ou`versionStage`, cette opération utilise par défaut la version avec l'`AWSCURRENT`étiquette.

### Réponse
<a name="ipc-operation-getsecretvalue-response"></a>

La réponse de cette opération contient les informations suivantes :

`secretId`(Python :`secret_id`)  
L'identifiant du secret.

`versionId`(Python :`version_id`)  
L'ID de cette version du secret.

`versionStage`(Python :`version_stage`)  
La liste des labels de mise en scène attachés à cette version du secret.

`secretValue`(Python :`secret_value`)  
La valeur de cette version du secret. Cet objet contient `SecretValue` les informations suivantes.    
`secretString`(Python :`secret_string`)  
Partie déchiffrée des informations secrètes protégées que vous avez fournies à Secrets Manager sous forme de chaîne.  
`secretBinary`(Python :`secret_binary`)  
(Facultatif) Partie déchiffrée des informations secrètes protégées que vous avez fournies à Secrets Manager sous forme de données binaires sous la forme d'un tableau d'octets. Cette propriété contient les données binaires sous forme de chaîne codée en base64.  
Cette propriété n'est pas utilisée si vous avez créé le secret dans la console Secrets Manager.

### Exemples
<a name="ipc-operation-getsecretvalue-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Java (IPC client V1) ]

**Example Exemple : obtenir une valeur secrète**  
Cet exemple utilise une `IPCUtils` classe pour créer une connexion au service AWS IoT Greengrass Core IPC. Pour de plus amples informations, veuillez consulter [Connectez-vous au service AWS IoT Greengrass Core IPC](interprocess-communication.md#ipc-service-connect).

```
package com.aws.greengrass.docs.samples.ipc;

import com.aws.greengrass.docs.samples.ipc.util.IPCUtils;
import software.amazon.awssdk.aws.greengrass.GetSecretValueResponseHandler;
import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClient;
import software.amazon.awssdk.aws.greengrass.model.GetSecretValueRequest;
import software.amazon.awssdk.aws.greengrass.model.GetSecretValueResponse;
import software.amazon.awssdk.aws.greengrass.model.UnauthorizedError;
import software.amazon.awssdk.eventstreamrpc.EventStreamRPCConnection;

import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class GetSecretValue {

    public static final int TIMEOUT_SECONDS = 10;

    public static void main(String[] args) {
        String secretArn = args[0];
        String versionStage = args[1];
        try (EventStreamRPCConnection eventStreamRPCConnection =
                     IPCUtils.getEventStreamRpcConnection()) {
            GreengrassCoreIPCClient ipcClient =
                    new GreengrassCoreIPCClient(eventStreamRPCConnection);
            GetSecretValueResponseHandler responseHandler =
                    GetSecretValue.getSecretValue(ipcClient, secretArn, versionStage);
            CompletableFuture<GetSecretValueResponse> futureResponse =
                    responseHandler.getResponse();
            try {
                GetSecretValueResponse response = futureResponse.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
                response.getSecretValue().postFromJson();
                String secretString = response.getSecretValue().getSecretString();
                System.out.println("Successfully retrieved secret value: " + secretString);
            } catch (TimeoutException e) {
                System.err.println("Timeout occurred while retrieving secret: " + secretArn);
            } catch (ExecutionException e) {
                if (e.getCause() instanceof UnauthorizedError) {
                    System.err.println("Unauthorized error while retrieving secret: " + secretArn);
                } else {
                    throw e;
                }
            }
        } catch (InterruptedException e) {
            System.out.println("IPC interrupted.");
        } catch (ExecutionException e) {
            System.err.println("Exception occurred when using IPC.");
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static GetSecretValueResponseHandler getSecretValue(GreengrassCoreIPCClient greengrassCoreIPCClient, String secretArn, String versionStage) {
        GetSecretValueRequest getSecretValueRequest = new GetSecretValueRequest();
        getSecretValueRequest.setSecretId(secretArn);
        getSecretValueRequest.setVersionStage(versionStage);
        return greengrassCoreIPCClient.getSecretValue(getSecretValueRequest, Optional.empty());
    }
}
```

------
#### [ Python (IPC client V1) ]

**Example Exemple : obtenir une valeur secrète**  
Cet exemple suppose que vous utilisez la version 1.5.4 ou ultérieure de Kit SDK des appareils AWS IoT for Python v2. 

```
import json

import awsiot.greengrasscoreipc
from awsiot.greengrasscoreipc.model import (
    GetSecretValueRequest,
    GetSecretValueResponse,
    UnauthorizedError
)

secret_id = 'arn:aws:secretsmanager:us-west-2:123456789012:secret:MyGreengrassSecret-abcdef'
TIMEOUT = 10

ipc_client = awsiot.greengrasscoreipc.connect()

request = GetSecretValueRequest()
request.secret_id = secret_id
request.version_stage = 'AWSCURRENT'
operation = ipc_client.new_get_secret_value()
operation.activate(request)
future_response = operation.get_response()
response = future_response.result(TIMEOUT)
secret_json = json.loads(response.secret_value.secret_string)
# Handle secret value.
```

------
#### [ JavaScript ]

**Example Exemple : obtenir une valeur secrète**  

```
import {
    GetSecretValueRequest,
} from 'aws-iot-device-sdk-v2/dist/greengrasscoreipc/model';
import * as greengrasscoreipc from "aws-iot-device-sdk-v2/dist/greengrasscoreipc";
 
class GetSecretValue {
    private readonly secretId : string;
    private readonly versionStage : string;
    private ipcClient : greengrasscoreipc.Client
 
    constructor() {
        this.secretId = "<define_your_own_secretId>"
        this.versionStage = "<define_your_own_versionStage>"
 
        this.getSecretValue().then(r => console.log("Started workflow"));
    }
 
    private async getSecretValue() {
        try {
            this.ipcClient = await getIpcClient();
 
            const getSecretValueRequest : GetSecretValueRequest = {
                secretId: this.secretId,
                versionStage: this.versionStage,
            };
 
            const result = await this.ipcClient.getSecretValue(getSecretValueRequest);
            const secretString = result.secretValue.secretString;
            console.log("Successfully retrieved secret value: " + secretString)
        } catch (e) {
            // parse the error depending on your use cases
            throw e
        }
    }
}
 
export async function getIpcClient(){
    try {
        const ipcClient = greengrasscoreipc.createClient();
        await ipcClient.connect()
            .catch(error => {
                // parse the error depending on your use cases
                throw error;
            });
        return ipcClient
    } catch (err) {
        // parse the error depending on your use cases
        throw err
    }
}
 
const getSecretValue = new GetSecretValue();
```

------

## Exemples
<a name="ipc-secret-manager-examples"></a>

Utilisez les exemples suivants pour apprendre à utiliser le service IPC du gestionnaire de secrets dans vos composants.

### Exemple : secret d'impression (Python, client IPC V1)
<a name="ipc-secret-manager-example-print-secret-python"></a>

Cet exemple de composant imprime la valeur d'un secret que vous déployez sur le périphérique principal.

**Important**  
Cet exemple de composant imprime la valeur d'un secret. Ne l'utilisez donc qu'avec les secrets qui stockent des données de test. N'utilisez pas ce composant pour imprimer la valeur d'un secret contenant des informations importantes.

**Topics**
+ [Formule](#ipc-secret-manager-example-print-secret-python-recipe)
+ [Artefacts](#ipc-secret-manager-example-print-secret-python-artifacts)
+ [Usage](#ipc-secret-manager-example-print-secret-python-usage)

#### Formule
<a name="ipc-secret-manager-example-print-secret-python-recipe"></a>

L'exemple de recette suivant définit un paramètre de configuration ARN secret et permet au composant d'obtenir la valeur de n'importe quel secret sur le périphérique principal.

**Note**  <a name="ipc-secret-manager-authorization-policy-resource-wildcard"></a>
Dans un environnement de production, nous vous recommandons de réduire la portée de la politique d'autorisation afin que le composant ne récupère que les secrets qu'il utilise. Vous pouvez remplacer le `*` caractère générique par une liste de secrets ARNs lorsque vous déployez le composant.

------
#### [ JSON ]

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PrintSecret",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "Prints the value of an AWS Secrets Manager secret.",
  "ComponentPublisher": "Amazon",
  "ComponentDependencies": {
    "aws.greengrass.SecretManager": {
      "VersionRequirement": "^2.0.0",
      "DependencyType": "HARD"
    }
  },
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "SecretArn": "",
      "accessControl": {
        "aws.greengrass.SecretManager": {
          "com.example.PrintSecret:secrets:1": {
            "policyDescription": "Allows access to a secret.",
            "operations": [
              "aws.greengrass#GetSecretValue"
            ],
            "resources": [
              "*"
            ]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": "python3 -m pip install --user awsiotsdk",
        "Run": "python3 -u {artifacts:path}/print_secret.py \"{configuration:/SecretArn}\""
      }
    },
    {
      "Platform": {
        "os": "windows"
      },
      "Lifecycle": {
        "install": "py -3 -m pip install --user awsiotsdk",
        "Run": "py -3 -u {artifacts:path}/print_secret.py \"{configuration:/SecretArn}\""
      }
    }
  ]
}
```

------
#### [ YAML ]

```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.PrintSecret
ComponentVersion: 1.0.0
ComponentDescription: Prints the value of a Secrets Manager secret.
ComponentPublisher: Amazon
ComponentDependencies:
  aws.greengrass.SecretManager:
    VersionRequirement: "^2.0.0"
    DependencyType: HARD
ComponentConfiguration:
  DefaultConfiguration:
    SecretArn: ''
    accessControl:
      aws.greengrass.SecretManager:
        com.example.PrintSecret:secrets:1:
          policyDescription: Allows access to a secret.
          operations:
            - aws.greengrass#GetSecretValue
          resources:
            - "*"
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install: python3 -m pip install --user awsiotsdk
      Run: python3 -u {artifacts:path}/print_secret.py "{configuration:/SecretArn}"
  - Platform:
      os: windows
    Lifecycle:
      install: py -3 -m pip install --user awsiotsdk
      Run: py -3 -u {artifacts:path}/print_secret.py "{configuration:/SecretArn}"
```

------

#### Artefacts
<a name="ipc-secret-manager-example-print-secret-python-artifacts"></a>

L'exemple d'application Python suivant montre comment utiliser le service IPC du gestionnaire de secrets pour obtenir la valeur d'un secret sur le périphérique principal.

```
import concurrent.futures
import json
import sys
import traceback

import awsiot.greengrasscoreipc
from awsiot.greengrasscoreipc.model import (
    GetSecretValueRequest,
    GetSecretValueResponse,
    UnauthorizedError
)

TIMEOUT = 10

if len(sys.argv) == 1:
    print('Provide SecretArn in the component configuration.', file=sys.stdout)
    exit(1)

secret_id = sys.argv[1]

try:
    ipc_client = awsiot.greengrasscoreipc.connect()

    request = GetSecretValueRequest()
    request.secret_id = secret_id
    operation = ipc_client.new_get_secret_value()
    operation.activate(request)
    future_response = operation.get_response()

    try:
        response = future_response.result(TIMEOUT)
        secret_json = json.loads(response.secret_value.secret_string)
        print('Successfully got secret: ' + secret_id)
        print('Secret value: ' + str(secret_json))
    except concurrent.futures.TimeoutError:
        print('Timeout occurred while getting secret: ' + secret_id, file=sys.stderr)
    except UnauthorizedError as e:
        print('Unauthorized error while getting secret: ' + secret_id, file=sys.stderr)
        raise e
    except Exception as e:
        print('Exception while getting secret: ' + secret_id, file=sys.stderr)
        raise e
except Exception:
    print('Exception occurred when using IPC.', file=sys.stderr)
    traceback.print_exc()
    exit(1)
```

#### Usage
<a name="ipc-secret-manager-example-print-secret-python-usage"></a>

Vous pouvez utiliser cet exemple de composant avec le [composant gestionnaire de secrets](secret-manager-component.md) pour déployer et imprimer la valeur d'un secret sur votre périphérique principal.

**Pour créer, déployer et imprimer un secret de test**

1. Créez un secret Secrets Manager avec des données de test.

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

   ```
   aws secretsmanager create-secret \
     --name MyTestGreengrassSecret \
     --secret-string '{"my-secret-key": "my-secret-value"}'
   ```

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

   ```
   aws secretsmanager create-secret ^
     --name MyTestGreengrassSecret ^
     --secret-string '{"my-secret-key": "my-secret-value"}'
   ```

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

   ```
   aws secretsmanager create-secret `
     --name MyTestGreengrassSecret `
     --secret-string '{"my-secret-key": "my-secret-value"}'
   ```

------

   Enregistrez l'ARN du secret à utiliser dans les étapes suivantes.

   Pour plus d'informations, consultez la section [Création d'un secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) dans le *guide de AWS Secrets Manager l'utilisateur*.

1. Déployez le [composant secret manager](secret-manager-component.md) (`aws.greengrass.SecretManager`) avec la mise à jour de fusion de configuration suivante. Spécifiez l'ARN du secret que vous avez créé précédemment.

   ```
   {
     "cloudSecrets": [
       {
         "arn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:MyTestGreengrassSecret-abcdef"
       }
     ]
   }
   ```

   Pour plus d'informations, consultez [Déployer AWS IoT Greengrass des composants sur des appareils](manage-deployments.md) la commande de [déploiement de la CLI Greengrass](gg-cli-deployment.md).

1. Créez et déployez le composant d'exemple présenté dans cette section avec la mise à jour de fusion de configuration suivante. Spécifiez l'ARN du secret que vous avez créé précédemment.

   ```
   {
     "SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:MyTestGreengrassSecret",
     "accessControl": {
       "aws.greengrass.SecretManager": {
         "com.example.PrintSecret:secrets:1": {
           "policyDescription": "Allows access to a secret.",
           "operations": [
             "aws.greengrass#GetSecretValue"
           ],
           "resources": [
             "arn:aws:secretsmanager:us-west-2:123456789012:secret:MyTestGreengrassSecret-abcdef"
           ]
         }
       }
     }
   }
   ```

   Pour de plus amples informations, consultez [Création de AWS IoT Greengrass composants](create-components.md).

1. Consultez les journaux du logiciel AWS IoT Greengrass principal pour vérifier que les déploiements sont réussis, et consultez le journal des `com.example.PrintSecret` composants pour voir la valeur secrète imprimée. Pour de plus amples informations, veuillez consulter [AWS IoT Greengrass Journaux de surveillance](monitor-logs.md).

# Interagissez avec les ombres locales
<a name="ipc-local-shadows"></a>

Utilisez le service Shadow IPC pour interagir avec les ombres locales sur un appareil. L'appareil avec lequel vous choisissez d'interagir peut être votre appareil principal ou un appareil client connecté. 

Pour utiliser ces opérations IPC, incluez le [composant Shadow Manager](shadow-manager-component.md) en tant que dépendance dans votre composant personnalisé. Vous pouvez ensuite utiliser les opérations IPC dans vos composants personnalisés pour interagir avec les ombres locales de votre appareil via le gestionnaire d'ombres. Pour permettre aux composants personnalisés de réagir aux modifications des états d'ombre locaux, vous pouvez également utiliser le service publish/subscribe IPC pour vous abonner à des événements fantômes. Pour plus d'informations sur l'utilisation du publish/subscribe service, consultez le[Publier/souscrire des messages locaux](ipc-publish-subscribe.md).

**Note**  <a name="note-requirement-enable-shadow-manager-client-devices"></a>
Pour permettre à un périphérique principal d'interagir avec les ombres du périphérique client, vous devez également configurer et déployer le composant de pont MQTT. Pour plus d'informations, voir [Activer le Shadow Manager pour communiquer avec les appareils clients](work-with-client-device-shadows.md).

**Topics**
+ [Versions minimales du SDK](#ipc-local-shadows-sdk-versions)
+ [Autorisation](#ipc-local-shadow-authorization)
+ [GetThingShadow](#ipc-operation-getthingshadow)
+ [UpdateThingShadow](#ipc-operation-updatethingshadow)
+ [DeleteThingShadow](#ipc-operation-deletethingshadow)
+ [ListNamedShadowsForThing](#ipc-operation-listnamedshadowsforthing)

## Versions minimales du SDK
<a name="ipc-local-shadows-sdk-versions"></a>

Le tableau suivant répertorie les versions minimales Kit SDK des appareils AWS IoT que vous devez utiliser pour interagir avec les ombres locales.


| Kit SDK | Version minimale | 
| --- | --- | 
|  [Kit SDK des appareils AWS IoT pour Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.4.0  | 
|  [Kit SDK des appareils AWS IoT pour Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.6.0  | 
|  [Kit SDK des appareils AWS IoT pour C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [Kit SDK des appareils AWS IoT pour JavaScript v2](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

## Autorisation
<a name="ipc-local-shadow-authorization"></a>

Pour utiliser le service Shadow IPC dans un composant personnalisé, vous devez définir des politiques d'autorisation permettant à votre composant d'interagir avec les ombres. Pour plus d'informations sur la définition des politiques d'autorisation, consultez[Autoriser les composants à effectuer des opérations IPC](interprocess-communication.md#ipc-authorization-policies).

Les politiques d'autorisation pour l'interaction parallèle ont les propriétés suivantes.

**Identifiant du service IPC :** `aws.greengrass.ShadowManager`


| Opération | Description | Ressources | 
| --- | --- | --- | 
|  `aws.greengrass#GetThingShadow`  |  Permet à un composant de récupérer l'ombre d'un objet.  |  L'une des chaînes suivantes :  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/ipc-local-shadows.html)  | 
|  `aws.greengrass#UpdateThingShadow`  |  Permet à un composant de mettre à jour l'ombre d'un objet.  |  L'une des chaînes suivantes :  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/ipc-local-shadows.html)  | 
|  `aws.greengrass#DeleteThingShadow`  |  Permet à un composant de supprimer l'ombre d'un objet.  |  L'une des chaînes suivantes :  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/ipc-local-shadows.html)  | 
|  `aws.greengrass#ListNamedShadowsForThing`  |  Permet à un composant de récupérer la liste des ombres nommées pour un objet.  |  Chaîne de nom d'objet qui permet d'accéder à l'objet pour répertorier ses ombres. `*`À utiliser pour autoriser l'accès à tout.  | 

**Identifiant du service IPC :** `aws.greengrass.ipc.pubsub`


| Opération | Description | Ressources | 
| --- | --- | --- | 
|  `aws.greengrass#SubscribeToTopic`  |  Permet à un composant de s'abonner à des messages pour les sujets que vous spécifiez.  |  L'une des chaînes de rubrique suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/ipc-local-shadows.html) La valeur du préfixe de rubrique `shadowTopicPrefix` dépend du type d'ombre :  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/greengrass/v2/developerguide/ipc-local-shadows.html) `*`À utiliser pour autoriser l'accès à tous les sujets. <a name="ipc-local-publish-subscribe-authorization-mqtt-wildcards"></a>Dans [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 et versions ultérieures, vous pouvez vous abonner à des sujets contenant des caractères génériques MQTT (et). `#` `+` Cette chaîne de rubrique prend en charge les caractères génériques des rubriques MQTT sous forme de caractères littéraux. Par exemple, si la politique d'autorisation d'un composant accorde l'accès à `test/topic/#``test/topic/#`, le composant peut s'abonner, mais pas`test/topic/filter`.  | 

### Variables de recette dans les politiques d'autorisation fictives locales
<a name="ipc-local-shadow-authorization-recipe-variables"></a>

[Si vous utilisez la version 2.6.0 ou ultérieure du noyau [Greengrass et que vous définissez l'option de [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)configuration du noyau](greengrass-nucleus-component.md) Greengrass sur`true`, vous pouvez utiliser la variable de recette dans les politiques d'autorisation. `{iot:thingName}`](component-recipe-reference.md#recipe-variables) Cette fonctionnalité vous permet de configurer une politique d'autorisation unique pour un groupe de périphériques principaux, chaque périphérique principal ne pouvant accéder qu'à son propre périphérique fantôme. Par exemple, vous pouvez autoriser un composant à accéder à la ressource suivante pour les opérations IPC parallèles.

```
$aws/things/{iot:thingName}/shadow/
```

### Exemples de politiques d'autorisation
<a name="ipc-local-shadow-authorization-policy-examples"></a>

Vous pouvez vous référer aux exemples de politiques d'autorisation suivants pour vous aider à configurer les politiques d'autorisation pour vos composants.

**Example Exemple : autoriser un groupe d'appareils principaux à interagir avec les ombres locales**  
 <a name="phrase-example-uses-recipe-variables-in-configuration"></a>Cet exemple utilise une fonctionnalité disponible pour les versions 2.6.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. Greengrass nucleus v2.6.0 ajoute la prise en charge de la plupart des [variables de recette](component-recipe-reference.md#recipe-variables), notamment dans les configurations de composants`{iot:thingName}`. Pour activer cette fonctionnalité, définissez l'option de configuration du noyau de Greengrass sur. [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)`true` Pour un exemple qui fonctionne pour toutes les versions du noyau Greengrass, consultez l'[exemple de politique d'autorisation pour un appareil monocœur](#ipc-local-shadows-authorization-example-single-device).
L'exemple de politique d'autorisation suivant permet `com.example.MyShadowInteractionComponent` au composant d'interagir avec l'ombre de périphérique classique et l'ombre nommée `myNamedShadow` pour le périphérique principal qui exécute le composant. Cette politique permet également à ce composant de recevoir des messages sur des sujets locaux pour ces ombres.  

```
{
  "accessControl": {
    "aws.greengrass.ShadowManager": {
      "com.example.MyShadowInteractionComponent:shadow:1": {
        "policyDescription": "Allows access to shadows",
        "operations": [
          "aws.greengrass#GetThingShadow",
          "aws.greengrass#UpdateThingShadow",
          "aws.greengrass#DeleteThingShadow"
        ],
        "resources": [
          "$aws/things/{iot:thingName}/shadow",
          "$aws/things/{iot:thingName}/shadow/name/myNamedShadow"
        ]
      },
      "com.example.MyShadowInteractionComponent:shadow:2": {
        "policyDescription": "Allows access to things with shadows",
        "operations": [
          "aws.greengrass#ListNamedShadowsForThing"
        ],
        "resources": [
          "{iot:thingName}"
        ]
      }    
    },
    "aws.greengrass.ipc.pubsub": {
      "com.example.MyShadowInteractionComponent:pubsub:1": {
        "policyDescription": "Allows access to shadow pubsub topics",
        "operations": [
          "aws.greengrass#SubscribeToTopic"
        ],
        "resources": [
          "$aws/things/{iot:thingName}/shadow/get/accepted",
          "$aws/things/{iot:thingName}/shadow/name/myNamedShadow/get/accepted"
        ]
      }
    }
  }
}
```

```
accessControl:
  aws.greengrass.ShadowManager:
    'com.example.MyShadowInteractionComponent:shadow:1':
      policyDescription: 'Allows access to shadows'
      operations:
        - 'aws.greengrass#GetThingShadow'
        - 'aws.greengrass#UpdateThingShadow'
        - 'aws.greengrass#DeleteThingShadow'
      resources:
        - $aws/things/{iot:thingName}/shadow
        - $aws/things/{iot:thingName}/shadow/name/myNamedShadow
    'com.example.MyShadowInteractionComponent:shadow:2':
      policyDescription: 'Allows access to things with shadows'
      operations:
        - 'aws.greengrass#ListNamedShadowsForThing'
      resources:
        - '{iot:thingName}'
  aws.greengrass.ipc.pubsub:
    'com.example.MyShadowInteractionComponent:pubsub:1':
      policyDescription: 'Allows access to shadow pubsub topics'
      operations:
        - 'aws.greengrass#SubscribeToTopic'
      resources:
        - $aws/things/{iot:thingName}/shadow/get/accepted
        - $aws/things/{iot:thingName}/shadow/name/myNamedShadow/get/accepted
```

**Example Exemple : autoriser un groupe d'appareils principaux à interagir avec les ombres des appareils clients**  
[Cette fonctionnalité nécessite [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 ou version ultérieure, [Shadow Manager](shadow-manager-component.md) v2.2.0 ou version ultérieure, et MQTT bridge v2.2.0 ou version ultérieure.](mqtt-bridge-component.md) Vous devez configurer le pont MQTT pour [permettre au Shadow Manager de communiquer avec les appareils clients.](work-with-client-device-shadows.md#enable-shadow-manager-client-devices)
L'exemple de politique d'autorisation suivant permet au composant `com.example.MyShadowInteractionComponent` d'interagir avec toutes les ombres de périphériques pour les appareils clients dont le nom commence par`MyClientDevice`.  
Pour permettre à un périphérique principal d'interagir avec les ombres du périphérique client, vous devez également configurer et déployer le composant de pont MQTT. Pour plus d'informations, voir [Activer le Shadow Manager pour communiquer avec les appareils clients](work-with-client-device-shadows.md).

```
{
  "accessControl": {
    "aws.greengrass.ShadowManager": {
      "com.example.MyShadowInteractionComponent:shadow:1": {
        "policyDescription": "Allows access to shadows",
        "operations": [
          "aws.greengrass#GetThingShadow",
          "aws.greengrass#UpdateThingShadow",
          "aws.greengrass#DeleteThingShadow"
        ],
        "resources": [
          "$aws/things/MyClientDevice*/shadow",
          "$aws/things/MyClientDevice*/shadow/name/*"
        ]
      },
      "com.example.MyShadowInteractionComponent:shadow:2": {
        "policyDescription": "Allows access to things with shadows",
        "operations": [
          "aws.greengrass#ListNamedShadowsForThing"
        ],
        "resources": [
          "MyClientDevice*"
        ]
      }    
    }
  }
}
```

```
accessControl:
  aws.greengrass.ShadowManager:
    'com.example.MyShadowInteractionComponent:shadow:1':
      policyDescription: 'Allows access to shadows'
      operations:
        - 'aws.greengrass#GetThingShadow'
        - 'aws.greengrass#UpdateThingShadow'
        - 'aws.greengrass#DeleteThingShadow'
      resources:
        - $aws/things/MyClientDevice*/shadow
        - $aws/things/MyClientDevice*/shadow/name/*
    'com.example.MyShadowInteractionComponent:shadow:2':
      policyDescription: 'Allows access to things with shadows'
      operations:
        - 'aws.greengrass#ListNamedShadowsForThing'
      resources:
        - MyClientDevice*
```<a name="ipc-local-shadows-authorization-example-single-device"></a>

**Example Exemple : autoriser un appareil central à interagir avec les ombres locales**  
L'exemple de politique d'autorisation suivant permet `com.example.MyShadowInteractionComponent` au composant d'interagir avec l'ombre classique du périphérique et l'ombre nommée `myNamedShadow` pour le périphérique`MyThingName`. Cette politique permet également à ce composant de recevoir des messages sur des sujets locaux pour ces ombres.   

```
{
  "accessControl": {
    "aws.greengrass.ShadowManager": {
      "com.example.MyShadowInteractionComponent:shadow:1": {
        "policyDescription": "Allows access to shadows",
        "operations": [
          "aws.greengrass#GetThingShadow",
          "aws.greengrass#UpdateThingShadow",
          "aws.greengrass#DeleteThingShadow"
        ],
        "resources": [
          "$aws/things/MyThingName/shadow",
          "$aws/things/MyThingName/shadow/name/myNamedShadow"
        ]
      },
      "com.example.MyShadowInteractionComponent:shadow:2": {
        "policyDescription": "Allows access to things with shadows",
        "operations": [
          "aws.greengrass#ListNamedShadowsForThing"
        ],
        "resources": [
          "MyThingName"
        ]
      }    
    },
    "aws.greengrass.ipc.pubsub": {
      "com.example.MyShadowInteractionComponent:pubsub:1": {
        "policyDescription": "Allows access to shadow pubsub topics",
        "operations": [
          "aws.greengrass#SubscribeToTopic"
        ],
        "resources": [
          "$aws/things/MyThingName/shadow/get/accepted",
          "$aws/things/MyThingName/shadow/name/myNamedShadow/get/accepted"
        ]
      }
    }
  }
}
```

```
accessControl:
  aws.greengrass.ShadowManager:
    'com.example.MyShadowInteractionComponent:shadow:1':
      policyDescription: 'Allows access to shadows'
      operations:
        - 'aws.greengrass#GetThingShadow'
        - 'aws.greengrass#UpdateThingShadow'
        - 'aws.greengrass#DeleteThingShadow'
      resources:
        - $aws/things/MyThingName/shadow
        - $aws/things/MyThingName/shadow/name/myNamedShadow
    'com.example.MyShadowInteractionComponent:shadow:2':
      policyDescription: 'Allows access to things with shadows'
      operations:
        - 'aws.greengrass#ListNamedShadowsForThing'
      resources:
        - MyThingName
  aws.greengrass.ipc.pubsub:
    'com.example.MyShadowInteractionComponent:pubsub:1':
      policyDescription: 'Allows access to shadow pubsub topics'
      operations:
        - 'aws.greengrass#SubscribeToTopic'
      resources:
        - $aws/things/MyThingName/shadow/get/accepted
        - $aws/things/MyThingName/shadow/name/myNamedShadow/get/accepted
```<a name="interact-with-shadows-react-example-authorization-policies"></a>

**Example Exemple : autoriser un groupe de périphériques principaux à réagir aux modifications de l'état parallèle local**  
 <a name="phrase-example-uses-recipe-variables-in-configuration"></a>Cet exemple utilise une fonctionnalité disponible pour les versions 2.6.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. Greengrass nucleus v2.6.0 ajoute la prise en charge de la plupart des [variables de recette](component-recipe-reference.md#recipe-variables), notamment dans les configurations de composants`{iot:thingName}`. Pour activer cette fonctionnalité, définissez l'option de configuration du noyau de Greengrass sur. [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)`true` Pour un exemple qui fonctionne pour toutes les versions du noyau Greengrass, consultez l'[exemple de politique d'autorisation pour un appareil monocœur](#interact-with-shadows-react-example-authorization-policy-single-device).
L'exemple de politique de contrôle d'accès suivant permet `com.example.MyShadowReactiveComponent` au client de recevoir des messages sur le `/update/delta` sujet de l'ombre de périphérique classique et de l'ombre nommée `myNamedShadow` sur chaque périphérique principal qui exécute le composant.  

```
{
  "accessControl": {
    "aws.greengrass.ipc.pubsub": {
      "com.example.MyShadowReactiveComponent:pubsub:1": {
        "policyDescription": "Allows access to shadow pubsub topics",
        "operations": [
          "aws.greengrass#SubscribeToTopic"
        ],
        "resources": [
          "$aws/things/{iot:thingName}/shadow/update/delta",
          "$aws/things/{iot:thingName}/shadow/name/myNamedShadow/update/delta"
        ]
      }
    }
  }
}
```

```
accessControl:
  aws.greengrass.ipc.pubsub:
    "com.example.MyShadowReactiveComponent:pubsub:1":
      policyDescription: Allows access to shadow pubsub topics
      operations:
        - 'aws.greengrass#SubscribeToTopic'
      resources:
        - $aws/things/{iot:thingName}/shadow/update/delta
        - $aws/things/{iot:thingName}/shadow/name/myNamedShadow/update/delta
```<a name="interact-with-shadows-react-example-authorization-policy-single-device"></a>

**Example Exemple : autoriser un périphérique à cœur unique à réagir aux modifications de l'état fantôme local**  
L'exemple de politique de contrôle d'accès suivant permet `com.example.MyShadowReactiveComponent` au client de recevoir des messages sur le `/update/delta` sujet correspondant à l'ombre classique de l'appareil et à l'ombre nommée `myNamedShadow` pour l'appareil`MyThingName`.  

```
{
  "accessControl": {
    "aws.greengrass.ipc.pubsub": {
      "com.example.MyShadowReactiveComponent:pubsub:1": {
        "policyDescription": "Allows access to shadow pubsub topics",
        "operations": [
          "aws.greengrass#SubscribeToTopic"
        ],
        "resources": [
          "$aws/things/MyThingName/shadow/update/delta",
          "$aws/things/MyThingName/shadow/name/myNamedShadow/update/delta"
        ]
      }
    }
  }
}
```

```
accessControl:
  aws.greengrass.ipc.pubsub:
    "com.example.MyShadowReactiveComponent:pubsub:1":
      policyDescription: Allows access to shadow pubsub topics
      operations:
        - 'aws.greengrass#SubscribeToTopic'
      resources:
        - $aws/things/MyThingName/shadow/update/delta
        - $aws/things/MyThingName/shadow/name/myNamedShadow/update/delta
```

## GetThingShadow
<a name="ipc-operation-getthingshadow"></a>

Obtenez l'ombre d'un objet spécifique.

### Demande
<a name="ipc-operation-getthingshadow-request"></a>

La demande de cette opération comporte les paramètres suivants :

`thingName`(Python :`thing_name`)  <a name="ipc-local-shadows-thing-name"></a>
Nom de l'objet.  
Type : `string`

`shadowName`(Python :`shadow_name`)  <a name="ipc-local-shadows-shadow-name"></a>
Nom du shadow. Pour spécifier l'ombre classique de l'objet, définissez ce paramètre sur une chaîne vide (`""`).  
Le AWS IoT Greengrass service utilise le `AWSManagedGreengrassV2Deployment` nom shadow pour gérer les déploiements qui ciblent des appareils principaux individuels. Cette ombre nommée est réservée à l'usage du AWS IoT Greengrass service. Ne mettez pas à jour ou ne supprimez pas cette ombre nommée.
Type : `string`

### Réponse
<a name="ipc-operation-getthingshadow-response"></a>

La réponse de cette opération contient les informations suivantes :

`payload`  
Le document d'état de réponse sous forme de blob.  
Type : `object` qui contient les informations suivantes :    
`state`  
Les informations sur l'état.  
Cet objet contient les informations suivantes.    
`desired`  
Les propriétés d'état et les valeurs dont la mise à jour est demandée dans l'appareil.  
Type : `map` de paires clé-valeur  
`reported`  
Les propriétés d'état et les valeurs signalées par l'appareil.  
Type : `map` de paires clé-valeur  
`delta`  
Différence entre les propriétés et valeurs d'état souhaitées et signalées. Cette propriété n'est présente que si les `reported` états `desired` et sont différents.  
Type : `map` de paires clé-valeur  
`metadata`  
Les horodatages de chaque attribut dans les `reported` sections `desired` et afin que vous puissiez déterminer quand l'état a été mis à jour.   
Type : `string`  
`timestamp`  
L'époque, la date et l'heure auxquelles la réponse a été générée.  
Type : `integer`  
`clientToken`(Python :`clientToken`)  
Le jeton utilisé pour faire correspondre la demande et la réponse correspondante  
Type : `string`  
`version`  
Version du document fantôme local.  
Type : `integer`

### Erreurs
<a name="ipc-operation-getthingshadow-errors"></a>

Cette opération peut renvoyer les erreurs suivantes.

`InvalidArgumentsError`  <a name="ipc-invalidargumentserror"></a>
<a name="ipc-invalidargumentserror-para"></a>Le service parallèle local n'est pas en mesure de valider les paramètres de la demande. Cela peut se produire si la demande contient du JSON mal formé ou des caractères non pris en charge. 

`ResourceNotFoundError`  <a name="ipc-resourcenotfounderror"></a>
Le document parallèle local demandé est introuvable.

`ServiceError`  <a name="ipc-serviceerror"></a>
Une erreur de service interne s'est produite ou le nombre de demandes adressées au service IPC a dépassé les limites spécifiées dans les paramètres de `maxTotalLocalRequestsRate` configuration `maxLocalRequestsPerSecondPerThing` et dans le composant Shadow Manager.

`UnauthorizedError`  <a name="ipc-unauthorizederror"></a>
La politique d'autorisation du composant n'inclut pas les autorisations requises pour cette opération.

### Exemples
<a name="ipc-operation-getthingshadow-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Java (IPC client V1) ]

**Example Exemple : Get a thing Shadow**  
Cet exemple utilise une `IPCUtils` classe pour créer une connexion au service AWS IoT Greengrass Core IPC. Pour de plus amples informations, veuillez consulter [Connectez-vous au service AWS IoT Greengrass Core IPC](interprocess-communication.md#ipc-service-connect).

```
package com.aws.greengrass.docs.samples.ipc;

import com.aws.greengrass.docs.samples.ipc.util.IPCUtils;
import software.amazon.awssdk.aws.greengrass.GetThingShadowResponseHandler;
import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClient;
import software.amazon.awssdk.aws.greengrass.model.GetThingShadowRequest;
import software.amazon.awssdk.aws.greengrass.model.GetThingShadowResponse;
import software.amazon.awssdk.aws.greengrass.model.ResourceNotFoundError;
import software.amazon.awssdk.aws.greengrass.model.UnauthorizedError;
import software.amazon.awssdk.eventstreamrpc.EventStreamRPCConnection;

import java.nio.charset.StandardCharsets;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class GetThingShadow {

    public static final int TIMEOUT_SECONDS = 10;

    public static void main(String[] args) {
        // Use the current core device's name if thing name isn't set.
        String thingName = args[0].isEmpty() ? System.getenv("AWS_IOT_THING_NAME") : args[0];
        String shadowName = args[1];
        try (EventStreamRPCConnection eventStreamRPCConnection =
                     IPCUtils.getEventStreamRpcConnection()) {
            GreengrassCoreIPCClient ipcClient =
                    new GreengrassCoreIPCClient(eventStreamRPCConnection);
            GetThingShadowResponseHandler responseHandler =
                    GetThingShadow.getThingShadow(ipcClient, thingName, shadowName);
            CompletableFuture<GetThingShadowResponse> futureResponse =
                    responseHandler.getResponse();
            try {
                GetThingShadowResponse response = futureResponse.get(TIMEOUT_SECONDS,
                        TimeUnit.SECONDS);
                String shadowPayload = new String(response.getPayload(), StandardCharsets.UTF_8);
                System.out.printf("Successfully got shadow %s/%s: %s%n", thingName, shadowName,
                        shadowPayload);
            } catch (TimeoutException e) {
                System.err.printf("Timeout occurred while getting shadow: %s/%s%n", thingName,
                        shadowName);
            } catch (ExecutionException e) {
                if (e.getCause() instanceof UnauthorizedError) {
                    System.err.printf("Unauthorized error while getting shadow: %s/%s%n",
                            thingName, shadowName);
                } else if (e.getCause() instanceof ResourceNotFoundError) {
                    System.err.printf("Unable to find shadow to get: %s/%s%n", thingName,
                            shadowName);
                } else {
                    throw e;
                }
            }
        } catch (InterruptedException e) {
            System.out.println("IPC interrupted.");
        } catch (ExecutionException e) {
            System.err.println("Exception occurred when using IPC.");
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static GetThingShadowResponseHandler getThingShadow(GreengrassCoreIPCClient greengrassCoreIPCClient, String thingName, String shadowName) {
        GetThingShadowRequest getThingShadowRequest = new GetThingShadowRequest();
        getThingShadowRequest.setThingName(thingName);
        getThingShadowRequest.setShadowName(shadowName);
        return greengrassCoreIPCClient.getThingShadow(getThingShadowRequest, Optional.empty());
    }
}
```

------
#### [ Python (IPC client V1) ]

**Example Exemple : Get a thing Shadow**  

```
import awsiot.greengrasscoreipc
import awsiot.greengrasscoreipc.client as client
from awsiot.greengrasscoreipc.model import GetThingShadowRequest

TIMEOUT = 10

def sample_get_thing_shadow_request(thingName, shadowName):
    try:
        # set up IPC client to connect to the IPC server
        ipc_client = awsiot.greengrasscoreipc.connect()
                
        # create the GetThingShadow request
        get_thing_shadow_request = GetThingShadowRequest()
        get_thing_shadow_request.thing_name = thingName
        get_thing_shadow_request.shadow_name = shadowName
        
        # retrieve the GetThingShadow response after sending the request to the IPC server
        op = ipc_client.new_get_thing_shadow()
        op.activate(get_thing_shadow_request)
        fut = op.get_response()
        
        result = fut.result(TIMEOUT)
        return result.payload
        
    except InvalidArgumentsError as e:
        # add error handling
        ...
    # except ResourceNotFoundError | UnauthorizedError | ServiceError
```

------
#### [ JavaScript ]

**Example Exemple : Get a thing Shadow**  

```
import {
    GetThingShadowRequest
} from 'aws-iot-device-sdk-v2/dist/greengrasscoreipc/model';
import * as greengrasscoreipc from 'aws-iot-device-sdk-v2/dist/greengrasscoreipc';

class GetThingShadow {
    private ipcClient: greengrasscoreipc.Client;
    private thingName: string;
    private shadowName: string;

    constructor() {
        // Define args parameters here           
        this.thingName = "<define_your_own_thingName>";
        this.shadowName = "<define_your_own_shadowName>";
        this.bootstrap();
    }

    async bootstrap() {
        try {
            this.ipcClient = await getIpcClient();
        } catch (err) {
            // parse the error depending on your use cases
            throw err
        }
        
        try {
            await this.handleGetThingShadowOperation(this.thingName,
                this.shadowName);
        } catch (err) {
            // parse the error depending on your use cases
            throw err
        }
    }

    async handleGetThingShadowOperation(
        thingName: string,
        shadowName: string
    ) {
        const request: GetThingShadowRequest = {
            thingName: thingName,
            shadowName: shadowName
        };
        const response = await this.ipcClient.getThingShadow(request);
    }
}

export async function getIpcClient() {
    try {
        const ipcClient = greengrasscoreipc.createClient();
        await ipcClient.connect()
            .catch(error => {
                // parse the error depending on your use cases
                throw error;
            });
        return ipcClient
    } catch (err) {
        // parse the error depending on your use caseså
        throw err
    }
}

const startScript = new GetThingShadow();
```

------

## UpdateThingShadow
<a name="ipc-operation-updatethingshadow"></a>

Mettez à jour l'ombre pour l'objet spécifié. Si aucune ombre n'existe, une ombre est créée.

### Demande
<a name="ipc-operation-updatethingshadow-request"></a>

La demande de cette opération comporte les paramètres suivants :

`thingName`(Python :`thing_name`)  <a name="ipc-local-shadows-thing-name"></a>
Nom de l'objet.  
Type : `string`

`shadowName`(Python :`shadow_name`)  <a name="ipc-local-shadows-shadow-name"></a>
Nom du shadow. Pour spécifier l'ombre classique de l'objet, définissez ce paramètre sur une chaîne vide (`""`).  
Le AWS IoT Greengrass service utilise le `AWSManagedGreengrassV2Deployment` nom shadow pour gérer les déploiements qui ciblent des appareils principaux individuels. Cette ombre nommée est réservée à l'usage du AWS IoT Greengrass service. Ne mettez pas à jour ou ne supprimez pas cette ombre nommée.
Type : `string`

`payload`  
Le document d'état de la demande sous forme de blob.  
Type : `object` qui contient les informations suivantes :    
`state`  
Informations d'état à mettre à jour. Cette opération IPC n'affecte que les champs spécifiés.  
Cet objet contient les informations suivantes. Généralement, vous utiliserez la `desired` propriété ou la `reported` propriété, mais pas les deux dans la même demande.    
`desired`  
Les propriétés d'état et les valeurs demandées pour être mises à jour dans l'appareil.  
Type : `map` de paires clé-valeur  
`reported`  
Les propriétés d'état et les valeurs signalées par l'appareil.  
Type : `map` de paires clé-valeur  
`clientToken`(Python :`client_token`)  
(Facultatif) Le jeton utilisé pour faire correspondre la demande et la réponse correspondante du jeton client.  
Type : `string`  
`version`  
(Facultatif) Version du document fantôme local à mettre à jour. Le service parallèle traite la mise à jour uniquement si la version spécifiée correspond à la dernière version dont il dispose.  
Type : `integer`

### Réponse
<a name="ipc-operation-updatethingshadow-response"></a>

La réponse de cette opération contient les informations suivantes :

`payload`  
Le document d'état de réponse sous forme de blob.  
Type : `object` qui contient les informations suivantes :    
`state`  
Les informations sur l'état.  
Cet objet contient les informations suivantes.    
`desired`  
Les propriétés d'état et les valeurs demandées pour être mises à jour dans l'appareil.  
Type : `map` de paires clé-valeur  
`reported`  
Les propriétés d'état et les valeurs signalées par l'appareil.  
Type : `map` de paires clé-valeur  
`delta`  
Les propriétés d'état et les valeurs signalées par l'appareil.  
Type : `map` de paires clé-valeur  
`metadata`  
Les horodatages de chaque attribut dans les `reported` sections `desired` et afin que vous puissiez déterminer quand l'état a été mis à jour.   
Type : `string`  
`timestamp`  
L'époque, la date et l'heure auxquelles la réponse a été générée.  
Type : `integer`  
`clientToken`(Python :`client_token`)  
Le jeton utilisé pour faire correspondre la demande et la réponse correspondante.  
Type : `string`  
`version`  
Version du document fantôme local une fois la mise à jour terminée.  
Type : `integer`

### Erreurs
<a name="ipc-operation-updatethingshadow-errors"></a>

Cette opération peut renvoyer les erreurs suivantes.

`ConflictError`  
Le service fantôme local a rencontré un conflit de version lors de l'opération de mise à jour. Cela se produit lorsque la version de la charge utile de la demande ne correspond pas à la version du dernier document parallèle local disponible.

`InvalidArgumentsError`  
<a name="ipc-invalidargumentserror-para"></a>Le service parallèle local n'est pas en mesure de valider les paramètres de la demande. Cela peut se produire si la demande contient du JSON mal formé ou des caractères non pris en charge.   
Une valeur valide `payload` possède les propriétés suivantes :  
+ Le `state` nœud existe et est un objet qui contient les informations `reported` d'état `desired` ou. 
+ Les `reported` nœuds `desired` et sont soit des objets, soit des nœuds nuls. Au moins l'un de ces objets doit contenir des informations d'état valides. 
+ La profondeur des `reported` objets `desired` et ne peut pas dépasser huit nœuds. 
+ La longueur de la `clientToken` valeur ne peut pas dépasser 64 caractères. 
+  La `version` valeur doit être `1` ou supérieure. 

`ServiceError`  <a name="ipc-serviceerror"></a>
Une erreur de service interne s'est produite ou le nombre de demandes adressées au service IPC a dépassé les limites spécifiées dans les paramètres de `maxTotalLocalRequestsRate` configuration `maxLocalRequestsPerSecondPerThing` et dans le composant Shadow Manager.

`UnauthorizedError`  <a name="ipc-unauthorizederror"></a>
La politique d'autorisation du composant n'inclut pas les autorisations requises pour cette opération.

### Exemples
<a name="ipc-operation-updatethingshadow-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Java (IPC client V1) ]

**Example Exemple : mettre à jour un objet (shadow)**  
Cet exemple utilise une `IPCUtils` classe pour créer une connexion au service AWS IoT Greengrass Core IPC. Pour de plus amples informations, veuillez consulter [Connectez-vous au service AWS IoT Greengrass Core IPC](interprocess-communication.md#ipc-service-connect).

```
package com.aws.greengrass.docs.samples.ipc;

import com.aws.greengrass.docs.samples.ipc.util.IPCUtils;
import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClient;
import software.amazon.awssdk.aws.greengrass.UpdateThingShadowResponseHandler;
import software.amazon.awssdk.aws.greengrass.model.UnauthorizedError;
import software.amazon.awssdk.aws.greengrass.model.UpdateThingShadowRequest;
import software.amazon.awssdk.aws.greengrass.model.UpdateThingShadowResponse;
import software.amazon.awssdk.eventstreamrpc.EventStreamRPCConnection;

import java.nio.charset.StandardCharsets;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class UpdateThingShadow {

    public static final int TIMEOUT_SECONDS = 10;

    public static void main(String[] args) {
        // Use the current core device's name if thing name isn't set.
        String thingName = args[0].isEmpty() ? System.getenv("AWS_IOT_THING_NAME") : args[0];
        String shadowName = args[1];
        byte[] shadowPayload = args[2].getBytes(StandardCharsets.UTF_8);
        try (EventStreamRPCConnection eventStreamRPCConnection =
                     IPCUtils.getEventStreamRpcConnection()) {
            GreengrassCoreIPCClient ipcClient =
                    new GreengrassCoreIPCClient(eventStreamRPCConnection);
            UpdateThingShadowResponseHandler responseHandler =
                    UpdateThingShadow.updateThingShadow(ipcClient, thingName, shadowName,
                            shadowPayload);
            CompletableFuture<UpdateThingShadowResponse> futureResponse =
                    responseHandler.getResponse();
            try {
                futureResponse.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
                System.out.printf("Successfully updated shadow: %s/%s%n", thingName, shadowName);
            } catch (TimeoutException e) {
                System.err.printf("Timeout occurred while updating shadow: %s/%s%n", thingName,
                        shadowName);
            } catch (ExecutionException e) {
                if (e.getCause() instanceof UnauthorizedError) {
                    System.err.printf("Unauthorized error while updating shadow: %s/%s%n",
                            thingName, shadowName);
                } else {
                    throw e;
                }
            }
        } catch (InterruptedException e) {
            System.out.println("IPC interrupted.");
        } catch (ExecutionException e) {
            System.err.println("Exception occurred when using IPC.");
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static UpdateThingShadowResponseHandler updateThingShadow(GreengrassCoreIPCClient greengrassCoreIPCClient, String thingName, String shadowName, byte[] shadowPayload) {
        UpdateThingShadowRequest updateThingShadowRequest = new UpdateThingShadowRequest();
        updateThingShadowRequest.setThingName(thingName);
        updateThingShadowRequest.setShadowName(shadowName);
        updateThingShadowRequest.setPayload(shadowPayload);
        return greengrassCoreIPCClient.updateThingShadow(updateThingShadowRequest,
                Optional.empty());
    }
}
```

------
#### [ Python (IPC client V1) ]

**Example Exemple : mettre à jour un objet (shadow)**  

```
import awsiot.greengrasscoreipc
import awsiot.greengrasscoreipc.client as client
from awsiot.greengrasscoreipc.model import UpdateThingShadowRequest

TIMEOUT = 10

def sample_update_thing_shadow_request(thingName, shadowName, payload):
    try:
        # set up IPC client to connect to the IPC server
        ipc_client = awsiot.greengrasscoreipc.connect()
                
        # create the UpdateThingShadow request
        update_thing_shadow_request = UpdateThingShadowRequest()
        update_thing_shadow_request.thing_name = thingName
        update_thing_shadow_request.shadow_name = shadowName
        update_thing_shadow_request.payload = payload
                        
        # retrieve the UpdateThingShadow response after sending the request to the IPC server
        op = ipc_client.new_update_thing_shadow()
        op.activate(update_thing_shadow_request)
        fut = op.get_response()
        
        result = fut.result(TIMEOUT)
        return result.payload
        
    except InvalidArgumentsError as e:
        # add error handling
    ...
    # except ConflictError | UnauthorizedError | ServiceError
```

------
#### [ JavaScript ]

**Example Exemple : mettre à jour un objet (shadow)**  

```
import {
    UpdateThingShadowRequest
} from 'aws-iot-device-sdk-v2/dist/greengrasscoreipc/model';
import * as greengrasscoreipc from 'aws-iot-device-sdk-v2/dist/greengrasscoreipc';

class UpdateThingShadow {
    private ipcClient: greengrasscoreipc.Client;
    private thingName: string;
    private shadowName: string;
    private shadowDocumentStr: string;

    constructor() {
        // Define args parameters here

        this.thingName = "<define_your_own_thingName>";
        this.shadowName = "<define_your_own_shadowName>";
        this.shadowDocumentStr = "<define_your_own_payload>";

        this.bootstrap();
    }

    async bootstrap() {
        try {
            this.ipcClient = await getIpcClient();
        } catch (err) {
            // parse the error depending on your use cases
            throw err
        }

        try {
            await this.handleUpdateThingShadowOperation(
                this.thingName,
                this.shadowName,
                this.shadowDocumentStr);
        } catch (err) {
            // parse the error depending on your use cases
            throw err
        }
    }

    async handleUpdateThingShadowOperation(
        thingName: string,
        shadowName: string,
        payloadStr: string
    ) {
        const request: UpdateThingShadowRequest = {
            thingName: thingName,
            shadowName: shadowName,
            payload: payloadStr
        }
        // make the UpdateThingShadow request
        const response = await this.ipcClient.updateThingShadow(request);
    }
}

export async function getIpcClient() {
    try {
        const ipcClient = greengrasscoreipc.createClient();
        await ipcClient.connect()
            .catch(error => {
                // parse the error depending on your use cases
                throw error;
            });
        return ipcClient
    } catch (err) {
        // parse the error depending on your use cases
        throw err
    }
}

const startScript = new UpdateThingShadow();
```

------

## DeleteThingShadow
<a name="ipc-operation-deletethingshadow"></a>

Supprime le shadow de l'objet spécifié. 

À partir de la version 2.0.4 du gestionnaire d'ombres, la suppression d'une ombre augmente le numéro de version. Par exemple, lorsque vous supprimez l'ombre `MyThingShadow` dans la version 1, la version de l'ombre supprimée est 2. Si vous recréez ensuite une ombre portant ce nom`MyThingShadow`, la version de cette ombre est 3. 

### Demande
<a name="ipc-operation-deletethingshadow-request"></a>

La demande de cette opération comporte les paramètres suivants :

`thingName`(Python :`thing_name`)  <a name="ipc-local-shadows-thing-name"></a>
Nom de l'objet.  
Type : `string`

`shadowName`(Python :`shadow_name`)  <a name="ipc-local-shadows-shadow-name"></a>
Nom du shadow. Pour spécifier l'ombre classique de l'objet, définissez ce paramètre sur une chaîne vide (`""`).  
Le AWS IoT Greengrass service utilise le `AWSManagedGreengrassV2Deployment` nom shadow pour gérer les déploiements qui ciblent des appareils principaux individuels. Cette ombre nommée est réservée à l'usage du AWS IoT Greengrass service. Ne mettez pas à jour ou ne supprimez pas cette ombre nommée.
Type : `string`

### Réponse
<a name="ipc-operation-deletethingshadow-response"></a>

La réponse de cette opération contient les informations suivantes :

`payload`  
Document d'état de réponse vide.

### Erreurs
<a name="ipc-operation-deletethingshadow-errors"></a>

Cette opération peut renvoyer les erreurs suivantes.

`InvalidArgumentsError`  <a name="ipc-invalidargumentserror"></a>
<a name="ipc-invalidargumentserror-para"></a>Le service parallèle local n'est pas en mesure de valider les paramètres de la demande. Cela peut se produire si la demande contient du JSON mal formé ou des caractères non pris en charge. 

`ResourceNotFoundError`  <a name="ipc-resourcenotfounderror"></a>
Le document parallèle local demandé est introuvable.

`ServiceError`  <a name="ipc-serviceerror"></a>
Une erreur de service interne s'est produite ou le nombre de demandes adressées au service IPC a dépassé les limites spécifiées dans les paramètres de `maxTotalLocalRequestsRate` configuration `maxLocalRequestsPerSecondPerThing` et dans le composant Shadow Manager.

`UnauthorizedError`  <a name="ipc-unauthorizederror"></a>
La politique d'autorisation du composant n'inclut pas les autorisations requises pour cette opération.

### Exemples
<a name="ipc-operation-deletethingshadow-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Java (IPC client V1) ]

**Example Exemple : supprimer une ombre d'objet**  
Cet exemple utilise une `IPCUtils` classe pour créer une connexion au service AWS IoT Greengrass Core IPC. Pour de plus amples informations, veuillez consulter [Connectez-vous au service AWS IoT Greengrass Core IPC](interprocess-communication.md#ipc-service-connect).

```
package com.aws.greengrass.docs.samples.ipc;

import com.aws.greengrass.docs.samples.ipc.util.IPCUtils;
import software.amazon.awssdk.aws.greengrass.DeleteThingShadowResponseHandler;
import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClient;
import software.amazon.awssdk.aws.greengrass.model.DeleteThingShadowRequest;
import software.amazon.awssdk.aws.greengrass.model.DeleteThingShadowResponse;
import software.amazon.awssdk.aws.greengrass.model.ResourceNotFoundError;
import software.amazon.awssdk.aws.greengrass.model.UnauthorizedError;
import software.amazon.awssdk.eventstreamrpc.EventStreamRPCConnection;

import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class DeleteThingShadow {

    public static final int TIMEOUT_SECONDS = 10;

    public static void main(String[] args) {
        // Use the current core device's name if thing name isn't set.
        String thingName = args[0].isEmpty() ? System.getenv("AWS_IOT_THING_NAME") : args[0];
        String shadowName = args[1];
        try (EventStreamRPCConnection eventStreamRPCConnection =
                     IPCUtils.getEventStreamRpcConnection()) {
            GreengrassCoreIPCClient ipcClient =
                    new GreengrassCoreIPCClient(eventStreamRPCConnection);
            DeleteThingShadowResponseHandler responseHandler =
                    DeleteThingShadow.deleteThingShadow(ipcClient, thingName, shadowName);
            CompletableFuture<DeleteThingShadowResponse> futureResponse =
                    responseHandler.getResponse();
            try {
                futureResponse.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
                System.out.printf("Successfully deleted shadow: %s/%s%n", thingName, shadowName);
            } catch (TimeoutException e) {
                System.err.printf("Timeout occurred while deleting shadow: %s/%s%n", thingName,
                        shadowName);
            } catch (ExecutionException e) {
                if (e.getCause() instanceof UnauthorizedError) {
                    System.err.printf("Unauthorized error while deleting shadow: %s/%s%n",
                            thingName, shadowName);
                } else if (e.getCause() instanceof ResourceNotFoundError) {
                    System.err.printf("Unable to find shadow to delete: %s/%s%n", thingName,
                            shadowName);
                } else {
                    throw e;
                }
            }
        } catch (InterruptedException e) {
            System.out.println("IPC interrupted.");
        } catch (ExecutionException e) {
            System.err.println("Exception occurred when using IPC.");
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static DeleteThingShadowResponseHandler deleteThingShadow(GreengrassCoreIPCClient greengrassCoreIPCClient, String thingName, String shadowName) {
        DeleteThingShadowRequest deleteThingShadowRequest = new DeleteThingShadowRequest();
        deleteThingShadowRequest.setThingName(thingName);
        deleteThingShadowRequest.setShadowName(shadowName);
        return greengrassCoreIPCClient.deleteThingShadow(deleteThingShadowRequest,
                Optional.empty());
    }
}
```

------
#### [ Python (IPC client V1) ]

**Example Exemple : supprimer une ombre d'objet**  

```
import awsiot.greengrasscoreipc
import awsiot.greengrasscoreipc.client as client
from awsiot.greengrasscoreipc.model import DeleteThingShadowRequest

TIMEOUT = 10

def sample_delete_thing_shadow_request(thingName, shadowName):
    try:
        # set up IPC client to connect to the IPC server
        ipc_client = awsiot.greengrasscoreipc.connect()
                
        # create the DeleteThingShadow request
        delete_thing_shadow_request = DeleteThingShadowRequest()
        delete_thing_shadow_request.thing_name = thingName
        delete_thing_shadow_request.shadow_name = shadowName
                        
        # retrieve the DeleteThingShadow response after sending the request to the IPC server
        op = ipc_client.new_delete_thing_shadow()
        op.activate(delete_thing_shadow_request)
        fut = op.get_response()
        
        result = fut.result(TIMEOUT)
        return result.payload
        
    except InvalidArgumentsError as e:
        # add error handling
    ...
    # except ResourceNotFoundError | UnauthorizedError | ServiceError
```

------
#### [ JavaScript ]

**Example Exemple : supprimer une ombre d'objet**  

```
import {
    DeleteThingShadowRequest
} from 'aws-iot-device-sdk-v2/dist/greengrasscoreipc/model';
import * as greengrasscoreipc from 'aws-iot-device-sdk-v2/dist/greengrasscoreipc';

class DeleteThingShadow {
    private ipcClient: greengrasscoreipc.Client;
    private thingName: string;
    private shadowName: string;

    constructor() {
        // Define args parameters here
        this.thingName = "<define_your_own_thingName>";
        this.shadowName = "<define_your_own_shadowName>";
        this.bootstrap();
    }

    async bootstrap() {
        try {
            this.ipcClient = await getIpcClient();
        } catch (err) {
            // parse the error depending on your use cases
            throw err
        }

        try {
            await this.handleDeleteThingShadowOperation(this.thingName, this.shadowName)
        } catch (err) {
            // parse the error depending on your use cases
            throw err
        }
    }

    async handleDeleteThingShadowOperation(thingName: string, shadowName: string) {
        const request: DeleteThingShadowRequest = {
            thingName: thingName,
            shadowName: shadowName
        }
        // make the DeleteThingShadow request
        const response = await this.ipcClient.deleteThingShadow(request);
    }
}

export async function getIpcClient() {
    try {
        const ipcClient = greengrasscoreipc.createClient();
        await ipcClient.connect()
            .catch(error => {
                // parse the error depending on your use cases
                throw error;
            });
        return ipcClient
    } catch (err) {
        // parse the error depending on your use cases
        throw err
    }
}

const startScript = new DeleteThingShadow();
```

------

## ListNamedShadowsForThing
<a name="ipc-operation-listnamedshadowsforthing"></a>

Répertoriez les ombres nommées pour l'objet spécifié.

### Demande
<a name="ipc-operation-listnamedshadowsforthing-request"></a>

La demande de cette opération comporte les paramètres suivants :

`thingName`(Python :`thing_name`)  <a name="ipc-local-shadows-thing-name"></a>
Nom de l'objet.  
Type : `string`

`pageSize`(Python :`page_size`)  
(Facultatif) Le nombre de noms fictifs à renvoyer lors de chaque appel.   
Type : `integer`  
Par défaut: 25  
Maximum : 100

`nextToken`(Python :`next_token`)  
(Facultatif) Le jeton permettant de récupérer le prochain ensemble de résultats. Cette valeur est renvoyée sur les résultats paginés et est utilisée dans l'appel qui renvoie la page suivante.  
Type : `string`

### Réponse
<a name="ipc-operation-listnamedshadowsforthing-response"></a>

La réponse de cette opération contient les informations suivantes :

`results`  
La liste des noms des ombres.   
Type : `array`

`timestamp`  
(Facultatif) Date et heure auxquelles la réponse a été générée.   
Type : `integer`

`nextToken`(Python :`next_token`)  
(Facultatif) La valeur du jeton à utiliser dans les demandes paginées pour récupérer la page suivante de la séquence. Ce jeton n'est pas présent lorsqu'il n'y a plus de noms d'ombres à renvoyer.  
Type : `string`  
Si le format de page demandé correspond exactement au nombre de noms d'ombres dans la réponse, ce jeton est présent ; toutefois, lorsqu'il est utilisé, il renvoie une liste vide.

### Erreurs
<a name="ipc-operation-listnamedshadowsforthing-errors"></a>

Cette opération peut renvoyer les erreurs suivantes.

`InvalidArgumentsError`  <a name="ipc-invalidargumentserror"></a>
<a name="ipc-invalidargumentserror-para"></a>Le service parallèle local n'est pas en mesure de valider les paramètres de la demande. Cela peut se produire si la demande contient du JSON mal formé ou des caractères non pris en charge. 

`ResourceNotFoundError`  <a name="ipc-resourcenotfounderror"></a>
Le document parallèle local demandé est introuvable.

`ServiceError`  <a name="ipc-serviceerror"></a>
Une erreur de service interne s'est produite ou le nombre de demandes adressées au service IPC a dépassé les limites spécifiées dans les paramètres de `maxTotalLocalRequestsRate` configuration `maxLocalRequestsPerSecondPerThing` et dans le composant Shadow Manager.

`UnauthorizedError`  <a name="ipc-unauthorizederror"></a>
La politique d'autorisation du composant n'inclut pas les autorisations requises pour cette opération.

### Exemples
<a name="ipc-operation-listnamedshadowsforthing-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Java (IPC client V1) ]

**Example Exemple : répertorier un objet nommé ombres**  
Cet exemple utilise une `IPCUtils` classe pour créer une connexion au service AWS IoT Greengrass Core IPC. Pour de plus amples informations, veuillez consulter [Connectez-vous au service AWS IoT Greengrass Core IPC](interprocess-communication.md#ipc-service-connect).

```
package com.aws.greengrass.docs.samples.ipc;

import com.aws.greengrass.docs.samples.ipc.util.IPCUtils;
import software.amazon.awssdk.aws.greengrass.GreengrassCoreIPCClient;
import software.amazon.awssdk.aws.greengrass.ListNamedShadowsForThingResponseHandler;
import software.amazon.awssdk.aws.greengrass.model.ListNamedShadowsForThingRequest;
import software.amazon.awssdk.aws.greengrass.model.ListNamedShadowsForThingResponse;
import software.amazon.awssdk.aws.greengrass.model.ResourceNotFoundError;
import software.amazon.awssdk.aws.greengrass.model.UnauthorizedError;
import software.amazon.awssdk.eventstreamrpc.EventStreamRPCConnection;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ListNamedShadowsForThing {

    public static final int TIMEOUT_SECONDS = 10;

    public static void main(String[] args) {
        // Use the current core device's name if thing name isn't set.
        String thingName = args[0].isEmpty() ? System.getenv("AWS_IOT_THING_NAME") : args[0];
        try (EventStreamRPCConnection eventStreamRPCConnection =
                     IPCUtils.getEventStreamRpcConnection()) {
            GreengrassCoreIPCClient ipcClient =
                    new GreengrassCoreIPCClient(eventStreamRPCConnection);
            List<String> namedShadows = new ArrayList<>();
            String nextToken = null;
            try {
                // Send additional requests until there's no pagination token in the response.
                do {
                    ListNamedShadowsForThingResponseHandler responseHandler =
                            ListNamedShadowsForThing.listNamedShadowsForThing(ipcClient, thingName,
                                    nextToken, 25);
                    CompletableFuture<ListNamedShadowsForThingResponse> futureResponse =
                            responseHandler.getResponse();
                    ListNamedShadowsForThingResponse response =
                            futureResponse.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
                    List<String> responseNamedShadows = response.getResults();
                    namedShadows.addAll(responseNamedShadows);
                    nextToken = response.getNextToken();
                } while (nextToken != null);
                System.out.printf("Successfully got named shadows for thing %s: %s%n", thingName,
                        String.join(",", namedShadows));
            } catch (TimeoutException e) {
                System.err.println("Timeout occurred while listing named shadows for thing: " + thingName);
            } catch (ExecutionException e) {
                if (e.getCause() instanceof UnauthorizedError) {
                    System.err.println("Unauthorized error while listing named shadows for " +
                            "thing: " + thingName);
                } else if (e.getCause() instanceof ResourceNotFoundError) {
                    System.err.println("Unable to find thing to list named shadows: " + thingName);
                } else {
                    throw e;
                }
            }
        } catch (InterruptedException e) {
            System.out.println("IPC interrupted.");
        } catch (ExecutionException e) {
            System.err.println("Exception occurred when using IPC.");
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static ListNamedShadowsForThingResponseHandler listNamedShadowsForThing(GreengrassCoreIPCClient greengrassCoreIPCClient, String thingName, String nextToken, int pageSize) {
        ListNamedShadowsForThingRequest listNamedShadowsForThingRequest =
                new ListNamedShadowsForThingRequest();
        listNamedShadowsForThingRequest.setThingName(thingName);
        listNamedShadowsForThingRequest.setNextToken(nextToken);
        listNamedShadowsForThingRequest.setPageSize(pageSize);
        return greengrassCoreIPCClient.listNamedShadowsForThing(listNamedShadowsForThingRequest,
                Optional.empty());
    }
}
```

------
#### [ Python (IPC client V1) ]

**Example Exemple : répertorier un objet nommé ombres**  

```
import awsiot.greengrasscoreipc
import awsiot.greengrasscoreipc.client as client
from awsiot.greengrasscoreipc.model import ListNamedShadowsForThingRequest

TIMEOUT = 10

def sample_list_named_shadows_for_thing_request(thingName, nextToken, pageSize):
    try:
        # set up IPC client to connect to the IPC server
        ipc_client = awsiot.greengrasscoreipc.connect()
                
        # create the ListNamedShadowsForThingRequest request
        list_named_shadows_for_thing_request = ListNamedShadowsForThingRequest()
        list_named_shadows_for_thing_request.thing_name = thingName
        list_named_shadows_for_thing_request.next_token = nextToken
        list_named_shadows_for_thing_request.page_size = pageSize
        
        # retrieve the ListNamedShadowsForThingRequest response after sending the request to the IPC server
        op = ipc_client.new_list_named_shadows_for_thing()
        op.activate(list_named_shadows_for_thing_request)
        fut = op.get_response()
        
        list_result = fut.result(TIMEOUT)
        
        # additional returned fields
        timestamp = list_result.timestamp
        next_token = result.next_token
        named_shadow_list = list_result.results
        
        return named_shadow_list, next_token, timestamp
                
    except InvalidArgumentsError as e:
        # add error handling
    ...
    # except ResourceNotFoundError | UnauthorizedError | ServiceError
```

------
#### [ JavaScript ]

**Example Exemple : répertorier un objet nommé ombres**  

```
import {
    ListNamedShadowsForThingRequest
} from 'aws-iot-device-sdk-v2/dist/greengrasscoreipc/model';
import * as greengrasscoreipc from 'aws-iot-device-sdk-v2/dist/greengrasscoreipc';

class listNamedShadowsForThing {
    private ipcClient: greengrasscoreipc.Client;
    private thingName: string;
    private pageSizeStr: string;
    private nextToken: string;

    constructor() {
        // Define args parameters here
        this.thingName = "<define_your_own_thingName>";
        this.pageSizeStr = "<define_your_own_pageSize>";
        this.nextToken = "<define_your_own_token>";
        this.bootstrap();
    }

    async bootstrap() {
        try {
            this.ipcClient = await getIpcClient();
        } catch (err) {
            // parse the error depending on your use cases
            throw err
        }
        
        try {
            await this.handleListNamedShadowsForThingOperation(this.thingName,
                this.nextToken, this.pageSizeStr);
        } catch (err) {
            // parse the error depending on your use cases
            throw err
        }
    }

    async handleListNamedShadowsForThingOperation(
        thingName: string,
        nextToken: string,
        pageSizeStr: string
    ) {
        let request: ListNamedShadowsForThingRequest = {
            thingName: thingName,
            nextToken: nextToken,
        };
        if (pageSizeStr) {
            request.pageSize = parseInt(pageSizeStr);
        }
        // make the ListNamedShadowsForThing request
        const response = await this.ipcClient.listNamedShadowsForThing(request);
        const shadowNames = response.results;
    }
}

export async function getIpcClient(){
    try {
        const ipcClient = greengrasscoreipc.createClient();
        await ipcClient.connect()
            .catch(error => {
                // parse the error depending on your use cases
                throw error;
            });
        return ipcClient
    } catch (err) {
        // parse the error depending on your use cases
        throw err
    }
}

const startScript = new listNamedShadowsForThing();
```

------

# Gérez les déploiements et les composants locaux
<a name="ipc-local-deployments-components"></a>

**Note**  
Cette fonctionnalité est disponible pour les versions 2.6.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.

Utilisez le service IPC Greengrass CLI pour gérer les déploiements locaux et les composants Greengrass sur le périphérique principal.

Pour utiliser ces opérations IPC, incluez la version 2.6.0 ou ultérieure du composant Greengrass [CLI en tant que dépendance dans votre composant](greengrass-cli-component.md) personnalisé. Vous pouvez ensuite utiliser les opérations IPC dans vos composants personnalisés pour effectuer les opérations suivantes :
+ Créez des déploiements locaux pour modifier et configurer les composants Greengrass sur le périphérique principal.
+ Redémarrez et arrêtez les composants Greengrass sur le périphérique principal.
+ Générez un mot de passe que vous pouvez utiliser pour vous connecter à la [console de débogage locale](local-debug-console-component.md).

**Topics**
+ [Versions minimales du SDK](#ipc-local-deployments-components-sdk-versions)
+ [Autorisation](#ipc-local-deployments-components-authorization)
+ [CreateLocalDeployment](#ipc-operation-createlocaldeployment)
+ [ListLocalDeployments](#ipc-operation-listlocaldeployments)
+ [GetLocalDeploymentStatus](#ipc-operation-getlocaldeploymentstatus)
+ [ListComponents](#ipc-operation-listcomponents)
+ [GetComponentDetails](#ipc-operation-getcomponentdetails)
+ [RestartComponent](#ipc-operation-restartcomponent)
+ [StopComponent](#ipc-operation-stopcomponent)
+ [CreateDebugPassword](#ipc-operation-createdebugpassword)

## Versions minimales du SDK
<a name="ipc-local-deployments-components-sdk-versions"></a>

Le tableau suivant répertorie les versions minimales du Kit SDK des appareils AWS IoT que vous devez utiliser pour interagir avec le service IPC Greengrass CLI.


| Kit SDK | Version minimale | 
| --- | --- | 
|  [Kit SDK des appareils AWS IoT pour Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.2.10  | 
|  [Kit SDK des appareils AWS IoT pour Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.5.3  | 
|  [Kit SDK des appareils AWS IoT pour C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [Kit SDK des appareils AWS IoT pour JavaScript v2](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

## Autorisation
<a name="ipc-local-deployments-components-authorization"></a>

Pour utiliser le service IPC Greengrass CLI dans un composant personnalisé, vous devez définir des politiques d'autorisation qui permettent à votre composant de gérer les déploiements et les composants locaux. Pour plus d'informations sur la définition des politiques d'autorisation, consultez[Autoriser les composants à effectuer des opérations IPC](interprocess-communication.md#ipc-authorization-policies).

Les politiques d'autorisation de la Greengrass CLI présentent les propriétés suivantes.

**Identifiant du service IPC :** `aws.greengrass.Cli`


| Opération | Description | Ressources | 
| --- | --- | --- | 
|  `aws.greengrass#CreateLocalDeployment`  |  Permet à un composant de créer un déploiement local sur le périphérique principal.  |  `*`  | 
|  `aws.greengrass#ListLocalDeployments`  |  Permet à un composant de répertorier les déploiements locaux sur le périphérique principal.  |  `*`  | 
|  `aws.greengrass#GetLocalDeploymentStatus`  |  Permet à un composant d'obtenir l'état d'un déploiement local sur le périphérique principal.  |  Un identifiant de déploiement local, ou `*` pour autoriser l'accès à tous les déploiements locaux.  | 
|  `aws.greengrass#ListComponents`  |  Permet à un composant de répertorier les composants du périphérique principal.  |  `*`  | 
|  `aws.greengrass#GetComponentDetails`  |  Permet à un composant d'obtenir des informations sur un composant du périphérique principal.  |  Un nom de composant, tel que`com.example.HelloWorld`, ou `*` pour autoriser l'accès à tous les composants.  | 
|  `aws.greengrass#RestartComponent`  |  Permet à un composant de redémarrer un composant sur le périphérique principal.  |  Un nom de composant, tel que`com.example.HelloWorld`, ou `*` pour autoriser l'accès à tous les composants.  | 
|  `aws.greengrass#StopComponent`  |  Permet à un composant d'arrêter un composant du périphérique principal.  |  Un nom de composant, tel que`com.example.HelloWorld`, ou `*` pour autoriser l'accès à tous les composants.  | 
|  `aws.greengrass#CreateDebugPassword`  |  Permet à un composant de générer un mot de passe à utiliser pour se connecter au [composant de console de débogage local](local-debug-console-component.md).  |  `*`  | 

**Example Exemple de politique d'autorisation**  
Les exemples de politiques d'autorisation suivants permettent à un composant de créer des déploiements locaux, de visualiser tous les déploiements et composants locaux, ainsi que de redémarrer et d'arrêter un composant nommé. `com.example.HelloWorld`  

```
{
  "accessControl": {
    "aws.greengrass.Cli": {
      "com.example.MyLocalManagerComponent:cli:1": {
        "policyDescription": "Allows access to create local deployments and view deployments and components.",
        "operations": [
          "aws.greengrass#CreateLocalDeployment",
          "aws.greengrass#ListLocalDeployments",
          "aws.greengrass#GetLocalDeploymentStatus",
          "aws.greengrass#ListComponents",
          "aws.greengrass#GetComponentDetails"
        ],
        "resources": [
          "*"
        ]
      }
    },
    "aws.greengrass.Cli": {
      "com.example.MyLocalManagerComponent:cli:2": {
        "policyDescription": "Allows access to restart and stop the Hello World component.",
        "operations": [
          "aws.greengrass#RestartComponent",
          "aws.greengrass#StopComponent"
        ],
        "resources": [
          "com.example.HelloWorld"
        ]
      }
    }
  }
}
```

## CreateLocalDeployment
<a name="ipc-operation-createlocaldeployment"></a>

Créez ou mettez à jour un déploiement local à l'aide de recettes de composants, d'artefacts et d'arguments d'exécution spécifiés.

Cette opération fournit les mêmes fonctionnalités que la [commande de création de déploiement](gg-cli-deployment.md#deployment-create) dans la CLI Greengrass.

### Demande
<a name="ipc-operation-createlocaldeployment-request"></a>

La demande de cette opération comporte les paramètres suivants :

`recipeDirectoryPath`(Python :`recipe_directory_path`)  
(Facultatif) Le chemin absolu vers le dossier contenant les fichiers de recettes de composants.

`artifactDirectoryPath`(Python :`artifact_directory_path`)  
(Facultatif) Le chemin absolu vers le dossier contenant les fichiers d'artefacts à inclure dans le déploiement. Le dossier des artefacts doit contenir la structure de dossiers suivante :  

```
/path/to/artifact/folder/component-name/component-version/artifacts
```

`rootComponentVersionsToAdd`(Python :`root_component_versions_to_add`)  
(Facultatif) Les versions des composants à installer sur le périphérique principal. Cet objet est une carte qui contient les paires clé-valeur suivantes : `ComponentToVersionMap`    
`key`  
Le nom du composant.  
`value`  
Version du composant.

`rootComponentsToRemove`(Python :`root_components_to_remove`)  
(Facultatif) Les composants à désinstaller du périphérique principal. Spécifiez une liste dans laquelle chaque entrée est le nom d'un composant.

`componentToConfiguration`(Python :`component_to_configuration`)  
(Facultatif) Les mises à jour de configuration pour chaque composant du déploiement. Cet objet est une carte qui contient les paires clé-valeur suivantes : `ComponentToConfiguration`    
`key`  
Le nom du composant.  
`value`  
L'objet JSON de mise à jour de configuration pour le composant. L'objet JSON doit avoir le format suivant.  

```
{ 
  "MERGE": {
    "config-key": "config-value"
  },
  "RESET": [
    "path/to/reset/"
  ]
}
```
Pour plus d'informations sur les mises à jour de configuration, consultez[Mettre à jour les configurations des composants](update-component-configurations.md).

`componentToRunWithInfo`(Python :`component_to_run_with_info`)  
(Facultatif) La configuration d'exécution pour chaque composant du déploiement. Cette configuration inclut l'utilisateur du système qui possède les processus de chaque composant et les limites du système à appliquer à chaque composant. Cet objet est une carte qui contient les paires clé-valeur suivantes : `ComponentToRunWithInfo`    
`key`  
Le nom du composant.  
`value`  
Configuration d'exécution du composant. Si vous omettez un paramètre de configuration d'exécution, le logiciel AWS IoT Greengrass Core utilise les valeurs par défaut que vous configurez sur le noyau [Greengrass](greengrass-nucleus-component.md). Cet objet contient `RunWithInfo` les informations suivantes :    
`posixUser`(Python :`posix_user`)  
(Facultatif) <a name="deployment-posix-user-definition"></a>L'utilisateur du système POSIX et, éventuellement, le groupe à utiliser pour exécuter ce composant sur les périphériques principaux Linux. L'utilisateur et le groupe, s'ils sont spécifiés, doivent exister sur chaque périphérique principal Linux. Spécifiez l'utilisateur et le groupe en les séparant par deux points (`:`) au format suivant : `user:group`. Le groupe est facultatif. Si vous ne spécifiez aucun groupe, le logiciel AWS IoT Greengrass Core utilise le groupe principal pour l'utilisateur. Pour plus d'informations, consultez [Configurer l'utilisateur qui exécute les composants](configure-greengrass-core-v2.md#configure-component-user).   
`windowsUser`(Python :`windows_user`)  
(Facultatif) <a name="deployment-windows-user-definition"></a>Utilisateur Windows à utiliser pour exécuter ce composant sur les appareils principaux de Windows. L'utilisateur doit exister sur chaque appareil principal de Windows, et son nom et son mot de passe doivent être stockés dans l'instance Credentials Manager du LocalSystem compte. Pour plus d'informations, consultez [Configurer l'utilisateur qui exécute les composants](configure-greengrass-core-v2.md#configure-component-user).   
`systemResourceLimits`(Python :`system_resource_limits`)  
(Facultatif) <a name="deployment-system-resource-limits-definition"></a>Les limites de ressources système à appliquer aux processus de ce composant. Vous pouvez appliquer des limites de ressources système aux composants Lambda génériques et non conteneurisés. Pour plus d'informations, consultez [Configuration des limites de ressources système pour les composants](configure-greengrass-core-v2.md#configure-component-system-resource-limits).   
AWS IoT Greengrass ne prend actuellement pas en charge cette fonctionnalité sur les appareils Windows principaux.   
Cet objet contient `SystemResourceLimits` les informations suivantes :    
`cpus`  
(Facultatif) <a name="system-resource-limits-cpu-definition-this"></a>Durée maximale du processeur que les processus de ce composant peuvent utiliser sur le périphérique principal. Le temps processeur total d'un appareil principal est équivalent au nombre de cœurs processeurs de l'appareil. Par exemple, sur un périphérique principal doté de 4 cœurs de processeur, vous pouvez définir cette valeur `2` pour limiter les processus de ce composant à 50 % d'utilisation de chaque cœur de processeur. Sur un appareil doté d'un cœur de processeur, vous pouvez définir cette valeur `0.25` pour limiter les processus de ce composant à 25 % d'utilisation du processeur. Si vous définissez cette valeur sur un nombre supérieur au nombre de cœurs de processeur, le logiciel AWS IoT Greengrass Core ne limite pas l'utilisation du processeur par le composant.   
`memory`  
(Facultatif) <a name="system-resource-limits-memory-definition-this"></a>La quantité maximale de RAM (en kilo-octets) que les processus de ce composant peuvent utiliser sur le périphérique principal. 

`groupName`(Python :`group_name`)  
(Facultatif) Nom du groupe d'objets à cibler dans le cadre de ce déploiement.

### Réponse
<a name="ipc-operation-createlocaldeployment-response"></a>

La réponse de cette opération contient les informations suivantes :

`deploymentId`(Python :`deployment_id`)  
ID du déploiement local créé par la demande.

## ListLocalDeployments
<a name="ipc-operation-listlocaldeployments"></a>

Obtient le statut des 10 derniers déploiements locaux.

Cette opération fournit les mêmes fonctionnalités que la [commande de liste de déploiement](gg-cli-deployment.md#deployment-list) dans la CLI Greengrass.

### Demande
<a name="ipc-operation-listlocaldeployments-request"></a>

La demande de cette opération ne comporte aucun paramètre.

### Réponse
<a name="ipc-operation-listlocaldeployments-response"></a>

La réponse de cette opération contient les informations suivantes :

`localDeployments`(Python :`local_deployments`)  
La liste des déploiements locaux. Chaque objet de cette liste est un `LocalDeployment` objet qui contient les informations suivantes :  <a name="ipc-local-deployment-object-shape"></a>  
`deploymentId`(Python :`deployment_id`)  
ID du déploiement local.  
`status`  
État du déploiement local. Cette énumération possède `DeploymentStatus` les valeurs suivantes :  
+ `QUEUED`
+ `IN_PROGRESS`
+ `SUCCEEDED`
+ `FAILED`

## GetLocalDeploymentStatus
<a name="ipc-operation-getlocaldeploymentstatus"></a>

Obtient le statut d'un déploiement local.

Cette opération fournit les mêmes fonctionnalités que la [commande d'état du déploiement](gg-cli-deployment.md#deployment-status) dans la CLI Greengrass.

### Demande
<a name="ipc-operation-getlocaldeploymentstatus-request"></a>

La demande de cette opération comporte les paramètres suivants :

`deploymentId`(Python :`deployment_id`)  
ID du déploiement local à obtenir.

### Réponse
<a name="ipc-operation-getlocaldeploymentstatus-response"></a>

La réponse de cette opération contient les informations suivantes :

`deployment`  
Le déploiement local. Cet objet contient `LocalDeployment` les informations suivantes :  <a name="ipc-local-deployment-object-shape"></a>  
`deploymentId`(Python :`deployment_id`)  
ID du déploiement local.  
`status`  
État du déploiement local. Cette énumération possède `DeploymentStatus` les valeurs suivantes :  
+ `QUEUED`
+ `IN_PROGRESS`
+ `SUCCEEDED`
+ `FAILED`

## ListComponents
<a name="ipc-operation-listcomponents"></a>

Obtient le nom, la version, l'état et la configuration de chaque composant racine sur le périphérique principal. Un *composant racine* est un composant que vous spécifiez dans un déploiement. Cette réponse n'inclut pas les composants installés en tant que dépendances d'autres composants.

Cette opération fournit les mêmes fonctionnalités que la [commande de liste de composants](gg-cli-component.md#component-list) dans la CLI Greengrass.

### Demande
<a name="ipc-operation-listcomponents-request"></a>

La demande de cette opération ne comporte aucun paramètre.

### Réponse
<a name="ipc-operation-listcomponents-response"></a>

La réponse de cette opération contient les informations suivantes :

`components`  
Liste des composants racine du périphérique principal. Chaque objet de cette liste est un `ComponentDetails` objet qui contient les informations suivantes :  <a name="ipc-component-details-object-shape"></a>  
`componentName`(Python :`component_name`)  
Le nom du composant.  
`version`  
Version du composant.  
`state`  
État du composant. Cet état peut être l'un des suivants :  
+ `BROKEN`
+ `ERRORED`
+ `FINISHED`
+ `INSTALLED`
+ `NEW`
+ `RUNNING`
+ `STARTING`
+ `STOPPING`  
`configuration`  
Configuration du composant en tant qu'objet JSON.

## GetComponentDetails
<a name="ipc-operation-getcomponentdetails"></a>

Obtient la version, le statut et la configuration d'un composant sur le périphérique principal.

Cette opération fournit les mêmes fonctionnalités que la [commande component details](gg-cli-component.md#component-details) de la CLI Greengrass.

### Demande
<a name="ipc-operation-getcomponentdetails-request"></a>

La demande de cette opération comporte les paramètres suivants :

`componentName`(Python :`component_name`)  
Nom du composant à obtenir.

### Réponse
<a name="ipc-operation-getcomponentdetails-response"></a>

La réponse de cette opération contient les informations suivantes :

`componentDetails`(Python :`component_details`)  
Les détails du composant. Cet objet contient `ComponentDetails` les informations suivantes :  <a name="ipc-component-details-object-shape"></a>  
`componentName`(Python :`component_name`)  
Le nom du composant.  
`version`  
Version du composant.  
`state`  
État du composant. Cet état peut être l'un des suivants :  
+ `BROKEN`
+ `ERRORED`
+ `FINISHED`
+ `INSTALLED`
+ `NEW`
+ `RUNNING`
+ `STARTING`
+ `STOPPING`  
`configuration`  
Configuration du composant en tant qu'objet JSON.

## RestartComponent
<a name="ipc-operation-restartcomponent"></a>

Redémarre un composant sur le périphérique principal.

**Note**  
Bien que vous puissiez redémarrer n'importe quel composant, nous vous recommandons de ne redémarrer que [les composants génériques](develop-greengrass-components.md#component-types).

Cette opération fournit les mêmes fonctionnalités que la [commande de redémarrage du composant](gg-cli-component.md#component-restart) dans la CLI Greengrass.

### Demande
<a name="ipc-operation-restartcomponent-request"></a>

La demande de cette opération comporte les paramètres suivants :

`componentName`(Python :`component_name`)  
Le nom du composant.

### Réponse
<a name="ipc-operation-restartcomponent-response"></a>

La réponse de cette opération contient les informations suivantes :

`restartStatus`(Python :`restart_status`)  
État de la demande de redémarrage. Le statut de la demande peut être l'un des suivants :  
+ `SUCCEEDED`
+ `FAILED`

`message`  
Un message expliquant pourquoi le composant n'a pas pu redémarrer, en cas d'échec de la demande.

### Exemples
<a name="ipc-operation-restartcomponent-examples"></a>

Les exemples suivants montrent comment appeler cette opération dans le code de composant personnalisé.

------
#### [ Rust ]

**Example Exemple : redémarrage d'un composant**  

```
use gg_sdk::Sdk;

fn main() {
    let sdk = Sdk::init();
    sdk.connect().expect("Failed to establish IPC connection");

    let component_name = "com.example.HelloWorld";

    sdk.restart_component(component_name)
        .expect("Failed to restart component");

    println!("Successfully requested restart for component: {component_name}");
}
```

------
#### [ C ]

**Example Exemple : redémarrage d'un composant**  

```
#include <gg/error.h>
#include <gg/ipc/client.h>
#include <gg/sdk.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    gg_sdk_init();

    GgError err = ggipc_connect();
    if (err != GG_ERR_OK) {
        fprintf(stderr, "Failed to establish IPC connection.\n");
        exit(-1);
    }

    GgBuffer component_name = GG_STR("com.example.HelloWorld");

    err = ggipc_restart_component(component_name);
    if (err != GG_ERR_OK) {
        fprintf(
            stderr,
            "Failed to restart component: %.*s\n",
            (int) component_name.len,
            component_name.data
        );
        exit(-1);
    }

    printf(
        "Successfully requested restart for component: %.*s\n",
        (int) component_name.len,
        component_name.data
    );
}
```

------
#### [ C\$1\$1 (Component SDK) ]

**Example Exemple : redémarrage d'un composant**  

```
#include <gg/ipc/client.hpp>
#include <iostream>

int main() {
    auto &client = gg::ipc::Client::get();

    auto error = client.connect();
    if (error) {
        std::cerr << "Failed to establish IPC connection.\n";
        exit(-1);
    }

    std::string_view component_name = "com.example.HelloWorld";

    error = client.restart_component(component_name);
    if (error) {
        std::cerr << "Failed to restart component: " << component_name << "\n";
        exit(-1);
    }

    std::cout << "Successfully requested restart for component: "
              << component_name << "\n";
}
```

------

## StopComponent
<a name="ipc-operation-stopcomponent"></a>

Arrête les processus d'un composant sur le périphérique principal.

**Note**  
Bien que vous puissiez arrêter n'importe quel composant, nous vous recommandons de n'arrêter que [les composants génériques](develop-greengrass-components.md#component-types).

Cette opération fournit les mêmes fonctionnalités que la [commande d'arrêt du composant](gg-cli-component.md#component-stop) dans la CLI Greengrass.

### Demande
<a name="ipc-operation-stopcomponent-request"></a>

La demande de cette opération comporte les paramètres suivants :

`componentName`(Python :`component_name`)  
Le nom du composant.

### Réponse
<a name="ipc-operation-stopcomponent-response"></a>

La réponse de cette opération contient les informations suivantes :

`stopStatus`(Python :`stop_status`)  
État de la demande d'arrêt. Le statut de la demande peut être l'un des suivants :  
+ `SUCCEEDED`
+ `FAILED`

`message`  
Un message expliquant pourquoi le composant n'a pas pu s'arrêter, en cas d'échec de la demande.

## CreateDebugPassword
<a name="ipc-operation-createdebugpassword"></a>

Génère un mot de passe aléatoire que vous pouvez utiliser pour vous connecter au [composant de console de débogage local](local-debug-console-component.md). Le mot de passe expire 8 heures après sa création.

Cette opération fournit les mêmes fonctionnalités que la [get-debug-password commande](gg-cli-get-debug-password.md) de la CLI Greengrass.

### Demande
<a name="ipc-operation-createdebugpassword-request"></a>

La demande de cette opération ne comporte aucun paramètre.

### Réponse
<a name="ipc-operation-createdebugpassword-response"></a>

La réponse de cette opération contient les informations suivantes :

`username`  
Le nom d'utilisateur à utiliser pour se connecter.

`password`  
Le mot de passe à utiliser pour se connecter.

`passwordExpiration`(Python :`password_expiration`)  
Heure à laquelle le mot de passe expire.

`certificateSHA256Hash`(Python :`certificate_sha256_hash`)  
L'empreinte SHA-256 du certificat autosigné utilisé par la console de débogage locale lorsque le protocole HTTPS est activé. Lorsque vous ouvrez la console de débogage locale, utilisez cette empreinte pour vérifier que le certificat est légitime et que la connexion est sécurisée.

`certificateSHA1Hash`(Python :`certificate_sha1_hash`)  
L'empreinte SHA-1 du certificat autosigné utilisé par la console de débogage locale lorsque le protocole HTTPS est activé. Lorsque vous ouvrez la console de débogage locale, utilisez cette empreinte pour vérifier que le certificat est légitime et que la connexion est sécurisée.

# Authentifier et autoriser les appareils clients
<a name="ipc-client-device-auth"></a>

**Note**  
Cette fonctionnalité est disponible pour les versions 2.6.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.

Utilisez le service IPC d'authentification des appareils clients pour développer un composant de courtier local personnalisé auquel les appareils IoT locaux, tels que les appareils clients, peuvent se connecter.

Pour utiliser ces opérations IPC, incluez la version 2.2.0 ou ultérieure du composant d'[authentification du périphérique client en tant que dépendance dans votre composant](client-device-auth-component.md) personnalisé. Vous pouvez ensuite utiliser les opérations IPC dans vos composants personnalisés pour effectuer les opérations suivantes :
+ Vérifiez l'identité des appareils clients qui se connectent au périphérique principal.
+ Créez une session pour qu'un appareil client se connecte au périphérique principal.
+ Vérifiez si un appareil client est autorisé à effectuer une action.
+ Recevez une notification lorsque le certificat de serveur de l'appareil principal change.

**Topics**
+ [Versions minimales du SDK](#ipc-client-device-auth-sdk-versions)
+ [Autorisation](#ipc-client-device-auth-authorization)
+ [VerifyClientDeviceIdentity](#ipc-operation-verifyclientdeviceidentity)
+ [GetClientDeviceAuthToken](#ipc-operation-getclientdeviceauthtoken)
+ [AuthorizeClientDeviceAction](#ipc-operation-authorizeclientdeviceaction)
+ [SubscribeToCertificateUpdates](#ipc-operation-subscribetocertificateupdates)

## Versions minimales du SDK
<a name="ipc-client-device-auth-sdk-versions"></a>

Le tableau suivant répertorie les versions minimales du service IPC Kit SDK des appareils AWS IoT que vous devez utiliser pour interagir avec le service IPC d'authentification de l'appareil client.


| Kit SDK | Version minimale | 
| --- | --- | 
|  [Kit SDK des appareils AWS IoT pour Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.9.3  | 
|  [Kit SDK des appareils AWS IoT pour Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.11.3  | 
|  [Kit SDK des appareils AWS IoT pour C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.18.3  | 
|  [Kit SDK des appareils AWS IoT pour JavaScript v2](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

## Autorisation
<a name="ipc-client-device-auth-authorization"></a>

Pour utiliser le service IPC d'authentification de l'appareil client dans un composant personnalisé, vous devez définir des politiques d'autorisation permettant à votre composant d'effectuer ces opérations. Pour plus d'informations sur la définition des politiques d'autorisation, consultez[Autoriser les composants à effectuer des opérations IPC](interprocess-communication.md#ipc-authorization-policies).

Les politiques d'autorisation pour l'authentification et l'autorisation des appareils clients présentent les propriétés suivantes.

**Identifiant du service IPC :** `aws.greengrass.clientdevices.Auth`


| Opération | Description | Ressources | 
| --- | --- | --- | 
|  `aws.greengrass#VerifyClientDeviceIdentity`  |  Permet à un composant de vérifier l'identité d'un appareil client.  |  `*`  | 
|  `aws.greengrass#GetClientDeviceAuthToken`  |  Permet à un composant de valider les informations d'identification d'un appareil client et de créer une session pour cet appareil client.  |  `*`  | 
|  `aws.greengrass#AuthorizeClientDeviceAction`  |  Permet à un composant de vérifier si un appareil client est autorisé à effectuer une action.  |  `*`  | 
|  `aws.greengrass#SubscribeToCertificateUpdates`  |  Permet à un composant de recevoir des notifications lorsque le certificat de serveur de l'appareil principal change.  |  `*`  | 
|  `*`  |  Permet à un composant d'effectuer toutes les opérations de service IPC d'authentification du périphérique client.  |  `*`  | 

### Exemples de politiques d'autorisation
<a name="ipc-client-device-auth-authorization-policy-examples"></a>

Vous pouvez vous référer à l'exemple de politique d'autorisation suivant pour vous aider à configurer les politiques d'autorisation pour vos composants.

**Example Exemple de politique d'autorisation**  
L'exemple de politique d'autorisation suivant permet à un composant d'effectuer toutes les opérations IPC d'authentification du périphérique client.  

```
{
  "accessControl": {
    "aws.greengrass.clientdevices.Auth": {
      "com.example.MyLocalBrokerComponent:clientdevices:1": {
        "policyDescription": "Allows access to authenticate and authorize client devices.",
        "operations": [
          "aws.greengrass#VerifyClientDeviceIdentity",
          "aws.greengrass#GetClientDeviceAuthToken",
          "aws.greengrass#AuthorizeClientDeviceAction",
          "aws.greengrass#SubscribeToCertificateUpdates"
        ],
        "resources": [
          "*"
        ]
      }
    }
  }
}
```

## VerifyClientDeviceIdentity
<a name="ipc-operation-verifyclientdeviceidentity"></a>

Vérifiez l'identité d'un appareil client. Cette opération vérifie si le périphérique client est valide AWS IoT .

### Demande
<a name="ipc-operation-verifyclientdeviceidentity-request"></a>

La demande de cette opération comporte les paramètres suivants :

`credential`  
Les informations d'identification de l'appareil client. Cet objet contient `ClientDeviceCredential` les informations suivantes :    
`clientDeviceCertificate`(Python :`client_device_certificate`)  
Le certificat de périphérique X.509 de l'appareil client.

### Réponse
<a name="ipc-operation-verifyclientdeviceidentity-response"></a>

La réponse de cette opération contient les informations suivantes :

`isValidClientDevice`(Python :`is_valid_client_device`)  
Si l'identité de l'appareil client est valide.

## GetClientDeviceAuthToken
<a name="ipc-operation-getclientdeviceauthtoken"></a>

Valide les informations d'identification d'un appareil client et crée une session pour l'appareil client. Cette opération renvoie un jeton de session que vous pouvez utiliser dans les demandes suivantes pour [autoriser les actions de l'appareil client](#ipc-operation-authorizeclientdeviceaction).

Pour connecter correctement un appareil client, le [composant d'authentification du périphérique client](client-device-auth-component.md#client-device-auth-component-configuration) doit accorder l'`mqtt:connect`autorisation pour l'ID client utilisé par le périphérique client.

### Demande
<a name="ipc-operation-getclientdeviceauthtoken-request"></a>

La demande de cette opération comporte les paramètres suivants :

`credential`  
Les informations d'identification de l'appareil client. Cet objet contient `CredentialDocument` les informations suivantes :    
`mqttCredential`(Python :`mqtt_credential`)  
Les informations d'identification MQTT de l'appareil client. Spécifiez l'ID client et le certificat que l'appareil client utilise pour se connecter. Cet objet contient `MQTTCredential` les informations suivantes :    
`clientId`(Python :`client_id`)  
L'ID client à utiliser pour se connecter.  
`certificatePem`(Python :`certificate_pem`)  
Le certificat de périphérique X.509 à utiliser pour la connexion.  
`username`  
Cette propriété n'est pas utilisée actuellement.  
`password`  
Cette propriété n'est pas utilisée actuellement.

### Réponse
<a name="ipc-operation-getclientdeviceauthtoken-response"></a>

La réponse de cette opération contient les informations suivantes :

`clientDeviceAuthToken`(Python :`client_device_auth_token`)  
Le jeton de session pour l'appareil client. Vous pouvez utiliser ce jeton de session dans les demandes suivantes pour autoriser les actions de cet appareil client.

## AuthorizeClientDeviceAction
<a name="ipc-operation-authorizeclientdeviceaction"></a>

Vérifiez si un appareil client est autorisé à effectuer une action sur une ressource. Les *politiques d'autorisation des appareils clients* spécifient les autorisations que les appareils clients peuvent exécuter lorsqu'ils sont connectés à un périphérique principal. Vous définissez les politiques d'autorisation de l'appareil client lorsque vous configurez le [composant d'authentification du périphérique client](client-device-auth-component.md#client-device-auth-component-configuration).

### Demande
<a name="ipc-operation-authorizeclientdeviceaction-request"></a>

La demande de cette opération comporte les paramètres suivants :

`clientDeviceAuthToken`(Python :`client_device_auth_token`)  
Le jeton de session pour l'appareil client.

`operation`  
L'opération à autoriser.

`resource`  
Ressource sur laquelle le dispositif client effectue l'opération.

### Réponse
<a name="ipc-operation-authorizeclientdeviceaction-response"></a>

La réponse de cette opération contient les informations suivantes :

`isAuthorized`(Python :`is_authorized`)  
Si le dispositif client est autorisé à effectuer l'opération sur la ressource.

## SubscribeToCertificateUpdates
<a name="ipc-operation-subscribetocertificateupdates"></a>

Abonnez-vous pour recevoir le nouveau certificat de serveur de l'appareil principal à chaque rotation. Lorsque le certificat de serveur change, les courtiers doivent le recharger à l'aide du nouveau certificat de serveur.

Le [composant d'authentification de l'appareil client](client-device-auth-component.md) effectue une rotation des certificats de serveur tous les 7 jours par défaut. Vous pouvez configurer l'intervalle de rotation entre 2 et 10 jours.

<a name="ipc-subscribe-operation-note"></a>Il s'agit d'une opération d'abonnement dans le cadre de laquelle vous vous abonnez à un flux de messages d'événements. Pour utiliser cette opération, définissez un gestionnaire de réponse au flux avec des fonctions qui gèrent les messages d'événements, les erreurs et la fermeture du flux. Pour de plus amples informations, veuillez consulter [Abonnez-vous aux diffusions d'événements IPC](interprocess-communication.md#ipc-subscribe-operations).

**Type de message d'événement :** `CertificateUpdateEvent`

### Demande
<a name="ipc-operation-subscribetocertificateupdates-request"></a>

La demande de cette opération comporte les paramètres suivants :

`certificateOptions`(Python :`certificate_options`)  
Les types de mises à jour de certificats auxquels vous devez vous abonner. Cet objet contient `CertificateOptions` les informations suivantes :    
`certificateType`(Python :`certificate_type`)  
Type de mises à jour de certificat auxquelles vous devez vous abonner. Choisissez l'option suivante :  
+ `SERVER`

### Réponse
<a name="ipc-operation-subscribetocertificateupdates-response"></a>

La réponse de cette opération contient les informations suivantes :

`messages`  
Le flux de messages. Cet objet contient `CertificateUpdateEvent` les informations suivantes :    
`certificateUpdate`(Python :`certificate_update`)  
Les informations relatives au nouveau certificat. Cet objet contient `CertificateUpdate` les informations suivantes :    
`certificate`  
Certificat.  
`privateKey`(Python :`private_key`)  
La clé privée du certificat.  
`publicKey`(Python :`public_key`)  
La clé publique du certificat.  
`caCertificates`(Python :`ca_certificates`)  
Liste des certificats de l'autorité de certification (CA) de la chaîne de certificats de l'autorité de certification du certificat.