Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Usa il SDK per dispositivi AWS IoT per comunicare con il nucleo Greengrass, altri componenti e AWS IoT Core
<a name="interprocess-communication"></a>

I componenti in esecuzione sul dispositivo principale possono utilizzare la libreria AWS IoT Greengrass Core interprocess communication (IPC) SDK per dispositivi AWS IoT per comunicare con il AWS IoT Greengrass nucleo e altri componenti Greengrass. Per sviluppare ed eseguire componenti personalizzati che utilizzano IPC, è necessario utilizzare il servizio IPC SDK per dispositivi AWS IoT di AWS IoT Greengrass base ed eseguire operazioni IPC.

L'interfaccia IPC supporta due tipi di operazioni:
+ **Richiesta/risposta**

  I componenti inviano una richiesta al servizio IPC e ricevono una risposta che contiene il risultato della richiesta.
+ **Subscription**

  I componenti inviano una richiesta di sottoscrizione al servizio IPC e prevedono un flusso di messaggi relativi agli eventi in risposta. I componenti forniscono un gestore di sottoscrizioni che gestisce i messaggi di eventi, gli errori e la chiusura dei flussi. SDK per dispositivi AWS IoT Include un'interfaccia di gestione con la risposta e i tipi di eventi corretti per ogni operazione IPC. Per ulteriori informazioni, consulta [Iscriviti ai flussi di eventi IPC](#ipc-subscribe-operations).

**Topics**
+ [Versioni client IPC](#ipc-client-versions)
+ [Supportato per la comunicazione tra processi SDKs](#ipc-requirements)
+ [Connect al servizio AWS IoT Greengrass Core IPC](#ipc-service-connect)
+ [Autorizza i componenti a eseguire operazioni IPC](#ipc-authorization-policies)
+ [Iscriviti ai flussi di eventi IPC](#ipc-subscribe-operations)
+ [Le migliori pratiche IPC](#ipc-best-practices)
+ [Pubblicare/sottoscrivere messaggi locali](ipc-publish-subscribe.md)
+ [AWS IoT Core Pubblicare/sottoscrivere messaggi MQTT](ipc-iot-core-mqtt.md)
+ [Interagisci con il ciclo di vita dei componenti](ipc-component-lifecycle.md)
+ [Interazione con la configurazione dei componenti](ipc-component-configuration.md)
+ [Recupera valori segreti](ipc-secret-manager.md)
+ [Interagisci con le ombre locali](ipc-local-shadows.md)
+ [Gestisci le implementazioni e i componenti locali](ipc-local-deployments-components.md)
+ [Autentica e autorizza i dispositivi client](ipc-client-device-auth.md)

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

Nelle versioni successive di Java e Python SDKs, AWS IoT Greengrass fornisce una versione migliorata del client IPC, chiamata client IPC V2. Client IPC V2:
+ Riduce la quantità di codice da scrivere per utilizzare le operazioni IPC e aiuta a evitare gli errori comuni che possono verificarsi con il client IPC V1.
+ Richiama i callback del gestore delle sottoscrizioni in un thread separato, quindi ora è possibile eseguire codice di blocco, incluse chiamate di funzioni IPC aggiuntive, nei callback del gestore delle sottoscrizioni. Il client IPC V1 utilizza lo stesso thread per comunicare con il server IPC e chiamare i callback del gestore delle sottoscrizioni.
+ Consente di chiamare le operazioni di sottoscrizione utilizzando espressioni Lambda (Java) o funzioni (Python). Il client IPC V1 richiede la definizione di classi di gestione delle sottoscrizioni.
+ Fornisce versioni sincrone e asincrone di ogni operazione IPC. Il client IPC V1 fornisce solo versioni asincrone di ogni operazione.

Si consiglia di utilizzare il client IPC V2 per sfruttare questi miglioramenti. Tuttavia, molti esempi in questa documentazione e in alcuni contenuti online dimostrano solo come utilizzare il client IPC V1. È possibile utilizzare i seguenti esempi e tutorial per visualizzare componenti di esempio che utilizzano il client IPC V2:
+ [PublishToTopicesempi](ipc-publish-subscribe.md#ipc-operation-publishtotopic-examples)
+ [SubscribeToTopicesempi](ipc-publish-subscribe.md#ipc-operation-subscribetotopic-examples)
+ [Tutorial: Sviluppa un componente Greengrass che rinvii gli aggiornamenti dei componenti](defer-component-updates-tutorial.md)
+ [Tutorial: Interagisci con i dispositivi IoT locali tramite MQTT](client-devices-tutorial.md)

Attualmente, SDK per dispositivi AWS IoT for C\$1\$1 v2 supporta solo il client IPC V1.

## Supportato per la comunicazione tra processi SDKs
<a name="ipc-requirements"></a>

Le librerie AWS IoT Greengrass Core IPC sono incluse nelle seguenti SDK per dispositivi AWS IoT versioni.


| SDK | Versione minima | Utilizzo | 
| --- | --- | --- | 
|  [SDK per dispositivi AWS IoT per Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.6.0  |  Per informazioni, consultare [Utilizzare SDK per dispositivi AWS IoT per Java v2 (client IPC V2)](#ipc-java-v2).  | 
|  [SDK per dispositivi AWS IoT per Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.9.0  |  Per informazioni, consultare [Uso SDK per dispositivi AWS IoT per Python v2 (client IPC V2)](#ipc-python-v2).  | 
|  [SDK per dispositivi AWS IoT per C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  |  Per informazioni, consultare [Utilizzare SDK per dispositivi AWS IoT per C\$1\$1 v2](#ipc-cpp).  | 
|  [SDK per dispositivi AWS IoT per v2 JavaScript ](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  |  Per informazioni, consultare [Usa SDK per dispositivi AWS IoT per JavaScript v2 (client IPC V1)](#ipc-nodejs).  | 

## Connect al servizio AWS IoT Greengrass Core IPC
<a name="ipc-service-connect"></a>

Per utilizzare la comunicazione tra processi nel componente personalizzato, è necessario creare una connessione a un socket del server IPC eseguito dal software AWS IoT Greengrass Core. Completate le seguenti attività per scaricarlo e utilizzarlo SDK per dispositivi AWS IoT nella lingua di vostra scelta. 

### Utilizzare SDK per dispositivi AWS IoT per Java v2 (client IPC V2)
<a name="ipc-java-v2"></a>

**Per utilizzare il SDK per dispositivi AWS IoT per Java v2 (client IPC V2)**

1. Scaricate il file [SDK per dispositivi AWS IoT per Java v2 (v1.6.0](https://github.com/aws/aws-iot-device-sdk-java-v2) o successivo).

1. <a name="use-ipc-java-component-install-step"></a>Effettuate una delle seguenti operazioni per eseguire il codice personalizzato nel componente:
   + Crea il tuo componente come file JAR che include ed esegui SDK per dispositivi AWS IoT questo file JAR nella ricetta del componente.
   + Definisci il SDK per dispositivi AWS IoT JAR come elemento del componente e aggiungi quell'artefatto al classpath quando esegui l'applicazione nella ricetta del componente.

1. Utilizzate il codice seguente per creare il 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);
   }
   ```

### Uso SDK per dispositivi AWS IoT per Python v2 (client IPC V2)
<a name="ipc-python-v2"></a>

**Per usare SDK per dispositivi AWS IoT for Python v2 (client IPC V2)**

1. Scaricate il file [SDK per dispositivi AWS IoT per Python](https://github.com/aws/aws-iot-device-sdk-python-v2) (v1.9.0 o successivo).

1. <a name="use-ipc-python-component-install-step"></a>Aggiungi i [passaggi di installazione dell'SDK al ciclo di vita dell'installazione](https://github.com/aws/aws-iot-device-sdk-python-v2#installation) nella ricetta del componente.

1. Crea una connessione al servizio AWS IoT Greengrass Core IPC. Utilizzate il codice seguente per creare il 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)
   ```

### Utilizzare SDK per dispositivi AWS IoT per C\$1\$1 v2
<a name="ipc-cpp"></a>

<a name="iot-device-sdk-cpp-v2-build-requirements-intro"></a>Per creare la SDK per dispositivi AWS IoT v2 per C\$1\$1, un dispositivo deve disporre dei seguenti strumenti:<a name="iot-device-sdk-cpp-v2-build-requirements"></a>
+ C\$1\$1 11 o versione successiva
+ CMake 3.1 o successivo
+ Uno dei seguenti compilatori:
  + GCC 4.8 o successivo
  + Clang 3.9 o successivo
  + MSVC 2015 o versione successiva

**Per usare il per C\$1\$1 SDK per dispositivi AWS IoT v2**

1. Scarica la versione [SDK per dispositivi AWS IoT per C\$1\$1 v2 (v1.17.0](https://github.com/aws/aws-iot-device-sdk-cpp-v2) o successiva).

1. Segui le [istruzioni di installazione nel README per creare il file](https://github.com/aws/aws-iot-device-sdk-cpp-v2#Installation) per C\$1\$1 v2 dal codice sorgente SDK per dispositivi AWS IoT .

1. Nel tuo strumento di compilazione C\$1\$1, collega la libreria IPC Greengrass`AWS::GreengrassIpc-cpp`, che hai creato nel passaggio precedente. L'`CMakeLists.txt`esempio seguente collega la libreria IPC Greengrass a un progetto con cui create. 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. Nel codice del componente, create una connessione al servizio AWS IoT Greengrass Core IPC per creare un client IPC (). `Aws::Greengrass::GreengrassCoreIpcClient` È necessario definire un gestore del ciclo di vita della connessione IPC che gestisca gli eventi di connessione, disconnessione ed errore IPC. L'esempio seguente crea un client IPC e un gestore del ciclo di vita della connessione IPC che stampa quando il client IPC si connette, si disconnette e rileva errori.

   ```
   #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. Per eseguire il codice personalizzato nel componente, crea il codice come artefatto binario ed esegui l'artefatto binario nella ricetta del componente. Imposta l'`Execute`autorizzazione dell'artefatto per consentire al software AWS IoT Greengrass Core di `OWNER` eseguire l'artefatto binario.

   La `Manifests` sezione relativa alla ricetta del componente potrebbe essere simile all'esempio seguente.

------
#### [ 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
   ```

------

### Usa SDK per dispositivi AWS IoT per JavaScript v2 (client IPC V1)
<a name="ipc-nodejs"></a>

<a name="iot-device-sdk-nodejs-build-requirements-intro"></a>Per creare SDK per dispositivi AWS IoT for JavaScript v2 da utilizzare con NodeJS, un dispositivo deve disporre dei seguenti strumenti:<a name="iot-device-sdk-nodejs-build-requirements"></a>
+ NodeJS 10.0 o versione successiva
  + Esegui `node -v` per controllare la versione di Node.
+ CMake 3.1 o versione successiva

**Per utilizzare SDK per dispositivi AWS IoT for JavaScript v2 (client IPC V1)**

1. Scarica la versione [SDK per dispositivi AWS IoT per JavaScript v2 (v1.12.10](https://github.com/aws/aws-iot-device-sdk-js-v2) o successiva).

1. Segui le [istruzioni di installazione nel README per compilare la](https://github.com/aws/aws-iot-device-sdk-js-v2/tree/v1.12.1#installation) versione v2 dal SDK per dispositivi AWS IoT codice sorgente. JavaScript

1. Crea una connessione al servizio AWS IoT Greengrass Core IPC. Completa i seguenti passaggi per creare il client IPC e stabilire una connessione.

1. Utilizzate il codice seguente per creare il client IPC.

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

1. Usa il codice seguente per stabilire una connessione dal tuo componente al nucleo Greengrass.

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

## Autorizza i componenti a eseguire operazioni IPC
<a name="ipc-authorization-policies"></a>

Per consentire ai componenti personalizzati di utilizzare alcune operazioni IPC, è necessario definire *politiche di autorizzazione* che consentano al componente di eseguire l'operazione su determinate risorse. Ogni politica di autorizzazione definisce un elenco di operazioni e un elenco di risorse consentite dalla politica. Ad esempio, il servizio publish/subscribe di messaggistica IPC definisce le operazioni di pubblicazione e sottoscrizione per le risorse tematiche. È possibile utilizzare il carattere `*` jolly per consentire l'accesso a tutte le operazioni o a tutte le risorse.

Le politiche di autorizzazione vengono definite con il parametro di `accessControl` configurazione, che è possibile impostare nella ricetta del componente o quando si distribuisce il componente. L'`accessControl`oggetto mappa gli identificatori del servizio IPC su elenchi di politiche di autorizzazione. È possibile definire più politiche di autorizzazione per ogni servizio IPC per controllare l'accesso. Ogni politica di autorizzazione ha un ID di policy, che deve essere univoco tra tutti i componenti.

**Suggerimento**  
Per creare una politica univoca IDs, è possibile combinare il nome del componente, il nome del servizio IPC e un contatore. Ad esempio, un componente denominato `com.example.HelloWorld` potrebbe definire due politiche di publish/subscribe autorizzazione con le seguenti: IDs  
`com.example.HelloWorld:pubsub:1`
`com.example.HelloWorld:pubsub:2`

Le politiche di autorizzazione utilizzano il seguente formato. Questo oggetto è il parametro `accessControl` di configurazione.

------
#### [ 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
```

------

### Wildcard nelle politiche di autorizzazione
<a name="ipc-authorization-policy-wildcards"></a>

È possibile utilizzare il carattere `*` jolly nell'`resources`elemento delle politiche di autorizzazione IPC per consentire l'accesso a più risorse in un'unica politica di autorizzazione.
+ In tutte le versioni del [nucleo Greengrass](greengrass-nucleus-component.md), è possibile specificare un singolo `*` carattere come risorsa per consentire l'accesso a tutte le risorse.
+ In [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 e versioni successive, puoi specificare il carattere in una risorsa in modo che corrisponda a qualsiasi combinazione di `*` caratteri. Ad esempio, è possibile specificare di consentire l'accesso `factory/1/devices/Thermostat*/status` a un argomento di stato per tutti i dispositivi termostati di una fabbrica, dove il nome di ogni dispositivo inizia con. `Thermostat`

Quando si definiscono le politiche di autorizzazione per il servizio AWS IoT Core MQTT IPC, è anche possibile utilizzare i caratteri jolly MQTT (`+`and`#`) per abbinare più risorse. Per ulteriori informazioni, vedete i caratteri [jolly MQTT nelle politiche di autorizzazione MQTT IPC](ipc-iot-core-mqtt.md#ipc-iot-core-mqtt-authorization-mqtt-wildcards). AWS IoT Core 

### Variabili di ricetta nelle politiche di autorizzazione
<a name="ipc-authorization-policy-recipe-variables"></a>

[Se si utilizza [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 o versione successiva e si imposta l'opzione di [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)configurazione di Greengrass nucleus su`true`, è possibile utilizzare la variabile recipe nelle politiche di autorizzazione. `{iot:thingName}`](component-recipe-reference.md#recipe-variables) Quando è necessaria una politica di autorizzazione che includa il nome del dispositivo principale, ad esempio per gli argomenti MQTT o le ombre dei dispositivi, è possibile utilizzare questa variabile recipe per configurare un'unica politica di autorizzazione per un gruppo di dispositivi principali. Ad esempio, è possibile consentire a un componente l'accesso alla seguente risorsa per le operazioni IPC shadow.

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

### Caratteri speciali nelle politiche di autorizzazione
<a name="ipc-authorization-policy-special-characters"></a>

Per specificare un valore letterale `*` o un `?` carattere in una politica di autorizzazione, è necessario utilizzare una sequenza di escape. Le seguenti sequenze di escape indicano al software AWS IoT Greengrass Core di utilizzare il valore letterale anziché il significato speciale del carattere. Ad esempio, il `*` carattere è un [jolly](#ipc-authorization-policy-wildcards) che corrisponde a qualsiasi combinazione di caratteri.


| Carattere letterale | Sequenza di escape | Note | 
| --- | --- | --- | 
|  `*`  |  `${*}`  |  | 
|  `?`  |  `${?}`  |  AWS IoT Greengrass attualmente non supporta il carattere `?` jolly, che corrisponde a qualsiasi carattere singolo.  | 
|  `$`  |  `${$}`  |  Usa questa sequenza di escape per abbinare una risorsa che contiene`${`. Ad esempio, per abbinare una risorsa denominata`${resourceName}`, è necessario specificare`${$}{resourceName}`. Altrimenti, per far corrispondere una risorsa che contiene`$`, è possibile utilizzare un valore letterale`$`, ad esempio per consentire l'accesso a un argomento che inizia con`$aws`.  | 

### Esempi di politiche di autorizzazione
<a name="ipc-authorization-policy-examples"></a>

Puoi fare riferimento ai seguenti esempi di politiche di autorizzazione per aiutarti a configurare le politiche di autorizzazione per i tuoi componenti.

**Example Esempio di ricetta dei componenti con una politica di autorizzazione**  
Il seguente esempio di ricetta del componente include un `accessControl` oggetto che definisce una politica di autorizzazione. Questa politica autorizza il `com.example.HelloWorld` componente a pubblicare sull'`test/topic`argomento.  

```
{
  "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 Esempio di aggiornamento della configurazione del componente con una politica di autorizzazione**  
L'esempio seguente di aggiornamento della configurazione in una distribuzione specifica di configurare un componente con un `accessControl` oggetto che definisce una politica di autorizzazione. Questa politica autorizza il `com.example.HelloWorld` componente a pubblicare sull'`test/topic`argomento.    
**Configurazione da unire**  

```
{
  "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"
        ]
      }
    }
  }
}
```
Il comando seguente crea una distribuzione su un dispositivo principale.  

```
aws greengrassv2 create-deployment --cli-input-json file://hello-world-deployment.json
```
Il `hello-world-deployment.json` file contiene il seguente documento JSON.  

```
{
  "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\"]}}}}"
      }
    }
  }
}
```
Il seguente comando [Greengrass CLI](greengrass-cli-component.md) crea una distribuzione locale su un dispositivo principale.  

```
sudo greengrass-cli deployment create \
  --recipeDir recipes \
  --artifactDir artifacts \
  --merge "com.example.HelloWorld=1.0.0" \
  --update-config hello-world-configuration.json
```
Il `hello-world-configuration.json` file contiene il seguente documento JSON.  

```
{
  "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"
            ]
          }
        }
      }
    }
  }
}
```

## Iscriviti ai flussi di eventi IPC
<a name="ipc-subscribe-operations"></a>

È possibile utilizzare le operazioni IPC per sottoscrivere flussi di eventi su un dispositivo core Greengrass. Per utilizzare un'operazione di sottoscrizione, definisci un *gestore di sottoscrizioni* e crea una richiesta al servizio IPC. Quindi, il client IPC esegue le funzioni del gestore delle sottoscrizioni ogni volta che il dispositivo principale trasmette un messaggio di evento al componente.

È possibile chiudere un abbonamento per interrompere l'elaborazione dei messaggi relativi agli eventi. A tale scopo, chiamate `closeStream()` (Java), `close()` (Python) o `Close()` (C\$1\$1) sull'oggetto dell'operazione di sottoscrizione utilizzato per aprire l'abbonamento.

Il servizio AWS IoT Greengrass Core IPC supporta le seguenti operazioni di sottoscrizione:
+ [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**
+ [Definire i gestori di sottoscrizione](#ipc-define-subscription-handlers)
+ [Esempi di gestori di sottoscrizioni](#ipc-subscription-handler-examples)

### Definire i gestori di sottoscrizione
<a name="ipc-define-subscription-handlers"></a>

Per definire un gestore di sottoscrizioni, definite le funzioni di callback che gestiscono i messaggi di evento, gli errori e la chiusura dei flussi. Se si utilizza il client IPC V1, è necessario definire queste funzioni in una classe. Se si utilizza il client IPC V2, disponibile nelle versioni successive di Java e Python SDKs, è possibile definire queste funzioni senza creare una classe di gestione delle sottoscrizioni.

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

Se si utilizza il client IPC V1, è necessario implementare l'interfaccia generica. `software.amazon.awssdk.eventstreamrpc.StreamResponseHandler<StreamEventType>` *StreamEventType*è il tipo di messaggio di evento per l'operazione di sottoscrizione. Definite le seguenti funzioni per gestire i messaggi di evento, gli errori e la chiusura dei flussi.

[Se si utilizza il client IPC V2, è possibile definire queste funzioni al di fuori di una classe di gestione delle sottoscrizioni o utilizzare espressioni lambda.](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html)

`void onStreamEvent(StreamEventType event)`  
Il callback che il client IPC chiama quando riceve un messaggio di evento, ad esempio un messaggio MQTT o una notifica di aggiornamento del componente.

`boolean onStreamError(Throwable error)`  
Il callback che il client IPC chiama quando si verifica un errore di stream.  
<a name="ipc-subscription-handler-on-stream-error-return-value"></a>Restituisci true per chiudere il flusso di sottoscrizioni a causa dell'errore o restituisci false per mantenere aperto lo stream.

`void onStreamClosed()`  
Il callback che il client IPC chiama alla chiusura dello stream.

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

Se si utilizza il client IPC V1, è necessario estendere la classe stream response handler che corrisponde all'operazione di sottoscrizione. SDK per dispositivi AWS IoT Include una classe di gestione delle sottoscrizioni per ogni operazione di sottoscrizione. *StreamEventType*è il tipo di messaggio di evento per l'operazione di sottoscrizione. Definite le seguenti funzioni per gestire i messaggi di evento, gli errori e la chiusura dei flussi.

[Se si utilizza il client IPC V2, è possibile definire queste funzioni al di fuori di una classe di gestione delle sottoscrizioni o utilizzare espressioni lambda.](https://docs.python.org/3/tutorial/controlflow.html#lambda-expressions)

`def on_stream_event(self, event: StreamEventType) -> None`  
Il callback che il client IPC chiama quando riceve un messaggio di evento, ad esempio un messaggio MQTT o una notifica di aggiornamento del componente.

`def on_stream_error(self, error: Exception) -> bool`  
Il callback che il client IPC chiama quando si verifica un errore di stream.  
<a name="ipc-subscription-handler-on-stream-error-return-value"></a>Restituisci true per chiudere il flusso di sottoscrizioni a causa dell'errore o restituisci false per mantenere aperto lo stream.

`def on_stream_closed(self) -> None`  
Il callback che il client IPC chiama alla chiusura dello stream.

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

Implementa una classe che deriva dalla classe stream response handler che corrisponde all'operazione di sottoscrizione. SDK per dispositivi AWS IoT Include una classe base di gestione delle sottoscrizioni per ogni operazione di sottoscrizione. *StreamEventType*è il tipo di messaggio di evento per l'operazione di sottoscrizione. Definite le seguenti funzioni per gestire i messaggi di evento, gli errori e la chiusura dei flussi.

`void OnStreamEvent(StreamEventType *event)`  
Il callback che il client IPC chiama quando riceve un messaggio di evento, ad esempio un messaggio MQTT o una notifica di aggiornamento del componente.

`bool OnStreamError(OperationError *error)`  
Il callback che il client IPC chiama quando si verifica un errore di stream.  
<a name="ipc-subscription-handler-on-stream-error-return-value"></a>Restituisci true per chiudere il flusso di sottoscrizioni a causa dell'errore o restituisci false per mantenere aperto lo stream.

`void OnStreamClosed()`  
Il callback che il client IPC chiama alla chiusura dello stream.

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

Implementa una classe che deriva dalla classe stream response handler che corrisponde all'operazione di sottoscrizione. SDK per dispositivi AWS IoT Include una classe base di gestione delle sottoscrizioni per ogni operazione di sottoscrizione. *StreamEventType*è il tipo di messaggio di evento per l'operazione di sottoscrizione. Definite le seguenti funzioni per gestire i messaggi di evento, gli errori e la chiusura dei flussi.

`on(event: 'ended', listener: StreamingOperationEndedListener)`  
Il callback che il client IPC chiama alla chiusura dello stream.

`on(event: 'streamError', listener: StreamingRpcErrorListener)`  
Il callback che il client IPC chiama quando si verifica un errore di streaming.  
<a name="ipc-subscription-handler-on-stream-error-return-value"></a>Restituisci true per chiudere il flusso di sottoscrizioni a causa dell'errore o restituisci false per mantenere aperto lo stream.

`on(event: 'message', listener: (message: InboundMessageType) => void)`  
Il callback che il client IPC chiama quando riceve un messaggio di evento, ad esempio un messaggio MQTT o una notifica di aggiornamento del componente.

------

### Esempi di gestori di sottoscrizioni
<a name="ipc-subscription-handler-examples"></a>

L'esempio seguente mostra come utilizzare l'[SubscribeToTopic](ipc-publish-subscribe.md#ipc-operation-subscribetotopic)operazione e un gestore di sottoscrizioni per sottoscrivere i messaggi di pubblicazione/sottoscrizione locali.

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

**Example Esempio: iscriversi ai messaggi locali publish/subscribe**  <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 Esempio: iscriversi ai publish/subscribe messaggi locali**  <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 Esempio: iscriversi ai publish/subscribe messaggi locali**  <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 Esempio: iscriversi ai publish/subscribe messaggi locali**  <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 Esempio: iscriversi ai publish/subscribe messaggi locali**  

```
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 Esempio: iscriversi ai publish/subscribe messaggi locali**  

```
#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 Esempio: iscriversi ai publish/subscribe messaggi locali**  

```
#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);
    }
}
```

------

## Le migliori pratiche IPC
<a name="ipc-best-practices"></a>

Le migliori pratiche per l'utilizzo di IPC nei componenti personalizzati differiscono tra il client IPC V1 e il client IPC V2. Segui le migliori pratiche per la versione del client IPC che utilizzi.

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

Il client IPC V2 esegue le funzioni di callback in un thread separato, quindi rispetto al client IPC V1, ci sono meno linee guida da seguire quando si utilizzano IPC e si scrivono le funzioni di gestione delle sottoscrizioni.
+ <a name="ipc-best-practice-reuse-one-client"></a>**Riutilizza un client IPC**

  Dopo aver creato un client IPC, tienilo aperto e riutilizzalo per tutte le operazioni IPC. La creazione di più client utilizza risorse aggiuntive e può causare perdite di risorse.
+ **Gestisci le eccezioni**

  Il client IPC V2 registra le eccezioni non rilevate nelle funzioni di gestione delle sottoscrizioni. È necessario catturare le eccezioni nelle funzioni del gestore per gestire gli errori che si verificano nel codice.

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

Il client IPC V1 utilizza un singolo thread che comunica con il server IPC e chiama i gestori di sottoscrizione. È necessario considerare questo comportamento sincrono quando si scrivono funzioni di gestione delle sottoscrizioni.
+ <a name="ipc-best-practice-reuse-one-client"></a>**Riutilizza un client IPC**

  Dopo aver creato un client IPC, tienilo aperto e riutilizzalo per tutte le operazioni IPC. La creazione di più client utilizza risorse aggiuntive e può causare perdite di risorse.
+ **Esegui il codice di blocco in modo asincrono**

  Il client IPC V1 non può inviare nuove richieste o elaborare nuovi messaggi di eventi mentre il thread è bloccato. È necessario eseguire il codice di blocco in un thread separato eseguito dalla funzione di gestione. Il codice di blocco include `sleep` chiamate, loop in esecuzione continua e I/O richieste sincrone il cui completamento richiede tempo.
+ **Invia nuove richieste IPC in modo asincrono**

  Il client IPC V1 non può inviare una nuova richiesta dall'interno delle funzioni di gestione delle sottoscrizioni, poiché la richiesta blocca la funzione di gestione se si attende una risposta. È necessario inviare le richieste IPC in un thread separato eseguito dalla funzione di gestione.
+ **Gestisci le eccezioni**

  Il client IPC V1 non gestisce le eccezioni non rilevate nelle funzioni di gestione delle sottoscrizioni. Se la funzione di gestione genera un'eccezione, l'abbonamento si chiude e l'eccezione non viene visualizzata nei registri dei componenti. È necessario catturare le eccezioni nelle funzioni del gestore per mantenere aperto l'abbonamento e registrare gli errori che si verificano nel codice.

------

# Pubblicare/sottoscrivere messaggi locali
<a name="ipc-publish-subscribe"></a>

La messaggistica Publish/subscribe (pubsub) consente di inviare e ricevere messaggi relativi agli argomenti. I componenti possono pubblicare messaggi su argomenti per inviare messaggi ad altri componenti. Quindi, i componenti sottoscritti a quell'argomento possono agire sui messaggi che ricevono.

**Nota**  
Non è possibile utilizzare questo servizio publish/subscribe IPC per pubblicare o sottoscrivere MQTT. AWS IoT Core Per ulteriori informazioni su come scambiare messaggi con AWS IoT Core MQTT, vedere. [AWS IoT Core Pubblicare/sottoscrivere messaggi MQTT](ipc-iot-core-mqtt.md)

**Topics**
+ [Versioni SDK minime](#ipc-publish-subscribe-sdk-versions)
+ [Autorizzazione](#ipc-publish-subscribe-authorization)
+ [PublishToTopic](#ipc-operation-publishtotopic)
+ [SubscribeToTopic](#ipc-operation-subscribetotopic)
+ [Esempi](#ipc-publish-subscribe-examples)

## Versioni SDK minime
<a name="ipc-publish-subscribe-sdk-versions"></a>

La tabella seguente elenca le versioni minime da utilizzare per pubblicare e sottoscrivere messaggi da e verso argomenti locali. SDK per dispositivi AWS IoT 


| SDK | Versione minima | 
| --- | --- | 
|  [SDK per dispositivi AWS IoT per Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.2.10  | 
|  [SDK per dispositivi AWS IoT per Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.5.3  | 
|  [SDK per dispositivi AWS IoT per C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [SDK per dispositivi AWS IoT per JavaScript  ](https://github.com/aws/aws-iot-device-sdk-js-v2) v2  |  v1.12.0  | 

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

Per utilizzare la publish/subscribe messaggistica locale in un componente personalizzato, è necessario definire politiche di autorizzazione che consentano al componente di inviare e ricevere messaggi relativi agli argomenti. Per informazioni sulla definizione delle politiche di autorizzazione, vedere[Autorizza i componenti a eseguire operazioni IPC](interprocess-communication.md#ipc-authorization-policies).

Le politiche di autorizzazione per la publish/subscribe messaggistica hanno le seguenti proprietà.

**Identificatore del servizio IPC:** `aws.greengrass.ipc.pubsub`


| Operation | Description | Resources | 
| --- | --- | --- | 
|  `aws.greengrass#PublishToTopic`  |  Consente a un componente di pubblicare messaggi sugli argomenti specificati.  |  Una stringa di argomento, ad esempio`test/topic`. Usa an `*` per abbinare qualsiasi combinazione di caratteri in un argomento. Questa stringa di argomento non supporta i caratteri jolly degli argomenti MQTT (`#`and`+`).  | 
|  `aws.greengrass#SubscribeToTopic`  |  Consente a un componente di sottoscrivere i messaggi per gli argomenti specificati.  |  Una stringa di argomento, ad esempio`test/topic`. Usa an `*` per abbinare qualsiasi combinazione di caratteri in un argomento. <a name="ipc-local-publish-subscribe-authorization-mqtt-wildcards"></a>In [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 e versioni successive, è possibile sottoscrivere argomenti che contengono caratteri jolly degli argomenti MQTT (and). `#` `+` Questa stringa di argomenti supporta i caratteri jolly degli argomenti MQTT come caratteri letterali. Ad esempio, se la politica di autorizzazione di un componente concede l'accesso a`test/topic/#`, il componente può sottoscrivere`test/topic/#`, ma non può sottoscrivere. `test/topic/filter`  | 
|  `*`  |  Consente a un componente di pubblicare e sottoscrivere messaggi per gli argomenti specificati.  |  Una stringa di argomento, ad esempio`test/topic`. Usa an `*` per abbinare qualsiasi combinazione di caratteri in un argomento. <a name="ipc-local-publish-subscribe-authorization-mqtt-wildcards"></a>In [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 e versioni successive, è possibile sottoscrivere argomenti che contengono caratteri jolly degli argomenti MQTT (and). `#` `+` Questa stringa di argomenti supporta i caratteri jolly degli argomenti MQTT come caratteri letterali. Ad esempio, se la politica di autorizzazione di un componente concede l'accesso a`test/topic/#`, il componente può sottoscrivere`test/topic/#`, ma non può sottoscrivere. `test/topic/filter`  | 

### Esempi di politiche di autorizzazione
<a name="ipc-publish-subscribe-authorization-policy-examples"></a>

È possibile fare riferimento al seguente esempio di politica di autorizzazione per configurare le politiche di autorizzazione per i componenti.

**Example Esempio di politica di autorizzazione**  
Il seguente esempio di politica di autorizzazione consente a un componente di pubblicare e sottoscrivere tutti gli argomenti.  

```
{
  "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>

Pubblicare un messaggio in un argomento.

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

La richiesta di questa operazione ha i seguenti parametri:

`topic`  
L'argomento su cui pubblicare il messaggio.

`publishMessage`(Python:) `publish_message`  
Il messaggio da pubblicare. Questo oggetto contiene `PublishMessage` le seguenti informazioni. È necessario specificare uno tra `jsonMessage` e`binaryMessage`.  <a name="ipc-publish-subscribe-message-shape"></a>  
`jsonMessage`(Python:) `json_message`  
(Facoltativo) Un messaggio JSON. Questo oggetto contiene `JsonMessage` le seguenti informazioni:    
`message`  
Il messaggio JSON come oggetto.  
`context`  <a name="ipc-publish-subscribe-message-context-variable"></a>
Il contesto del messaggio, ad esempio l'argomento in cui è stato pubblicato il messaggio.  
[Questa funzionalità è disponibile per la versione 2.6.0 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md) La tabella seguente elenca le versioni minime di da utilizzare per SDK per dispositivi AWS IoT accedere al contesto del messaggio.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v2/developerguide/ipc-publish-subscribe.html)
Il software AWS IoT Greengrass Core utilizza gli stessi oggetti di messaggio nelle operazioni and. `PublishToTopic` `SubscribeToTopic` Il software AWS IoT Greengrass Core imposta questo oggetto contestuale nei messaggi al momento della sottoscrizione e lo ignora nei messaggi pubblicati.
Questo oggetto contiene `MessageContext` le seguenti informazioni:    
`topic`  
L'argomento in cui è stato pubblicato il messaggio.  
`binaryMessage`(Python:) `binary_message`  
(Facoltativo) Un messaggio binario. Questo oggetto contiene `BinaryMessage` le seguenti informazioni:    
`message`  
Il messaggio binario come blob.  
`context`  <a name="ipc-publish-subscribe-message-context-variable"></a>
Il contesto del messaggio, ad esempio l'argomento in cui è stato pubblicato il messaggio.  
[Questa funzionalità è disponibile per la versione 2.6.0 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md) La tabella seguente elenca le versioni minime di da utilizzare per SDK per dispositivi AWS IoT accedere al contesto del messaggio.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v2/developerguide/ipc-publish-subscribe.html)
Il software AWS IoT Greengrass Core utilizza gli stessi oggetti di messaggio nelle operazioni and. `PublishToTopic` `SubscribeToTopic` Il software AWS IoT Greengrass Core imposta questo oggetto contestuale nei messaggi al momento della sottoscrizione e lo ignora nei messaggi pubblicati.
Questo oggetto contiene `MessageContext` le seguenti informazioni:    
`topic`  
L'argomento in cui è stato pubblicato il messaggio.

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

Questa operazione non fornisce alcuna informazione nella sua risposta.

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

Gli esempi seguenti mostrano come chiamare questa operazione nel codice componente personalizzato.

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

**Example Esempio: pubblicare un messaggio binario**  

```
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 Esempio: pubblicare un messaggio binario**  

```
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 Esempio: pubblicare un messaggio binario**  

```
#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 Esempio: pubblicare un messaggio binario**  

```
    
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 Esempio: pubblicare un messaggio binario**  

```
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 Esempio: pubblicare un messaggio binario**  

```
#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 Esempio: pubblicare un messaggio binario**  

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

Iscriviti ai messaggi su un argomento.

<a name="ipc-subscribe-operation-note"></a>Questa operazione è un'operazione di sottoscrizione in cui ci si iscrive a un flusso di messaggi di eventi. Per utilizzare questa operazione, definite un gestore di risposte di flusso con funzioni che gestiscono i messaggi di evento, gli errori e la chiusura dei flussi. Per ulteriori informazioni, consulta [Iscriviti ai flussi di eventi IPC](interprocess-communication.md#ipc-subscribe-operations).

**Tipo di messaggio di evento:** `SubscriptionResponseMessage`

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

La richiesta di questa operazione ha i seguenti parametri:

`topic`  
L'argomento a cui iscriversi.  
In [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 e versioni successive, questo argomento supporta i caratteri jolly dell'argomento MQTT (and). `#` `+`

`receiveMode`(Python:) `receive_mode`  
(Facoltativo) Il comportamento che specifica se il componente riceve messaggi da se stesso. È possibile modificare questo comportamento per consentire a un componente di agire sui propri messaggi. Il comportamento predefinito dipende dal fatto che l'argomento contenga un jolly MQTT. Seleziona una delle opzioni seguenti:  
+ `RECEIVE_ALL_MESSAGES`— Ricevi tutti i messaggi che corrispondono all'argomento, inclusi i messaggi del componente che effettua la sottoscrizione.

  Questa modalità è l'opzione predefinita quando ci si iscrive a un argomento che non contiene caratteri jolly MQTT.
+ `RECEIVE_MESSAGES_FROM_OTHERS`— Ricevi tutti i messaggi che corrispondono all'argomento, ad eccezione dei messaggi del componente che sottoscrive.

  Questa modalità è l'opzione predefinita quando ci si iscrive a un argomento che contiene un metacarattero MQTT.
[Questa funzionalità è disponibile per la versione 2.6.0 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md) La tabella seguente elenca le versioni minime di SDK per dispositivi AWS IoT che è necessario utilizzare per impostare la modalità di ricezione.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v2/developerguide/ipc-publish-subscribe.html)

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

La risposta di questa operazione contiene le seguenti informazioni:

`messages`  
Il flusso di messaggi. Questo oggetto contiene `SubscriptionResponseMessage` le seguenti informazioni. Ogni messaggio contiene `jsonMessage` o`binaryMessage`.  <a name="ipc-publish-subscribe-message-shape"></a>  
`jsonMessage`(Python:) `json_message`  
(Facoltativo) Un messaggio JSON. Questo oggetto contiene `JsonMessage` le seguenti informazioni:    
`message`  
Il messaggio JSON come oggetto.  
`context`  <a name="ipc-publish-subscribe-message-context-variable"></a>
Il contesto del messaggio, ad esempio l'argomento in cui è stato pubblicato il messaggio.  
[Questa funzionalità è disponibile per la versione 2.6.0 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md) La tabella seguente elenca le versioni minime di da utilizzare per SDK per dispositivi AWS IoT accedere al contesto del messaggio.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v2/developerguide/ipc-publish-subscribe.html)
Il software AWS IoT Greengrass Core utilizza gli stessi oggetti di messaggio nelle operazioni and. `PublishToTopic` `SubscribeToTopic` Il software AWS IoT Greengrass Core imposta questo oggetto contestuale nei messaggi al momento della sottoscrizione e lo ignora nei messaggi pubblicati.
Questo oggetto contiene `MessageContext` le seguenti informazioni:    
`topic`  
L'argomento in cui è stato pubblicato il messaggio.  
`binaryMessage`(Python:) `binary_message`  
(Facoltativo) Un messaggio binario. Questo oggetto contiene `BinaryMessage` le seguenti informazioni:    
`message`  
Il messaggio binario come blob.  
`context`  <a name="ipc-publish-subscribe-message-context-variable"></a>
Il contesto del messaggio, ad esempio l'argomento in cui è stato pubblicato il messaggio.  
[Questa funzionalità è disponibile per la versione 2.6.0 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md) La tabella seguente elenca le versioni minime di da utilizzare per SDK per dispositivi AWS IoT accedere al contesto del messaggio.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v2/developerguide/ipc-publish-subscribe.html)
Il software AWS IoT Greengrass Core utilizza gli stessi oggetti di messaggio nelle operazioni and. `PublishToTopic` `SubscribeToTopic` Il software AWS IoT Greengrass Core imposta questo oggetto contestuale nei messaggi al momento della sottoscrizione e lo ignora nei messaggi pubblicati.
Questo oggetto contiene `MessageContext` le seguenti informazioni:    
`topic`  
L'argomento in cui è stato pubblicato il messaggio.

`topicName`(Python:) `topic_name`  
L'argomento su cui è stato pubblicato il messaggio.  
Questa proprietà non è attualmente utilizzata. In [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 e versioni successive, puoi ottenere il `(jsonMessage|binaryMessage).context.topic` valore da `SubscriptionResponseMessage` a per ottenere l'argomento in cui è stato pubblicato il messaggio.

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

I seguenti esempi mostrano come chiamare questa operazione nel codice componente personalizzato.

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

**Example Esempio: iscriversi ai publish/subscribe messaggi locali**  <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 Esempio: iscriversi ai publish/subscribe messaggi locali**  <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 Esempio: iscriversi ai publish/subscribe messaggi locali**  <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 Esempio: iscriversi ai publish/subscribe messaggi locali**  <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 Esempio: iscriversi ai publish/subscribe messaggi locali**  

```
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 Esempio: iscriversi ai publish/subscribe messaggi locali**  

```
#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 Esempio: iscriversi ai publish/subscribe messaggi locali**  

```
#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);
    }
}
```

------

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

Utilizza i seguenti esempi per imparare a utilizzare il servizio publish/subscribe IPC nei tuoi componenti.

### publish/subscribe Editore di esempio (Java, client IPC V1)
<a name="ipc-publish-subscribe-example-publisher-java"></a>

La seguente ricetta di esempio consente al componente di pubblicare su tutti gli argomenti.

------
#### [ 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'applicazione Java di esempio seguente mostra come utilizzare il servizio IPC publish/subscribe per pubblicare messaggi su altri componenti.

```
/* 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);
        }
    }
}
```

### Esempio di publish/subscribe sottoscrittore (Java, client IPC V1)
<a name="ipc-publish-subscribe-example-subscriber-java"></a>

La seguente ricetta di esempio consente al componente di sottoscrivere tutti gli argomenti.

------
#### [ 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'applicazione Java di esempio seguente mostra come utilizzare il servizio IPC publish/subscribe per sottoscrivere i messaggi di altri componenti.

```
/* 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.");
        }
    }
}
```

### publish/subscribe Editore di esempio (Python, client IPC V1)
<a name="ipc-publish-subscribe-example-publisher-python"></a>

La seguente ricetta di esempio consente al componente di pubblicare su tutti gli argomenti.

------
#### [ 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'esempio seguente di applicazione Python dimostra come utilizzare il servizio IPC publish/subscribe per pubblicare messaggi su altri componenti.

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

### Esempio di publish/subscribe sottoscrittore (Python, client IPC V1)
<a name="ipc-publish-subscribe-example-subscriber-python"></a>

La seguente ricetta di esempio consente al componente di sottoscrivere tutti gli argomenti.

------
#### [ 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'esempio seguente di applicazione Python dimostra come utilizzare il servizio IPC publish/subscribe per sottoscrivere messaggi ad altri componenti.

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

### publish/subscribe Editore di esempio (C\$1\$1, client IPC V1)
<a name="ipc-publish-subscribe-example-publisher-cpp"></a>

La seguente ricetta di esempio consente al componente di pubblicare su tutti gli argomenti.

------
#### [ 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'applicazione C\$1\$1 di esempio seguente mostra come utilizzare il servizio IPC publish/subscribe per pubblicare messaggi su altri componenti.

```
#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;
}
```

### Esempio di publish/subscribe sottoscrittore (C\$1\$1, client IPC V1)
<a name="ipc-publish-subscribe-example-subscriber-cpp"></a>

La seguente ricetta di esempio consente al componente di sottoscrivere tutti gli argomenti.

------
#### [ 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'applicazione C\$1\$1 di esempio seguente mostra come utilizzare il servizio IPC publish/subscribe per sottoscrivere i messaggi di altri componenti.

```
#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;
}
```

### Editore di esempio (Rust) publish/subscribe
<a name="ipc-publish-subscribe-example-publisher-rust"></a>

La seguente ricetta di esempio consente al componente di pubblicare su tutti gli argomenti.

```
{
  "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'esempio seguente di applicazione Rust dimostra come utilizzare il servizio IPC publish/subscribe per pubblicare messaggi su altri componenti.

```
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}");
}
```

### Esempio di abbonato (Rust) publish/subscribe
<a name="ipc-publish-subscribe-example-subscriber-rust"></a>

La seguente ricetta di esempio consente al componente di iscriversi a tutti gli argomenti.

```
{
  "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'esempio seguente di applicazione Rust dimostra come utilizzare il servizio IPC publish/subscribe per sottoscrivere messaggi provenienti da altri componenti.

```
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));
    }
}
```

### Editore di esempio (C) publish/subscribe
<a name="ipc-publish-subscribe-example-publisher-c"></a>

La seguente ricetta di esempio consente al componente di pubblicare su tutti gli argomenti.

```
{
  "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'esempio seguente di applicazione C dimostra come utilizzare il servizio IPC publish/subscribe per pubblicare messaggi su altri componenti.

```
#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
    );
}
```

### Esempio di abbonato (C) publish/subscribe
<a name="ipc-publish-subscribe-example-subscriber-c"></a>

La seguente ricetta di esempio consente al componente di sottoscrivere tutti gli argomenti.

```
{
  "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'esempio seguente di applicazione C dimostra come utilizzare il servizio IPC publish/subscribe per sottoscrivere messaggi provenienti da altri componenti.

```
#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);
}
```

### publish/subscribe Editore di esempio (C\$1\$1, Component SDK)
<a name="ipc-publish-subscribe-example-publisher-cpp-component-sdk"></a>

La seguente ricetta di esempio consente al componente di pubblicare su tutti gli argomenti.

```
{
  "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'applicazione C\$1\$1 di esempio seguente mostra come utilizzare il servizio IPC publish/subscribe per pubblicare messaggi su altri componenti.

```
#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";
}
```

### Esempio di publish/subscribe sottoscrittore (C\$1\$1, Component SDK)
<a name="ipc-publish-subscribe-example-subscriber-cpp-component-sdk"></a>

La seguente ricetta di esempio consente al componente di sottoscrivere tutti gli argomenti.

```
{
  "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'applicazione C\$1\$1 di esempio seguente mostra come utilizzare il servizio IPC publish/subscribe per sottoscrivere messaggi provenienti da altri componenti.

```
#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);
    }
}
```

# AWS IoT Core Pubblicare/sottoscrivere messaggi MQTT
<a name="ipc-iot-core-mqtt"></a>

Il servizio IPC di messaggistica AWS IoT Core MQTT consente di inviare e ricevere messaggi MQTT da e verso. AWS IoT Core I componenti possono pubblicare messaggi AWS IoT Core e sottoscrivere argomenti per agire sui messaggi MQTT provenienti da altre fonti. *Per ulteriori informazioni sull' AWS IoT Core implementazione di MQTT, consultate [MQTT nella Developer](https://docs.aws.amazon.com/iot/latest/developerguide/mqtt.html) Guide.AWS IoT Core *

**Nota**  
Questo servizio IPC di messaggistica MQTT consente di scambiare messaggi con. AWS IoT Core Per ulteriori informazioni su come scambiare messaggi tra componenti, vedere. [Pubblicare/sottoscrivere messaggi locali](ipc-publish-subscribe.md)

**Topics**
+ [Versioni SDK minime](#ipc-iot-core-mqtt-sdk-versions)
+ [Autorizzazione](#ipc-iot-core-mqtt-authorization)
+ [PublishToIoTCore](#ipc-operation-publishtoiotcore)
+ [SubscribeToIoTCore](#ipc-operation-subscribetoiotcore)
+ [Esempi](#ipc-iot-core-mqtt-examples)

## Versioni SDK minime
<a name="ipc-iot-core-mqtt-sdk-versions"></a>

La tabella seguente elenca le versioni minime da utilizzare per pubblicare e sottoscrivere messaggi MQTT da e verso. SDK per dispositivi AWS IoT AWS IoT Core


| SDK | Versione minima | 
| --- | --- | 
|  [SDK per dispositivi AWS IoT per Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.2.10  | 
|  [SDK per dispositivi AWS IoT per Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.5.3  | 
|  [SDK per dispositivi AWS IoT per C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [SDK per dispositivi AWS IoT per v2 JavaScript ](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

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

Per utilizzare la messaggistica AWS IoT Core MQTT in un componente personalizzato, è necessario definire politiche di autorizzazione che consentano al componente di inviare e ricevere messaggi su argomenti. Per informazioni sulla definizione delle politiche di autorizzazione, vedere[Autorizza i componenti a eseguire operazioni IPC](interprocess-communication.md#ipc-authorization-policies).

Le politiche di autorizzazione per la messaggistica AWS IoT Core MQTT hanno le seguenti proprietà.

**Identificatore del servizio IPC:** `aws.greengrass.ipc.mqttproxy`


| Operation | Description | Resources | 
| --- | --- | --- | 
|  `aws.greengrass#PublishToIoTCore`  |  Consente a un componente di pubblicare messaggi AWS IoT Core sugli argomenti MQTT specificati.  |  Una stringa di argomenti, ad esempio`test/topic`, o `*` per consentire l'accesso a tutti gli argomenti. È possibile utilizzare i caratteri jolly degli argomenti MQTT (`#`and`+`) per abbinare più risorse.  | 
|  `aws.greengrass#SubscribeToIoTCore`  |  Consente a un componente di sottoscrivere i messaggi provenienti dagli AWS IoT Core argomenti specificati.  |  Una stringa di argomento, ad esempio`test/topic`, o `*` per consentire l'accesso a tutti gli argomenti. È possibile utilizzare i caratteri jolly degli argomenti MQTT (`#`and`+`) per abbinare più risorse.  | 
|  `*`  |  Consente a un componente di pubblicare e sottoscrivere messaggi AWS IoT Core MQTT per gli argomenti specificati.  |  Una stringa di argomenti, ad esempio`test/topic`, o `*` per consentire l'accesso a tutti gli argomenti. È possibile utilizzare i caratteri jolly degli argomenti MQTT (`#`and`+`) per abbinare più risorse.  | 

### I caratteri jolly MQTT nelle politiche di autorizzazione MQTT AWS IoT Core
<a name="ipc-iot-core-mqtt-authorization-mqtt-wildcards"></a>

È possibile utilizzare i caratteri jolly MQTT nelle AWS IoT Core politiche di autorizzazione MQTT IPC. I componenti possono pubblicare e sottoscrivere argomenti che corrispondono al filtro degli argomenti consentito in una politica di autorizzazione. Ad esempio, se la politica di autorizzazione di un componente concede l'accesso a`test/topic/#`, il componente può sottoscrivere`test/topic/#`, pubblicare e sottoscrivere`test/topic/filter`.

### Variabili Recipe nelle politiche di autorizzazione AWS IoT Core MQTT
<a name="ipc-iot-core-mqtt-authorization-recipe-variables"></a>

Se si utilizza la versione 2.6.0 o successiva del [nucleo Greengrass](greengrass-nucleus-component.md), è possibile utilizzare la variabile recipe nelle politiche di autorizzazione. `{iot:thingName}` Questa funzionalità consente di configurare un'unica politica di autorizzazione per un gruppo di dispositivi principali, in cui ogni dispositivo principale può accedere solo agli argomenti che contengono il proprio nome. Ad esempio, è possibile consentire a un componente l'accesso alla seguente risorsa tematica.

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

Per ulteriori informazioni, consultare [Variabili di ricetta](component-recipe-reference.md#recipe-variables) e [Usa le variabili di ricetta negli aggiornamenti di fusione](update-component-configurations.md#merge-configuration-update-recipe-variables).

### Esempi di politiche di autorizzazione
<a name="ipc-iot-core-mqtt-authorization-policy-examples"></a>

Puoi fare riferimento ai seguenti esempi di politiche di autorizzazione per aiutarti a configurare le politiche di autorizzazione per i tuoi componenti.

**Example Esempio di politica di autorizzazione con accesso illimitato**  
Il seguente esempio di politica di autorizzazione consente a un componente di pubblicare e sottoscrivere tutti gli argomenti.  

```
{
  "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 Esempio di politica di autorizzazione con accesso limitato**  
Il seguente esempio di politica di autorizzazione consente a un componente di pubblicare e sottoscrivere due argomenti denominati `factory/1/events` e`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 Esempio di politica di autorizzazione per un gruppo di dispositivi principali**  
[Questo esempio utilizza una funzionalità disponibile per la versione 2.6.0 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md) Greengrass nucleus v2.6.0 aggiunge il supporto per la maggior parte delle [variabili di ricetta](component-recipe-reference.md#recipe-variables), ad esempio nelle configurazioni dei componenti. `{iot:thingName}`
Il seguente esempio di politica di autorizzazione consente a un componente di pubblicare e sottoscrivere un argomento che contiene il nome del dispositivo principale che esegue il componente.  

```
{
  "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>

Pubblica un messaggio MQTT AWS IoT Core su un argomento.

Quando si pubblicano messaggi MQTT su AWS IoT Core, esiste una quota di 100 transazioni al secondo. Se si supera questa quota, i messaggi vengono messi in coda per l'elaborazione sul dispositivo Greengrass. È inoltre prevista una quota di 512 Kb di dati al secondo e una quota a livello di account di 20.000 pubblicazioni al secondo (2.000 in alcune). Regioni AWS Per ulteriori informazioni sui limiti e le quote del broker di messaggi MQTT in AWS IoT Core, vedere [AWS IoT Core Message Broker and Protocol Limits and Protocol](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#message-broker-limits). 

Se superi queste quote, il dispositivo Greengrass limita la pubblicazione dei messaggi a. AWS IoT Core I messaggi vengono archiviati in uno spooler in memoria. Per impostazione predefinita, la memoria allocata allo spooler è 2,5 Mb. Se lo spooler si riempie, i nuovi messaggi vengono rifiutati. È possibile aumentare le dimensioni dello spooler. Per ulteriori informazioni, consulta [Configurazione](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration) nella documentazione [Nucleo Greengrass](greengrass-nucleus-component.md). Per evitare di riempire lo spooler e di dover aumentare la memoria allocata, limita le richieste di pubblicazione a non più di 100 richieste al secondo.

Quando la tua applicazione deve inviare messaggi a una velocità maggiore o messaggi più grandi, prendi in considerazione l'utilizzo di [Stream manager](stream-manager-component.md) per inviare messaggi a Kinesis Data Streams. Il componente stream manager è progettato per trasferire grandi volumi di dati a. Cloud AWS Per ulteriori informazioni, consulta [Gestisci i flussi di dati sui dispositivi core Greengrass](manage-data-streams.md).

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

La richiesta di questa operazione ha i seguenti parametri:

`topicName`(Python:) `topic_name`  
L'argomento su cui pubblicare il messaggio.

`qos`  <a name="ipc-iot-core-mqtt-qos"></a>
Il QoS MQTT da usare. Questo enum`QOS`, ha i seguenti valori:  
+ `AT_MOST_ONCE`— QoS 0. Il messaggio MQTT viene recapitato al massimo una volta.
+ `AT_LEAST_ONCE`— QoS 1. Il messaggio MQTT viene recapitato almeno una volta.

`payload`  
(Facoltativo) Il payload del messaggio sotto forma di blob.

Le seguenti funzionalità sono disponibili per la versione 2.10.0 e successive se si utilizza MQTT 5. [Nucleo Greengrass](greengrass-nucleus-component.md) Queste funzionalità vengono ignorate quando si utilizza MQTT 3.1.1. La tabella seguente elenca la versione minima dell'SDK del AWS IoT dispositivo da utilizzare per accedere a queste funzionalità.


| SDK | Versione minima | 
| --- | --- | 
| [SDK per dispositivi AWS IoT per Python](https://github.com/aws/aws-iot-device-sdk-python-v2) v2 | v1.15.0 | 
| [SDK per dispositivi AWS IoT per Java](https://github.com/aws/aws-iot-device-sdk-java-v2) v2 | v1.13.0 | 
| [SDK per dispositivi AWS IoT per C\$1\$1](https://github.com/aws/aws-iot-device-sdk-cpp-v2) v2 | v1.24.0 | 
| [SDK per dispositivi AWS IoT per JavaScript  ](https://github.com/aws/aws-iot-device-sdk-js-v2) v2  | v1.13.0 | 

`payloadFormat`  
(Facoltativo) Il formato del payload del messaggio. Se non si imposta il`payloadFormat`, si presume che il tipo sia. `BYTES` L'enum ha i seguenti valori:   
+ `BYTES`— Il contenuto del payload è un blob binario.
+ `UTF8`— Il contenuto del payload è una UTF8 stringa di caratteri.

`retain`  
(Facoltativo) Indica se impostare l'opzione di conservazione MQTT su `true` durante la pubblicazione.

`userProperties`  
(Facoltativo) Un elenco di oggetti specifici dell'applicazione da inviare`UserProperty`. L'`UserProperty`oggetto è definito come segue:  

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

`messageExpiryIntervalSeconds`  
(Facoltativo) Il numero di secondi prima che il messaggio scada e venga eliminato dal server. Se questo valore non è impostato, il messaggio non scade.

`correlationData`  
(Facoltativo) Informazioni aggiunte alla richiesta che possono essere utilizzate per associare una richiesta a una risposta.

`responseTopic`  
(Facoltativo) L'argomento da utilizzare per il messaggio di risposta.

`contentType`  
(Facoltativo) Un identificatore specifico dell'applicazione del tipo di contenuto del messaggio.

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

Questa operazione non fornisce alcuna informazione nella sua risposta.

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

Gli esempi seguenti mostrano come chiamare questa operazione nel codice componente personalizzato.

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

**Example Esempio: pubblicare un messaggio**  

```
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 Esempio: pubblicare un messaggio**  
Questo esempio presuppone che si stia utilizzando la versione 1.5.4 o successiva di for SDK per dispositivi AWS IoT 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 Esempio: pubblicare un messaggio**  
Questo esempio utilizza una `IPCUtils` classe per creare una connessione al servizio AWS IoT Greengrass Core IPC. Per ulteriori informazioni, consulta [Connect al servizio 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 Esempio: pubblicare un messaggio**  
Questo esempio presuppone che si stia utilizzando la versione 1.5.4 o successiva di for SDK per dispositivi AWS IoT 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 Esempio: pubblicare un messaggio**  

```
#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 Esempio: pubblicare un messaggio**  

```
    
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 Esempio: pubblicare un messaggio**  

```
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 Esempio: pubblicare un messaggio**  

```
#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 Esempio: pubblicare un messaggio**  

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

Iscriviti ai messaggi MQTT da AWS IoT Core su un argomento o un filtro per argomenti. Il software AWS IoT Greengrass Core rimuove gli abbonamenti quando il componente raggiunge la fine del suo ciclo di vita.

<a name="ipc-subscribe-operation-note"></a>Questa operazione è un'operazione di sottoscrizione in cui ci si iscrive a un flusso di messaggi di eventi. Per utilizzare questa operazione, definite un gestore di risposte di flusso con funzioni che gestiscono i messaggi di evento, gli errori e la chiusura dei flussi. Per ulteriori informazioni, consulta [Iscriviti ai flussi di eventi IPC](interprocess-communication.md#ipc-subscribe-operations).

**Tipo di messaggio di evento:** `IoTCoreMessage`

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

La richiesta di questa operazione ha i seguenti parametri:

`topicName`(Python:) `topic_name`  
L'argomento a cui iscriversi. È possibile utilizzare i caratteri jolly degli argomenti MQTT (`#`and`+`) per sottoscrivere più argomenti.

`qos`  <a name="ipc-iot-core-mqtt-qos"></a>
Il QoS MQTT da usare. Questo enum`QOS`, ha i seguenti valori:  
+ `AT_MOST_ONCE`— QoS 0. Il messaggio MQTT viene recapitato al massimo una volta.
+ `AT_LEAST_ONCE`— QoS 1. Il messaggio MQTT viene recapitato almeno una volta.

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

La risposta di questa operazione contiene le seguenti informazioni:

`messages`  
Il flusso di messaggi MQTT. Questo oggetto contiene `IoTCoreMessage` le seguenti informazioni:    
`message`  
Il messaggio MQTT. Questo oggetto contiene `MQTTMessage` le seguenti informazioni:    
`topicName`(Python:) `topic_name`  
L'argomento su cui è stato pubblicato il messaggio.  
`payload`  
(Facoltativo) Il payload del messaggio sotto forma di blob.
Le seguenti funzionalità sono disponibili per la versione 2.10.0 e successive se si utilizza MQTT 5. [Nucleo Greengrass](greengrass-nucleus-component.md) Queste funzionalità vengono ignorate quando si utilizza MQTT 3.1.1. La tabella seguente elenca la versione minima dell'SDK del AWS IoT dispositivo da utilizzare per accedere a queste funzionalità.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v2/developerguide/ipc-iot-core-mqtt.html)  
`payloadFormat`  
(Facoltativo) Il formato del payload del messaggio. Se non si imposta il`payloadFormat`, si presume che il tipo sia. `BYTES` L'enum ha i seguenti valori:   
+ `BYTES`— Il contenuto del payload è un blob binario.
+ `UTF8`— Il contenuto del payload è una UTF8 stringa di caratteri.  
`retain`  
(Facoltativo) Indica se impostare l'opzione di conservazione MQTT su `true` durante la pubblicazione.  
`userProperties`  
(Facoltativo) Un elenco di oggetti specifici dell'applicazione da inviare`UserProperty`. L'`UserProperty`oggetto è definito come segue:  

```
UserProperty:
  key: string
  value: string
```  
`messageExpiryIntervalSeconds`  
(Facoltativo) Il numero di secondi prima che il messaggio scada e venga eliminato dal server. Se questo valore non è impostato, il messaggio non scade.  
`correlationData`  
(Facoltativo) Informazioni aggiunte alla richiesta che possono essere utilizzate per associare una richiesta a una risposta.  
`responseTopic`  
(Facoltativo) L'argomento da utilizzare per il messaggio di risposta.  
`contentType`  
(Facoltativo) Un identificatore specifico dell'applicazione del tipo di contenuto del messaggio.

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

Gli esempi seguenti mostrano come chiamare questa operazione nel codice componente personalizzato.

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

**Example Esempio: iscriversi ai messaggi**  

```
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 Esempio: iscriversi ai messaggi**  
Questo esempio presuppone che si stia utilizzando la versione 1.5.4 o successiva di for SDK per dispositivi AWS IoT 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 Esempio: iscriversi ai messaggi**  
Questo esempio utilizza una `IPCUtils` classe per creare una connessione al servizio AWS IoT Greengrass Core IPC. Per ulteriori informazioni, consulta [Connect al servizio 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 Esempio: sottoscrizione ai messaggi**  
Questo esempio presuppone che si stia utilizzando la versione 1.5.4 o successiva di for SDK per dispositivi AWS IoT 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 Esempio: iscriversi ai messaggi**  

```
#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 Esempio: iscriversi ai messaggi**  

```
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 Esempio: iscriversi ai messaggi**  

```
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 Esempio: iscriversi ai messaggi**  

```
#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 Esempio: iscriversi ai messaggi**  

```
#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);
    }
}
```

------

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

Utilizzate i seguenti esempi per imparare a utilizzare il servizio AWS IoT Core MQTT IPC nei vostri componenti.

### Esempio di editore AWS IoT Core MQTT (C\$1\$1, client IPC V1)
<a name="ipc-iot-core-mqtt-example-publisher-cpp"></a>

La seguente ricetta di esempio consente al componente di pubblicare su tutti gli argomenti.

------
#### [ 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'applicazione C\$1\$1 di esempio seguente mostra come utilizzare il servizio AWS IoT Core MQTT IPC su cui pubblicare messaggi. 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;
}
```

### Esempio di abbonato AWS IoT Core MQTT (C\$1\$1, client IPC V1)
<a name="ipc-iot-core-mqtt-example-subscriber-cpp"></a>

La seguente ricetta di esempio consente al componente di sottoscrivere tutti gli argomenti.

------
#### [ 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'applicazione C\$1\$1 di esempio seguente mostra come utilizzare il servizio AWS IoT Core MQTT IPC per iscriversi ai messaggi da. 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;
}
```

### Esempio di editore AWS IoT Core MQTT (Rust)
<a name="ipc-iot-core-mqtt-example-publisher-rust"></a>

La seguente ricetta di esempio consente al componente di pubblicare su tutti gli argomenti.

```
{
  "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'esempio seguente di applicazione Rust dimostra come utilizzare il servizio AWS IoT Core MQTT IPC su cui pubblicare messaggi. 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}");
}
```

### Esempio di abbonato AWS IoT Core MQTT (Rust)
<a name="ipc-iot-core-mqtt-example-subscriber-rust"></a>

La seguente ricetta di esempio consente al componente di sottoscrivere tutti gli argomenti.

```
{
  "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'esempio seguente di applicazione Rust mostra come utilizzare il servizio AWS IoT Core MQTT IPC per iscriversi ai messaggi da. 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));
    }
}
```

### Esempio di editore AWS IoT Core MQTT (C)
<a name="ipc-iot-core-mqtt-example-publisher-c"></a>

La seguente ricetta di esempio consente al componente di pubblicare su tutti gli argomenti.

```
{
  "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'esempio seguente di applicazione C mostra come utilizzare il servizio AWS IoT Core MQTT IPC su cui pubblicare messaggi. 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
    );
}
```

### Esempio di abbonato AWS IoT Core MQTT (C)
<a name="ipc-iot-core-mqtt-example-subscriber-c"></a>

La seguente ricetta di esempio consente al componente di sottoscrivere tutti gli argomenti.

```
{
  "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'esempio seguente di applicazione C mostra come utilizzare il servizio AWS IoT Core MQTT IPC per iscriversi ai messaggi da. 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);
}
```

### Esempio di editore AWS IoT Core MQTT (C\$1\$1, Component SDK)
<a name="ipc-iot-core-mqtt-example-publisher-cpp-component-sdk"></a>

La seguente ricetta di esempio consente al componente di pubblicare su tutti gli argomenti.

```
{
  "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'applicazione C\$1\$1 di esempio seguente mostra come utilizzare il servizio AWS IoT Core MQTT IPC su cui pubblicare messaggi. 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";
}
```

### Esempio di abbonato AWS IoT Core MQTT (C\$1\$1, Component SDK)
<a name="ipc-iot-core-mqtt-example-subscriber-cpp-component-sdk"></a>

La seguente ricetta di esempio consente al componente di sottoscrivere tutti gli argomenti.

```
{
  "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'applicazione C\$1\$1 di esempio seguente mostra come utilizzare il servizio AWS IoT Core MQTT IPC per iscriversi ai messaggi da. 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);
    }
}
```

# Interagisci con il ciclo di vita dei componenti
<a name="ipc-component-lifecycle"></a>

Utilizza il servizio IPC del ciclo di vita dei componenti per:
+ Aggiorna lo stato del componente sul dispositivo principale.
+ Iscriviti agli aggiornamenti sullo stato dei componenti.
+ Impedisci al nucleus di interrompere il componente per applicare un aggiornamento durante una distribuzione.
+ Metti in pausa e riprendi i processi dei componenti.

**Topics**
+ [Versioni SDK minime](#ipc-component-lifecycle-sdk-versions)
+ [Autorizzazione](#ipc-component-lifecycle-authorization)
+ [UpdateState](#ipc-operation-updatestate)
+ [SubscribeToComponentUpdates](#ipc-operation-subscribetocomponentupdates)
+ [DeferComponentUpdate](#ipc-operation-defercomponentupdate)
+ [PauseComponent](#ipc-operation-pausecomponent)
+ [ResumeComponent](#ipc-operation-resumecomponent)

## Versioni SDK minime
<a name="ipc-component-lifecycle-sdk-versions"></a>

La tabella seguente elenca le versioni minime da utilizzare per interagire con il SDK per dispositivi AWS IoT ciclo di vita dei componenti.


| SDK | Versione minima | 
| --- | --- | 
|  [SDK per dispositivi AWS IoT per Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.2.10  | 
|  [SDK per dispositivi AWS IoT per Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.5.3  | 
|  [SDK per dispositivi AWS IoT per C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [SDK per dispositivi AWS IoT per v2 JavaScript ](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

## Autorizzazione
<a name="ipc-component-lifecycle-authorization"></a>

Per mettere in pausa o riprendere altri componenti di un componente personalizzato, è necessario definire politiche di autorizzazione che consentano al componente di gestire altri componenti. Per informazioni sulla definizione delle politiche di autorizzazione, vedere. [Autorizza i componenti a eseguire operazioni IPC](interprocess-communication.md#ipc-authorization-policies)

Le politiche di autorizzazione per la gestione del ciclo di vita dei componenti hanno le seguenti proprietà.

**Identificatore del servizio IPC:** `aws.greengrass.ipc.lifecycle`


| Operation | Description | Resources | 
| --- | --- | --- | 
|  `aws.greengrass#PauseComponent`  |  Consente a un componente di mettere in pausa i componenti specificati.  |  Un nome di componente o `*` per consentire l'accesso a tutti i componenti.  | 
|  `aws.greengrass#ResumeComponent`  |  Consente a un componente di ripristinare i componenti specificati.  |  Un nome di componente o `*` per consentire l'accesso a tutti i componenti.  | 
|  `*`  |  Consente a un componente di mettere in pausa e riprendere i componenti specificati.  |  Un nome di componente o `*` per consentire l'accesso a tutti i componenti.  | 

### Esempi di politiche di autorizzazione
<a name="ipc-component-lifecycle-authorization-policy-examples"></a>

È possibile fare riferimento al seguente esempio di politica di autorizzazione per configurare le politiche di autorizzazione per i componenti.

**Example Esempio di politica di autorizzazione**  
Il seguente esempio di politica di autorizzazione consente a un componente di mettere in pausa e riprendere tutti i componenti.  

```
{
  "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>

Aggiorna lo stato del componente sul dispositivo principale.

### Richiesta
<a name="ipc-operation-updatestate-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`state`  
Lo stato da impostare. Questo enum ha `LifecycleState` i seguenti valori:  
+ `RUNNING`
+ `ERRORED`

### Risposta
<a name="ipc-operation-updatestate-response"></a>

Questa operazione non fornisce alcuna informazione nella sua risposta.

### Esempi
<a name="ipc-operation-updatestate-examples"></a>

Gli esempi seguenti mostrano come chiamare questa operazione nel codice componente personalizzato.

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

**Example Esempio: aggiorna lo stato**  

```
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 Esempio: stato di aggiornamento**  

```
#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 Esempio: stato di aggiornamento**  

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

Iscriviti per ricevere notifiche prima che il software AWS IoT Greengrass Core aggiorni un componente. La notifica specifica se il nucleo verrà riavviato o meno come parte dell'aggiornamento.

Il nucleus invia notifiche di aggiornamento solo se la politica di aggiornamento dei componenti della distribuzione specifica di notificare i componenti. Il comportamento predefinito consiste nel notificare i componenti. Per ulteriori informazioni, vedete [Creare distribuzione](create-deployments.md) l'[DeploymentComponentUpdatePolicy](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeploymentComponentUpdatePolicy.html)oggetto che potete fornire quando chiamate l'[CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html)operazione.

**Importante**  
Le distribuzioni locali non notificano i componenti prima degli aggiornamenti.

<a name="ipc-subscribe-operation-note"></a>Questa operazione è un'operazione di sottoscrizione in cui ci si iscrive a un flusso di messaggi di eventi. Per utilizzare questa operazione, definite un gestore di risposte di flusso con funzioni che gestiscono i messaggi di evento, gli errori e la chiusura dei flussi. Per ulteriori informazioni, consulta [Iscriviti ai flussi di eventi IPC](interprocess-communication.md#ipc-subscribe-operations).

**Tipo di messaggio di evento:** `ComponentUpdatePolicyEvents`

**Suggerimento**  
Puoi seguire un tutorial per imparare a sviluppare un componente che rinvii in modo condizionale gli aggiornamenti dei componenti. Per ulteriori informazioni, consulta [Tutorial: Sviluppa un componente Greengrass che rinvii gli aggiornamenti dei componenti](defer-component-updates-tutorial.md).

### Richiesta
<a name="ipc-operation-subscribetocomponentupdates-request"></a>

La richiesta di questa operazione non ha parametri.

### Risposta
<a name="ipc-operation-subscribetocomponentupdates-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`messages`  
Il flusso di messaggi di notifica. Questo oggetto contiene `ComponentUpdatePolicyEvents` le seguenti informazioni:    
`preUpdateEvent`(Python:) `pre_update_event`  
(Facoltativo) Un evento che indica che il nucleo desidera aggiornare un componente. È possibile rispondere con l'[DeferComponentUpdate](#ipc-operation-defercomponentupdate)operazione di conferma o rinviare l'aggiornamento fino a quando il componente non sarà pronto per il riavvio. Questo oggetto contiene `PreComponentUpdateEvent` le seguenti informazioni:    
`deploymentId`(Python:) `deployment_id`  
L'ID della AWS IoT Greengrass distribuzione che aggiorna il componente.  
`isGgcRestarting`(Python:) `is_ggc_restarting`  
Se il nucleo deve essere riavviato o meno per applicare l'aggiornamento.  
`postUpdateEvent`(Python:) `post_update_event`  
(Facoltativo) Un evento che indica che il nucleo ha aggiornato un componente. Questo oggetto contiene `PostComponentUpdateEvent` le seguenti informazioni:    
`deploymentId`(Python:) `deployment_id`  
L'ID della AWS IoT Greengrass distribuzione che ha aggiornato il componente.  
Questa funzionalità richiede la versione 2.7.0 o successiva del componente Greengrass nucleus.

## DeferComponentUpdate
<a name="ipc-operation-defercomponentupdate"></a>

Riconosci o rimanda l'aggiornamento di un componente con cui lo scopri. [SubscribeToComponentUpdates](#ipc-operation-subscribetocomponentupdates) Specificate il tempo di attesa prima che il nucleo verifichi nuovamente se il componente è pronto per procedere con l'aggiornamento del componente. È inoltre possibile utilizzare questa operazione per comunicare al nucleo che il componente è pronto per l'aggiornamento.

Se un componente non risponde alla notifica di aggiornamento del componente, il nucleus attende il periodo di tempo specificato nella politica di aggiornamento dei componenti della distribuzione. Dopo tale timeout, il nucleus procede con la distribuzione. Il timeout predefinito per l'aggiornamento dei componenti è di 60 secondi. Per ulteriori informazioni, vedere [Creare distribuzione](create-deployments.md) e l'[DeploymentComponentUpdatePolicy](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeploymentComponentUpdatePolicy.html)oggetto che è possibile fornire quando si chiama l'[CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html)operazione.

**Suggerimento**  
Puoi seguire un tutorial per imparare a sviluppare un componente che differisca in modo condizionale gli aggiornamenti dei componenti. Per ulteriori informazioni, consulta [Tutorial: Sviluppa un componente Greengrass che rinvii gli aggiornamenti dei componenti](defer-component-updates-tutorial.md).

### Richiesta
<a name="ipc-operation-defercomponentupdate-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`deploymentId`(Python:) `deployment_id`  
L'ID della AWS IoT Greengrass distribuzione da rinviare.

`message`  
(Facoltativo) Il nome del componente per il quale posticipare gli aggiornamenti.  
Il valore predefinito è il nome del componente che effettua la richiesta.

`recheckAfterMs`(Python:) `recheck_after_ms`  
Il periodo di tempo in millisecondi per il quale posticipare l'aggiornamento. Il nucleo attende questo intervallo di tempo e poi ne invia un altro `PreComponentUpdateEvent` con cui è possibile eseguire l'individuazione. [SubscribeToComponentUpdates](#ipc-operation-subscribetocomponentupdates)  
`0`Specificare di confermare l'aggiornamento. Questo indica al nucleo che il componente è pronto per l'aggiornamento.  
Il valore predefinito è zero millisecondi, il che significa che conferma l'aggiornamento.

### Risposta
<a name="ipc-operation-defercomponentupdate-response"></a>

Questa operazione non fornisce alcuna informazione nella sua risposta.

## PauseComponent
<a name="ipc-operation-pausecomponent"></a>

Questa funzionalità è disponibile per la versione 2.4.0 e successive del componente [Greengrass](greengrass-nucleus-component.md) nucleus. AWS IoT Greengrass attualmente non supporta questa funzionalità sui dispositivi Windows core. 

Sospende i processi di un componente sul dispositivo principale. Per riprendere un componente, utilizzate l'[ResumeComponent](#ipc-operation-resumecomponent)operazione.

È possibile mettere in pausa solo i componenti generici. Se si tenta di mettere in pausa qualsiasi altro tipo di componente, questa operazione genera un. `InvalidRequestError`

**Nota**  
Questa operazione non può mettere in pausa i processi containerizzati, come i contenitori Docker. [Per mettere in pausa e riprendere un contenitore Docker, puoi utilizzare i comandi docker pause e [docker unpause](https://docs.docker.com/engine/reference/commandline/pause/).](https://docs.docker.com/engine/reference/commandline/unpause/)

Questa operazione non mette in pausa le dipendenze dei componenti o i componenti che dipendono dal componente che metti in pausa. Considerate questo comportamento quando mettete in pausa un componente che dipende da un altro componente, poiché il componente dipendente potrebbe riscontrare problemi quando la sua dipendenza viene messa in pausa.

Quando si riavvia o si spegne un componente in pausa, ad esempio durante una distribuzione, il Greengrass nucleus riprende il componente ed esegue il suo ciclo di vita di spegnimento. Per ulteriori informazioni sul riavvio di un componente, vedere. [RestartComponent](ipc-local-deployments-components.md#ipc-operation-restartcomponent)

**Importante**  
Per utilizzare questa operazione, è necessario definire una politica di autorizzazione che conceda il permesso di utilizzare questa operazione. Per ulteriori informazioni, consulta [Autorizzazione](#ipc-component-lifecycle-authorization).

### Versioni SDK minime
<a name="ipc-operation-pausecomponent-sdk-versions"></a>

La tabella seguente elenca le versioni minime da utilizzare per mettere in pausa e riprendere i componenti. SDK per dispositivi AWS IoT 


| SDK | Versione minima | 
| --- | --- | 
|  [SDK per dispositivi AWS IoT per Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.4.3  | 
|  [SDK per dispositivi AWS IoT per Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.6.2  | 
|  [SDK per dispositivi AWS IoT per C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.13.1  | 
|  [SDK per dispositivi AWS IoT per v2 JavaScript ](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

### Richiesta
<a name="ipc-operation-defercomponentupdate-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`componentName`(Python:) `component_name`  
Il nome del componente da mettere in pausa, che deve essere un componente generico. Per ulteriori informazioni, consulta [Tipi di componenti](develop-greengrass-components.md#component-types).

### Risposta
<a name="ipc-operation-defercomponentupdate-response"></a>

Questa operazione non fornisce alcuna informazione nella sua risposta.

## ResumeComponent
<a name="ipc-operation-resumecomponent"></a>

Questa funzionalità è disponibile per la versione 2.4.0 e successive del componente [Greengrass](greengrass-nucleus-component.md) nucleus. AWS IoT Greengrass attualmente non supporta questa funzionalità sui dispositivi Windows core. 

Riprende i processi di un componente sul dispositivo principale. Per mettere in pausa un componente, utilizzate l'operazione. [PauseComponent](#ipc-operation-pausecomponent)

È possibile riprendere solo i componenti in pausa. Se si tenta di riprendere un componente che non è in pausa, questa operazione genera un. `InvalidRequestError`

**Importante**  
Per utilizzare questa operazione, è necessario definire una politica di autorizzazione che conceda l'autorizzazione a farlo. Per ulteriori informazioni, consulta [Autorizzazione](#ipc-component-lifecycle-authorization).

### Versioni SDK minime
<a name="ipc-operation-resumecomponent-sdk-versions"></a>

La tabella seguente elenca le versioni minime da utilizzare per mettere in pausa e riprendere i componenti. SDK per dispositivi AWS IoT 


| SDK | Versione minima | 
| --- | --- | 
|  [SDK per dispositivi AWS IoT per Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.4.3  | 
|  [SDK per dispositivi AWS IoT per Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.6.2  | 
|  [SDK per dispositivi AWS IoT per C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.13.1  | 
|  [SDK per dispositivi AWS IoT per v2 JavaScript ](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

### Richiesta
<a name="ipc-operation-defercomponentupdate-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`componentName`(Python:) `component_name`  
Il nome del componente da riprendere.

### Risposta
<a name="ipc-operation-defercomponentupdate-response"></a>

Questa operazione non fornisce alcuna informazione nella sua risposta.

# Interazione con la configurazione dei componenti
<a name="ipc-component-configuration"></a>

Il servizio IPC di configurazione dei componenti consente di effettuare le seguenti operazioni:
+ Ottieni e imposta i parametri di configurazione dei componenti.
+ Iscriviti agli aggiornamenti della configurazione dei componenti.
+ Convalida gli aggiornamenti della configurazione dei componenti prima che il nucleo li applichi.

**Topics**
+ [Versioni SDK minime](#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)

## Versioni SDK minime
<a name="ipc-component-configuration-sdk-versions"></a>

La tabella seguente elenca le versioni minime di SDK per dispositivi AWS IoT da utilizzare per interagire con la configurazione dei componenti.


| SDK | Versione minima | 
| --- | --- | 
|  [SDK per dispositivi AWS IoT per Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.2.10  | 
|  [SDK per dispositivi AWS IoT per Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.5.3  | 
|  [SDK per dispositivi AWS IoT per C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [SDK per dispositivi AWS IoT per v2 JavaScript ](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

## GetConfiguration
<a name="ipc-operation-getconfiguration"></a>

Ottiene un valore di configurazione per un componente sul dispositivo principale. Specificate il percorso chiave per il quale ottenere un valore di configurazione.

### Richiesta
<a name="ipc-operation-getconfiguration-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`componentName`(Python:) `component_name`  <a name="ipc-configuration-request-component-name"></a>
(Facoltativo) Il nome del componente.  
Il valore predefinito è il nome del componente che effettua la richiesta.

`keyPath`(Python:) `key_path`  
Il percorso chiave verso il valore di configurazione. Specificate un elenco in cui ogni voce è la chiave per un singolo livello nell'oggetto di configurazione. Ad esempio, specificate di `["mqtt", "port"]` ottenere il valore di `port` nella seguente configurazione.  

```
{
  "mqtt": {
    "port": 443
  }
}
```
Per ottenere la configurazione completa del componente, specificate un elenco vuoto.

### Risposta
<a name="ipc-operation-getconfiguration-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`componentName`(Python:) `component_name`  <a name="ipc-configuration-response-component-name"></a>
Il nome del componente.

`value`  
La configurazione richiesta come oggetto.

### Esempi
<a name="ipc-operation-getconfiguration-examples"></a>

Gli esempi seguenti mostrano come chiamare questa operazione nel codice componente personalizzato.

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

**Example Esempio: Get 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 Esempio: Get 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 Esempio: Get 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>

Aggiorna un valore di configurazione per questo componente sul dispositivo principale.

### Richiesta
<a name="ipc-operation-updateconfiguration-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`keyPath`(Python:) `key_path`  
(Facoltativo) Il percorso chiave del nodo contenitore (l'oggetto) da aggiornare. Specificate un elenco in cui ogni voce è la chiave per un singolo livello nell'oggetto di configurazione. Ad esempio, specificate il percorso della chiave `["mqtt"]` e il valore `{ "port": 443 }` di unione di cui impostare il valore `port` nella seguente configurazione.  

```
{
  "mqtt": {
    "port": 443
  }
}
```
Il percorso chiave deve specificare un nodo contenitore (un oggetto) nella configurazione. Se il nodo non esiste nella configurazione del componente, questa operazione lo crea e imposta il suo valore sull'oggetto in`valueToMerge`.  
Il valore predefinito è la radice dell'oggetto di configurazione.

`timestamp`  
L'ora attuale dell'epoca Unix in millisecondi. Questa operazione utilizza questo timestamp per risolvere gli aggiornamenti simultanei della chiave. Se la chiave nella configurazione del componente ha un timestamp maggiore di quello della richiesta, la richiesta ha esito negativo.

`valueToMerge`(Python:) `value_to_merge`  
L'oggetto di configurazione da unire nella posizione specificata. `keyPath` Per ulteriori informazioni, consulta [Aggiornamento delle configurazioni dei componenti](update-component-configurations.md).

### Risposta
<a name="ipc-operation-updateconfiguration-response"></a>

Questa operazione non fornisce alcuna informazione nella sua risposta.

### Esempi
<a name="ipc-operation-updateconfiguration-examples"></a>

Gli esempi seguenti mostrano come chiamare questa operazione nel codice componente personalizzato.

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

**Example Esempio: aggiornamento della configurazione**  

```
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 Esempio: aggiornamento della configurazione**  

```
#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 Esempio: aggiornamento della configurazione**  

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

Iscriviti per ricevere notifiche quando la configurazione di un componente viene aggiornata. Quando sottoscrivi una chiave, ricevi una notifica ogni volta che un elemento secondario di quella chiave si aggiorna.

<a name="ipc-subscribe-operation-note"></a>Questa operazione è un'operazione di sottoscrizione in cui ti iscrivi a un flusso di messaggi di eventi. Per utilizzare questa operazione, definite un gestore di risposte di flusso con funzioni che gestiscono i messaggi di evento, gli errori e la chiusura dei flussi. Per ulteriori informazioni, consulta [Iscriviti ai flussi di eventi IPC](interprocess-communication.md#ipc-subscribe-operations).

**Tipo di messaggio di evento:** `ConfigurationUpdateEvents`

### Richiesta
<a name="ipc-operation-subscribetoconfigurationupdate-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`componentName`(Python:) `component_name`  <a name="ipc-configuration-request-component-name"></a>
(Facoltativo) Il nome del componente.  
Il valore predefinito è il nome del componente che effettua la richiesta.

`keyPath`(Python:) `key_path`  
Il percorso chiave del valore di configurazione a cui sottoscrivere. Specificate un elenco in cui ogni voce è la chiave per un singolo livello nell'oggetto di configurazione. Ad esempio, specificate di `["mqtt", "port"]` ottenere il valore di `port` nella seguente configurazione.  

```
{
  "mqtt": {
    "port": 443
  }
}
```
Per sottoscrivere gli aggiornamenti per tutti i valori nella configurazione del componente, specificate un elenco vuoto.

### Risposta
<a name="ipc-operation-subscribetoconfigurationupdate-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`messages`  
Il flusso di messaggi di notifica. Questo oggetto contiene `ConfigurationUpdateEvents` le seguenti informazioni:    
`configurationUpdateEvent`(Python:) `configuration_update_event`  
L'evento di aggiornamento della configurazione. Questo oggetto contiene `ConfigurationUpdateEvent` le seguenti informazioni:    
`componentName`(Python:) `component_name`  <a name="ipc-configuration-response-component-name"></a>
Il nome del componente.  
`keyPath`(Python:) `key_path`  
Il percorso chiave del valore di configurazione che è stato aggiornato.

### Esempi
<a name="ipc-operation-subscribetoconfigurationupdate-examples"></a>

Gli esempi seguenti mostrano come chiamare questa operazione nel codice componente personalizzato.

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

**Example Esempio: sottoscrizione agli aggiornamenti di configurazione**  

```
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 Esempio: sottoscrizione agli aggiornamenti di configurazione**  

```
#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 Esempio: sottoscrizione agli aggiornamenti di configurazione**  

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

Iscriviti per ricevere notifiche prima degli aggiornamenti della configurazione di questo componente. Ciò consente ai componenti di convalidare gli aggiornamenti alla propria configurazione. Utilizzate l'[SendConfigurationValidityReport](#ipc-operation-sendconfigurationvalidityreport)operazione per indicare al nucleo se la configurazione è valida o meno.

**Importante**  
Le distribuzioni locali non notificano ai componenti gli aggiornamenti.

<a name="ipc-subscribe-operation-note"></a>Questa operazione è un'operazione di sottoscrizione in cui ci si iscrive a un flusso di messaggi di eventi. Per utilizzare questa operazione, definite un gestore di risposte di flusso con funzioni che gestiscono i messaggi di evento, gli errori e la chiusura dei flussi. Per ulteriori informazioni, consulta [Iscriviti ai flussi di eventi IPC](interprocess-communication.md#ipc-subscribe-operations).

**Tipo di messaggio di evento:** `ValidateConfigurationUpdateEvents`

### Richiesta
<a name="ipc-operation-subscribetovalidateconfigurationupdates-request"></a>

La richiesta di questa operazione non ha parametri.

### Risposta
<a name="ipc-operation-subscribetovalidateconfigurationupdates-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`messages`  
Il flusso di messaggi di notifica. Questo oggetto contiene `ValidateConfigurationUpdateEvents` le seguenti informazioni:    
`validateConfigurationUpdateEvent`(Python:) `validate_configuration_update_event`  
L'evento di aggiornamento della configurazione. Questo oggetto contiene `ValidateConfigurationUpdateEvent` le seguenti informazioni:    
`deploymentId`(Python:) `deployment_id`  
L'ID della AWS IoT Greengrass distribuzione che aggiorna il componente.  
`configuration`  
L'oggetto che contiene la nuova configurazione.

## SendConfigurationValidityReport
<a name="ipc-operation-sendconfigurationvalidityreport"></a>

Indica al nucleo se un aggiornamento della configurazione di questo componente è valido o meno. L'implementazione fallisce se dici al nucleus che la nuova configurazione non è valida. Utilizza l'[SubscribeToValidateConfigurationUpdates](#ipc-operation-subscribetovalidateconfigurationupdates)operazione per sottoscrivere e convalidare gli aggiornamenti di configurazione.

Se un componente non risponde a una notifica di convalida dell'aggiornamento della configurazione, il nucleus attende il periodo di tempo specificato nella politica di convalida della configurazione della distribuzione. Dopo tale timeout, il nucleo procede con la distribuzione. Il timeout di convalida dei componenti predefinito è di 20 secondi. Per ulteriori informazioni, vedere [Creare distribuzione](create-deployments.md) e l'[DeploymentConfigurationValidationPolicy](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeploymentConfigurationValidationPolicy.html)oggetto che è possibile fornire quando si chiama l'[CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html)operazione.

### Richiesta
<a name="ipc-operation-sendconfigurationvalidityreport-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`configurationValidityReport`(Python:) `configuration_validity_report`  
Il rapporto che indica al nucleo se l'aggiornamento della configurazione è valido o meno. Questo oggetto contiene `ConfigurationValidityReport` le seguenti informazioni:    
`status`  
Lo stato di validità. Questo enum ha `ConfigurationValidityStatus` i seguenti valori:  
+ `ACCEPTED`— La configurazione è valida e il nucleo può applicarla a questo componente.
+ `REJECTED`— La configurazione non è valida e l'implementazione non riesce.  
`deploymentId`(Python:) `deployment_id`  
L'ID della AWS IoT Greengrass distribuzione che ha richiesto l'aggiornamento della configurazione.  
`message`  
(Facoltativo) Un messaggio che riporta il motivo per cui la configurazione non è valida.

### Risposta
<a name="ipc-operation-sendconfigurationvalidityreport-response"></a>

Questa operazione non fornisce alcuna informazione nella sua risposta.

# Recupera valori segreti
<a name="ipc-secret-manager"></a>

Utilizza il servizio IPC di gestione dei segreti per recuperare i valori segreti dai segreti sul dispositivo principale. Utilizzi il [componente secret manager](secret-manager-component.md) per distribuire segreti crittografati sui dispositivi principali. Quindi, puoi utilizzare un'operazione IPC per decrittografare il segreto e utilizzarne il valore nei componenti personalizzati.

**Topics**
+ [Versioni SDK minime](#ipc-secret-manager-sdk-versions)
+ [Autorizzazione](#ipc-secret-manager-authorization)
+ [GetSecretValue](#ipc-operation-getsecretvalue)
+ [Esempi](#ipc-secret-manager-examples)

## Versioni SDK minime
<a name="ipc-secret-manager-sdk-versions"></a>

La tabella seguente elenca le versioni minime di da utilizzare per recuperare i valori segreti dai segreti sul dispositivo principale. SDK per dispositivi AWS IoT 


| SDK | Versione minima | 
| --- | --- | 
|  [SDK per dispositivi AWS IoT per Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.2.10  | 
|  [SDK per dispositivi AWS IoT per Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.5.3  | 
|  [SDK per dispositivi AWS IoT per C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [SDK per dispositivi AWS IoT per v2 JavaScript ](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

## Autorizzazione
<a name="ipc-secret-manager-authorization"></a>

Per utilizzare il gestore segreto in un componente personalizzato, è necessario definire politiche di autorizzazione che consentano al componente di ottenere il valore dei segreti archiviati sul dispositivo principale. Per informazioni sulla definizione delle politiche di autorizzazione, vedere[Autorizza i componenti a eseguire operazioni IPC](interprocess-communication.md#ipc-authorization-policies).

Le politiche di autorizzazione per il gestore segreto hanno le seguenti proprietà.

**Identificatore del servizio IPC:** `aws.greengrass.SecretManager`


| Operation | Description | Resources | 
| --- | --- | --- | 
|  `aws.greengrass#GetSecretValue` o `*`  |  Consente a un componente di ottenere il valore dei segreti crittografati sul dispositivo principale.  |  Un ARN segreto di Secrets Manager o `*` per consentire l'accesso a tutti i segreti.  | 

### Esempi di politiche di autorizzazione
<a name="ipc-secret-manager-authorization-policy-examples"></a>

È possibile fare riferimento al seguente esempio di politica di autorizzazione per configurare le politiche di autorizzazione per i componenti.

**Example Esempio di politica di autorizzazione**  
Il seguente esempio di politica di autorizzazione consente a un componente di ottenere il valore di qualsiasi segreto sul dispositivo principale.  
In un ambiente di produzione, si consiglia di ridurre l'ambito della politica di autorizzazione, in modo che il componente recuperi solo i segreti che utilizza. È possibile modificare il carattere `*` jolly in un elenco di segreti ARNs quando si distribuisce il componente.

```
{
  "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>

Ottiene il valore di un segreto archiviato nel dispositivo principale.

Questa operazione è simile all'operazione Secrets Manager che è possibile utilizzare per ottenere il valore di un segreto in Cloud AWS. Per ulteriori informazioni, consulta [GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html) nella *documentazione di riferimento dell’API Gestione dei segreti AWS *.

### Richiesta
<a name="ipc-operation-getsecretvalue-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`refresh`(Python:) `refresh`  
(opzionale): se sincronizzare il segreto richiesto con l'ultimo valore Gestione dei segreti AWS fornito dal servizio.  
Se impostato su true, il gestore segreto richiederà al Gestione dei segreti AWS servizio l'ultimo valore dell'etichetta segreta specificata e restituirà quel valore come risposta. In caso contrario, verrà restituito il valore segreto archiviato localmente.  
 Questo parametro non funzionerà insieme al `versionId` parametro nella richiesta. Questo parametro funziona se usato insieme a Nucleus 2.13.0 e versioni successive.

`secretId`(Python:) `secret_id`  
Il nome del segreto da ottenere. Puoi specificare l'Amazon Resource Name (ARN) o il nome descrittivo del segreto.

`versionId`(Python:) `version_id`  
(Facoltativo) L'ID della versione da ottenere.  
È possibile specificare `versionId` o `versionStage`.  
Se non specifichi `versionId` o`versionStage`, per impostazione predefinita per questa operazione viene utilizzata la versione con l'`AWSCURRENT`etichetta.

`versionStage`(Python:) `version_stage`  
(Facoltativo) L'etichetta temporanea della versione da scaricare.  
È possibile specificare `versionId` o `versionStage`.  
Se non specifichi `versionId` o`versionStage`, per impostazione predefinita per questa operazione viene utilizzata la versione con l'etichetta. `AWSCURRENT`

### Risposta
<a name="ipc-operation-getsecretvalue-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`secretId`(Python:) `secret_id`  
L'ID del segreto.

`versionId`(Python:) `version_id`  
L'ID di questa versione del segreto.

`versionStage`(Python:) `version_stage`  
L'elenco delle etichette di staging allegate a questa versione del segreto.

`secretValue`(Python:) `secret_value`  
Il valore di questa versione del segreto. Questo oggetto contiene `SecretValue` le seguenti informazioni.    
`secretString`(Python:) `secret_string`  
La parte decrittografata delle informazioni segrete protette che hai fornito a Secrets Manager come stringa.  
`secretBinary`(Python:) `secret_binary`  
(Facoltativo) La parte decrittografata delle informazioni segrete protette fornite a Secrets Manager come dati binari sotto forma di matrice di byte. Questa proprietà contiene i dati binari sotto forma di stringa con codifica Base64.  
Questa proprietà non viene utilizzata se hai creato il segreto nella console Secrets Manager.

### Esempi
<a name="ipc-operation-getsecretvalue-examples"></a>

Gli esempi seguenti mostrano come chiamare questa operazione nel codice componente personalizzato.

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

**Example Esempio: ottieni un valore segreto**  
Questo esempio utilizza una `IPCUtils` classe per creare una connessione al servizio AWS IoT Greengrass Core IPC. Per ulteriori informazioni, consulta [Connect al servizio 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 Esempio: ottieni un valore segreto**  
Questo esempio presuppone che si stia utilizzando la versione 1.5.4 o successiva di for SDK per dispositivi AWS IoT 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 Esempio: ottieni un valore segreto**  

```
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();
```

------

## Esempi
<a name="ipc-secret-manager-examples"></a>

Utilizza i seguenti esempi per imparare a utilizzare il servizio IPC di gestione segreta nei tuoi componenti.

### Esempio: segreto di stampa (Python, client IPC V1)
<a name="ipc-secret-manager-example-print-secret-python"></a>

Questo componente di esempio stampa il valore di un segreto che viene distribuito sul dispositivo principale.

**Importante**  
Questo componente di esempio stampa il valore di un segreto, quindi usalo solo con i segreti che memorizzano i dati di test. Non utilizzate questo componente per stampare il valore di un segreto che memorizza informazioni importanti.

**Topics**
+ [Recipe](#ipc-secret-manager-example-print-secret-python-recipe)
+ [Artifacts](#ipc-secret-manager-example-print-secret-python-artifacts)
+ [Utilizzo](#ipc-secret-manager-example-print-secret-python-usage)

#### Recipe
<a name="ipc-secret-manager-example-print-secret-python-recipe"></a>

La seguente ricetta di esempio definisce un parametro di configurazione ARN segreto e consente al componente di ottenere il valore di qualsiasi segreto sul dispositivo principale.

**Nota**  <a name="ipc-secret-manager-authorization-policy-resource-wildcard"></a>
In un ambiente di produzione, si consiglia di ridurre l'ambito della politica di autorizzazione, in modo che il componente recuperi solo i segreti che utilizza. È possibile modificare il carattere `*` jolly in un elenco di segreti ARNs quando si distribuisce il componente.

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

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PrintSecret",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "Prints the value of an Gestione dei segreti AWS 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}"
```

------

#### Artifacts
<a name="ipc-secret-manager-example-print-secret-python-artifacts"></a>

L'esempio seguente di applicazione Python dimostra come utilizzare il servizio IPC del gestore segreto per ottenere il valore di un segreto sul dispositivo principale.

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

#### Utilizzo
<a name="ipc-secret-manager-example-print-secret-python-usage"></a>

È possibile utilizzare questo componente di esempio con il [componente secret manager](secret-manager-component.md) per distribuire e stampare il valore di un segreto sul dispositivo principale.

**Per creare, distribuire e stampare un segreto di test**

1. Crea un segreto di Secrets Manager con i dati di 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"}'
   ```

------

   Salva l'ARN del segreto da utilizzare nei passaggi seguenti.

   Per ulteriori informazioni, consulta [Creazione di un segreto](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) nella *Guida per l'Gestione dei segreti AWS utente*.

1. Implementate il [componente secret manager](secret-manager-component.md) (`aws.greengrass.SecretManager`) con il seguente aggiornamento di fusione della configurazione. Specificate l'ARN del segreto che avete creato in precedenza.

   ```
   {
     "cloudSecrets": [
       {
         "arn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:MyTestGreengrassSecret-abcdef"
       }
     ]
   }
   ```

   Per ulteriori informazioni, consulta [Implementazione AWS IoT Greengrass dei componenti sui dispositivi](manage-deployments.md) o il comando di distribuzione della [CLI di Greengrass](gg-cli-deployment.md).

1. Crea e distribuisci il componente di esempio in questa sezione con il seguente aggiornamento di configurazione merge. Specificate l'ARN del segreto che avete creato in precedenza.

   ```
   {
     "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"
           ]
         }
       }
     }
   }
   ```

   Per ulteriori informazioni, consulta [Crea AWS IoT Greengrass componenti](create-components.md)

1. Visualizza i log del software AWS IoT Greengrass Core per verificare che le distribuzioni abbiano esito positivo e visualizza il registro dei `com.example.PrintSecret` componenti per vedere il valore segreto stampato. Per ulteriori informazioni, consulta [Monitora AWS IoT Greengrass i registri](monitor-logs.md).

# Interagisci con le ombre locali
<a name="ipc-local-shadows"></a>

Utilizzate il servizio shadow IPC per interagire con le ombre locali su un dispositivo. Il dispositivo con cui scegli di interagire può essere il tuo dispositivo principale o un dispositivo client connesso. 

Per utilizzare queste operazioni IPC, includete il [componente shadow manager](shadow-manager-component.md) come dipendenza nel componente personalizzato. È quindi possibile utilizzare le operazioni IPC nei componenti personalizzati per interagire con le ombre locali sul dispositivo tramite lo shadow manager. Per consentire ai componenti personalizzati di reagire ai cambiamenti negli stati shadow locali, puoi anche utilizzare il servizio publish/subscribe IPC per sottoscrivere gli eventi shadow. Per ulteriori informazioni sull'utilizzo del publish/subscribe servizio, vedere. [Pubblicare/sottoscrivere messaggi locali](ipc-publish-subscribe.md)

**Nota**  <a name="note-requirement-enable-shadow-manager-client-devices"></a>
Per consentire a un dispositivo principale di interagire con le ombre dei dispositivi client, è inoltre necessario configurare e distribuire il componente bridge MQTT. Per ulteriori informazioni, consultate [Attivare lo shadow manager per comunicare con](work-with-client-device-shadows.md) i dispositivi client.

**Topics**
+ [Versioni SDK minime](#ipc-local-shadows-sdk-versions)
+ [Autorizzazione](#ipc-local-shadow-authorization)
+ [GetThingShadow](#ipc-operation-getthingshadow)
+ [UpdateThingShadow](#ipc-operation-updatethingshadow)
+ [DeleteThingShadow](#ipc-operation-deletethingshadow)
+ [ListNamedShadowsForThing](#ipc-operation-listnamedshadowsforthing)

## Versioni SDK minime
<a name="ipc-local-shadows-sdk-versions"></a>

La tabella seguente elenca le versioni minime di SDK per dispositivi AWS IoT da utilizzare per interagire con le ombre locali.


| SDK | Versione minima | 
| --- | --- | 
|  [SDK per dispositivi AWS IoT per Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.4.0  | 
|  [SDK per dispositivi AWS IoT per Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.6.0  | 
|  [SDK per dispositivi AWS IoT per C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [SDK per dispositivi AWS IoT per v2 JavaScript ](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

## Autorizzazione
<a name="ipc-local-shadow-authorization"></a>

Per utilizzare il servizio shadow IPC in un componente personalizzato, è necessario definire politiche di autorizzazione che consentano al componente di interagire con le ombre. Per informazioni sulla definizione delle politiche di autorizzazione, vedere. [Autorizza i componenti a eseguire operazioni IPC](interprocess-communication.md#ipc-authorization-policies)

Le politiche di autorizzazione per l'interazione shadow hanno le seguenti proprietà.

**Identificatore del servizio IPC:** `aws.greengrass.ShadowManager`


| Operation | Description | Resources | 
| --- | --- | --- | 
|  `aws.greengrass#GetThingShadow`  |  Consente a un componente di recuperare l'ombra di un oggetto.  |  Una delle seguenti stringhe:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v2/developerguide/ipc-local-shadows.html)  | 
|  `aws.greengrass#UpdateThingShadow`  |  Consente a un componente di aggiornare l'ombra di un oggetto.  |  Una delle seguenti stringhe:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v2/developerguide/ipc-local-shadows.html)  | 
|  `aws.greengrass#DeleteThingShadow`  |  Consente a un componente di eliminare l'ombra di un oggetto.  |  Una delle seguenti stringhe:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v2/developerguide/ipc-local-shadows.html)  | 
|  `aws.greengrass#ListNamedShadowsForThing`  |  Consente a un componente di recuperare l'elenco delle ombre denominate per un oggetto.  |  Una stringa di nome dell'oggetto che consente di accedere all'oggetto per elencarne le ombre. `*`Da utilizzare per consentire l'accesso a tutte le cose.  | 

**Identificatore del servizio IPC:** `aws.greengrass.ipc.pubsub`


| Operation | Description | Resources | 
| --- | --- | --- | 
|  `aws.greengrass#SubscribeToTopic`  |  Consente a un componente di sottoscrivere i messaggi per gli argomenti specificati.  |  Una delle seguenti stringhe di argomenti: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v2/developerguide/ipc-local-shadows.html) Il valore del prefisso dell'argomento `shadowTopicPrefix` dipende dal tipo di ombra:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v2/developerguide/ipc-local-shadows.html) Utilizzato `*` per consentire l'accesso a tutti gli argomenti. <a name="ipc-local-publish-subscribe-authorization-mqtt-wildcards"></a>In [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 e versioni successive, è possibile sottoscrivere argomenti che contengono caratteri jolly degli argomenti MQTT (and). `#` `+` Questa stringa di argomenti supporta i caratteri jolly degli argomenti MQTT come caratteri letterali. Ad esempio, se la politica di autorizzazione di un componente concede l'accesso a`test/topic/#`, il componente può sottoscrivere`test/topic/#`, ma non può sottoscrivere. `test/topic/filter`  | 

### Variabili Recipe nelle politiche di autorizzazione shadow locali
<a name="ipc-local-shadow-authorization-recipe-variables"></a>

[Se si utilizza la versione 2.6.0 o successiva del nucleo di [Greengrass e si imposta l'opzione di [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)configurazione di Greengrass nucleus](greengrass-nucleus-component.md) su`true`, è possibile utilizzare la variabile recipe nelle politiche di autorizzazione. `{iot:thingName}`](component-recipe-reference.md#recipe-variables) Questa funzionalità consente di configurare un'unica politica di autorizzazione per un gruppo di dispositivi principali, in cui ogni dispositivo principale può accedere solo alla propria ombra. Ad esempio, è possibile consentire a un componente l'accesso alla seguente risorsa per le operazioni IPC shadow.

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

### Esempi di politiche di autorizzazione
<a name="ipc-local-shadow-authorization-policy-examples"></a>

Puoi fare riferimento ai seguenti esempi di politiche di autorizzazione per aiutarti a configurare le politiche di autorizzazione per i tuoi componenti.

**Example Esempio: consenti a un gruppo di dispositivi principali di interagire con le ombre locali**  
 <a name="phrase-example-uses-recipe-variables-in-configuration"></a>[Questo esempio utilizza una funzionalità disponibile per la versione 2.6.0 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md) Greengrass nucleus v2.6.0 aggiunge il supporto per la maggior parte delle [variabili di ricetta](component-recipe-reference.md#recipe-variables), ad esempio nelle configurazioni dei componenti. `{iot:thingName}` Per abilitare questa funzionalità, imposta l'opzione di [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)configurazione del nucleo di Greengrass su. `true` Per un esempio che funziona per tutte le versioni del Greengrass nucleus, vedi la [politica di autorizzazione di esempio per un dispositivo single core](#ipc-local-shadows-authorization-example-single-device).
Il seguente esempio di politica di autorizzazione consente `com.example.MyShadowInteractionComponent` al componente di interagire con la classica ombra del dispositivo e l'ombra denominata `myNamedShadow` per il dispositivo principale che esegue il componente. Questa politica consente inoltre a questo componente di ricevere messaggi su argomenti locali relativi a queste ombre.  

```
{
  "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 Esempio: consenti a un gruppo di dispositivi principali di interagire con le ombre dei dispositivi client**  
[Questa funzionalità richiede [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 o successivo, [shadow manager v2.2.0 o successivo e MQTT](shadow-manager-component.md) bridge v2.2.0 o successivo.](mqtt-bridge-component.md) [È necessario configurare il bridge MQTT per consentire allo shadow manager di comunicare con i dispositivi client.](work-with-client-device-shadows.md#enable-shadow-manager-client-devices)
Il seguente esempio di politica di autorizzazione consente `com.example.MyShadowInteractionComponent` al componente di interagire con tutte le ombre dei dispositivi per i dispositivi client i cui nomi iniziano con. `MyClientDevice`  
Per consentire a un dispositivo principale di interagire con le ombre dei dispositivi client, è inoltre necessario configurare e distribuire il componente bridge MQTT. Per ulteriori informazioni, consultate [Attivare lo shadow manager per comunicare con](work-with-client-device-shadows.md) i dispositivi client.

```
{
  "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 Esempio: consenti a un dispositivo single-core di interagire con le ombre locali**  
Il seguente esempio di politica di autorizzazione consente `com.example.MyShadowInteractionComponent` al componente di interagire con la classica ombra del dispositivo e l'ombra denominata `myNamedShadow` per il dispositivo`MyThingName`. Questa politica consente inoltre a questo componente di ricevere messaggi su argomenti locali relativi a queste ombre.   

```
{
  "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 Esempio: consentire a un gruppo di dispositivi principali di reagire ai cambiamenti dello stato ombra locale**  
 <a name="phrase-example-uses-recipe-variables-in-configuration"></a>[Questo esempio utilizza una funzionalità disponibile per la versione 2.6.0 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md) Greengrass nucleus v2.6.0 aggiunge il supporto per la maggior parte delle [variabili di ricetta](component-recipe-reference.md#recipe-variables), ad esempio nelle configurazioni dei componenti. `{iot:thingName}` Per abilitare questa funzionalità, imposta l'opzione di [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)configurazione del nucleo di Greengrass su. `true` Per un esempio che funziona per tutte le versioni del Greengrass nucleus, vedi la [politica di autorizzazione di esempio per un dispositivo single core](#interact-with-shadows-react-example-authorization-policy-single-device).
Il seguente esempio di politica di controllo degli accessi consente `com.example.MyShadowReactiveComponent` all'utente personalizzato di ricevere messaggi sull'`/update/delta`argomento per il dispositivo shadow classico e l'shadow denominato `myNamedShadow` su ogni dispositivo principale su cui è in esecuzione il componente.  

```
{
  "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 Esempio: consentire a un dispositivo single-core di reagire ai cambiamenti dello stato ombra locale**  
Il seguente esempio di politica di controllo degli accessi consente `com.example.MyShadowReactiveComponent` all'utente personalizzato di ricevere messaggi sull'`/update/delta`argomento per il dispositivo shadow classico e l'ombra denominata `myNamedShadow` per il dispositivo`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>

Ottieni l'ombra per una cosa specificata.

### Richiesta
<a name="ipc-operation-getthingshadow-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`thingName`(Python:) `thing_name`  <a name="ipc-local-shadows-thing-name"></a>
Nome dell'oggetto.  
Tipo: `string`

`shadowName`(Python:) `shadow_name`  <a name="ipc-local-shadows-shadow-name"></a>
Il nome della copia shadow. Per specificare l'ombra classica dell'oggetto, imposta questo parametro su una stringa vuota (`""`).  
Il AWS IoT Greengrass servizio utilizza lo shadow `AWSManagedGreengrassV2Deployment` denominato per gestire le distribuzioni destinate a singoli dispositivi core. Questa ombra denominata è riservata all'uso da parte del AWS IoT Greengrass servizio. Non aggiornare o eliminare questa ombra denominata.
Tipo: `string`

### Risposta
<a name="ipc-operation-getthingshadow-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`payload`  
Il documento sullo stato della risposta sotto forma di blob.  
Tipo: `object` che contiene le seguenti informazioni:    
`state`  
Le informazioni sullo stato.  
Questo oggetto contiene le seguenti informazioni.    
`desired`  
Le proprietà e i valori dello stato da aggiornare nel dispositivo.  
Tipo: `map` di coppie chiave-valore  
`reported`  
Le proprietà e i valori dello stato riportati dal dispositivo.  
Tipo: `map` di coppie chiave-valore  
`delta`  
La differenza tra le proprietà e i valori dello stato desiderati e quelli riportati. Questa proprietà è presente solo se gli `reported` stati `desired` and sono diversi.  
Tipo: `map` di coppie chiave-valore  
`metadata`  
I timestamp per ogni attributo nelle `reported` sezioni `desired` and in modo da poter determinare quando lo stato è stato aggiornato.   
Tipo: `string`  
`timestamp`  
L'epoca, la data e l'ora in cui è stata generata la risposta.  
Tipo: `integer`  
`clientToken`(Python:) `clientToken`  
Il token utilizzato per abbinare la richiesta e la risposta corrispondente  
Tipo: `string`  
`version`  
La versione del documento shadow locale.  
Tipo: `integer`

### Errori
<a name="ipc-operation-getthingshadow-errors"></a>

Questa operazione può restituire i seguenti errori.

`InvalidArgumentsError`  <a name="ipc-invalidargumentserror"></a>
<a name="ipc-invalidargumentserror-para"></a>Il servizio shadow locale non è in grado di convalidare i parametri della richiesta. Ciò può verificarsi se la richiesta contiene caratteri JSON non validi o non supportati. 

`ResourceNotFoundError`  <a name="ipc-resourcenotfounderror"></a>
Il documento shadow locale richiesto non può essere trovato.

`ServiceError`  <a name="ipc-serviceerror"></a>
Si è verificato un errore interno del servizio oppure il numero di richieste al servizio IPC ha superato i limiti specificati nei parametri di `maxTotalLocalRequestsRate` configurazione `maxLocalRequestsPerSecondPerThing` e nel componente shadow manager.

`UnauthorizedError`  <a name="ipc-unauthorizederror"></a>
La politica di autorizzazione del componente non include le autorizzazioni necessarie per questa operazione.

### Esempi
<a name="ipc-operation-getthingshadow-examples"></a>

Gli esempi seguenti mostrano come chiamare questa operazione nel codice del componente personalizzato.

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

**Example Esempio: Get a thing shadow**  
Questo esempio utilizza una `IPCUtils` classe per creare una connessione al servizio AWS IoT Greengrass Core IPC. Per ulteriori informazioni, consulta [Connect al servizio 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 Esempio: 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 Esempio: ottieni un'ombra per una cosa**  

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

Aggiorna l'ombra per l'oggetto specificato. Se non esiste un'ombra, ne viene creata una.

### Richiesta
<a name="ipc-operation-updatethingshadow-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`thingName`(Python:) `thing_name`  <a name="ipc-local-shadows-thing-name"></a>
Nome dell'oggetto.  
Tipo: `string`

`shadowName`(Python:) `shadow_name`  <a name="ipc-local-shadows-shadow-name"></a>
Il nome della copia shadow. Per specificare l'ombra classica dell'oggetto, imposta questo parametro su una stringa vuota (`""`).  
Il AWS IoT Greengrass servizio utilizza lo shadow `AWSManagedGreengrassV2Deployment` denominato per gestire le distribuzioni destinate a singoli dispositivi core. Questa ombra denominata è riservata all'uso da parte del AWS IoT Greengrass servizio. Non aggiornare o eliminare questa ombra denominata.
Tipo: `string`

`payload`  
Il documento di stato della richiesta come blob.  
Tipo: `object` che contiene le seguenti informazioni:    
`state`  
Le informazioni sullo stato da aggiornare. Questa operazione IPC ha effetto solo sui campi specificati.  
Questo oggetto contiene le seguenti informazioni. In genere, utilizzerai la `desired` proprietà o la `reported` proprietà, ma non entrambe nella stessa richiesta.    
`desired`  
Le proprietà e i valori dello stato di cui si richiede l'aggiornamento nel dispositivo.  
Tipo: `map` di coppie chiave-valore  
`reported`  
Le proprietà e i valori dello stato riportati dal dispositivo.  
Tipo: `map` di coppie chiave-valore  
`clientToken`(Python:) `client_token`  
(Facoltativo) Il token utilizzato per abbinare la richiesta e la risposta corrispondente dal token client.  
Tipo: `string`  
`version`  
(Facoltativo) La versione del documento shadow locale da aggiornare. Il servizio shadow elabora l'aggiornamento solo se la versione specificata corrisponde all'ultima versione disponibile.  
Tipo: `integer`

### Risposta
<a name="ipc-operation-updatethingshadow-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`payload`  
Il documento sullo stato della risposta sotto forma di blob.  
Tipo: `object` che contiene le seguenti informazioni:    
`state`  
Le informazioni sullo stato.  
Questo oggetto contiene le seguenti informazioni.    
`desired`  
Le proprietà e i valori dello stato da aggiornare nel dispositivo.  
Tipo: `map` di coppie chiave-valore  
`reported`  
Le proprietà e i valori dello stato riportati dal dispositivo.  
Tipo: `map` di coppie chiave-valore  
`delta`  
Le proprietà e i valori dello stato riportati dal dispositivo.  
Tipo: `map` di coppie chiave-valore  
`metadata`  
I timestamp per ogni attributo nelle `reported` sezioni `desired` and in modo da poter determinare quando lo stato è stato aggiornato.   
Tipo: `string`  
`timestamp`  
L'epoca, la data e l'ora in cui è stata generata la risposta.  
Tipo: `integer`  
`clientToken`(Python:) `client_token`  
Il token utilizzato per abbinare la richiesta e la risposta corrispondente.  
Tipo: `string`  
`version`  
La versione del documento shadow locale dopo il completamento dell'aggiornamento.  
Tipo: `integer`

### Errori
<a name="ipc-operation-updatethingshadow-errors"></a>

Questa operazione può restituire i seguenti errori.

`ConflictError`  
Il servizio shadow locale ha rilevato un conflitto di versione durante l'operazione di aggiornamento. Ciò si verifica quando la versione nel payload della richiesta non corrisponde alla versione dell'ultimo documento shadow locale disponibile.

`InvalidArgumentsError`  
<a name="ipc-invalidargumentserror-para"></a>Il servizio shadow locale non è in grado di convalidare i parametri della richiesta. Ciò può verificarsi se la richiesta contiene caratteri JSON non validi o non supportati.   
Un valido `payload` ha le seguenti proprietà:  
+ Il `state` nodo esiste ed è un oggetto che contiene le informazioni `reported` sullo stato `desired` o. 
+ I `reported` nodi `desired` and sono oggetti o nulli. Almeno uno di questi oggetti deve contenere informazioni sullo stato valide. 
+ La profondità degli `reported` oggetti `desired` e non può superare gli otto nodi. 
+ La lunghezza del `clientToken` valore non può superare i 64 caratteri. 
+  Il `version` valore deve essere uguale `1` o superiore. 

`ServiceError`  <a name="ipc-serviceerror"></a>
Si è verificato un errore interno del servizio oppure il numero di richieste al servizio IPC ha superato i limiti specificati nei parametri di `maxTotalLocalRequestsRate` configurazione `maxLocalRequestsPerSecondPerThing` e nel componente shadow manager.

`UnauthorizedError`  <a name="ipc-unauthorizederror"></a>
La politica di autorizzazione del componente non include le autorizzazioni necessarie per questa operazione.

### Esempi
<a name="ipc-operation-updatethingshadow-examples"></a>

Gli esempi seguenti mostrano come chiamare questa operazione nel codice del componente personalizzato.

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

**Example Esempio: aggiorna l'ombra di una cosa**  
Questo esempio utilizza una `IPCUtils` classe per creare una connessione al servizio AWS IoT Greengrass Core IPC. Per ulteriori informazioni, consulta [Connect al servizio 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 Esempio: aggiorna l'ombra di una cosa**  

```
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 Esempio: aggiornare l'ombra di una cosa**  

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

Elimina la copia shadow per l'oggetto specificato. 

A partire da shadow manager v2.0.4, l'eliminazione di un'ombra incrementa il numero di versione. Ad esempio, quando si elimina l'ombra `MyThingShadow` nella versione 1, la versione dell'ombra eliminata è 2. Se poi ricreate un'ombra con il nome`MyThingShadow`, la versione per quell'ombra è 3. 

### Richiesta
<a name="ipc-operation-deletethingshadow-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`thingName`(Python:) `thing_name`  <a name="ipc-local-shadows-thing-name"></a>
Nome dell'oggetto.  
Tipo: `string`

`shadowName`(Python:) `shadow_name`  <a name="ipc-local-shadows-shadow-name"></a>
Il nome della copia shadow. Per specificare l'ombra classica dell'oggetto, imposta questo parametro su una stringa vuota (`""`).  
Il AWS IoT Greengrass servizio utilizza lo shadow `AWSManagedGreengrassV2Deployment` denominato per gestire le distribuzioni destinate a singoli dispositivi core. Questa ombra denominata è riservata all'uso da parte del AWS IoT Greengrass servizio. Non aggiornare o eliminare questa ombra denominata.
Tipo: `string`

### Risposta
<a name="ipc-operation-deletethingshadow-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`payload`  
Un documento vuoto sullo stato della risposta.

### Errori
<a name="ipc-operation-deletethingshadow-errors"></a>

Questa operazione può restituire i seguenti errori.

`InvalidArgumentsError`  <a name="ipc-invalidargumentserror"></a>
<a name="ipc-invalidargumentserror-para"></a>Il servizio shadow locale non è in grado di convalidare i parametri della richiesta. Ciò può verificarsi se la richiesta contiene caratteri JSON non validi o non supportati. 

`ResourceNotFoundError`  <a name="ipc-resourcenotfounderror"></a>
Il documento shadow locale richiesto non può essere trovato.

`ServiceError`  <a name="ipc-serviceerror"></a>
Si è verificato un errore interno del servizio oppure il numero di richieste al servizio IPC ha superato i limiti specificati nei parametri di `maxTotalLocalRequestsRate` configurazione `maxLocalRequestsPerSecondPerThing` e nel componente shadow manager.

`UnauthorizedError`  <a name="ipc-unauthorizederror"></a>
La politica di autorizzazione del componente non include le autorizzazioni necessarie per questa operazione.

### Esempi
<a name="ipc-operation-deletethingshadow-examples"></a>

Gli esempi seguenti mostrano come chiamare questa operazione nel codice del componente personalizzato.

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

**Example Esempio: eliminare l'ombra di una cosa**  
Questo esempio utilizza una `IPCUtils` classe per creare una connessione al servizio AWS IoT Greengrass Core IPC. Per ulteriori informazioni, consulta [Connect al servizio 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 Esempio: eliminare un'ombra di oggetto**  

```
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 Esempio: eliminare l'ombra di una cosa**  

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

Elenca le ombre denominate per l'oggetto specificato.

### Richiesta
<a name="ipc-operation-listnamedshadowsforthing-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`thingName`(Python:) `thing_name`  <a name="ipc-local-shadows-thing-name"></a>
Nome dell'oggetto.  
Tipo: `string`

`pageSize`(Python:) `page_size`  
(Facoltativo) Il numero di nomi shadow da restituire in ogni chiamata.   
Tipo: `integer`  
Impostazione predefinita: 25  
Massimo: 100

`nextToken`(Python:) `next_token`  
(Facoltativo) Il token per recuperare il prossimo set di risultati. Questo valore viene restituito sui risultati di paging e viene utilizzato nella chiamata che restituisce la pagina successiva.  
Tipo: `string`

### Risposta
<a name="ipc-operation-listnamedshadowsforthing-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`results`  
L'elenco dei nomi delle ombre.   
Tipo: `array`

`timestamp`  
(Facoltativo) La data e l'ora in cui è stata generata la risposta.   
Tipo: `integer`

`nextToken`(Python:) `next_token`  
(Facoltativo) Il valore del token da utilizzare nelle richieste paginate per recuperare la pagina successiva nella sequenza. Questo token non è presente quando non ci sono più nomi ombra da restituire.  
Tipo: `string`  
Se la dimensione della pagina richiesta corrisponde esattamente al numero di nomi shadow nella risposta, allora questo token è presente; tuttavia, se utilizzato, restituisce un elenco vuoto.

### Errori
<a name="ipc-operation-listnamedshadowsforthing-errors"></a>

Questa operazione può restituire i seguenti errori.

`InvalidArgumentsError`  <a name="ipc-invalidargumentserror"></a>
<a name="ipc-invalidargumentserror-para"></a>Il servizio shadow locale non è in grado di convalidare i parametri della richiesta. Ciò può verificarsi se la richiesta contiene caratteri JSON non validi o non supportati. 

`ResourceNotFoundError`  <a name="ipc-resourcenotfounderror"></a>
Il documento shadow locale richiesto non può essere trovato.

`ServiceError`  <a name="ipc-serviceerror"></a>
Si è verificato un errore interno del servizio oppure il numero di richieste al servizio IPC ha superato i limiti specificati nei parametri di `maxTotalLocalRequestsRate` configurazione `maxLocalRequestsPerSecondPerThing` e nel componente shadow manager.

`UnauthorizedError`  <a name="ipc-unauthorizederror"></a>
La politica di autorizzazione del componente non include le autorizzazioni necessarie per questa operazione.

### Esempi
<a name="ipc-operation-listnamedshadowsforthing-examples"></a>

Gli esempi seguenti mostrano come chiamare questa operazione nel codice del componente personalizzato.

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

**Example Esempio: elenca una cosa chiamata shadows**  
Questo esempio utilizza una `IPCUtils` classe per creare una connessione al servizio AWS IoT Greengrass Core IPC. Per ulteriori informazioni, consulta [Connect al servizio 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 Esempio: elenca una cosa chiamata shadows**  

```
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 Esempio: elenca una cosa chiamata ombre**  

```
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();
```

------

# Gestisci le implementazioni e i componenti locali
<a name="ipc-local-deployments-components"></a>

**Nota**  
[Questa funzionalità è disponibile per la versione 2.6.0 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md)

Utilizza il servizio IPC Greengrass CLI per gestire le distribuzioni locali e i componenti Greengrass sul dispositivo principale.

Per utilizzare queste operazioni IPC, includete la versione 2.6.0 o successiva del componente [Greengrass CLI](greengrass-cli-component.md) come dipendenza nel componente personalizzato. È quindi possibile utilizzare le operazioni IPC nei componenti personalizzati per effettuare le seguenti operazioni:
+ Crea distribuzioni locali per modificare e configurare i componenti Greengrass sul dispositivo principale.
+ Riavvia e arresta i componenti Greengrass sul dispositivo principale.
+ Genera una password che puoi usare per accedere alla console di [debug locale](local-debug-console-component.md).

**Topics**
+ [Versioni SDK minime](#ipc-local-deployments-components-sdk-versions)
+ [Autorizzazione](#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)

## Versioni SDK minime
<a name="ipc-local-deployments-components-sdk-versions"></a>

La tabella seguente elenca le versioni minime di SDK per dispositivi AWS IoT che è necessario utilizzare per interagire con il servizio IPC CLI Greengrass.


| SDK | Versione minima | 
| --- | --- | 
|  [SDK per dispositivi AWS IoT per Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.2.10  | 
|  [SDK per dispositivi AWS IoT per Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.5.3  | 
|  [SDK per dispositivi AWS IoT per C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [SDK per dispositivi AWS IoT per v2 JavaScript ](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

## Autorizzazione
<a name="ipc-local-deployments-components-authorization"></a>

Per utilizzare il servizio IPC Greengrass CLI in un componente personalizzato, è necessario definire politiche di autorizzazione che consentano al componente di gestire distribuzioni e componenti locali. Per informazioni sulla definizione delle politiche di autorizzazione, vedere. [Autorizza i componenti a eseguire operazioni IPC](interprocess-communication.md#ipc-authorization-policies)

Le politiche di autorizzazione per la CLI Greengrass hanno le seguenti proprietà.

**Identificatore del servizio IPC:** `aws.greengrass.Cli`


| Operation | Description | Resources | 
| --- | --- | --- | 
|  `aws.greengrass#CreateLocalDeployment`  |  Consente a un componente di creare una distribuzione locale sul dispositivo principale.  |  `*`  | 
|  `aws.greengrass#ListLocalDeployments`  |  Consente a un componente di elencare le distribuzioni locali sul dispositivo principale.  |  `*`  | 
|  `aws.greengrass#GetLocalDeploymentStatus`  |  Consente a un componente di ottenere lo stato di una distribuzione locale sul dispositivo principale.  |  Un ID di distribuzione locale o `*` per consentire l'accesso a tutte le distribuzioni locali.  | 
|  `aws.greengrass#ListComponents`  |  Consente a un componente di elencare i componenti sul dispositivo principale.  |  `*`  | 
|  `aws.greengrass#GetComponentDetails`  |  Consente a un componente di ottenere dettagli su un componente del dispositivo principale.  |  Un nome di componente, ad esempio`com.example.HelloWorld`, o `*` per consentire l'accesso a tutti i componenti.  | 
|  `aws.greengrass#RestartComponent`  |  Consente a un componente di riavviare un componente sul dispositivo principale.  |  Un nome di componente, ad esempio`com.example.HelloWorld`, o `*` per consentire l'accesso a tutti i componenti.  | 
|  `aws.greengrass#StopComponent`  |  Consente a un componente di arrestare un componente sul dispositivo principale.  |  Un nome di componente, ad esempio`com.example.HelloWorld`, o `*` per consentire l'accesso a tutti i componenti.  | 
|  `aws.greengrass#CreateDebugPassword`  |  Consente a un componente di generare una password da utilizzare per accedere al [componente della console di debug locale](local-debug-console-component.md).  |  `*`  | 

**Example Esempio di politica di autorizzazione**  
I seguenti esempi di politiche di autorizzazione consentono a un componente di creare distribuzioni locali, visualizzare tutte le distribuzioni e i componenti locali e riavviare e arrestare un componente denominato. `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>

Crea o aggiorna una distribuzione locale utilizzando ricette di componenti, artefatti e argomenti di runtime specifici.

Questa operazione fornisce le stesse funzionalità del [comando deployment create](gg-cli-deployment.md#deployment-create) nella CLI di Greengrass.

### Richiesta
<a name="ipc-operation-createlocaldeployment-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`recipeDirectoryPath`(Python:) `recipe_directory_path`  
(Facoltativo) Il percorso assoluto della cartella che contiene i file di ricette dei componenti.

`artifactDirectoryPath`(Python:) `artifact_directory_path`  
(Facoltativo) Il percorso assoluto della cartella che contiene i file degli artefatti da includere nella distribuzione. La cartella artifacts deve contenere la seguente struttura di cartelle:  

```
/path/to/artifact/folder/component-name/component-version/artifacts
```

`rootComponentVersionsToAdd`(Python:) `root_component_versions_to_add`  
(Facoltativo) Le versioni dei componenti da installare sul dispositivo principale. Questo oggetto è una mappa che contiene le seguenti coppie chiave-valore: `ComponentToVersionMap`    
`key`  
Il nome del componente.  
`value`  
La versione del componente.

`rootComponentsToRemove`(Python:) `root_components_to_remove`  
(Facoltativo) I componenti da disinstallare dal dispositivo principale. Specificate un elenco in cui ogni voce è il nome di un componente.

`componentToConfiguration`(Python:) `component_to_configuration`  
(Facoltativo) La configurazione viene aggiornata per ogni componente della distribuzione. Questo oggetto è una mappa che contiene le seguenti coppie chiave-valore: `ComponentToConfiguration`    
`key`  
Il nome del componente.  
`value`  
L'oggetto JSON di aggiornamento della configurazione per il componente. L'oggetto JSON deve avere il seguente formato.  

```
{ 
  "MERGE": {
    "config-key": "config-value"
  },
  "RESET": [
    "path/to/reset/"
  ]
}
```
Per ulteriori informazioni sugli aggiornamenti della configurazione, vedere[Aggiornamento delle configurazioni dei componenti](update-component-configurations.md).

`componentToRunWithInfo`(Python:) `component_to_run_with_info`  
(Facoltativo) La configurazione di runtime per ogni componente della distribuzione. Questa configurazione include l'utente di sistema che possiede i processi di ciascun componente e i limiti di sistema da applicare a ciascun componente. Questo oggetto è una mappa che contiene le seguenti coppie chiave-valore: `ComponentToRunWithInfo`    
`key`  
Il nome del componente.  
`value`  
La configurazione di runtime per il componente. Se si omette un parametro di configurazione di runtime, il software AWS IoT Greengrass Core utilizza i valori predefiniti configurati sul nucleo [Greengrass](greengrass-nucleus-component.md). Questo oggetto contiene `RunWithInfo` le seguenti informazioni:    
`posixUser`(Python:) `posix_user`  
(Facoltativo) <a name="deployment-posix-user-definition"></a>L'utente e, facoltativamente, il gruppo del sistema POSIX da utilizzare per eseguire questo componente sui dispositivi core Linux. L'utente e il gruppo, se specificato, devono esistere su ogni dispositivo principale di Linux. Specifica l'utente e il gruppo separati da due punti (`:`) nel seguente formato: `user:group`. Il gruppo è facoltativo. Se non si specifica un gruppo, il software AWS IoT Greengrass Core utilizza il gruppo primario per l'utente. Per ulteriori informazioni, consulta [Configurare l'utente che esegue i componenti](configure-greengrass-core-v2.md#configure-component-user).   
`windowsUser`(Python:) `windows_user`  
(Facoltativo) <a name="deployment-windows-user-definition"></a>L'utente Windows da utilizzare per eseguire questo componente sui dispositivi Windows principali. L'utente deve esistere su ogni dispositivo Windows principale e il nome e la password devono essere memorizzati nell'istanza di Credentials Manager dell' LocalSystem account. Per ulteriori informazioni, consulta [Configurare l'utente che esegue i componenti](configure-greengrass-core-v2.md#configure-component-user).   
`systemResourceLimits`(Python:) `system_resource_limits`  
(Facoltativo) <a name="deployment-system-resource-limits-definition"></a>I limiti delle risorse di sistema da applicare ai processi di questo componente. È possibile applicare limiti di risorse di sistema a componenti Lambda generici e non containerizzati. Per ulteriori informazioni, consulta [Configura i limiti delle risorse di sistema per i componenti](configure-greengrass-core-v2.md#configure-component-system-resource-limits).   
AWS IoT Greengrass attualmente non supporta questa funzionalità sui dispositivi Windows core.   
Questo oggetto contiene `SystemResourceLimits` le seguenti informazioni:    
`cpus`  
(Facoltativo) <a name="system-resource-limits-cpu-definition-this"></a>La quantità massima di tempo di CPU che i processi di questo componente possono utilizzare sul dispositivo principale. Il tempo totale della CPU di un dispositivo principale è equivalente al numero di core CPU del dispositivo. Ad esempio, su un dispositivo principale con 4 core CPU, è possibile impostare questo valore in modo da `2` limitare i processi di questo componente al 50% di utilizzo di ciascun core della CPU. Su un dispositivo con 1 core di CPU, puoi impostare questo valore `0.25` per limitare i processi di questo componente al 25 percento di utilizzo della CPU. Se imposti questo valore su un numero maggiore del numero di core CPU, il software AWS IoT Greengrass Core non limita l'utilizzo della CPU del componente.   
`memory`  
(Facoltativo) <a name="system-resource-limits-memory-definition-this"></a>La quantità massima di RAM (in kilobyte) che i processi di questo componente possono utilizzare sul dispositivo principale. 

`groupName`(Python:) `group_name`  
(Facoltativo) Il nome del gruppo di oggetti a cui indirizzare questa distribuzione.

### Risposta
<a name="ipc-operation-createlocaldeployment-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`deploymentId`(Python:) `deployment_id`  
L'ID della distribuzione locale creata dalla richiesta.

## ListLocalDeployments
<a name="ipc-operation-listlocaldeployments"></a>

Ottiene lo stato delle ultime 10 distribuzioni locali.

Questa operazione fornisce le stesse funzionalità del [comando deployment list](gg-cli-deployment.md#deployment-list) nella CLI di Greengrass.

### Richiesta
<a name="ipc-operation-listlocaldeployments-request"></a>

La richiesta di questa operazione non ha parametri.

### Risposta
<a name="ipc-operation-listlocaldeployments-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`localDeployments`(Python:) `local_deployments`  
L'elenco delle distribuzioni locali. Ogni oggetto in questo elenco è un `LocalDeployment` oggetto che contiene le seguenti informazioni:  <a name="ipc-local-deployment-object-shape"></a>  
`deploymentId`(Python:) `deployment_id`  
L'ID della distribuzione locale.  
`status`  
Lo stato della distribuzione locale. Questo enum`DeploymentStatus`, ha i seguenti valori:  
+ `QUEUED`
+ `IN_PROGRESS`
+ `SUCCEEDED`
+ `FAILED`

## GetLocalDeploymentStatus
<a name="ipc-operation-getlocaldeploymentstatus"></a>

Ottiene lo stato di una distribuzione locale.

Questa operazione fornisce le stesse funzionalità del [comando deployment status](gg-cli-deployment.md#deployment-status) nella CLI di Greengrass.

### Richiesta
<a name="ipc-operation-getlocaldeploymentstatus-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`deploymentId`(Python:) `deployment_id`  
L'ID della distribuzione locale da ottenere.

### Risposta
<a name="ipc-operation-getlocaldeploymentstatus-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`deployment`  
La distribuzione locale. Questo oggetto contiene `LocalDeployment` le seguenti informazioni:  <a name="ipc-local-deployment-object-shape"></a>  
`deploymentId`(Python:) `deployment_id`  
L'ID della distribuzione locale.  
`status`  
Lo stato della distribuzione locale. Questo enum`DeploymentStatus`, ha i seguenti valori:  
+ `QUEUED`
+ `IN_PROGRESS`
+ `SUCCEEDED`
+ `FAILED`

## ListComponents
<a name="ipc-operation-listcomponents"></a>

Ottiene il nome, la versione, lo stato e la configurazione di ogni componente principale sul dispositivo principale. Un *componente root* è un componente specificato in una distribuzione. Questa risposta non include i componenti installati come dipendenze di altri componenti.

Questa operazione fornisce le stesse funzionalità del [comando dell'elenco dei componenti](gg-cli-component.md#component-list) nella CLI di Greengrass.

### Richiesta
<a name="ipc-operation-listcomponents-request"></a>

La richiesta di questa operazione non ha parametri.

### Risposta
<a name="ipc-operation-listcomponents-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`components`  
L'elenco dei componenti principali del dispositivo principale. Ogni oggetto in questo elenco è un `ComponentDetails` oggetto che contiene le seguenti informazioni:  <a name="ipc-component-details-object-shape"></a>  
`componentName`(Python:) `component_name`  
Il nome del componente.  
`version`  
La versione del componente.  
`state`  
Lo stato del componente. Questo stato può essere uno dei seguenti:  
+ `BROKEN`
+ `ERRORED`
+ `FINISHED`
+ `INSTALLED`
+ `NEW`
+ `RUNNING`
+ `STARTING`
+ `STOPPING`  
`configuration`  
La configurazione del componente come oggetto JSON.

## GetComponentDetails
<a name="ipc-operation-getcomponentdetails"></a>

Ottiene la versione, lo stato e la configurazione di un componente sul dispositivo principale.

Questa operazione fornisce le stesse funzionalità del [comando component details](gg-cli-component.md#component-details) nella CLI di Greengrass.

### Richiesta
<a name="ipc-operation-getcomponentdetails-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`componentName`(Python:) `component_name`  
Il nome del componente da ottenere.

### Risposta
<a name="ipc-operation-getcomponentdetails-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`componentDetails`(Python:) `component_details`  
I dettagli del componente. Questo oggetto contiene `ComponentDetails` le seguenti informazioni:  <a name="ipc-component-details-object-shape"></a>  
`componentName`(Python:) `component_name`  
Il nome del componente.  
`version`  
La versione del componente.  
`state`  
Lo stato del componente. Questo stato può essere uno dei seguenti:  
+ `BROKEN`
+ `ERRORED`
+ `FINISHED`
+ `INSTALLED`
+ `NEW`
+ `RUNNING`
+ `STARTING`
+ `STOPPING`  
`configuration`  
La configurazione del componente come oggetto JSON.

## RestartComponent
<a name="ipc-operation-restartcomponent"></a>

Riavvia un componente sul dispositivo principale.

**Nota**  
Sebbene sia possibile riavviare qualsiasi componente, si consiglia di riavviare solo [i componenti generici](develop-greengrass-components.md#component-types).

Questa operazione fornisce le stesse funzionalità del [comando di riavvio del componente](gg-cli-component.md#component-restart) nella CLI di Greengrass.

### Richiesta
<a name="ipc-operation-restartcomponent-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`componentName`(Python:) `component_name`  
Il nome del componente.

### Risposta
<a name="ipc-operation-restartcomponent-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`restartStatus`(Python:) `restart_status`  
Lo stato della richiesta di riavvio. Lo stato della richiesta può essere uno dei seguenti:  
+ `SUCCEEDED`
+ `FAILED`

`message`  
Un messaggio sul motivo per cui il componente non è riuscito a riavviarsi, se la richiesta non è riuscita.

### Esempi
<a name="ipc-operation-restartcomponent-examples"></a>

Gli esempi seguenti mostrano come chiamare questa operazione nel codice del componente personalizzato.

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

**Example Esempio: riavviare un componente**  

```
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 Esempio: riavviare un componente**  

```
#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 Esempio: riavviare un componente**  

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

Interrompe i processi di un componente sul dispositivo principale.

**Nota**  
Sebbene sia possibile interrompere qualsiasi componente, si consiglia di interrompere solo [i componenti generici](develop-greengrass-components.md#component-types).

Questa operazione fornisce le stesse funzionalità del [comando component stop](gg-cli-component.md#component-stop) nella CLI di Greengrass.

### Richiesta
<a name="ipc-operation-stopcomponent-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`componentName`(Python:) `component_name`  
Il nome del componente.

### Risposta
<a name="ipc-operation-stopcomponent-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`stopStatus`(Python:) `stop_status`  
Lo stato della richiesta di interruzione. Lo stato della richiesta può essere uno dei seguenti:  
+ `SUCCEEDED`
+ `FAILED`

`message`  
Un messaggio sul motivo per cui il componente non è riuscito a fermarsi, se la richiesta non è riuscita.

## CreateDebugPassword
<a name="ipc-operation-createdebugpassword"></a>

Genera una password casuale che è possibile utilizzare per accedere al [componente della console di debug locale](local-debug-console-component.md). La password scade 8 ore dopo la generazione.

Questa operazione fornisce le stesse funzionalità del [get-debug-password comando](gg-cli-get-debug-password.md) nella CLI di Greengrass.

### Richiesta
<a name="ipc-operation-createdebugpassword-request"></a>

La richiesta di questa operazione non ha parametri.

### Risposta
<a name="ipc-operation-createdebugpassword-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`username`  
Il nome utente da usare per accedere.

`password`  
La password da usare per accedere.

`passwordExpiration`(Python:) `password_expiration`  
L'ora in cui scade la password.

`certificateSHA256Hash`(Python:) `certificate_sha256_hash`  
L'impronta digitale SHA-256 per il certificato autofirmato utilizzato dalla console di debug locale quando HTTPS è abilitato. Quando apri la console di debug locale, usa questa impronta digitale per verificare che il certificato sia legittimo e che la connessione sia sicura.

`certificateSHA1Hash`(Python:) `certificate_sha1_hash`  
L'impronta digitale SHA-1 per il certificato autofirmato che la console di debug locale utilizza quando HTTPS è abilitato. Quando apri la console di debug locale, usa questa impronta digitale per verificare che il certificato sia legittimo e che la connessione sia sicura.

# Autentica e autorizza i dispositivi client
<a name="ipc-client-device-auth"></a>

**Nota**  
[Questa funzionalità è disponibile per la versione 2.6.0 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md)

Utilizza il servizio IPC di autenticazione dei dispositivi client per sviluppare un componente broker locale personalizzato a cui possano connettersi i dispositivi IoT locali, come i dispositivi client.

Per utilizzare queste operazioni IPC, includi la versione 2.2.0 o successiva del componente di [autenticazione del dispositivo client come dipendenza nel componente](client-device-auth-component.md) personalizzato. È quindi possibile utilizzare le operazioni IPC nei componenti personalizzati per effettuare le seguenti operazioni:
+ Verifica l'identità dei dispositivi client che si connettono al dispositivo principale.
+ Crea una sessione per consentire a un dispositivo client di connettersi al dispositivo principale.
+ Verifica se un dispositivo client è autorizzato a eseguire un'azione.
+ Ricevi una notifica quando il certificato del server del dispositivo principale cambia.

**Topics**
+ [Versioni SDK minime](#ipc-client-device-auth-sdk-versions)
+ [Autorizzazione](#ipc-client-device-auth-authorization)
+ [VerifyClientDeviceIdentity](#ipc-operation-verifyclientdeviceidentity)
+ [GetClientDeviceAuthToken](#ipc-operation-getclientdeviceauthtoken)
+ [AuthorizeClientDeviceAction](#ipc-operation-authorizeclientdeviceaction)
+ [SubscribeToCertificateUpdates](#ipc-operation-subscribetocertificateupdates)

## Versioni SDK minime
<a name="ipc-client-device-auth-sdk-versions"></a>

La tabella seguente elenca le versioni minime da utilizzare per interagire con il servizio IPC di autenticazione del dispositivo client. SDK per dispositivi AWS IoT 


| SDK | Versione minima | 
| --- | --- | 
|  [SDK per dispositivi AWS IoT per Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.9.3  | 
|  [SDK per dispositivi AWS IoT per Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.11.3  | 
|  [SDK per dispositivi AWS IoT per C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.18.3  | 
|  [SDK per dispositivi AWS IoT per v2 JavaScript ](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  | 

## Autorizzazione
<a name="ipc-client-device-auth-authorization"></a>

Per utilizzare il servizio IPC di autenticazione del dispositivo client in un componente personalizzato, è necessario definire politiche di autorizzazione che consentano al componente di eseguire queste operazioni. Per informazioni sulla definizione delle politiche di autorizzazione, vedere. [Autorizza i componenti a eseguire operazioni IPC](interprocess-communication.md#ipc-authorization-policies)

Le politiche di autorizzazione per l'autenticazione e l'autorizzazione dei dispositivi client hanno le seguenti proprietà.

**Identificatore del servizio IPC:** `aws.greengrass.clientdevices.Auth`


| Operation | Description | Resources | 
| --- | --- | --- | 
|  `aws.greengrass#VerifyClientDeviceIdentity`  |  Consente a un componente di verificare l'identità di un dispositivo client.  |  `*`  | 
|  `aws.greengrass#GetClientDeviceAuthToken`  |  Consente a un componente di convalidare le credenziali di un dispositivo client e di creare una sessione per quel dispositivo client.  |  `*`  | 
|  `aws.greengrass#AuthorizeClientDeviceAction`  |  Consente a un componente di verificare se un dispositivo client è autorizzato a eseguire un'azione.  |  `*`  | 
|  `aws.greengrass#SubscribeToCertificateUpdates`  |  Consente a un componente di ricevere notifiche quando il certificato del server del dispositivo principale ruota.  |  `*`  | 
|  `*`  |  Consente a un componente di eseguire tutte le operazioni del servizio IPC di autenticazione del dispositivo client.  |  `*`  | 

### Esempi di politiche di autorizzazione
<a name="ipc-client-device-auth-authorization-policy-examples"></a>

È possibile fare riferimento al seguente esempio di politica di autorizzazione per configurare le politiche di autorizzazione per i componenti.

**Example Esempio di politica di autorizzazione**  
Il seguente esempio di politica di autorizzazione consente a un componente di eseguire tutte le operazioni IPC di autenticazione dei dispositivi 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>

Verifica l'identità di un dispositivo client. Questa operazione verifica se il dispositivo client è valido AWS IoT .

### Richiesta
<a name="ipc-operation-verifyclientdeviceidentity-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`credential`  
Le credenziali del dispositivo client. Questo oggetto contiene `ClientDeviceCredential` le seguenti informazioni:    
`clientDeviceCertificate`(Python:) `client_device_certificate`  
Il certificato del dispositivo X.509 del dispositivo client.

### Risposta
<a name="ipc-operation-verifyclientdeviceidentity-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`isValidClientDevice`(Python:) `is_valid_client_device`  
Se l'identità del dispositivo client è valida.

## GetClientDeviceAuthToken
<a name="ipc-operation-getclientdeviceauthtoken"></a>

Convalida le credenziali di un dispositivo client e crea una sessione per il dispositivo client. Questa operazione restituisce un token di sessione che è possibile utilizzare nelle richieste successive per [autorizzare le azioni del dispositivo client](#ipc-operation-authorizeclientdeviceaction).

Per connettere correttamente un dispositivo client, il [componente di autenticazione del dispositivo client](client-device-auth-component.md#client-device-auth-component-configuration) deve concedere l'`mqtt:connect`autorizzazione per l'ID client utilizzato dal dispositivo client.

### Richiesta
<a name="ipc-operation-getclientdeviceauthtoken-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`credential`  
Le credenziali del dispositivo client. Questo oggetto contiene `CredentialDocument` le seguenti informazioni:    
`mqttCredential`(Python:) `mqtt_credential`  
Le credenziali MQTT del dispositivo client. Specificare l'ID client e il certificato utilizzati dal dispositivo client per la connessione. Questo oggetto contiene `MQTTCredential` le seguenti informazioni:    
`clientId`(Python:) `client_id`  
L'ID client da utilizzare per la connessione.  
`certificatePem`(Python:) `certificate_pem`  
Il certificato del dispositivo X.509 da utilizzare per la connessione.  
`username`  
Questa proprietà non è attualmente utilizzata.  
`password`  
Questa proprietà non è attualmente utilizzata.

### Risposta
<a name="ipc-operation-getclientdeviceauthtoken-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`clientDeviceAuthToken`(Python:) `client_device_auth_token`  
Il token di sessione per il dispositivo client. È possibile utilizzare questo token di sessione nelle richieste successive per autorizzare le azioni di questo dispositivo client.

## AuthorizeClientDeviceAction
<a name="ipc-operation-authorizeclientdeviceaction"></a>

Verifica se un dispositivo client è autorizzato a eseguire un'azione su una risorsa. Le *politiche di autorizzazione dei dispositivi client* specificano le autorizzazioni che i dispositivi client possono eseguire mentre sono connessi a un dispositivo principale. Le politiche di autorizzazione dei dispositivi client vengono definite quando si configura il componente di [autenticazione del dispositivo client](client-device-auth-component.md#client-device-auth-component-configuration).

### Richiesta
<a name="ipc-operation-authorizeclientdeviceaction-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`clientDeviceAuthToken`(Python:) `client_device_auth_token`  
Il token di sessione per il dispositivo client.

`operation`  
L'operazione da autorizzare.

`resource`  
La risorsa in cui il dispositivo client esegue l'operazione.

### Risposta
<a name="ipc-operation-authorizeclientdeviceaction-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`isAuthorized`(Python:) `is_authorized`  
Se il dispositivo client è autorizzato a eseguire l'operazione sulla risorsa.

## SubscribeToCertificateUpdates
<a name="ipc-operation-subscribetocertificateupdates"></a>

Abbonati per ricevere il nuovo certificato server del dispositivo principale ogni volta che ruota. Quando il certificato del server cambia, i broker devono ricaricarlo utilizzando il nuovo certificato del server.

Per impostazione predefinita, il [componente di autenticazione del dispositivo client](client-device-auth-component.md) ruota i certificati del server ogni 7 giorni. È possibile configurare l'intervallo di rotazione tra 2 e 10 giorni.

<a name="ipc-subscribe-operation-note"></a>Questa operazione è un'operazione di sottoscrizione in cui ci si iscrive a un flusso di messaggi di eventi. Per utilizzare questa operazione, definite un gestore di risposte di flusso con funzioni che gestiscono i messaggi di evento, gli errori e la chiusura dei flussi. Per ulteriori informazioni, consulta [Iscriviti ai flussi di eventi IPC](interprocess-communication.md#ipc-subscribe-operations).

**Tipo di messaggio di evento:** `CertificateUpdateEvent`

### Richiesta
<a name="ipc-operation-subscribetocertificateupdates-request"></a>

La richiesta di questa operazione ha i seguenti parametri:

`certificateOptions`(Python:) `certificate_options`  
I tipi di aggiornamenti dei certificati a cui sottoscrivere. Questo oggetto contiene `CertificateOptions` le seguenti informazioni:    
`certificateType`(Python:) `certificate_type`  
Il tipo di aggiornamenti dei certificati a cui sottoscrivere. Scegli la seguente opzione:  
+ `SERVER`

### Risposta
<a name="ipc-operation-subscribetocertificateupdates-response"></a>

La risposta di questa operazione contiene le seguenti informazioni:

`messages`  
Il flusso di messaggi. Questo oggetto contiene `CertificateUpdateEvent` le seguenti informazioni:    
`certificateUpdate`(Python:) `certificate_update`  
Le informazioni sul nuovo certificato. Questo oggetto contiene `CertificateUpdate` le seguenti informazioni:    
`certificate`  
Il certificato.  
`privateKey`(Python:) `private_key`  
La chiave privata del certificato.  
`publicKey`(Python:) `public_key`  
La chiave pubblica del certificato.  
`caCertificates`(Python:) `ca_certificates`  
L'elenco dei certificati di autorità di certificazione (CA) nella catena di certificati CA del certificato.