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.

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