Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verwenden Sie den AWS IoT Device SDK , um mit dem Greengrass-Kern und anderen Komponenten zu kommunizieren und AWS IoT Core
<a name="interprocess-communication"></a>

Komponenten, die auf Ihrem Core-Gerät ausgeführt werden, können die AWS IoT Greengrass Core Interprocess Communication (IPC) -Bibliothek in der verwenden, AWS IoT Device SDK um mit dem AWS IoT Greengrass Nucleus und anderen Greengrass-Komponenten zu kommunizieren. Um benutzerdefinierte Komponenten zu entwickeln und auszuführen, die IPC verwenden, müssen Sie den verwenden, AWS IoT Device SDK um eine Verbindung zum AWS IoT Greengrass Core IPC-Dienst herzustellen und IPC-Operationen durchzuführen.

Die IPC-Schnittstelle unterstützt zwei Arten von Operationen:
+ **Anfrage/Antwort**

  Komponenten senden eine Anfrage an den IPC-Dienst und erhalten eine Antwort, die das Ergebnis der Anfrage enthält.
+ **Abonnement**

  Komponenten senden eine Abonnementanfrage an den IPC-Dienst und erwarten als Antwort einen Strom von Ereignisnachrichten. Komponenten stellen einen Abonnement-Handler bereit, der Ereignismeldungen, Fehler und das Schließen von Streams verarbeitet. Das AWS IoT Device SDK beinhaltet eine Handler-Schnittstelle mit den richtigen Antwort- und Ereignistypen für jeden IPC-Vorgang. Weitere Informationen finden Sie unter [Abonnieren Sie IPC-Event-Streams](#ipc-subscribe-operations).

**Topics**
+ [IPC-Client-Versionen](#ipc-client-versions)
+ [Wird SDKs für die Kommunikation zwischen Prozessen unterstützt](#ipc-requirements)
+ [Connect zum AWS IoT Greengrass Core IPC-Dienst her](#ipc-service-connect)
+ [Autorisieren Sie Komponenten zur Ausführung von IPC-Vorgängen](#ipc-authorization-policies)
+ [Abonnieren Sie IPC-Event-Streams](#ipc-subscribe-operations)
+ [Bewährte IPC-Praktiken](#ipc-best-practices)
+ [Lokale Nachrichten veröffentlichen/abonnieren](ipc-publish-subscribe.md)
+ [MQTT-Nachrichten veröffentlichen/abonnieren AWS IoT Core](ipc-iot-core-mqtt.md)
+ [Interagieren Sie mit dem Lebenszyklus von Komponenten](ipc-component-lifecycle.md)
+ [Interagieren Sie mit der Komponentenkonfiguration](ipc-component-configuration.md)
+ [Geheime Werte abrufen](ipc-secret-manager.md)
+ [Interagiere mit lokalen Schatten](ipc-local-shadows.md)
+ [Lokale Bereitstellungen und Komponenten verwalten](ipc-local-deployments-components.md)
+ [Client-Geräte authentifizieren und autorisieren](ipc-client-device-auth.md)

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

In späteren Versionen von Java und Python SDKs wird eine verbesserte Version des IPC-Clients AWS IoT Greengrass bereitgestellt, die als IPC-Client V2 bezeichnet wird. IPC-Client V2:
+ Reduziert die Menge an Code, die Sie für die Verwendung von IPC-Operationen schreiben müssen, und trägt dazu bei, häufige Fehler zu vermeiden, die beim IPC-Client V1 auftreten können.
+ Ruft Abonnement-Handler-Callbacks in einem separaten Thread auf, sodass Sie jetzt Blockierungscode, einschließlich zusätzlicher IPC-Funktionsaufrufen, in Abonnement-Handler-Callbacks ausführen können. Der IPC-Client V1 verwendet denselben Thread, um mit dem IPC-Server zu kommunizieren und Abonnement-Handler-Callbacks aufzurufen.
+ Ermöglicht das Aufrufen von Abonnementvorgängen mithilfe von Lambda-Ausdrücken (Java) oder Funktionen (Python). Für den IPC-Client V1 müssen Sie Abonnement-Handler-Klassen definieren.
+ Stellt synchrone und asynchrone Versionen der einzelnen IPC-Operationen bereit. Der IPC-Client V1 stellt nur asynchrone Versionen der einzelnen Operationen bereit.

Wir empfehlen, dass Sie den IPC-Client V2 verwenden, um diese Verbesserungen nutzen zu können. Viele Beispiele in dieser Dokumentation und in einigen Online-Inhalten zeigen jedoch nur, wie der IPC-Client V1 verwendet wird. Anhand der folgenden Beispiele und Tutorials können Sie sich die Beispielkomponenten ansehen, die den IPC-Client V2 verwenden:
+ [PublishToTopicBeispiele](ipc-publish-subscribe.md#ipc-operation-publishtotopic-examples)
+ [SubscribeToTopicBeispiele](ipc-publish-subscribe.md#ipc-operation-subscribetotopic-examples)
+ [Tutorial: Entwickeln Sie eine Greengrass-Komponente, die Komponenten-Updates verzögert](defer-component-updates-tutorial.md)
+ [Tutorial: Interagieren Sie mit lokalen IoT-Geräten über MQTT](client-devices-tutorial.md)

Derzeit unterstützt der AWS IoT Device SDK für C\$1\$1 v2 nur den IPC-Client V1.

## Wird SDKs für die Kommunikation zwischen Prozessen unterstützt
<a name="ipc-requirements"></a>

Die AWS IoT Greengrass Core-IPC-Bibliotheken sind in den folgenden AWS IoT Device SDK Versionen enthalten.


| SDK | Mindestversion | Usage | 
| --- | --- | --- | 
|  [AWS IoT Device SDK für Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.6.0  |  Siehe [Verwenden Sie AWS IoT Device SDK für Java v2 (IPC-Client V2)](#ipc-java-v2)  | 
|  [AWS IoT Device SDK für Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.9.0  |  Siehe [Verwendung AWS IoT Device SDK für Python v2 (IPC-Client V2)](#ipc-python-v2)  | 
|  [AWS IoT Device SDK für C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  |  Siehe [Verwenden Sie AWS IoT Device SDK für C\$1\$1 v2](#ipc-cpp)  | 
|  [AWS IoT Device SDK für v2 JavaScript ](https://github.com/aws/aws-iot-device-sdk-js-v2)  |  v1.12.0  |  Siehe [Verwenden Sie AWS IoT Device SDK für JavaScript v2 (IPC-Client V1)](#ipc-nodejs)  | 

## Connect zum AWS IoT Greengrass Core IPC-Dienst her
<a name="ipc-service-connect"></a>

Um die Interprozesskommunikation in Ihrer benutzerdefinierten Komponente zu verwenden, müssen Sie eine Verbindung zu einem IPC-Server-Socket herstellen, auf dem die AWS IoT Greengrass Core-Software ausgeführt wird. Führen Sie die folgenden Aufgaben aus, um das herunterzuladen und AWS IoT Device SDK in der Sprache Ihrer Wahl zu verwenden. 

### Verwenden Sie AWS IoT Device SDK für Java v2 (IPC-Client V2)
<a name="ipc-java-v2"></a>

**Um den AWS IoT Device SDK für Java v2 (IPC-Client V2) zu verwenden**

1. Laden Sie das [AWS IoT Device SDK für Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2) (v1.6.0 oder höher) herunter.

1. <a name="use-ipc-java-component-install-step"></a>Führen Sie einen der folgenden Schritte aus, um Ihren benutzerdefinierten Code in Ihrer Komponente auszuführen:
   + Erstellen Sie Ihre Komponente als JAR-Datei, die die enthält AWS IoT Device SDK, und führen Sie diese JAR-Datei in Ihrem Komponentenrezept aus.
   + Definieren Sie das AWS IoT Device SDK JAR als Komponentenartefakt und fügen Sie dieses Artefakt dem Klassenpfad hinzu, wenn Sie Ihre Anwendung in Ihrem Komponentenrezept ausführen.

1. Verwenden Sie den folgenden Code, um den IPC-Client zu erstellen.

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

### Verwendung AWS IoT Device SDK für Python v2 (IPC-Client V2)
<a name="ipc-python-v2"></a>

**Um das AWS IoT Device SDK für Python v2 (IPC-Client V2) zu verwenden**

1. Laden Sie das [AWS IoT Device SDK für Python](https://github.com/aws/aws-iot-device-sdk-python-v2) herunter (v1.9.0 oder höher).

1. <a name="use-ipc-python-component-install-step"></a>Fügen Sie die [Installationsschritte](https://github.com/aws/aws-iot-device-sdk-python-v2#installation) des SDK zum Installationslebenszyklus im Rezept Ihrer Komponente hinzu.

1. Stellen Sie eine Verbindung zum AWS IoT Greengrass Core IPC-Dienst her. Verwenden Sie den folgenden Code, um den IPC-Client zu erstellen.

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

### Verwenden Sie AWS IoT Device SDK für C\$1\$1 v2
<a name="ipc-cpp"></a>

<a name="iot-device-sdk-cpp-v2-build-requirements-intro"></a>Um die AWS IoT Device SDK Version 2 für C\$1\$1 zu erstellen, muss ein Gerät über die folgenden Tools verfügen:<a name="iot-device-sdk-cpp-v2-build-requirements"></a>
+ C\$1\$1 11 oder höher
+ CMake 3.1 oder später
+ Einer der folgenden Compiler:
  + GCC 4.8 oder höher
  + Clang 3.9 oder höher
  + MSVC 2015 oder später

**Um das AWS IoT Device SDK für C\$1\$1 v2 zu verwenden**

1. Laden Sie das [AWS IoT Device SDK für C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2) (v1.17.0 oder höher) herunter.

1. Folgen Sie den [Installationsanweisungen in der README-Datei](https://github.com/aws/aws-iot-device-sdk-cpp-v2#Installation), um das AWS IoT Device SDK für C\$1\$1 v2 aus dem Quellcode zu erstellen.

1. Verlinken Sie in Ihrem C\$1\$1-Build-Tool die Greengrass IPC-Bibliothek,`AWS::GreengrassIpc-cpp`, die Sie im vorherigen Schritt erstellt haben. Das folgende `CMakeLists.txt` Beispiel verknüpft die Greengrass IPC-Bibliothek mit einem Projekt, mit dem Sie bauen. 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. Stellen Sie in Ihrem Komponentencode eine Verbindung zum AWS IoT Greengrass Core-IPC-Dienst her, um einen IPC-Client zu erstellen (). `Aws::Greengrass::GreengrassCoreIpcClient` Sie müssen einen IPC-Verbindungslebenszyklus-Handler definieren, der IPC-Verbindungs-, Verbindungstrennungs- und Fehlerereignisse behandelt. Im folgenden Beispiel werden ein IPC-Client und ein IPC-Verbindungslebenszyklus-Handler erstellt, der druckt, wenn der IPC-Client eine Verbindung herstellt oder die Verbindung trennt und auf Fehler stößt.

   ```
   #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. Um Ihren benutzerdefinierten Code in Ihrer Komponente auszuführen, erstellen Sie Ihren Code als binäres Artefakt und führen Sie das binäre Artefakt in Ihrem Komponentenrezept aus. Legen Sie die `Execute` Berechtigung des Artefakts auf fest, `OWNER` damit die AWS IoT Greengrass Core-Software das binäre Artefakt ausführen kann.

   Der `Manifests` Abschnitt Ihres Komponentenrezepts könnte dem folgenden Beispiel ähneln.

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

------

### Verwenden Sie AWS IoT Device SDK für JavaScript v2 (IPC-Client V1)
<a name="ipc-nodejs"></a>

<a name="iot-device-sdk-nodejs-build-requirements-intro"></a>Um das AWS IoT Device SDK für JavaScript v2 für die Verwendung mit NodeJS zu erstellen, muss ein Gerät über die folgenden Tools verfügen:<a name="iot-device-sdk-nodejs-build-requirements"></a>
+ NodeJS 10.0 oder höher
  + Führen Sie aus`node -v`, um die Node-Version zu überprüfen.
+ CMake 3.1 oder höher

**Um den AWS IoT Device SDK for JavaScript v2 zu verwenden (IPC-Client V1)**

1. Laden Sie das [AWS IoT Device SDK für JavaScript v2](https://github.com/aws/aws-iot-device-sdk-js-v2) herunter (v1.12.10 oder höher).

1. Folgen Sie den [Installationsanweisungen in der README-Datei](https://github.com/aws/aws-iot-device-sdk-js-v2/tree/v1.12.1#installation), um das AWS IoT Device SDK für JavaScript Version 2 aus dem Quellcode zu erstellen.

1. Stellen Sie eine Verbindung zum AWS IoT Greengrass Core IPC-Dienst her. Gehen Sie wie folgt vor, um den IPC-Client zu erstellen und eine Verbindung herzustellen.

1. Verwenden Sie den folgenden Code, um den IPC-Client zu erstellen.

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

1. Verwenden Sie den folgenden Code, um eine Verbindung von Ihrer Komponente zum Greengrass-Kern herzustellen.

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

## Autorisieren Sie Komponenten zur Ausführung von IPC-Vorgängen
<a name="ipc-authorization-policies"></a>

Damit Ihre benutzerdefinierten Komponenten einige IPC-Operationen verwenden können, müssen Sie *Autorisierungsrichtlinien* definieren, die es der Komponente ermöglichen, den Vorgang auf bestimmten Ressourcen auszuführen. Jede Autorisierungsrichtlinie definiert eine Liste von Vorgängen und eine Liste von Ressourcen, die die Richtlinie zulässt. Beispielsweise definiert der publish/subscribe IPC-Messaging-Dienst Veröffentlichungs- und Abonnementvorgänge für Themenressourcen. Sie können den `*` Platzhalter verwenden, um den Zugriff auf alle Operationen oder alle Ressourcen zu ermöglichen.

Autorisierungsrichtlinien definieren Sie mit dem `accessControl` Konfigurationsparameter, den Sie im Komponentenrezept oder bei der Bereitstellung der Komponente festlegen können. Das `accessControl` Objekt ordnet IPC-Dienstkennungen Listen von Autorisierungsrichtlinien zu. Sie können mehrere Autorisierungsrichtlinien für jeden IPC-Dienst definieren, um den Zugriff zu kontrollieren. Jede Autorisierungsrichtlinie hat eine Richtlinien-ID, die für alle Komponenten eindeutig sein muss.

**Tipp**  
Um eine eindeutige Richtlinie zu erstellen IDs, können Sie den Komponentennamen, den IPC-Dienstnamen und einen Zähler kombinieren. Eine Komponente mit dem Namen `com.example.HelloWorld` könnte beispielsweise zwei publish/subscribe Autorisierungsrichtlinien mit den folgenden IDs Kriterien definieren:  
`com.example.HelloWorld:pubsub:1`
`com.example.HelloWorld:pubsub:2`

Autorisierungsrichtlinien verwenden das folgende Format. Dieses Objekt ist der `accessControl` Konfigurationsparameter.

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

------

### Platzhalter in Autorisierungsrichtlinien
<a name="ipc-authorization-policy-wildcards"></a>

Sie können den `*` Platzhalter im `resources` Element der IPC-Autorisierungsrichtlinien verwenden, um den Zugriff auf mehrere Ressourcen in einer einzigen Autorisierungsrichtlinie zu ermöglichen.
+ In allen Versionen von [Greengrass Nucleus](greengrass-nucleus-component.md) können Sie ein einzelnes `*` Zeichen als Ressource angeben, um Zugriff auf alle Ressourcen zu gewähren.
+ In [Greengrass Nucleus](greengrass-nucleus-component.md) v2.6.0 und höher können Sie den `*` Charakter in einer Ressource so angeben, dass er einer beliebigen Zeichenkombination entspricht. Sie können beispielsweise angeben`factory/1/devices/Thermostat*/status`, dass allen Thermostatgeräten in einer Fabrik der Zugriff auf ein Statusthema gewährt wird, wobei der Name jedes Geräts mit beginnt. `Thermostat`

Wenn Sie Autorisierungsrichtlinien für den AWS IoT Core MQTT IPC-Dienst definieren, können Sie auch MQTT-Platzhalter (`+`und`#`) verwenden, um mehrere Ressourcen zuzuordnen. Weitere Informationen finden Sie unter [MQTT-Platzhalter in MQTT-IPC-Autorisierungsrichtlinien. AWS IoT Core](ipc-iot-core-mqtt.md#ipc-iot-core-mqtt-authorization-mqtt-wildcards)

### Rezeptvariablen in Autorisierungsrichtlinien
<a name="ipc-authorization-policy-recipe-variables"></a>

Wenn Sie [Greengrass Nucleus](greengrass-nucleus-component.md) v2.6.0 oder höher verwenden und die [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)Konfigurationsoption von Greengrass Nucleus auf einstellen`true`, können Sie die `{iot:thingName}` [Rezeptvariable](component-recipe-reference.md#recipe-variables) in Autorisierungsrichtlinien verwenden. Wenn Sie eine Autorisierungsrichtlinie benötigen, die den Namen des Kerngeräts enthält, z. B. für MQTT-Themen oder Geräteschatten, können Sie diese Rezeptvariable verwenden, um eine einzelne Autorisierungsrichtlinie für eine Gruppe von Kerngeräten zu konfigurieren. Beispielsweise können Sie einer Komponente den Zugriff auf die folgende Ressource für Shadow-IPC-Operationen gewähren.

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

### Sonderzeichen in Autorisierungsrichtlinien
<a name="ipc-authorization-policy-special-characters"></a>

Um ein Literal `*` oder ein `?` Zeichen in einer Autorisierungsrichtlinie anzugeben, müssen Sie eine Escape-Sequenz verwenden. Die folgenden Escape-Sequenzen weisen die AWS IoT Greengrass Core-Software an, den Literalwert anstelle der speziellen Bedeutung des Zeichens zu verwenden. Das `*` Zeichen ist beispielsweise ein [Platzhalter](#ipc-authorization-policy-wildcards), der einer beliebigen Kombination von Zeichen entspricht.


| Wörtliches Zeichen | Escape-Sequenz | Hinweise | 
| --- | --- | --- | 
|  `*`  |  `${*}`  |  | 
|  `?`  |  `${?}`  |  AWS IoT Greengrass unterstützt derzeit nicht den `?` Platzhalter, der einem einzelnen Zeichen entspricht.  | 
|  `$`  |  `${$}`  |  Verwenden Sie diese Escape-Sequenz, um eine Ressource zu finden, die enthält`${`. Um beispielsweise einer Ressource mit dem Namen zu entsprechen`${resourceName}`, müssen Sie Folgendes `${$}{resourceName}` angeben: Andernfalls können Sie für die Suche nach einer Ressource`$`, die Folgendes enthält, ein Literal verwenden`$`, z. B. um Zugriff auf ein Thema zu gewähren, das mit `$aws` beginnt.  | 

### Beispiele für Autorisierungsrichtlinien
<a name="ipc-authorization-policy-examples"></a>

Anhand der folgenden Beispiele für Autorisierungsrichtlinien können Sie Autorisierungsrichtlinien für Ihre Komponenten konfigurieren.

**Example Beispiel für ein Komponentenrezept mit einer Autorisierungsrichtlinie**  
Das folgende Beispiel für ein Komponentenrezept enthält ein `accessControl` Objekt, das eine Autorisierungsrichtlinie definiert. Diese Richtlinie autorisiert die `com.example.HelloWorld` Komponente, unter dem `test/topic` Thema zu veröffentlichen.  

```
{
  "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 Beispiel für ein Update der Komponentenkonfiguration mit einer Autorisierungsrichtlinie**  
Das folgende Beispiel für ein Konfigurationsupdate in einer Bereitstellung gibt an, dass eine Komponente mit einem `accessControl` Objekt konfiguriert werden soll, das eine Autorisierungsrichtlinie definiert. Diese Richtlinie autorisiert die `com.example.HelloWorld` Komponente, unter dem `test/topic` Thema zu veröffentlichen.    
**Konfiguration zum Zusammenführen**  

```
{
  "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"
        ]
      }
    }
  }
}
```
Der folgende Befehl erstellt eine Bereitstellung auf einem Kerngerät.  

```
aws greengrassv2 create-deployment --cli-input-json file://hello-world-deployment.json
```
Die `hello-world-deployment.json` Datei enthält das folgende JSON-Dokument.  

```
{
  "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\"]}}}}"
      }
    }
  }
}
```
Der folgende [Greengrass-CLI-Befehl](greengrass-cli-component.md) erstellt eine lokale Bereitstellung auf einem Core-Gerät.  

```
sudo greengrass-cli deployment create \
  --recipeDir recipes \
  --artifactDir artifacts \
  --merge "com.example.HelloWorld=1.0.0" \
  --update-config hello-world-configuration.json
```
Die `hello-world-configuration.json` Datei enthält das folgende JSON-Dokument.  

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

## Abonnieren Sie IPC-Event-Streams
<a name="ipc-subscribe-operations"></a>

Sie können IPC-Operationen verwenden, um Streams von Ereignissen auf einem Greengrass-Core-Gerät zu abonnieren. Um einen Abonnement-Vorgang zu verwenden, definieren Sie einen *Abonnement-Handler* und erstellen Sie eine Anfrage an den IPC-Dienst. Anschließend führt der IPC-Client die Funktionen des Abonnement-Handlers jedes Mal aus, wenn das Kerngerät eine Ereignismeldung an Ihre Komponente streamt.

Sie können ein Abonnement schließen, um die Verarbeitung von Ereignismeldungen zu beenden. Rufen Sie dazu `closeStream()` (Java), (Python) oder `close()` `Close()` (C\$1\$1) für das Objekt für den Abonnementvorgang auf, mit dem Sie das Abonnement geöffnet haben.

Der AWS IoT Greengrass Core IPC-Dienst unterstützt die folgenden Abonnementvorgänge:
+ [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**
+ [Definieren Sie Abonnement-Handler](#ipc-define-subscription-handlers)
+ [Beispiel für Abonnement-Handler](#ipc-subscription-handler-examples)

### Definieren Sie Abonnement-Handler
<a name="ipc-define-subscription-handlers"></a>

Um einen Abonnement-Handler zu definieren, definieren Sie Callback-Funktionen, die Ereignismeldungen, Fehler und das Schließen von Streams behandeln. Wenn Sie den IPC-Client V1 verwenden, müssen Sie diese Funktionen in einer Klasse definieren. Wenn Sie den IPC-Client V2 verwenden, der in späteren Versionen von Java und Python verfügbar ist, können Sie diese Funktionen definieren SDKs, ohne eine Abonnement-Handler-Klasse zu erstellen.

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

Wenn Sie den IPC-Client V1 verwenden, müssen Sie die generische `software.amazon.awssdk.eventstreamrpc.StreamResponseHandler<StreamEventType>` Schnittstelle implementieren. *StreamEventType*ist der Typ der Ereignisnachricht für den Abonnementvorgang. Definieren Sie die folgenden Funktionen, um Ereignismeldungen, Fehler und das Schließen von Streams zu behandeln.

Wenn Sie den IPC-Client V2 verwenden, können Sie diese Funktionen außerhalb einer Abonnement-Handler-Klasse definieren oder [Lambda-Ausdrücke](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html) verwenden.

`void onStreamEvent(StreamEventType event)`  
Der Callback, den der IPC-Client aufruft, wenn er eine Ereignisnachricht empfängt, z. B. eine MQTT-Nachricht oder eine Benachrichtigung über ein Komponenten-Update.

`boolean onStreamError(Throwable error)`  
Der Callback, den der IPC-Client aufruft, wenn ein Stream-Fehler auftritt.  
<a name="ipc-subscription-handler-on-stream-error-return-value"></a>Geben Sie true zurück, um den Abonnement-Stream aufgrund des Fehlers zu schließen, oder geben Sie false zurück, um den Stream geöffnet zu lassen.

`void onStreamClosed()`  
Der Callback, den der IPC-Client aufruft, wenn der Stream geschlossen wird.

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

Wenn Sie den IPC-Client V1 verwenden, müssen Sie die Stream-Response-Handler-Klasse erweitern, die dem Abonnementvorgang entspricht. Die AWS IoT Device SDK beinhaltet eine Abonnement-Handler-Klasse für jeden Abonnementvorgang. *StreamEventType*ist der Typ der Ereignisnachricht für den Abonnementvorgang. Definieren Sie die folgenden Funktionen, um Ereignismeldungen, Fehler und das Schließen von Streams zu behandeln.

Wenn Sie den IPC-Client V2 verwenden, können Sie diese Funktionen außerhalb einer Abonnement-Handler-Klasse definieren oder [Lambda-Ausdrücke](https://docs.python.org/3/tutorial/controlflow.html#lambda-expressions) verwenden.

`def on_stream_event(self, event: StreamEventType) -> None`  
Der Callback, den der IPC-Client aufruft, wenn er eine Ereignisnachricht empfängt, z. B. eine MQTT-Nachricht oder eine Benachrichtigung über ein Komponenten-Update.

`def on_stream_error(self, error: Exception) -> bool`  
Der Callback, den der IPC-Client aufruft, wenn ein Stream-Fehler auftritt.  
<a name="ipc-subscription-handler-on-stream-error-return-value"></a>Geben Sie true zurück, um den Abonnement-Stream aufgrund des Fehlers zu schließen, oder geben Sie false zurück, um den Stream geöffnet zu lassen.

`def on_stream_closed(self) -> None`  
Der Callback, den der IPC-Client aufruft, wenn der Stream geschlossen wird.

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

Implementieren Sie eine Klasse, die von der Stream-Response-Handler-Klasse abgeleitet ist, die dem Abonnementvorgang entspricht. Die AWS IoT Device SDK beinhaltet eine Abonnement-Handler-Basisklasse für jeden Abonnementvorgang. *StreamEventType*ist der Typ der Ereignisnachricht für den Abonnementvorgang. Definieren Sie die folgenden Funktionen, um Ereignismeldungen, Fehler und das Schließen von Streams zu behandeln.

`void OnStreamEvent(StreamEventType *event)`  
Der Callback, den der IPC-Client aufruft, wenn er eine Ereignisnachricht empfängt, z. B. eine MQTT-Nachricht oder eine Benachrichtigung über ein Komponenten-Update.

`bool OnStreamError(OperationError *error)`  
Der Callback, den der IPC-Client aufruft, wenn ein Stream-Fehler auftritt.  
<a name="ipc-subscription-handler-on-stream-error-return-value"></a>Geben Sie true zurück, um den Abonnement-Stream aufgrund des Fehlers zu schließen, oder geben Sie false zurück, um den Stream geöffnet zu lassen.

`void OnStreamClosed()`  
Der Callback, den der IPC-Client aufruft, wenn der Stream geschlossen wird.

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

Implementieren Sie eine Klasse, die von der Stream-Response-Handler-Klasse abgeleitet ist, die dem Abonnementvorgang entspricht. Die AWS IoT Device SDK beinhaltet eine Abonnement-Handler-Basisklasse für jeden Abonnementvorgang. *StreamEventType*ist der Typ der Ereignisnachricht für den Abonnementvorgang. Definieren Sie die folgenden Funktionen, um Ereignismeldungen, Fehler und das Schließen von Streams zu behandeln.

`on(event: 'ended', listener: StreamingOperationEndedListener)`  
Der Callback, den der IPC-Client aufruft, wenn der Stream geschlossen wird.

`on(event: 'streamError', listener: StreamingRpcErrorListener)`  
Der Callback, den der IPC-Client aufruft, wenn ein Stream-Fehler auftritt.  
<a name="ipc-subscription-handler-on-stream-error-return-value"></a>Geben Sie true zurück, um den Abonnement-Stream aufgrund des Fehlers zu schließen, oder geben Sie false zurück, um den Stream geöffnet zu lassen.

`on(event: 'message', listener: (message: InboundMessageType) => void)`  
Der Callback, den der IPC-Client aufruft, wenn er eine Ereignisnachricht empfängt, z. B. eine MQTT-Nachricht oder eine Benachrichtigung über ein Komponenten-Update.

------

### Beispiel für Abonnement-Handler
<a name="ipc-subscription-handler-examples"></a>

Das folgende Beispiel zeigt, wie der [SubscribeToTopic](ipc-publish-subscribe.md#ipc-operation-subscribetotopic) Vorgang und ein Abonnement-Handler verwendet werden, um lokale Veröffentlichungs-/Abonnementnachrichten zu abonnieren.

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

**Example Beispiel: Lokale Nachrichten abonnieren 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 Beispiel: Lokale publish/subscribe Nachrichten abonnieren**  <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 Beispiel: Lokale publish/subscribe Nachrichten abonnieren**  <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 Beispiel: Lokale publish/subscribe Nachrichten abonnieren**  <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 Beispiel: Lokale publish/subscribe Nachrichten abonnieren**  

```
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 Beispiel: Lokale publish/subscribe Nachrichten abonnieren**  

```
#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 Beispiel: Lokale publish/subscribe Nachrichten abonnieren**  

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

------

## Bewährte IPC-Praktiken
<a name="ipc-best-practices"></a>

Die bewährten Methoden für die Verwendung von IPC in benutzerdefinierten Komponenten unterscheiden sich zwischen IPC-Client V1 und IPC-Client V2. Folgen Sie den bewährten Methoden für die IPC-Client-Version, die Sie verwenden.

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

Der IPC-Client V2 führt Callback-Funktionen in einem separaten Thread aus, sodass Sie im Vergleich zu IPC-Client V1 weniger Richtlinien beachten müssen, wenn Sie IPC verwenden und Abonnement-Handler-Funktionen schreiben.
+ <a name="ipc-best-practice-reuse-one-client"></a>**Einen IPC-Client wiederverwenden**

  Nachdem Sie einen IPC-Client erstellt haben, lassen Sie ihn geöffnet und verwenden Sie ihn für alle IPC-Operationen erneut. Das Erstellen mehrerer Clients verbraucht zusätzliche Ressourcen und kann zu Ressourcenlecks führen.
+ **Behandeln Sie Ausnahmen**

  Der IPC-Client V2 protokolliert nicht abgefangene Ausnahmen in Abonnement-Handler-Funktionen. Sie sollten Ausnahmen in Ihren Handlerfunktionen abfangen, um Fehler zu behandeln, die in Ihrem Code auftreten.

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

Der IPC-Client V1 verwendet einen einzigen Thread, der mit dem IPC-Server kommuniziert und Abonnement-Handler aufruft. Sie müssen dieses synchrone Verhalten berücksichtigen, wenn Sie Abonnement-Handler-Funktionen schreiben.
+ <a name="ipc-best-practice-reuse-one-client"></a>**Einen IPC-Client wiederverwenden**

  Nachdem Sie einen IPC-Client erstellt haben, lassen Sie ihn geöffnet und verwenden Sie ihn für alle IPC-Operationen erneut. Das Erstellen mehrerer Clients verbraucht zusätzliche Ressourcen und kann zu Ressourcenlecks führen.
+ **Führen Sie den Blockierungscode asynchron aus**

  Der IPC-Client V1 kann keine neuen Anfragen senden oder neue Ereignisnachrichten verarbeiten, solange der Thread blockiert ist. Sie sollten den Blockierungscode in einem separaten Thread ausführen, den Sie von der Handler-Funktion aus ausführen. Blockierungscode umfasst `sleep` Aufrufe, Schleifen, die kontinuierlich ausgeführt werden, und synchrone I/O Anfragen, deren Abschluss einige Zeit in Anspruch nimmt.
+ **Senden Sie neue IPC-Anfragen asynchron**

  Der IPC-Client V1 kann innerhalb der Abonnement-Handler-Funktionen keine neue Anfrage senden, da die Anfrage die Handler-Funktion blockiert, wenn Sie auf eine Antwort warten. Sie sollten IPC-Anfragen in einem separaten Thread senden, den Sie von der Handler-Funktion aus ausführen.
+ **Behandeln Sie Ausnahmen**

  Der IPC-Client V1 behandelt keine nicht abgefangenen Ausnahmen in Abonnement-Handler-Funktionen. Wenn Ihre Handlerfunktion eine Ausnahme auslöst, wird das Abonnement geschlossen und die Ausnahme erscheint nicht in Ihren Komponentenprotokollen. Sie sollten Ausnahmen in Ihren Handler-Funktionen abfangen, um das Abonnement offen zu halten und Fehler zu protokollieren, die in Ihrem Code auftreten.

------

# Lokale Nachrichten veröffentlichen/abonnieren
<a name="ipc-publish-subscribe"></a>

Mit Publish/Sub-Nachrichten (Pubsub) können Sie Nachrichten zu Themen senden und empfangen. Komponenten können Nachrichten zu Themen veröffentlichen, um Nachrichten an andere Komponenten zu senden. Komponenten, die dieses Thema abonniert haben, können dann auf die Nachrichten reagieren, die sie erhalten.

**Anmerkung**  
Sie können diesen publish/subscribe IPC-Dienst nicht verwenden, um MQTT zu veröffentlichen oder zu AWS IoT Core abonnieren. Weitere Informationen zum Austausch von Nachrichten mit AWS IoT Core MQTT finden Sie unter. [MQTT-Nachrichten veröffentlichen/abonnieren AWS IoT Core](ipc-iot-core-mqtt.md)

**Topics**
+ [Minimale SDK-Versionen](#ipc-publish-subscribe-sdk-versions)
+ [Autorisierung](#ipc-publish-subscribe-authorization)
+ [PublishToTopic](#ipc-operation-publishtotopic)
+ [SubscribeToTopic](#ipc-operation-subscribetotopic)
+ [Beispiele](#ipc-publish-subscribe-examples)

## Minimale SDK-Versionen
<a name="ipc-publish-subscribe-sdk-versions"></a>

In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie verwenden müssen, um Nachrichten zu und von lokalen Themen zu veröffentlichen und zu abonnieren.


| SDK | Mindestversion | 
| --- | --- | 
|  [AWS IoT Device SDK für Java v2](https://github.com/aws/aws-iot-device-sdk-java-v2)  |  v1.2.10  | 
|  [AWS IoT Device SDK für Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2)  |  v1.5.3  | 
|  [AWS IoT Device SDK für C\$1\$1 v2](https://github.com/aws/aws-iot-device-sdk-cpp-v2)  |  v1.17.0  | 
|  [AWS IoT Device SDK for JavaScript  ](https://github.com/aws/aws-iot-device-sdk-js-v2) v2  |  v1.12.0  | 

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

Um lokales publish/subscribe Messaging in einer benutzerdefinierten Komponente zu verwenden, müssen Sie Autorisierungsrichtlinien definieren, die es Ihrer Komponente ermöglichen, Nachrichten an Themen zu senden und zu empfangen. Informationen zur Definition von Autorisierungsrichtlinien finden Sie unter[Autorisieren Sie Komponenten zur Ausführung von IPC-Vorgängen](interprocess-communication.md#ipc-authorization-policies).

Autorisierungsrichtlinien für publish/subscribe Messaging haben die folgenden Eigenschaften.

**IPC-Dienst-ID:** `aws.greengrass.ipc.pubsub`


| Operation | Description | Ressourcen | 
| --- | --- | --- | 
|  `aws.greengrass#PublishToTopic`  |  Ermöglicht einer Komponente, Nachrichten zu den von Ihnen angegebenen Themen zu veröffentlichen.  |  Eine Themenzeichenfolge, z. `test/topic` B. Verwenden Sie an`*`, um einer beliebigen Zeichenkombination in einem Thema zu entsprechen. Diese Themenzeichenfolge unterstützt keine Platzhalter (`#`und`+`) für MQTT-Themen.  | 
|  `aws.greengrass#SubscribeToTopic`  |  Ermöglicht einer Komponente, Nachrichten für die von Ihnen angegebenen Themen zu abonnieren.  |  Eine Themenzeichenfolge, z. `test/topic` B. Verwenden Sie an`*`, um einer beliebigen Zeichenkombination in einem Thema zu entsprechen. <a name="ipc-local-publish-subscribe-authorization-mqtt-wildcards"></a>In [Greengrass Nucleus](greengrass-nucleus-component.md) v2.6.0 und höher können Sie Themen abonnieren, die Platzhalter (und) für MQTT-Themen enthalten. `#` `+` Diese Themenzeichenfolge unterstützt Platzhalter für MQTT-Themen als Literalzeichen. Wenn beispielsweise die Autorisierungsrichtlinie einer Komponente Zugriff auf gewährt`test/topic/#`, kann die Komponente zwar etwas abonnieren`test/topic/#`, aber nicht abonnieren. `test/topic/filter`  | 
|  `*`  |  Ermöglicht einer Komponente, Nachrichten zu den von Ihnen angegebenen Themen zu veröffentlichen und zu abonnieren.  |  Eine Themenzeichenfolge, z. `test/topic` B. Verwenden Sie an`*`, um einer beliebigen Zeichenkombination in einem Thema zu entsprechen. <a name="ipc-local-publish-subscribe-authorization-mqtt-wildcards"></a>In [Greengrass Nucleus](greengrass-nucleus-component.md) v2.6.0 und höher können Sie Themen abonnieren, die Platzhalter (und) für MQTT-Themen enthalten. `#` `+` Diese Themenzeichenfolge unterstützt Platzhalter für MQTT-Themen als Literalzeichen. Wenn beispielsweise die Autorisierungsrichtlinie einer Komponente Zugriff auf gewährt`test/topic/#`, kann die Komponente zwar abonnieren`test/topic/#`, aber nicht abonnieren. `test/topic/filter`  | 

### Beispiele für Autorisierungsrichtlinien
<a name="ipc-publish-subscribe-authorization-policy-examples"></a>

Anhand des folgenden Beispiels für eine Autorisierungsrichtlinie können Sie Autorisierungsrichtlinien für Ihre Komponenten konfigurieren.

**Example Beispiel für eine Autorisierungsrichtlinie**  
Das folgende Beispiel für eine Autorisierungsrichtlinie ermöglicht es einer Komponente, alle Themen zu veröffentlichen und zu abonnieren.  

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

Veröffentlichen einer Nachricht für ein Thema.

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

Die Anforderung dieses Vorgangs hat die folgenden Parameter:

`topic`  
Das Thema, zu dem die Nachricht veröffentlicht werden soll.

`publishMessage`(Python:`publish_message`)  
Die zu veröffentlichende Nachricht. Dieses Objekt,`PublishMessage`, enthält die folgenden Informationen. Sie müssen einen von `jsonMessage` und angeben`binaryMessage`.  <a name="ipc-publish-subscribe-message-shape"></a>  
`jsonMessage`(Python:`json_message`)  
(Optional) Eine JSON-Nachricht. Dieses Objekt,`JsonMessage`, enthält die folgenden Informationen:    
`message`  
Die JSON-Nachricht als Objekt.  
`context`  <a name="ipc-publish-subscribe-message-context-variable"></a>
Der Kontext der Nachricht, z. B. das Thema, in dem die Nachricht veröffentlicht wurde.  
Diese Funktion ist für Version 2.6.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar. In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie für den Zugriff auf den Nachrichtenkontext verwenden müssen.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/ipc-publish-subscribe.html)
Die AWS IoT Greengrass Core-Software verwendet dieselben Nachrichtenobjekte in den Operationen `PublishToTopic` und`SubscribeToTopic`. Die AWS IoT Greengrass Core-Software legt dieses Kontextobjekt in Nachrichten fest, wenn Sie sie abonnieren, und ignoriert dieses Kontextobjekt in Nachrichten, die Sie veröffentlichen.
Dieses Objekt,`MessageContext`, enthält die folgenden Informationen:    
`topic`  
Das Thema, in dem die Nachricht veröffentlicht wurde.  
`binaryMessage`(Python:`binary_message`)  
(Optional) Eine binäre Nachricht. Dieses Objekt,`BinaryMessage`, enthält die folgenden Informationen:    
`message`  
Die binäre Nachricht als Blob.  
`context`  <a name="ipc-publish-subscribe-message-context-variable"></a>
Der Kontext der Nachricht, z. B. das Thema, in dem die Nachricht veröffentlicht wurde.  
Diese Funktion ist für Version 2.6.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar. In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie für den Zugriff auf den Nachrichtenkontext verwenden müssen.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/ipc-publish-subscribe.html)
Die AWS IoT Greengrass Core-Software verwendet dieselben Nachrichtenobjekte in den Operationen `PublishToTopic` und`SubscribeToTopic`. Die AWS IoT Greengrass Core-Software legt dieses Kontextobjekt in Nachrichten fest, wenn Sie sie abonnieren, und ignoriert dieses Kontextobjekt in Nachrichten, die Sie veröffentlichen.
Dieses Objekt,`MessageContext`, enthält die folgenden Informationen:    
`topic`  
Das Thema, in dem die Nachricht veröffentlicht wurde.

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

Dieser Vorgang liefert in seiner Antwort keine Informationen.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang in benutzerdefiniertem Komponentencode aufgerufen wird.

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

**Example Beispiel: Veröffentlichen Sie eine binäre Nachricht**  

```
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 Beispiel: Veröffentlichen Sie eine binäre Nachricht**  

```
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 Beispiel: Veröffentlichen Sie eine binäre Nachricht**  

```
#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 Beispiel: Veröffentlichen Sie eine binäre Nachricht**  

```
    
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 Beispiel: Veröffentlichen Sie eine binäre Nachricht**  

```
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 Beispiel: Veröffentlichen Sie eine binäre Nachricht**  

```
#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 Beispiel: Veröffentlichen Sie eine binäre Nachricht**  

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

Abonnieren Sie Nachrichten zu einem Thema.

<a name="ipc-subscribe-operation-note"></a>Bei diesem Vorgang handelt es sich um einen Abonnementvorgang, bei dem Sie einen Stream von Ereignisnachrichten abonnieren. Um diese Operation zu verwenden, definieren Sie einen Stream-Response-Handler mit Funktionen, die Ereignismeldungen, Fehler und das Schließen von Streams behandeln. Weitere Informationen finden Sie unter [Abonnieren Sie IPC-Event-Streams](interprocess-communication.md#ipc-subscribe-operations).

**Typ der Ereignisnachricht:** `SubscriptionResponseMessage`

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

Die Anforderung dieses Vorgangs hat die folgenden Parameter:

`topic`  
Das Thema, das abonniert werden soll.  
In [Greengrass Nucleus](greengrass-nucleus-component.md) v2.6.0 und höher unterstützt dieses Thema Platzhalter (und) für MQTT-Themen. `#` `+`

`receiveMode`(Python:`receive_mode`)  
(Optional) Das Verhalten, das angibt, ob die Komponente Nachrichten von sich selbst empfängt. Sie können dieses Verhalten ändern, damit eine Komponente auf ihre eigenen Nachrichten reagieren kann. Das Standardverhalten hängt davon ab, ob das Thema einen MQTT-Platzhalter enthält. Wählen Sie aus den folgenden Optionen aus:  
+ `RECEIVE_ALL_MESSAGES`— Empfangen Sie alle Nachrichten, die dem Thema entsprechen, einschließlich Nachrichten von der Komponente, die das Abonnement abonniert.

  Dieser Modus ist die Standardoption, wenn Sie ein Thema abonnieren, das keinen MQTT-Platzhalter enthält.
+ `RECEIVE_MESSAGES_FROM_OTHERS`— Empfangen Sie alle Nachrichten, die dem Thema entsprechen, mit Ausnahme von Nachrichten von der Komponente, die das Abonnement abonniert.

  Dieser Modus ist die Standardoption, wenn Sie ein Thema abonnieren, das einen MQTT-Platzhalter enthält.
Diese Funktion ist für Version 2.6.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar. In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie verwenden müssen, um den Empfangsmodus einzustellen.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/ipc-publish-subscribe.html)

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

Die Antwort dieser Operation enthält die folgenden Informationen:

`messages`  
Der Nachrichtenstrom. Dieses Objekt,`SubscriptionResponseMessage`, enthält die folgenden Informationen. Jede Nachricht enthält `jsonMessage` oder`binaryMessage`.  <a name="ipc-publish-subscribe-message-shape"></a>  
`jsonMessage`(Python:`json_message`)  
(Optional) Eine JSON-Nachricht. Dieses Objekt,`JsonMessage`, enthält die folgenden Informationen:    
`message`  
Die JSON-Nachricht als Objekt.  
`context`  <a name="ipc-publish-subscribe-message-context-variable"></a>
Der Kontext der Nachricht, z. B. das Thema, in dem die Nachricht veröffentlicht wurde.  
Diese Funktion ist für Version 2.6.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar. In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie für den Zugriff auf den Nachrichtenkontext verwenden müssen.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/ipc-publish-subscribe.html)
Die AWS IoT Greengrass Core-Software verwendet dieselben Nachrichtenobjekte in den Operationen `PublishToTopic` und`SubscribeToTopic`. Die AWS IoT Greengrass Core-Software legt dieses Kontextobjekt in Nachrichten fest, wenn Sie sie abonnieren, und ignoriert dieses Kontextobjekt in Nachrichten, die Sie veröffentlichen.
Dieses Objekt,`MessageContext`, enthält die folgenden Informationen:    
`topic`  
Das Thema, in dem die Nachricht veröffentlicht wurde.  
`binaryMessage`(Python:`binary_message`)  
(Optional) Eine binäre Nachricht. Dieses Objekt,`BinaryMessage`, enthält die folgenden Informationen:    
`message`  
Die binäre Nachricht als Blob.  
`context`  <a name="ipc-publish-subscribe-message-context-variable"></a>
Der Kontext der Nachricht, z. B. das Thema, in dem die Nachricht veröffentlicht wurde.  
Diese Funktion ist für Version 2.6.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar. In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie für den Zugriff auf den Nachrichtenkontext verwenden müssen.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/ipc-publish-subscribe.html)
Die AWS IoT Greengrass Core-Software verwendet dieselben Nachrichtenobjekte in den Operationen `PublishToTopic` und`SubscribeToTopic`. Die AWS IoT Greengrass Core-Software legt dieses Kontextobjekt in Nachrichten fest, wenn Sie sie abonnieren, und ignoriert dieses Kontextobjekt in Nachrichten, die Sie veröffentlichen.
Dieses Objekt,`MessageContext`, enthält die folgenden Informationen:    
`topic`  
Das Thema, in dem die Nachricht veröffentlicht wurde.

`topicName`(Python:`topic_name`)  
Das Thema, zu dem die Nachricht veröffentlicht wurde.  
Diese Eigenschaft wird derzeit nicht verwendet. In [Greengrass Nucleus](greengrass-nucleus-component.md) v2.6.0 und höher können Sie den `(jsonMessage|binaryMessage).context.topic` Wert von a abrufen, `SubscriptionResponseMessage` um das Thema abzurufen, in dem die Nachricht veröffentlicht wurde.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang in benutzerdefiniertem Komponentencode aufgerufen wird.

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

**Example Beispiel: Lokale publish/subscribe Nachrichten abonnieren**  <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 Beispiel: Lokale publish/subscribe Nachrichten abonnieren**  <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 Beispiel: Lokale publish/subscribe Nachrichten abonnieren**  <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 Beispiel: Lokale publish/subscribe Nachrichten abonnieren**  <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 Beispiel: Lokale publish/subscribe Nachrichten abonnieren**  

```
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 Beispiel: Lokale publish/subscribe Nachrichten abonnieren**  

```
#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 Beispiel: Lokale publish/subscribe Nachrichten abonnieren**  

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

------

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

Anhand der folgenden Beispiele erfahren Sie, wie Sie den publish/subscribe IPC-Service in Ihren Komponenten verwenden können.

### Beispiel für einen publish/subscribe Herausgeber (Java, IPC-Client V1)
<a name="ipc-publish-subscribe-example-publisher-java"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, zu allen Themen zu veröffentlichen.

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

------

Die folgende Java-Beispielanwendung zeigt, wie der Publish/Subscribe-IPC-Dienst verwendet wird, um Nachrichten in anderen Komponenten zu veröffentlichen.

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

### Beispiel für einen publish/subscribe Abonnenten (Java, IPC-Client V1)
<a name="ipc-publish-subscribe-example-subscriber-java"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, alle Themen zu abonnieren.

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

------

Die folgende Java-Beispielanwendung zeigt, wie der Publish/Subscribe-IPC-Dienst verwendet wird, um Nachrichten für andere Komponenten zu abonnieren.

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

### Beispiel für einen publish/subscribe Herausgeber (Python, IPC-Client V1)
<a name="ipc-publish-subscribe-example-publisher-python"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, zu allen Themen zu veröffentlichen.

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

------

Die folgende Python-Beispielanwendung zeigt, wie der Publish/Subscribe-IPC-Dienst verwendet wird, um Nachrichten in anderen Komponenten zu veröffentlichen.

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

### publish/subscribe Beispiel-Abonnent (Python, IPC-Client V1)
<a name="ipc-publish-subscribe-example-subscriber-python"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, alle Themen zu abonnieren.

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

------

Die folgende Python-Beispielanwendung zeigt, wie der Publish/Subscribe-IPC-Dienst verwendet wird, um Nachrichten für andere Komponenten zu abonnieren.

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

### Beispiel für einen publish/subscribe Herausgeber (C\$1\$1, IPC-Client V1)
<a name="ipc-publish-subscribe-example-publisher-cpp"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, zu allen Themen zu veröffentlichen.

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

------

Die folgende C\$1\$1-Beispielanwendung zeigt, wie der IPC-Dienst Publish/Subscribe verwendet wird, um Nachrichten in anderen Komponenten zu veröffentlichen.

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

### Beispiel für einen publish/subscribe Abonnenten (C\$1\$1, IPC-Client V1)
<a name="ipc-publish-subscribe-example-subscriber-cpp"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, alle Themen zu abonnieren.

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

------

Die folgende C\$1\$1-Beispielanwendung zeigt, wie der Publish/Subscribe-IPC-Dienst verwendet wird, um Nachrichten für andere Komponenten zu abonnieren.

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

### Beispiel für publish/subscribe einen Herausgeber (Rust)
<a name="ipc-publish-subscribe-example-publisher-rust"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, zu allen Themen zu veröffentlichen.

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

Die folgende Rust-Beispielanwendung zeigt, wie der IPC-Dienst Publish/Subscribe verwendet wird, um Nachrichten in anderen Komponenten zu veröffentlichen.

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

### Beispiel für publish/subscribe einen Abonnenten (Rust)
<a name="ipc-publish-subscribe-example-subscriber-rust"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, alle Themen zu abonnieren.

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

Die folgende Rust-Beispielanwendung zeigt, wie der IPC-Dienst Publish/Subscribe verwendet wird, um Nachrichten von anderen Komponenten zu abonnieren.

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

### Beispiel für publish/subscribe einen Herausgeber (C)
<a name="ipc-publish-subscribe-example-publisher-c"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, zu allen Themen zu veröffentlichen.

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

Die folgende C-Beispielanwendung zeigt, wie der IPC-Dienst Publish/Subscribe verwendet wird, um Nachrichten in anderen Komponenten zu veröffentlichen.

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

### Beispiel für publish/subscribe einen Abonnenten (C)
<a name="ipc-publish-subscribe-example-subscriber-c"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, alle Themen zu abonnieren.

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

Die folgende C-Beispielanwendung zeigt, wie der IPC-Dienst Publish/Subscribe verwendet wird, um Nachrichten von anderen Komponenten zu abonnieren.

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

### Beispiel für einen publish/subscribe Herausgeber (C\$1\$1, Komponenten-SDK)
<a name="ipc-publish-subscribe-example-publisher-cpp-component-sdk"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, zu allen Themen zu veröffentlichen.

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

Die folgende C\$1\$1-Beispielanwendung zeigt, wie der IPC-Dienst Publish/Subscribe verwendet wird, um Nachrichten in anderen Komponenten zu veröffentlichen.

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

### Beispiel für einen publish/subscribe Abonnenten (C\$1\$1, Komponenten-SDK)
<a name="ipc-publish-subscribe-example-subscriber-cpp-component-sdk"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, alle Themen zu abonnieren.

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

Die folgende C\$1\$1-Beispielanwendung zeigt, wie der Publish/Subscribe-IPC-Dienst verwendet wird, um Nachrichten von anderen Komponenten zu abonnieren.

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

# MQTT-Nachrichten veröffentlichen/abonnieren AWS IoT Core
<a name="ipc-iot-core-mqtt"></a>

Mit dem AWS IoT Core MQTT-Messaging-IPC-Dienst können Sie MQTT-Nachrichten an und von senden und empfangen. AWS IoT Core Komponenten können Nachrichten veröffentlichen AWS IoT Core und Themen abonnieren, um auf MQTT-Nachrichten aus anderen Quellen zu reagieren. *Weitere Informationen zur AWS IoT Core Implementierung von MQTT finden Sie unter [MQTT im AWS IoT Core Developer](https://docs.aws.amazon.com/iot/latest/developerguide/mqtt.html) Guide.*

**Anmerkung**  
Mit diesem MQTT-Messaging-IPC-Dienst können Sie Nachrichten austauschen mit. AWS IoT Core Weitere Hinweise zum Austausch von Nachrichten zwischen Komponenten finden Sie unter. [Lokale Nachrichten veröffentlichen/abonnieren](ipc-publish-subscribe.md)

**Topics**
+ [Minimale SDK-Versionen](#ipc-iot-core-mqtt-sdk-versions)
+ [Autorisierung](#ipc-iot-core-mqtt-authorization)
+ [PublishToIoTCore](#ipc-operation-publishtoiotcore)
+ [SubscribeToIoTCore](#ipc-operation-subscribetoiotcore)
+ [Beispiele](#ipc-iot-core-mqtt-examples)

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

In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie zum Veröffentlichen und Abonnieren von AWS IoT Core MQTT-Nachrichten verwenden müssen.


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

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

Um AWS IoT Core MQTT-Messaging in einer benutzerdefinierten Komponente zu verwenden, müssen Sie Autorisierungsrichtlinien definieren, die es Ihrer Komponente ermöglichen, Nachrichten zu Themen zu senden und zu empfangen. Informationen zur Definition von Autorisierungsrichtlinien finden Sie unter[Autorisieren Sie Komponenten zur Ausführung von IPC-Vorgängen](interprocess-communication.md#ipc-authorization-policies).

Autorisierungsrichtlinien für AWS IoT Core MQTT-Messaging haben die folgenden Eigenschaften.

**IPC-Dienst-ID:** `aws.greengrass.ipc.mqttproxy`


| Operation | Description | Ressourcen | 
| --- | --- | --- | 
|  `aws.greengrass#PublishToIoTCore`  |  Ermöglicht einer Komponente, Nachrichten zu den von Ihnen AWS IoT Core angegebenen MQTT-Themen zu veröffentlichen.  |  Eine Themenzeichenfolge, z. B. oder`test/topic`, `*` um den Zugriff auf alle Themen zu ermöglichen. Sie können Platzhalter (`#`und`+`) für MQTT-Themen verwenden, um mehrere Ressourcen zuzuordnen.  | 
|  `aws.greengrass#SubscribeToIoTCore`  |  Ermöglicht einer Komponente, Nachrichten zu den von Ihnen AWS IoT Core angegebenen Themen zu abonnieren.  |  Eine Themenzeichenfolge, z. B. oder`test/topic`, `*` um den Zugriff auf alle Themen zu ermöglichen. Sie können Platzhalter (`#`und`+`) für MQTT-Themen verwenden, um mehrere Ressourcen zuzuordnen.  | 
|  `*`  |  Ermöglicht einer Komponente, AWS IoT Core MQTT-Nachrichten für die von Ihnen angegebenen Themen zu veröffentlichen und zu abonnieren.  |  Eine Themenzeichenfolge, z. B. oder`test/topic`, `*` um den Zugriff auf alle Themen zu ermöglichen. Sie können Platzhalter (`#`und`+`) für MQTT-Themen verwenden, um mehrere Ressourcen zuzuordnen.  | 

### MQTT-Platzhalter in MQTT-Autorisierungsrichtlinien AWS IoT Core
<a name="ipc-iot-core-mqtt-authorization-mqtt-wildcards"></a>

Sie können MQTT-Platzhalter in AWS IoT Core MQTT-IPC-Autorisierungsrichtlinien verwenden. Komponenten können Themen veröffentlichen und abonnieren, die dem Themenfilter entsprechen, den Sie in einer Autorisierungsrichtlinie zulassen. Wenn beispielsweise die Autorisierungsrichtlinie einer Komponente Zugriff auf gewährt`test/topic/#`, kann die Komponente diese abonnieren`test/topic/#`, veröffentlichen und abonnieren`test/topic/filter`.

### Rezeptvariablen in AWS IoT Core MQTT-Autorisierungsrichtlinien
<a name="ipc-iot-core-mqtt-authorization-recipe-variables"></a>

Wenn Sie Version 2.6.0 oder höher von [Greengrass Nucleus](greengrass-nucleus-component.md) verwenden, können Sie die `{iot:thingName}` Rezeptvariable in Autorisierungsrichtlinien verwenden. Mit dieser Funktion können Sie eine einzige Autorisierungsrichtlinie für eine Gruppe von Kerngeräten konfigurieren, sodass jedes Kerngerät nur auf Themen zugreifen kann, die seinen eigenen Namen enthalten. Sie können einer Komponente beispielsweise Zugriff auf die folgende Themenressource gewähren.

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

Weitere Informationen erhalten Sie unter [Rezeptvariablen](component-recipe-reference.md#recipe-variables) und [Verwenden Sie Rezeptvariablen bei Merge-Updates](update-component-configurations.md#merge-configuration-update-recipe-variables).

### Beispiele für Autorisierungsrichtlinien
<a name="ipc-iot-core-mqtt-authorization-policy-examples"></a>

Anhand der folgenden Beispiele für Autorisierungsrichtlinien können Sie Autorisierungsrichtlinien für Ihre Komponenten konfigurieren.

**Example Beispiel für eine Autorisierungsrichtlinie mit uneingeschränktem Zugriff**  
Das folgende Beispiel für eine Autorisierungsrichtlinie ermöglicht es einer Komponente, alle Themen zu veröffentlichen und zu abonnieren.  

```
{
  "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 Beispiel für eine Autorisierungsrichtlinie mit eingeschränktem Zugriff**  
Das folgende Beispiel für eine Autorisierungsrichtlinie ermöglicht es einer Komponente, zwei Themen mit dem Namen und zu veröffentlichen `factory/1/events` und zu abonnieren`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 Beispiel für eine Autorisierungsrichtlinie für eine Gruppe von Kerngeräten**  
In diesem Beispiel wird eine Funktion verwendet, die für Version 2.6.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar ist. Greengrass Nucleus v2.6.0 bietet Unterstützung für die meisten [Rezeptvariablen](component-recipe-reference.md#recipe-variables), z. B. in `{iot:thingName}` Komponentenkonfigurationen.
Das folgende Beispiel für eine Autorisierungsrichtlinie ermöglicht es einer Komponente, ein Thema zu veröffentlichen und zu abonnieren, das den Namen des Kerngeräts enthält, auf dem die Komponente ausgeführt wird.  

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

Veröffentlicht eine MQTT-Nachricht zu einem AWS IoT Core Thema.

Wenn Sie MQTT-Nachrichten veröffentlichen AWS IoT Core, gilt ein Kontingent von 100 Transaktionen pro Sekunde. Wenn Sie dieses Kontingent überschreiten, werden Nachrichten auf dem Greengrass-Gerät zur Verarbeitung in die Warteschlange gestellt. Außerdem gibt es ein Kontingent von 512 KB an Daten pro Sekunde und ein kontoweites Kontingent von 20.000 Veröffentlichungen pro Sekunde (2.000 in einigen Fällen). AWS-Regionen Weitere Informationen zu den Grenzwerten für den MQTT-Nachrichtenbroker finden Sie unter Grenzwerte und Kontingente für [AWS IoT Core Nachrichtenbroker und Protokolle](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#message-broker-limits). AWS IoT Core

Wenn Sie diese Kontingente überschreiten, beschränkt das Greengrass-Gerät die Veröffentlichung von Nachrichten auf AWS IoT Core. Nachrichten werden in einem Spooler im Arbeitsspeicher gespeichert. Standardmäßig beträgt der dem Spooler zugewiesene Speicher 2,5 MB. Wenn der Spooler voll ist, werden neue Nachrichten zurückgewiesen. Sie können den Spooler vergrößern. Weitere Informationen finden Sie unter [Konfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration) in der [Grüngraskern](greengrass-nucleus-component.md)-Dokumentation. Um zu vermeiden, dass der Spooler voll wird und der zugewiesene Speicher vergrößert werden muss, beschränken Sie Veröffentlichungsanforderungen auf nicht mehr als 100 Anfragen pro Sekunde.

Wenn Ihre Anwendung Nachrichten mit einer höheren Geschwindigkeit oder größere Nachrichten senden muss, sollten Sie die [Stream-Manager](stream-manager-component.md) zum Senden von Nachrichten an Kinesis Data Streams verwenden. Die Stream Manager-Komponente ist für die Übertragung großer Datenmengen an den konzipiert. AWS Cloud Weitere Informationen finden Sie unter [Datenströme auf Greengrass-Kerngeräten verwalten](manage-data-streams.md).

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

Die Anforderung dieses Vorgangs hat die folgenden Parameter:

`topicName`(Python:`topic_name`)  
Das Thema, zu dem die Nachricht veröffentlicht werden soll.

`qos`  <a name="ipc-iot-core-mqtt-qos"></a>
Die zu verwendende MQTT-QoS. Diese Aufzählung,`QOS`, hat die folgenden Werte:  
+ `AT_MOST_ONCE`— QoS 0. Die MQTT-Nachricht wird höchstens einmal zugestellt.
+ `AT_LEAST_ONCE`— QoS 1. Die MQTT-Nachricht wird mindestens einmal zugestellt.

`payload`  
(Optional) Die Nutzlast der Nachricht als Blob.

Die folgenden Funktionen sind für Version 2.10.0 und höher verfügbar, [Grüngraskern](greengrass-nucleus-component.md) wenn Sie MQTT 5 verwenden. Diese Funktionen werden ignoriert, wenn Sie MQTT 3.1.1 verwenden. In der folgenden Tabelle ist die Mindestversion des AWS IoT Geräte-SDK aufgeführt, die Sie für den Zugriff auf diese Funktionen verwenden müssen.


| SDK | Mindestversion | 
| --- | --- | 
| [AWS IoT-Geräte-SDK for Python](https://github.com/aws/aws-iot-device-sdk-python-v2) v2 | v1.15.0 | 
| [AWS IoT Device SDK for Java](https://github.com/aws/aws-iot-device-sdk-java-v2) v2 | v1.13.0 | 
| [AWS IoT Device SDK for C\$1\$1](https://github.com/aws/aws-iot-device-sdk-cpp-v2) v2 | v1.24,0 | 
| [AWS IoT Device SDK for JavaScript  ](https://github.com/aws/aws-iot-device-sdk-js-v2) v2  | v1.13.0 | 

`payloadFormat`  
(Optional) Das Format der Nachrichtennutzlast. Wenn Sie den nicht festlegen`payloadFormat`, wird davon ausgegangen, dass `BYTES` der Typ Die Aufzählung hat die folgenden Werte:   
+ `BYTES`— Der Inhalt der Payload ist ein binärer Blob.
+ `UTF8`— Der Inhalt der Payload besteht aus einer UTF8 Zeichenfolge.

`retain`  
(Optional) Gibt an, ob die MQTT-Aufbewahrungsoption `true` beim Veröffentlichen auf gesetzt werden soll.

`userProperties`  
(Optional) Eine Liste von anwendungsspezifischen `UserProperty` Objekten, die gesendet werden sollen. Das `UserProperty` Objekt ist wie folgt definiert:  

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

`messageExpiryIntervalSeconds`  
(Optional) Die Anzahl der Sekunden, bevor die Nachricht abläuft und vom Server gelöscht wird. Wenn dieser Wert nicht festgelegt ist, läuft die Nachricht nicht ab.

`correlationData`  
(Optional) Der Anfrage hinzugefügte Informationen, die verwendet werden können, um eine Anfrage mit einer Antwort zu verknüpfen.

`responseTopic`  
(Optional) Das Thema, das für die Antwortnachricht verwendet werden soll.

`contentType`  
(Optional) Eine anwendungsspezifische Kennung für den Inhaltstyp der Nachricht.

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

Dieser Vorgang liefert in seiner Antwort keine Informationen.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang in benutzerdefiniertem Komponentencode aufgerufen wird.

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

**Example Beispiel: Veröffentlichen Sie eine Nachricht**  

```
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 Beispiel: Veröffentlichen Sie eine Nachricht**  
In diesem Beispiel wird davon ausgegangen, dass Sie Version 1.5.4 oder höher von AWS IoT Device SDK für Python v2 verwenden. 

```
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 Beispiel: Veröffentlichen Sie eine Nachricht**  
In diesem Beispiel wird eine `IPCUtils` Klasse verwendet, um eine Verbindung zum AWS IoT Greengrass Core-IPC-Dienst herzustellen. Weitere Informationen finden Sie unter [Connect zum AWS IoT Greengrass Core IPC-Dienst her](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 Beispiel: Veröffentlichen Sie eine Nachricht**  
In diesem Beispiel wird davon ausgegangen, dass Sie Version 1.5.4 oder höher von AWS IoT Device SDK für Python v2 verwenden. 

```
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 Beispiel: Veröffentlichen Sie eine Nachricht**  

```
#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 Beispiel: Veröffentlichen Sie eine Nachricht**  

```
    
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 Beispiel: Veröffentlichen Sie eine Nachricht**  

```
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 Beispiel: Veröffentlichen Sie eine Nachricht**  

```
#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 Beispiel: Veröffentlichen Sie eine Nachricht**  

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

Abonnieren Sie MQTT-Nachrichten AWS IoT Core über ein Thema oder einen Themenfilter. Die AWS IoT Greengrass Core-Software entfernt Abonnements, wenn die Komponente das Ende ihres Lebenszyklus erreicht hat.

<a name="ipc-subscribe-operation-note"></a>Bei diesem Vorgang handelt es sich um einen Abonnementvorgang, bei dem Sie einen Stream von Ereignisnachrichten abonnieren. Um diese Operation zu verwenden, definieren Sie einen Stream-Response-Handler mit Funktionen, die Ereignismeldungen, Fehler und das Schließen von Streams behandeln. Weitere Informationen finden Sie unter [Abonnieren Sie IPC-Event-Streams](interprocess-communication.md#ipc-subscribe-operations).

**Typ der Ereignisnachricht:** `IoTCoreMessage`

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

Die Anforderung dieses Vorgangs hat die folgenden Parameter:

`topicName`(Python:`topic_name`)  
Das Thema, das abonniert werden soll. Sie können Platzhalter (`#`und`+`) für MQTT-Themen verwenden, um mehrere Themen zu abonnieren.

`qos`  <a name="ipc-iot-core-mqtt-qos"></a>
Die zu verwendende MQTT-QoS. Diese Aufzählung,`QOS`, hat die folgenden Werte:  
+ `AT_MOST_ONCE`— QoS 0. Die MQTT-Nachricht wird höchstens einmal zugestellt.
+ `AT_LEAST_ONCE`— QoS 1. Die MQTT-Nachricht wird mindestens einmal zugestellt.

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

Die Antwort dieser Operation enthält die folgenden Informationen:

`messages`  
Der Stream von MQTT-Nachrichten. Dieses Objekt,`IoTCoreMessage`, enthält die folgenden Informationen:    
`message`  
Die MQTT-Nachricht. Dieses Objekt,`MQTTMessage`, enthält die folgenden Informationen:    
`topicName`(Python:`topic_name`)  
Das Thema, zu dem die Nachricht veröffentlicht wurde.  
`payload`  
(Optional) Die Nachrichten-Payload als Blob.
Die folgenden Funktionen sind für Version 2.10.0 und höher verfügbar, [Grüngraskern](greengrass-nucleus-component.md) wenn Sie MQTT 5 verwenden. Diese Funktionen werden ignoriert, wenn Sie MQTT 3.1.1 verwenden. In der folgenden Tabelle ist die Mindestversion des AWS IoT Geräte-SDK aufgeführt, die Sie für den Zugriff auf diese Funktionen verwenden müssen.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/ipc-iot-core-mqtt.html)  
`payloadFormat`  
(Optional) Das Format der Nachrichtennutzlast. Wenn Sie den nicht festlegen`payloadFormat`, wird davon ausgegangen, dass `BYTES` der Typ Die Aufzählung hat die folgenden Werte:   
+ `BYTES`— Der Inhalt der Payload ist ein binärer Blob.
+ `UTF8`— Der Inhalt der Payload besteht aus einer UTF8 Zeichenfolge.  
`retain`  
(Optional) Gibt an, ob die MQTT-Aufbewahrungsoption `true` beim Veröffentlichen auf gesetzt werden soll.  
`userProperties`  
(Optional) Eine Liste von anwendungsspezifischen `UserProperty` Objekten, die gesendet werden sollen. Das `UserProperty` Objekt ist wie folgt definiert:  

```
UserProperty:
  key: string
  value: string
```  
`messageExpiryIntervalSeconds`  
(Optional) Die Anzahl der Sekunden, bevor die Nachricht abläuft und vom Server gelöscht wird. Wenn dieser Wert nicht festgelegt ist, läuft die Nachricht nicht ab.  
`correlationData`  
(Optional) Der Anfrage hinzugefügte Informationen, die verwendet werden können, um eine Anfrage mit einer Antwort zu verknüpfen.  
`responseTopic`  
(Optional) Das Thema, das für die Antwortnachricht verwendet werden soll.  
`contentType`  
(Optional) Eine anwendungsspezifische Kennung für den Inhaltstyp der Nachricht.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang in benutzerdefiniertem Komponentencode aufgerufen wird.

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

**Example Beispiel: Nachrichten abonnieren**  

```
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 Beispiel: Nachrichten abonnieren**  
In diesem Beispiel wird davon ausgegangen, dass Sie Version 1.5.4 oder höher von AWS IoT Device SDK für Python v2 verwenden. 

```
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 Beispiel: Nachrichten abonnieren**  
In diesem Beispiel wird eine `IPCUtils` Klasse verwendet, um eine Verbindung zum AWS IoT Greengrass Core-IPC-Dienst herzustellen. Weitere Informationen finden Sie unter [Connect zum AWS IoT Greengrass Core IPC-Dienst her](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 Beispiel: Nachrichten abonnieren**  
In diesem Beispiel wird davon ausgegangen, dass Sie Version 1.5.4 oder höher von AWS IoT Device SDK für Python v2 verwenden. 

```
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 Beispiel: Nachrichten abonnieren**  

```
#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 Beispiel: Nachrichten abonnieren**  

```
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 Beispiel: Nachrichten abonnieren**  

```
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 Beispiel: Nachrichten abonnieren**  

```
#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 Beispiel: Nachrichten abonnieren**  

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

------

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

Verwenden Sie die folgenden Beispiele, um zu erfahren, wie Sie den AWS IoT Core MQTT IPC-Service in Ihren Komponenten verwenden können.

### Beispiel für einen AWS IoT Core MQTT-Publisher (C\$1\$1, IPC-Client V1)
<a name="ipc-iot-core-mqtt-example-publisher-cpp"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, zu allen Themen zu veröffentlichen.

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

------

Die folgende C\$1\$1-Beispielanwendung zeigt, wie der AWS IoT Core MQTT-IPC-Dienst verwendet wird, um Nachrichten zu veröffentlichen. 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;
}
```

### Beispiel für einen AWS IoT Core MQTT-Abonnenten (C\$1\$1, IPC-Client V1)
<a name="ipc-iot-core-mqtt-example-subscriber-cpp"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, alle Themen zu abonnieren.

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

------

Die folgende C\$1\$1-Beispielanwendung zeigt, wie der AWS IoT Core MQTT-IPC-Dienst verwendet wird, um Nachrichten von zu abonnieren. 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;
}
```

### Beispiel für einen AWS IoT Core MQTT-Publisher (Rust)
<a name="ipc-iot-core-mqtt-example-publisher-rust"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, in allen Themen zu veröffentlichen.

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

Die folgende Rust-Beispielanwendung zeigt, wie der AWS IoT Core MQTT-IPC-Dienst verwendet wird, um Nachrichten zu veröffentlichen. 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}");
}
```

### Beispiel für einen AWS IoT Core MQTT-Abonnenten (Rust)
<a name="ipc-iot-core-mqtt-example-subscriber-rust"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, alle Themen zu abonnieren.

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

Die folgende Rust-Beispielanwendung zeigt, wie der AWS IoT Core MQTT-IPC-Dienst verwendet wird, um Nachrichten von zu abonnieren. 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));
    }
}
```

### Beispiel für einen AWS IoT Core MQTT-Publisher (C)
<a name="ipc-iot-core-mqtt-example-publisher-c"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, in allen Themen zu veröffentlichen.

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

Die folgende C-Beispielanwendung zeigt, wie der AWS IoT Core MQTT-IPC-Dienst verwendet wird, um Nachrichten zu veröffentlichen. 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
    );
}
```

### Beispiel für einen AWS IoT Core MQTT-Abonnenten (C)
<a name="ipc-iot-core-mqtt-example-subscriber-c"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, alle Themen zu abonnieren.

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

Die folgende C-Beispielanwendung zeigt, wie Sie den AWS IoT Core MQTT-IPC-Dienst verwenden, um Nachrichten von zu abonnieren. 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);
}
```

### Beispiel für einen AWS IoT Core MQTT-Publisher (C\$1\$1, Component SDK)
<a name="ipc-iot-core-mqtt-example-publisher-cpp-component-sdk"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, zu allen Themen zu veröffentlichen.

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

Die folgende C\$1\$1-Beispielanwendung zeigt, wie der AWS IoT Core MQTT-IPC-Dienst verwendet wird, um Nachrichten zu veröffentlichen. 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";
}
```

### Beispiel für einen AWS IoT Core MQTT-Abonnenten (C\$1\$1, Component SDK)
<a name="ipc-iot-core-mqtt-example-subscriber-cpp-component-sdk"></a>

Das folgende Beispielrezept ermöglicht es der Komponente, alle Themen zu abonnieren.

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

Die folgende C\$1\$1-Beispielanwendung zeigt, wie der AWS IoT Core MQTT-IPC-Dienst verwendet wird, um Nachrichten von zu abonnieren. 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);
    }
}
```

# Interagieren Sie mit dem Lebenszyklus von Komponenten
<a name="ipc-component-lifecycle"></a>

Verwenden Sie den IPC-Service für den Komponentenlebenszyklus, um:
+ Aktualisieren Sie den Komponentenstatus auf dem Kerngerät.
+ Abonnieren Sie Updates zum Komponentenstatus.
+ Verhindern Sie, dass der Nucleus die Komponente während einer Bereitstellung unterbricht, um ein Update anzuwenden.
+ Unterbrechen Sie die Komponentenprozesse und setzen Sie sie fort.

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

## Minimale SDK-Versionen
<a name="ipc-component-lifecycle-sdk-versions"></a>

In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie für die Interaktion mit dem Komponentenlebenszyklus verwenden müssen.


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

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

Um andere Komponenten einer benutzerdefinierten Komponente anzuhalten oder wieder aufzunehmen, müssen Sie Autorisierungsrichtlinien definieren, die es Ihrer Komponente ermöglichen, andere Komponenten zu verwalten. Informationen zur Definition von Autorisierungsrichtlinien finden Sie unter[Autorisieren Sie Komponenten zur Ausführung von IPC-Vorgängen](interprocess-communication.md#ipc-authorization-policies).

Autorisierungsrichtlinien für das Lebenszyklusmanagement von Komponenten haben die folgenden Eigenschaften.

**IPC-Dienst-ID:** `aws.greengrass.ipc.lifecycle`


| Operation | Description | Ressourcen | 
| --- | --- | --- | 
|  `aws.greengrass#PauseComponent`  |  Ermöglicht einer Komponente, die von Ihnen angegebenen Komponenten anzuhalten.  |  Ein Komponentenname oder `*` um den Zugriff auf alle Komponenten zu ermöglichen.  | 
|  `aws.greengrass#ResumeComponent`  |  Ermöglicht einer Komponente, die von Ihnen angegebenen Komponenten wieder aufzunehmen.  |  Ein Komponentenname oder `*` um den Zugriff auf alle Komponenten zu ermöglichen.  | 
|  `*`  |  Ermöglicht einer Komponente, die von Ihnen angegebenen Komponenten anzuhalten und wieder aufzunehmen.  |  Ein Komponentenname oder `*` um den Zugriff auf alle Komponenten zu ermöglichen.  | 

### Beispiele für Autorisierungsrichtlinien
<a name="ipc-component-lifecycle-authorization-policy-examples"></a>

Anhand des folgenden Beispiels für Autorisierungsrichtlinien können Sie Autorisierungsrichtlinien für Ihre Komponenten konfigurieren.

**Example Beispiel für eine Autorisierungsrichtlinie**  
Das folgende Beispiel für eine Autorisierungsrichtlinie ermöglicht es einer Komponente, alle Komponenten anzuhalten und wieder aufzunehmen.  

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

Aktualisieren Sie den Status der Komponente auf dem Kerngerät.

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

Die Anfrage dieser Operation hat die folgenden Parameter:

`state`  
Der festzulegende Status. Diese Aufzählung,`LifecycleState`, hat die folgenden Werte:  
+ `RUNNING`
+ `ERRORED`

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

Dieser Vorgang liefert in seiner Antwort keine Informationen.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang in benutzerdefiniertem Komponentencode aufgerufen wird.

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

**Example Beispiel: Status aktualisieren**  

```
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 Beispiel: Status aktualisieren**  

```
#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 Beispiel: Status aktualisieren**  

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

Abonnieren Sie, um Benachrichtigungen zu erhalten, bevor die AWS IoT Greengrass Core-Software eine Komponente aktualisiert. Die Benachrichtigung gibt an, ob der Nucleus im Rahmen des Updates neu gestartet wird oder nicht.

Der Nucleus sendet nur dann Aktualisierungsbenachrichtigungen, wenn die Komponenten-Update-Richtlinie der Bereitstellung vorsieht, dass Komponenten benachrichtigt werden sollen. Das Standardverhalten besteht darin, Komponenten zu benachrichtigen. Weitere Informationen finden Sie unter [Erstellen von Bereitstellungen](create-deployments.md) und unter dem [DeploymentComponentUpdatePolicy](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeploymentComponentUpdatePolicy.html)Objekt, das Sie angeben können, wenn Sie den [CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html)Vorgang aufrufen.

**Wichtig**  
Bei lokalen Bereitstellungen werden Komponenten vor Updates nicht benachrichtigt.

<a name="ipc-subscribe-operation-note"></a>Bei diesem Vorgang handelt es sich um einen Abonnementvorgang, bei dem Sie einen Stream von Ereignisnachrichten abonnieren. Um diese Operation zu verwenden, definieren Sie einen Stream-Response-Handler mit Funktionen, die Ereignismeldungen, Fehler und das Schließen von Streams behandeln. Weitere Informationen finden Sie unter [Abonnieren Sie IPC-Event-Streams](interprocess-communication.md#ipc-subscribe-operations).

**Typ der Ereignisnachricht:** `ComponentUpdatePolicyEvents`

**Tipp**  
In einem Tutorial erfahren Sie, wie Sie eine Komponente entwickeln, die Komponenten-Updates bedingt verzögert. Weitere Informationen finden Sie unter [Tutorial: Entwickeln Sie eine Greengrass-Komponente, die Komponenten-Updates verzögert](defer-component-updates-tutorial.md).

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

Die Anfrage dieser Operation hat keine Parameter.

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

Die Antwort dieser Operation enthält die folgenden Informationen:

`messages`  
Der Stream von Benachrichtigungsnachrichten. Dieses Objekt,`ComponentUpdatePolicyEvents`, enthält die folgenden Informationen:    
`preUpdateEvent`(Python:`pre_update_event`)  
(Optional) Ein Ereignis, das anzeigt, dass der Nucleus eine Komponente aktualisieren möchte. Sie können darauf antworten, indem [DeferComponentUpdate](#ipc-operation-defercomponentupdate) Sie die Aktualisierung bestätigen oder verschieben, bis Ihre Komponente für den Neustart bereit ist. Dieses Objekt,`PreComponentUpdateEvent`, enthält die folgenden Informationen:    
`deploymentId`(Python:`deployment_id`)  
Die ID der AWS IoT Greengrass Bereitstellung, die die Komponente aktualisiert.  
`isGgcRestarting`(Python:`is_ggc_restarting`)  
Ob der Nucleus neu gestartet werden muss, um das Update zu installieren.  
`postUpdateEvent`(Python:`post_update_event`)  
(Optional) Ein Ereignis, das darauf hinweist, dass der Nucleus eine Komponente aktualisiert hat. Dieses Objekt,`PostComponentUpdateEvent`, enthält die folgenden Informationen:    
`deploymentId`(Python:`deployment_id`)  
Die ID der AWS IoT Greengrass Bereitstellung, die die Komponente aktualisiert hat.  
Für diese Funktion ist Version 2.7.0 oder höher der Greengrass Nucleus-Komponente erforderlich.

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

Bestätigen oder verschieben Sie ein Komponenten-Update, das Sie mit entdecken. [SubscribeToComponentUpdates](#ipc-operation-subscribetocomponentupdates) Sie geben an, wie lange es dauern soll, bis der Nucleus erneut überprüft, ob Ihre Komponente bereit ist, mit dem Komponenten-Update fortzufahren. Sie können diesen Vorgang auch verwenden, um dem Nucleus mitzuteilen, dass Ihre Komponente für das Update bereit ist.

Wenn eine Komponente nicht auf die Benachrichtigung über das Komponenten-Update reagiert, wartet der Nucleus so lange, wie Sie in der Komponenten-Update-Richtlinie für die Installation angegeben haben. Nach diesem Timeout fährt der Nucleus mit der Bereitstellung fort. Das Standard-Timeout für Komponenten-Updates beträgt 60 Sekunden. Weitere Informationen finden Sie unter [Erstellen von Bereitstellungen](create-deployments.md) und unter dem [DeploymentComponentUpdatePolicy](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeploymentComponentUpdatePolicy.html)Objekt, das Sie angeben können, wenn Sie den [CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html)Vorgang aufrufen.

**Tipp**  
Sie können einem Tutorial folgen, um zu erfahren, wie Sie eine Komponente entwickeln, die Komponenten-Updates bedingt verzögert. Weitere Informationen finden Sie unter [Tutorial: Entwickeln Sie eine Greengrass-Komponente, die Komponenten-Updates verzögert](defer-component-updates-tutorial.md).

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

Die Anforderung dieses Vorgangs hat die folgenden Parameter:

`deploymentId`(Python:`deployment_id`)  
Die ID der AWS IoT Greengrass Bereitstellung, die verschoben werden soll.

`message`  
(Optional) Der Name der Komponente, für die Updates verschoben werden sollen.  
Standardmäßig wird der Name der Komponente verwendet, die die Anfrage stellt.

`recheckAfterMs`(Python:`recheck_after_ms`)  
Die Zeitspanne in Millisekunden, um die Aktualisierung verschoben werden soll. Der Nukleus wartet auf diese Zeit und sendet dann eine weitere`PreComponentUpdateEvent`, mit der Sie etwas entdecken können. [SubscribeToComponentUpdates](#ipc-operation-subscribetocomponentupdates)  
Geben Sie `0` an, ob Sie das Update bestätigen möchten. Dadurch wird dem Nucleus mitgeteilt, dass Ihre Komponente für das Update bereit ist.  
Der Standardwert ist null Millisekunden, was bedeutet, dass das Update bestätigt wird.

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

Dieser Vorgang liefert in seiner Antwort keine Informationen.

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

Diese Funktion ist für Version 2.4.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar. AWS IoT Greengrass unterstützt diese Funktion derzeit nicht auf Windows Core-Geräten. 

Unterbricht die Prozesse einer Komponente auf dem Kerngerät. Verwenden Sie den [ResumeComponent](#ipc-operation-resumecomponent)Vorgang, um eine Komponente wieder aufzunehmen.

Sie können nur generische Komponenten anhalten. Wenn Sie versuchen, einen anderen Komponententyp anzuhalten, löst dieser Vorgang eine `InvalidRequestError` aus.

**Anmerkung**  
Durch diesen Vorgang können containerisierte Prozesse wie Docker-Container nicht angehalten werden. Um einen Docker-Container anzuhalten und wieder aufzunehmen, können Sie die Befehle [docker pause und [docker](https://docs.docker.com/engine/reference/commandline/unpause/) unpause](https://docs.docker.com/engine/reference/commandline/pause/) verwenden.

Dieser Vorgang unterbricht keine Komponentenabhängigkeiten oder Komponenten, die von der Komponente abhängen, die Sie anhalten. Beachten Sie dieses Verhalten, wenn Sie eine Komponente anhalten, die von einer anderen Komponente abhängig ist, da bei der abhängigen Komponente möglicherweise Probleme auftreten, wenn ihre Abhängigkeit unterbrochen wird.

Wenn Sie eine angehaltene Komponente neu starten oder herunterfahren, z. B. durch eine Bereitstellung, nimmt der Greengrass-Nucleus die Komponente wieder auf und führt ihren Shutdown-Lebenszyklus durch. Weitere Informationen zum Neustarten einer Komponente finden Sie unter. [RestartComponent](ipc-local-deployments-components.md#ipc-operation-restartcomponent)

**Wichtig**  
Um diesen Vorgang verwenden zu können, müssen Sie eine Autorisierungsrichtlinie definieren, die die Erlaubnis zur Verwendung dieses Vorgangs erteilt. Weitere Informationen finden Sie unter [Autorisierung](#ipc-component-lifecycle-authorization).

### Minimale SDK-Versionen
<a name="ipc-operation-pausecomponent-sdk-versions"></a>

In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie zum Anhalten und Wiederaufnehmen von Komponenten verwenden müssen.


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

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

Die Anfrage dieser Operation hat die folgenden Parameter:

`componentName`(Python:`component_name`)  
Der Name der Komponente, die angehalten werden soll. Dabei muss es sich um eine generische Komponente handeln. Weitere Informationen finden Sie unter [Komponententypen](develop-greengrass-components.md#component-types).

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

Dieser Vorgang liefert in seiner Antwort keine Informationen.

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

Diese Funktion ist für Version 2.4.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar. AWS IoT Greengrass unterstützt diese Funktion derzeit nicht auf Windows Core-Geräten. 

Setzt die Prozesse einer Komponente auf dem Kerngerät fort. Verwenden Sie den [PauseComponent](#ipc-operation-pausecomponent)Vorgang, um eine Komponente anzuhalten.

Sie können nur angehaltene Komponenten wieder aufnehmen. Wenn Sie versuchen, eine Komponente wieder aufzunehmen, die nicht angehalten wurde, löst dieser Vorgang eine aus. `InvalidRequestError`

**Wichtig**  
Um diesen Vorgang verwenden zu können, müssen Sie eine Autorisierungsrichtlinie definieren, die die entsprechende Berechtigung erteilt. Weitere Informationen finden Sie unter [Autorisierung](#ipc-component-lifecycle-authorization).

### Minimale SDK-Versionen
<a name="ipc-operation-resumecomponent-sdk-versions"></a>

In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie zum Anhalten und Wiederaufnehmen von Komponenten verwenden müssen.


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

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

Die Anfrage dieser Operation hat die folgenden Parameter:

`componentName`(Python:`component_name`)  
Der Name der Komponente, die fortgesetzt werden soll.

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

Dieser Vorgang liefert in seiner Antwort keine Informationen.

# Interagieren Sie mit der Komponentenkonfiguration
<a name="ipc-component-configuration"></a>

Mit dem IPC-Dienst für die Komponentenkonfiguration können Sie Folgendes tun:
+ Abrufen und Einstellen der Konfigurationsparameter für Komponenten.
+ Abonnieren Sie Updates zur Komponentenkonfiguration.
+ Validieren Sie Aktualisierungen der Komponentenkonfiguration, bevor der Nucleus sie einführt.

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

## Minimale SDK-Versionen
<a name="ipc-component-configuration-sdk-versions"></a>

In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie für die Interaktion mit der Komponentenkonfiguration verwenden müssen.


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

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

Ruft einen Konfigurationswert für eine Komponente auf dem Kerngerät ab. Sie geben den Schlüsselpfad an, für den ein Konfigurationswert abgerufen werden soll.

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

Die Anforderung dieses Vorgangs hat die folgenden Parameter:

`componentName`(Python:`component_name`)  <a name="ipc-configuration-request-component-name"></a>
(Optional) Der Name der Komponente.  
Standardmäßig wird der Name der Komponente verwendet, die die Anforderung stellt.

`keyPath`(Python:`key_path`)  
Der Schlüsselpfad zum Konfigurationswert. Geben Sie eine Liste an, in der jeder Eintrag der Schlüssel für eine einzelne Ebene im Konfigurationsobjekt ist. Geben Sie beispielsweise `["mqtt", "port"]` an, dass der Wert von `port` in der folgenden Konfiguration abgerufen werden soll.  

```
{
  "mqtt": {
    "port": 443
  }
}
```
Um die vollständige Konfiguration der Komponente abzurufen, geben Sie eine leere Liste an.

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

Die Antwort dieses Vorgangs enthält die folgenden Informationen:

`componentName`(Python:`component_name`)  <a name="ipc-configuration-response-component-name"></a>
Der Name der Komponente.

`value`  
Die angeforderte Konfiguration als Objekt.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang in benutzerdefiniertem Komponentencode aufgerufen wird.

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

**Example Beispiel: Konfiguration abrufen**  

```
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 Beispiel: Konfiguration abrufen**  

```
#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 Beispiel: Konfiguration abrufen**  

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

Aktualisiert einen Konfigurationswert für diese Komponente auf dem Kerngerät.

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

Die Anforderung dieses Vorgangs hat die folgenden Parameter:

`keyPath`(Python:`key_path`)  
(Optional) Der Schlüsselpfad zum Containerknoten (dem Objekt), der aktualisiert werden soll. Geben Sie eine Liste an, in der jeder Eintrag der Schlüssel für eine einzelne Ebene im Konfigurationsobjekt ist. Geben Sie beispielsweise den Schlüsselpfad `["mqtt"]` und den Zusammenführungswert `{ "port": 443 }` an, für den der Wert `port` in der folgenden Konfiguration festgelegt werden soll.  

```
{
  "mqtt": {
    "port": 443
  }
}
```
Der Schlüsselpfad muss einen Containerknoten (ein Objekt) in der Konfiguration angeben. Wenn der Knoten in der Konfiguration der Komponente nicht vorhanden ist, erstellt dieser Vorgang ihn und setzt seinen Wert auf das Objekt in`valueToMerge`.  
Standardmäßig wird das Stammverzeichnis des Konfigurationsobjekts verwendet.

`timestamp`  
Die aktuelle Zeit der Unix-Epoche in Millisekunden. Dieser Vorgang verwendet diesen Zeitstempel, um gleichzeitige Aktualisierungen des Schlüssels aufzulösen. Wenn der Schlüssel in der Komponentenkonfiguration einen größeren Zeitstempel als der Zeitstempel in der Anforderung hat, schlägt die Anforderung fehl.

`valueToMerge`(Python:`value_to_merge`)  
Das Konfigurationsobjekt, das an der von Ihnen angegebenen Position zusammengeführt werden soll`keyPath`. Weitere Informationen finden Sie unter [Komponentenkonfigurationen aktualisieren](update-component-configurations.md).

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

Dieser Vorgang liefert in seiner Antwort keine Informationen.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang in benutzerdefiniertem Komponentencode aufgerufen wird.

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

**Example Beispiel: Konfiguration aktualisieren**  

```
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 Beispiel: Konfiguration aktualisieren**  

```
#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 Beispiel: Konfiguration aktualisieren**  

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

Abonnieren Sie, um Benachrichtigungen zu erhalten, wenn die Konfiguration einer Komponente aktualisiert wird. Wenn Sie einen Schlüssel abonnieren, erhalten Sie eine Benachrichtigung, wenn ein untergeordnetes Element dieses Schlüssels aktualisiert wird.

<a name="ipc-subscribe-operation-note"></a>Bei diesem Vorgang handelt es sich um einen Abonnementvorgang, bei dem Sie einen Stream von Ereignisnachrichten abonnieren. Um diese Operation zu verwenden, definieren Sie einen Stream-Response-Handler mit Funktionen, die Ereignismeldungen, Fehler und das Schließen von Streams behandeln. Weitere Informationen finden Sie unter [Abonnieren Sie IPC-Event-Streams](interprocess-communication.md#ipc-subscribe-operations).

**Typ der Ereignisnachricht:** `ConfigurationUpdateEvents`

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

Die Anforderung dieses Vorgangs hat die folgenden Parameter:

`componentName`(Python:`component_name`)  <a name="ipc-configuration-request-component-name"></a>
(Optional) Der Name der Komponente.  
Standardmäßig wird der Name der Komponente verwendet, die die Anforderung stellt.

`keyPath`(Python:`key_path`)  
Der Schlüsselpfad zu dem Konfigurationswert, den Sie abonnieren möchten. Geben Sie eine Liste an, in der jeder Eintrag der Schlüssel für eine einzelne Ebene im Konfigurationsobjekt ist. Geben Sie beispielsweise `["mqtt", "port"]` an, dass der Wert von `port` in der folgenden Konfiguration abgerufen werden soll.  

```
{
  "mqtt": {
    "port": 443
  }
}
```
Um Updates für alle Werte in der Konfiguration der Komponente zu abonnieren, geben Sie eine leere Liste an.

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

Die Antwort dieses Vorgangs enthält die folgenden Informationen:

`messages`  
Der Stream von Benachrichtigungsnachrichten. Dieses Objekt,`ConfigurationUpdateEvents`, enthält die folgenden Informationen:    
`configurationUpdateEvent`(Python:`configuration_update_event`)  
Das Ereignis zur Aktualisierung der Konfiguration. Dieses Objekt,`ConfigurationUpdateEvent`, enthält die folgenden Informationen:    
`componentName`(Python:`component_name`)  <a name="ipc-configuration-response-component-name"></a>
Der Name der Komponente.  
`keyPath`(Python:`key_path`)  
Der Schlüsselpfad zu dem Konfigurationswert, der aktualisiert wurde.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang in benutzerdefiniertem Komponentencode aufgerufen wird.

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

**Example Beispiel: Abonnieren Sie Konfigurationsupdates**  

```
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 Beispiel: Abonnieren Sie Konfigurationsupdates**  

```
#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 Beispiel: Abonnieren Sie Konfigurationsupdates**  

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

Abonnieren Sie, um Benachrichtigungen vor den Konfigurationsupdates dieser Komponente zu erhalten. Auf diese Weise können Komponenten Aktualisierungen ihrer eigenen Konfiguration validieren. Verwenden Sie die [SendConfigurationValidityReport](#ipc-operation-sendconfigurationvalidityreport) Operation, um dem Nucleus mitzuteilen, ob die Konfiguration gültig ist oder nicht.

**Wichtig**  
Lokale Bereitstellungen benachrichtigen die Komponenten nicht über Updates.

<a name="ipc-subscribe-operation-note"></a>Bei diesem Vorgang handelt es sich um einen Abonnementvorgang, bei dem Sie einen Stream von Ereignisnachrichten abonnieren. Um diese Operation zu verwenden, definieren Sie einen Stream-Response-Handler mit Funktionen, die Ereignismeldungen, Fehler und das Schließen von Streams behandeln. Weitere Informationen finden Sie unter [Abonnieren Sie IPC-Event-Streams](interprocess-communication.md#ipc-subscribe-operations).

**Typ der Ereignisnachricht:** `ValidateConfigurationUpdateEvents`

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

Die Anfrage dieses Vorgangs hat keine Parameter.

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

Die Antwort dieser Operation enthält die folgenden Informationen:

`messages`  
Der Stream von Benachrichtigungsnachrichten. Dieses Objekt,`ValidateConfigurationUpdateEvents`, enthält die folgenden Informationen:    
`validateConfigurationUpdateEvent`(Python:`validate_configuration_update_event`)  
Das Ereignis zur Aktualisierung der Konfiguration. Dieses Objekt,`ValidateConfigurationUpdateEvent`, enthält die folgenden Informationen:    
`deploymentId`(Python:`deployment_id`)  
Die ID der AWS IoT Greengrass Bereitstellung, die die Komponente aktualisiert.  
`configuration`  
Das Objekt, das die neue Konfiguration enthält.

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

Teilen Sie dem Nucleus mit, ob ein Konfigurationsupdate für diese Komponente gültig ist oder nicht. Die Bereitstellung schlägt fehl, wenn Sie dem Nucleus mitteilen, dass die neue Konfiguration nicht gültig ist. Verwenden Sie den [SubscribeToValidateConfigurationUpdates](#ipc-operation-subscribetovalidateconfigurationupdates) Vorgang, um die Konfigurationsupdates zu abonnieren und zu validieren.

Wenn eine Komponente nicht auf eine Benachrichtigung zur Überprüfung des Konfigurationsupdates reagiert, wartet der Nucleus so lange, wie Sie in der Konfigurationsvalidierungsrichtlinie für die Bereitstellung angegeben haben. Nach diesem Timeout fährt der Nucleus mit der Bereitstellung fort. Das Standard-Timeout für die Komponentenvalidierung beträgt 20 Sekunden. Weitere Informationen finden Sie unter [Erstellen von Bereitstellungen](create-deployments.md) und unter dem [DeploymentConfigurationValidationPolicy](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeploymentConfigurationValidationPolicy.html)Objekt, das Sie angeben können, wenn Sie den [CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html)Vorgang aufrufen.

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

Die Anforderung dieses Vorgangs hat die folgenden Parameter:

`configurationValidityReport`(Python:`configuration_validity_report`)  
Der Bericht, der dem Nucleus mitteilt, ob das Konfigurationsupdate gültig ist oder nicht. Dieses Objekt,`ConfigurationValidityReport`, enthält die folgenden Informationen:    
`status`  
Der Gültigkeitsstatus. Diese Aufzählung,`ConfigurationValidityStatus`, hat die folgenden Werte:  
+ `ACCEPTED`— Die Konfiguration ist gültig und der Nucleus kann sie auf diese Komponente anwenden.
+ `REJECTED`— Die Konfiguration ist nicht gültig und die Bereitstellung schlägt fehl.  
`deploymentId`(Python:`deployment_id`)  
Die ID der AWS IoT Greengrass Bereitstellung, die das Konfigurationsupdate angefordert hat.  
`message`  
(Optional) Eine Meldung, die angibt, warum die Konfiguration nicht gültig ist.

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

Dieser Vorgang liefert in seiner Antwort keine Informationen.

# Geheime Werte abrufen
<a name="ipc-secret-manager"></a>

Verwenden Sie den Secret Manager IPC-Dienst, um geheime Werte aus Geheimnissen auf dem Kerngerät abzurufen. Sie verwenden die [Secret Manager-Komponente](secret-manager-component.md), um verschlüsselte Geheimnisse auf Kerngeräten bereitzustellen. Anschließend können Sie eine IPC-Operation verwenden, um das Geheimnis zu entschlüsseln und seinen Wert in Ihren benutzerdefinierten Komponenten zu verwenden.

**Topics**
+ [Minimale SDK-Versionen](#ipc-secret-manager-sdk-versions)
+ [Autorisierung](#ipc-secret-manager-authorization)
+ [GetSecretValue](#ipc-operation-getsecretvalue)
+ [Beispiele](#ipc-secret-manager-examples)

## Minimale SDK-Versionen
<a name="ipc-secret-manager-sdk-versions"></a>

In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie verwenden müssen, um geheime Werte aus Geheimnissen auf dem Kerngerät abzurufen.


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

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

Um den Secret Manager in einer benutzerdefinierten Komponente zu verwenden, müssen Sie Autorisierungsrichtlinien definieren, die es Ihrer Komponente ermöglichen, den Wert von Geheimnissen abzurufen, die Sie auf dem Kerngerät speichern. Informationen zur Definition von Autorisierungsrichtlinien finden Sie unter[Autorisieren Sie Komponenten zur Ausführung von IPC-Vorgängen](interprocess-communication.md#ipc-authorization-policies).

Autorisierungsrichtlinien für Secret Manager haben die folgenden Eigenschaften.

**IPC-Dienst-ID:** `aws.greengrass.SecretManager`


| Operation | Description | Ressourcen | 
| --- | --- | --- | 
|  `aws.greengrass#GetSecretValue` oder `*`  |  Ermöglicht einer Komponente, den Wert von Geheimnissen abzurufen, die auf dem Kerngerät verschlüsselt sind.  |  Ein geheimer ARN für Secrets Manager oder `*` um den Zugriff auf alle Geheimnisse zu ermöglichen.  | 

### Beispiele für Autorisierungsrichtlinien
<a name="ipc-secret-manager-authorization-policy-examples"></a>

Anhand des folgenden Beispiels für Autorisierungsrichtlinien können Sie Autorisierungsrichtlinien für Ihre Komponenten konfigurieren.

**Example Beispiel für eine Autorisierungsrichtlinie**  
Das folgende Beispiel für eine Autorisierungsrichtlinie ermöglicht es einer Komponente, den Wert eines beliebigen Geheimnisses auf dem Kerngerät abzurufen.  
Wir empfehlen, in einer Produktionsumgebung den Geltungsbereich der Autorisierungsrichtlinie zu reduzieren, sodass die Komponente nur die Geheimnisse abruft, die sie verwendet. Sie können den `*` Platzhalter ARNs bei der Bereitstellung der Komponente in eine geheime Liste ändern.

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

Ruft den Wert eines Geheimnisses ab, das Sie auf dem Kerngerät speichern.

Dieser Vorgang ähnelt dem Secrets Manager Manager-Vorgang, mit dem Sie den Wert eines Secrets in der abrufen können AWS Cloud. Weitere Informationen finden Sie unter [GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html) in der *AWS Secrets Manager -API-Referenz*.

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

Die Anfrage dieses Vorgangs hat die folgenden Parameter:

`refresh`(Python:`refresh`)  
(optional): Ob das angeforderte Geheimnis mit seinem neuesten Wert vom AWS Secrets Manager Dienst synchronisiert werden soll.  
Wenn dieser Wert auf true gesetzt ist, fordert Secret Manager den AWS Secrets Manager Dienst nach dem neuesten Wert des angegebenen geheimen Labels an und gibt diesen Wert als Antwort zurück. Andernfalls wird der geheime Wert zurückgegeben, der lokal gespeichert wurde.  
 Dieser Parameter funktioniert nicht in Verbindung mit dem `versionId` Parameter in der Anfrage. Dieser Parameter funktioniert, wenn er in Verbindung mit Nucleus 2.13.0 und höher verwendet wird.

`secretId`(Python:`secret_id`)  
Der Name des Geheimnisses, das abgerufen werden soll. Sie können entweder den Amazon-Ressourcennamen (ARN) oder den benutzerfreundlichen Namen des Geheimnisses angeben.

`versionId`(Python:`version_id`)  
(Optional) Die ID der Version, die abgerufen werden soll.  
Sie können entweder `versionId` oder `versionStage` angeben.  
Wenn Sie `versionId` oder nicht angeben`versionStage`, verwendet dieser Vorgang standardmäßig die Version mit der `AWSCURRENT` Bezeichnung.

`versionStage`(Python:`version_stage`)  
(Optional) Das Staging-Label der abzurufenden Version.  
Sie können entweder `versionId` oder `versionStage` angeben.  
Wenn Sie `versionId` oder nicht angeben`versionStage`, verwendet dieser Vorgang standardmäßig die Version mit dem `AWSCURRENT` Label.

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

Die Antwort dieses Vorgangs enthält die folgenden Informationen:

`secretId`(Python:`secret_id`)  
Die ID des Geheimnisses.

`versionId`(Python:`version_id`)  
Die ID dieser Version des Geheimnisses.

`versionStage`(Python:`version_stage`)  
Die Liste der Staging-Labels, die dieser Version des Secrets beigefügt sind.

`secretValue`(Python:`secret_value`)  
Der Wert dieser Version des Geheimnisses. Dieses Objekt,`SecretValue`, enthält die folgenden Informationen.    
`secretString`(Python:`secret_string`)  
Der entschlüsselte Teil der geschützten geheimen Information, die Sie Secrets Manager als Zeichenfolge zur Verfügung gestellt haben.  
`secretBinary`(Python:`secret_binary`)  
(Optional) Der entschlüsselte Teil der geschützten geheimen Information, die Sie Secrets Manager als Binärdaten in Form eines Byte-Arrays zur Verfügung gestellt haben. Diese Eigenschaft enthält die Binärdaten als Base64-kodierte Zeichenfolge.  
Diese Eigenschaft wird nicht verwendet, wenn Sie das Geheimnis in der Secrets Manager-Konsole erstellt haben.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang in benutzerdefiniertem Komponentencode aufgerufen wird.

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

**Example Beispiel: Holen Sie sich einen geheimen Wert**  
In diesem Beispiel wird eine `IPCUtils` Klasse verwendet, um eine Verbindung zum AWS IoT Greengrass Core-IPC-Dienst herzustellen. Weitere Informationen finden Sie unter [Connect zum AWS IoT Greengrass Core IPC-Dienst her](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 Beispiel: Holen Sie sich einen geheimen Wert**  
In diesem Beispiel wird davon ausgegangen, dass Sie Version 1.5.4 oder höher von AWS IoT Device SDK für Python v2 verwenden. 

```
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 Beispiel: Holen Sie sich einen geheimen Wert**  

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

------

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

Verwenden Sie die folgenden Beispiele, um zu erfahren, wie Sie den Secret Manager IPC-Dienst in Ihren Komponenten verwenden können.

### Beispiel: Geheimnis drucken (Python, IPC-Client V1)
<a name="ipc-secret-manager-example-print-secret-python"></a>

Diese Beispielkomponente gibt den Wert eines Secrets aus, das Sie auf dem Kerngerät bereitstellen.

**Wichtig**  
Diese Beispielkomponente gibt den Wert eines Geheimnisses aus. Verwenden Sie sie daher nur mit Geheimnissen, die Testdaten speichern. Verwenden Sie diese Komponente nicht, um den Wert eines Geheimnisses zu drucken, in dem wichtige Informationen gespeichert sind.

**Topics**
+ [Rezept](#ipc-secret-manager-example-print-secret-python-recipe)
+ [-Artefakte](#ipc-secret-manager-example-print-secret-python-artifacts)
+ [Usage](#ipc-secret-manager-example-print-secret-python-usage)

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

Das folgende Beispielrezept definiert einen geheimen ARN-Konfigurationsparameter und ermöglicht es der Komponente, den Wert eines beliebigen Geheimnisses auf dem Kerngerät abzurufen.

**Anmerkung**  <a name="ipc-secret-manager-authorization-policy-resource-wildcard"></a>
Wir empfehlen, in einer Produktionsumgebung den Geltungsbereich der Autorisierungsrichtlinie zu reduzieren, sodass die Komponente nur die Geheimnisse abruft, die sie verwendet. Sie können den `*` Platzhalter ARNs bei der Bereitstellung der Komponente in eine geheime Liste ändern.

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

```
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.PrintSecret",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "Prints the value of an AWS Secrets Manager secret.",
  "ComponentPublisher": "Amazon",
  "ComponentDependencies": {
    "aws.greengrass.SecretManager": {
      "VersionRequirement": "^2.0.0",
      "DependencyType": "HARD"
    }
  },
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "SecretArn": "",
      "accessControl": {
        "aws.greengrass.SecretManager": {
          "com.example.PrintSecret:secrets:1": {
            "policyDescription": "Allows access to a secret.",
            "operations": [
              "aws.greengrass#GetSecretValue"
            ],
            "resources": [
              "*"
            ]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": "python3 -m pip install --user awsiotsdk",
        "Run": "python3 -u {artifacts:path}/print_secret.py \"{configuration:/SecretArn}\""
      }
    },
    {
      "Platform": {
        "os": "windows"
      },
      "Lifecycle": {
        "install": "py -3 -m pip install --user awsiotsdk",
        "Run": "py -3 -u {artifacts:path}/print_secret.py \"{configuration:/SecretArn}\""
      }
    }
  ]
}
```

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

```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.PrintSecret
ComponentVersion: 1.0.0
ComponentDescription: Prints the value of a Secrets Manager secret.
ComponentPublisher: Amazon
ComponentDependencies:
  aws.greengrass.SecretManager:
    VersionRequirement: "^2.0.0"
    DependencyType: HARD
ComponentConfiguration:
  DefaultConfiguration:
    SecretArn: ''
    accessControl:
      aws.greengrass.SecretManager:
        com.example.PrintSecret:secrets:1:
          policyDescription: Allows access to a secret.
          operations:
            - aws.greengrass#GetSecretValue
          resources:
            - "*"
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install: python3 -m pip install --user awsiotsdk
      Run: python3 -u {artifacts:path}/print_secret.py "{configuration:/SecretArn}"
  - Platform:
      os: windows
    Lifecycle:
      install: py -3 -m pip install --user awsiotsdk
      Run: py -3 -u {artifacts:path}/print_secret.py "{configuration:/SecretArn}"
```

------

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

Die folgende Python-Beispielanwendung zeigt, wie der Secret Manager IPC-Dienst verwendet wird, um den Wert eines Secrets auf dem Kerngerät abzurufen.

```
import concurrent.futures
import json
import sys
import traceback

import awsiot.greengrasscoreipc
from awsiot.greengrasscoreipc.model import (
    GetSecretValueRequest,
    GetSecretValueResponse,
    UnauthorizedError
)

TIMEOUT = 10

if len(sys.argv) == 1:
    print('Provide SecretArn in the component configuration.', file=sys.stdout)
    exit(1)

secret_id = sys.argv[1]

try:
    ipc_client = awsiot.greengrasscoreipc.connect()

    request = GetSecretValueRequest()
    request.secret_id = secret_id
    operation = ipc_client.new_get_secret_value()
    operation.activate(request)
    future_response = operation.get_response()

    try:
        response = future_response.result(TIMEOUT)
        secret_json = json.loads(response.secret_value.secret_string)
        print('Successfully got secret: ' + secret_id)
        print('Secret value: ' + str(secret_json))
    except concurrent.futures.TimeoutError:
        print('Timeout occurred while getting secret: ' + secret_id, file=sys.stderr)
    except UnauthorizedError as e:
        print('Unauthorized error while getting secret: ' + secret_id, file=sys.stderr)
        raise e
    except Exception as e:
        print('Exception while getting secret: ' + secret_id, file=sys.stderr)
        raise e
except Exception:
    print('Exception occurred when using IPC.', file=sys.stderr)
    traceback.print_exc()
    exit(1)
```

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

Sie können diese Beispielkomponente zusammen mit der [Secret Manager-Komponente](secret-manager-component.md) verwenden, um den Wert eines Secrets auf Ihrem Kerngerät bereitzustellen und auszudrucken.

**Um ein Testgeheimnis zu erstellen, bereitzustellen und auszudrucken**

1. Erstellen Sie ein Secrets Manager Manager-Geheimnis mit Testdaten.

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

------

   Speichern Sie den ARN des Secrets, um ihn in den folgenden Schritten zu verwenden.

   Weitere Informationen finden Sie im *AWS Secrets Manager Benutzerhandbuch* unter [Creating a Secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html).

1. Stellen Sie die [Secret Manager-Komponente](secret-manager-component.md) (`aws.greengrass.SecretManager`) mit dem folgenden Update zur Zusammenführung der Konfiguration bereit. Geben Sie den ARN des Geheimnisses an, das Sie zuvor erstellt haben.

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

   Weitere Informationen finden Sie unter [AWS IoT Greengrass Komponenten auf Geräten bereitstellen](manage-deployments.md) oder im [Greengrass CLI-Bereitstellungsbefehl](gg-cli-deployment.md).

1. Erstellen und implementieren Sie die Beispielkomponente in diesem Abschnitt mit dem folgenden Update zur Zusammenführung der Konfiguration. Geben Sie den ARN des Geheimnisses an, das Sie zuvor erstellt haben.

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

   Weitere Informationen finden Sie unter [AWS IoT Greengrass Komponenten erstellen](create-components.md).

1. Sehen Sie sich die AWS IoT Greengrass Core-Softwareprotokolle an, um zu überprüfen, ob die Bereitstellungen erfolgreich waren, und sehen Sie sich das `com.example.PrintSecret` Komponentenprotokoll an, um den geheimen Wert gedruckt zu sehen. Weitere Informationen finden Sie unter [AWS IoT Greengrass Protokolle überwachen](monitor-logs.md).

# Interagiere mit lokalen Schatten
<a name="ipc-local-shadows"></a>

Verwenden Sie den Shadow-IPC-Dienst, um mit lokalen Schatten auf einem Gerät zu interagieren. Das Gerät, mit dem Sie interagieren möchten, kann Ihr Kerngerät oder ein verbundenes Client-Gerät sein. 

Um diese IPC-Operationen zu verwenden, fügen Sie die [Shadow Manager-Komponente](shadow-manager-component.md) als Abhängigkeit in Ihre benutzerdefinierte Komponente ein. Sie können dann IPC-Operationen in Ihren benutzerdefinierten Komponenten verwenden, um über den Shadow Manager mit lokalen Schatten auf Ihrem Gerät zu interagieren. Damit benutzerdefinierte Komponenten auf Änderungen in lokalen Shadow-Zuständen reagieren können, können Sie auch den publish/subscribe IPC-Dienst verwenden, um Shadow-Ereignisse zu abonnieren. Weitere Informationen zur Verwendung des publish/subscribe Dienstes finden Sie unter[Lokale Nachrichten veröffentlichen/abonnieren](ipc-publish-subscribe.md).

**Anmerkung**  <a name="note-requirement-enable-shadow-manager-client-devices"></a>
Damit ein Core-Gerät mit Client-Geräteschatten interagieren kann, müssen Sie auch die MQTT-Bridge-Komponente konfigurieren und bereitstellen. Weitere Informationen finden Sie unter [Aktivieren des Shadow-Managers für die Kommunikation mit Client-Geräten](work-with-client-device-shadows.md).

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

## Minimale SDK-Versionen
<a name="ipc-local-shadows-sdk-versions"></a>

In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie für die Interaktion mit lokalen Schatten verwenden müssen.


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

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

Um den Shadow-IPC-Dienst in einer benutzerdefinierten Komponente zu verwenden, müssen Sie Autorisierungsrichtlinien definieren, die es Ihrer Komponente ermöglichen, mit Shadows zu interagieren. Informationen zur Definition von Autorisierungsrichtlinien finden Sie unter[Autorisieren Sie Komponenten zur Ausführung von IPC-Vorgängen](interprocess-communication.md#ipc-authorization-policies).

Autorisierungsrichtlinien für Shadow-Interaktionen haben die folgenden Eigenschaften.

**IPC-Dienst-ID:** `aws.greengrass.ShadowManager`


| Operation | Description | Ressourcen | 
| --- | --- | --- | 
|  `aws.greengrass#GetThingShadow`  |  Ermöglicht einer Komponente, den Schatten eines Objekts abzurufen.  |  Eine der folgenden Zeichenketten:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/ipc-local-shadows.html)  | 
|  `aws.greengrass#UpdateThingShadow`  |  Ermöglicht einer Komponente, den Schatten eines Objekts zu aktualisieren.  |  Eine der folgenden Zeichenketten:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/ipc-local-shadows.html)  | 
|  `aws.greengrass#DeleteThingShadow`  |  Ermöglicht einer Komponente, den Schatten eines Objekts zu löschen.  |  Eine der folgenden Zeichenketten:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/ipc-local-shadows.html)  | 
|  `aws.greengrass#ListNamedShadowsForThing`  |  Ermöglicht einer Komponente, die Liste der benannten Schatten für ein Ding abzurufen.  |  Eine Zeichenfolge mit dem Namen eines Dings, die den Zugriff auf das Ding ermöglicht, um seine Schatten aufzulisten. Wird verwendet`*`, um den Zugriff auf alle Dinge zu ermöglichen.  | 

**IPC-Dienst-ID:** `aws.greengrass.ipc.pubsub`


| Operation | Description | Ressourcen | 
| --- | --- | --- | 
|  `aws.greengrass#SubscribeToTopic`  |  Ermöglicht einer Komponente, Nachrichten zu den von Ihnen angegebenen Themen zu abonnieren.  |  Eine der folgenden Themenzeichenfolgen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/ipc-local-shadows.html) Der Wert des Themenpräfixes `shadowTopicPrefix` hängt von der Art des Schattens ab:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/ipc-local-shadows.html) Wird verwendet`*`, um den Zugriff auf alle Themen zu ermöglichen. <a name="ipc-local-publish-subscribe-authorization-mqtt-wildcards"></a>In [Greengrass Nucleus](greengrass-nucleus-component.md) v2.6.0 und höher können Sie Themen abonnieren, die Platzhalter (und) für MQTT-Themen enthalten. `#` `+` Diese Themenzeichenfolge unterstützt Platzhalter für MQTT-Themen als Literalzeichen. Wenn beispielsweise die Autorisierungsrichtlinie einer Komponente Zugriff auf gewährt`test/topic/#`, kann die Komponente zwar abonnieren`test/topic/#`, aber nicht abonnieren. `test/topic/filter`  | 

### Rezeptvariablen in lokalen Shadow-Autorisierungsrichtlinien
<a name="ipc-local-shadow-authorization-recipe-variables"></a>

Wenn Sie Version 2.6.0 oder höher von [Greengrass Nucleus](greengrass-nucleus-component.md) verwenden und die [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)Konfigurationsoption von Greengrass Nucleus auf einstellen`true`, können Sie die `{iot:thingName}` [Rezeptvariable](component-recipe-reference.md#recipe-variables) in Autorisierungsrichtlinien verwenden. Mit dieser Funktion können Sie eine einzige Autorisierungsrichtlinie für eine Gruppe von Kerngeräten konfigurieren, wobei jedes Kerngerät nur auf seinen eigenen Schatten zugreifen kann. Beispielsweise können Sie einer Komponente den Zugriff auf die folgende Ressource für Shadow-IPC-Operationen gewähren.

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

### Beispiele für Autorisierungsrichtlinien
<a name="ipc-local-shadow-authorization-policy-examples"></a>

Anhand der folgenden Beispiele für Autorisierungsrichtlinien können Sie Autorisierungsrichtlinien für Ihre Komponenten konfigurieren.

**Example Beispiel: Erlauben Sie einer Gruppe von Kerngeräten, mit lokalen Shadows zu interagieren**  
 <a name="phrase-example-uses-recipe-variables-in-configuration"></a>In diesem Beispiel wird eine Funktion verwendet, die für Version 2.6.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar ist. Greengrass Nucleus v2.6.0 bietet Unterstützung für die meisten [Rezeptvariablen](component-recipe-reference.md#recipe-variables), z. B. in `{iot:thingName}` Komponentenkonfigurationen. Um diese Funktion zu aktivieren, setzen Sie die [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)Konfigurationsoption von Greengrass Nucleus auf. `true` Ein Beispiel, das für alle Versionen von Greengrass Nucleus funktioniert, finden Sie in der [Beispielautorisierungsrichtlinie für ein Single-Core-Gerät](#ipc-local-shadows-authorization-example-single-device).
Die folgende Beispielautorisierungsrichtlinie ermöglicht es der Komponente`com.example.MyShadowInteractionComponent`, mit dem klassischen Geräteshadow und dem benannten Shadow `myNamedShadow` für das Kerngerät zu interagieren, auf dem die Komponente ausgeführt wird. Diese Richtlinie ermöglicht es dieser Komponente auch, Nachrichten zu lokalen Themen für diese Shadows zu empfangen.  

```
{
  "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 Beispiel: Erlauben Sie einer Gruppe von Kerngeräten, mit Client-Geräteschatten zu interagieren**  
Diese Funktion erfordert [Greengrass Nucleus](greengrass-nucleus-component.md) v2.6.0 oder höher, [Shadow Manager](shadow-manager-component.md) v2.2.0 oder höher und [MQTT](mqtt-bridge-component.md) Bridge v2.2.0 oder höher. [Sie müssen MQTT Bridge so konfigurieren, dass Shadow Manager mit Client-Geräten kommunizieren kann.](work-with-client-device-shadows.md#enable-shadow-manager-client-devices)
Die folgende Beispielautorisierungsrichtlinie ermöglicht es der Komponente`com.example.MyShadowInteractionComponent`, mit allen Geräteschatten für Client-Geräte zu interagieren, deren Namen mit `MyClientDevice` beginnen.  
Damit ein Kerngerät mit Client-Geräteschatten interagieren kann, müssen Sie auch die MQTT-Bridge-Komponente konfigurieren und bereitstellen. Weitere Informationen finden Sie unter [Aktivieren des Shadow-Managers für die Kommunikation mit Client-Geräten](work-with-client-device-shadows.md).

```
{
  "accessControl": {
    "aws.greengrass.ShadowManager": {
      "com.example.MyShadowInteractionComponent:shadow:1": {
        "policyDescription": "Allows access to shadows",
        "operations": [
          "aws.greengrass#GetThingShadow",
          "aws.greengrass#UpdateThingShadow",
          "aws.greengrass#DeleteThingShadow"
        ],
        "resources": [
          "$aws/things/MyClientDevice*/shadow",
          "$aws/things/MyClientDevice*/shadow/name/*"
        ]
      },
      "com.example.MyShadowInteractionComponent:shadow:2": {
        "policyDescription": "Allows access to things with shadows",
        "operations": [
          "aws.greengrass#ListNamedShadowsForThing"
        ],
        "resources": [
          "MyClientDevice*"
        ]
      }    
    }
  }
}
```

```
accessControl:
  aws.greengrass.ShadowManager:
    'com.example.MyShadowInteractionComponent:shadow:1':
      policyDescription: 'Allows access to shadows'
      operations:
        - 'aws.greengrass#GetThingShadow'
        - 'aws.greengrass#UpdateThingShadow'
        - 'aws.greengrass#DeleteThingShadow'
      resources:
        - $aws/things/MyClientDevice*/shadow
        - $aws/things/MyClientDevice*/shadow/name/*
    'com.example.MyShadowInteractionComponent:shadow:2':
      policyDescription: 'Allows access to things with shadows'
      operations:
        - 'aws.greengrass#ListNamedShadowsForThing'
      resources:
        - MyClientDevice*
```<a name="ipc-local-shadows-authorization-example-single-device"></a>

**Example Beispiel: Erlauben Sie einem Single-Core-Gerät, mit lokalen Shadows zu interagieren**  
Das folgende Beispiel für eine Autorisierungsrichtlinie ermöglicht es der Komponente`com.example.MyShadowInteractionComponent`, mit dem klassischen Geräteshadow und dem benannten Shadow `myNamedShadow` für das Gerät zu interagieren`MyThingName`. Diese Richtlinie ermöglicht es dieser Komponente auch, Nachrichten zu lokalen Themen für diese Shadows zu empfangen.   

```
{
  "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 Beispiel: Erlauben Sie einer Gruppe von Core-Geräten, auf lokale Shadow-Status-Änderungen zu reagieren**  
 <a name="phrase-example-uses-recipe-variables-in-configuration"></a>In diesem Beispiel wird eine Funktion verwendet, die für Version 2.6.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar ist. Greengrass Nucleus v2.6.0 bietet Unterstützung für die meisten [Rezeptvariablen](component-recipe-reference.md#recipe-variables), z. B. in `{iot:thingName}` Komponentenkonfigurationen. Um diese Funktion zu aktivieren, setzen Sie die [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)Konfigurationsoption von Greengrass Nucleus auf. `true` Ein Beispiel, das für alle Versionen von Greengrass Nucleus funktioniert, finden Sie in der [Beispielautorisierungsrichtlinie für ein Single-Core-Gerät](#interact-with-shadows-react-example-authorization-policy-single-device).
Das folgende Beispiel für eine Zugriffskontrollrichtlinie ermöglicht es dem Benutzer`com.example.MyShadowReactiveComponent`, Nachrichten `/update/delta` zum Thema für den klassischen Geräteshadow und den benannten Shadow `myNamedShadow` auf jedem Kerngerät zu empfangen, auf dem die Komponente ausgeführt wird.  

```
{
  "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 Beispiel: Erlaubt einem Single-Core-Gerät, auf lokale Shadow-Status-Änderungen zu reagieren**  
Das folgende Beispiel für eine Zugriffskontrollrichtlinie ermöglicht es dem `com.example.MyShadowReactiveComponent` Benutzer, Nachrichten `/update/delta` zum Thema für den klassischen Geräteshadow und zum benannten Shadow `myNamedShadow` für das Gerät zu empfangen`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>

Ruft den Schatten für ein bestimmtes Objekt ab.

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

Die Anfrage dieser Operation hat die folgenden Parameter:

`thingName`(Python:`thing_name`)  <a name="ipc-local-shadows-thing-name"></a>
Der Name des Objekts.  
Typ: `string`

`shadowName`(Python:`shadow_name`)  <a name="ipc-local-shadows-shadow-name"></a>
Der Name des Schattens. Um den klassischen Schatten des Dings anzugeben, setzen Sie diesen Parameter auf eine leere Zeichenfolge (`""`).  
Der AWS IoT Greengrass Dienst verwendet den `AWSManagedGreengrassV2Deployment` benannten Shadow, um Bereitstellungen zu verwalten, die auf einzelne Kerngeräte abzielen. Dieser benannte Shadow ist für die Verwendung durch den AWS IoT Greengrass Dienst reserviert. Aktualisieren oder löschen Sie diesen benannten Schatten nicht.
Typ: `string`

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

Die Antwort dieses Vorgangs enthält die folgenden Informationen:

`payload`  
Das Dokument mit dem Antwortstatus als Blob.  
Typ: der `object` die folgenden Informationen enthält:    
`state`  
Die Informationen zum Bundesstaat.  
Dieses Objekt enthält die folgenden Informationen.    
`desired`  
Die Statuseigenschaften und Werte, deren Aktualisierung im Gerät angefordert wurde.  
Typ: `map` von Schlüssel-Wert-Paaren  
`reported`  
Die vom Gerät gemeldeten Statuseigenschaften und Werte.  
Typ: `map` von Schlüssel-Wert-Paaren  
`delta`  
Der Unterschied zwischen den gewünschten und den gemeldeten Zustandseigenschaften und -werten. Diese Eigenschaft ist nur vorhanden, wenn sich der `desired` `reported` Status und der Status unterscheiden.  
Typ: `map` von Schlüssel-Wert-Paaren  
`metadata`  
Die Zeitstempel für jedes Attribut in den `reported` Abschnitten `desired` und, sodass Sie feststellen können, wann der Status aktualisiert wurde.   
Typ: `string`  
`timestamp`  
Datum und Uhrzeit der Generierung der Antwort aus der Epoche.  
Typ: `integer`  
`clientToken`(Python:`clientToken`)  
Das Token, das verwendet wird, um die Anfrage und die entsprechende Antwort abzugleichen  
Typ: `string`  
`version`  
Die Version des lokalen Schattendokuments.  
Typ: `integer`

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

Dieser Vorgang kann die folgenden Fehler zurückgeben.

`InvalidArgumentsError`  <a name="ipc-invalidargumentserror"></a>
<a name="ipc-invalidargumentserror-para"></a>Der lokale Shadow-Dienst kann die Anforderungsparameter nicht validieren. Dies kann vorkommen, wenn die Anfrage falsch formatiertes JSON oder nicht unterstützte Zeichen enthält. 

`ResourceNotFoundError`  <a name="ipc-resourcenotfounderror"></a>
Das angeforderte lokale Shadow-Dokument konnte nicht gefunden werden.

`ServiceError`  <a name="ipc-serviceerror"></a>
Ein interner Dienstfehler ist aufgetreten, oder die Anzahl der Anfragen an den IPC-Dienst hat die in den `maxTotalLocalRequestsRate` Konfigurationsparametern `maxLocalRequestsPerSecondPerThing` und in der Shadow-Manager-Komponente angegebenen Grenzwerte überschritten.

`UnauthorizedError`  <a name="ipc-unauthorizederror"></a>
Die Autorisierungsrichtlinie der Komponente enthält keine erforderlichen Berechtigungen für diesen Vorgang.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang im benutzerdefinierten Komponentencode aufgerufen wird.

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

**Example Beispiel: Holen Sie sich ein Ding Shadow**  
In diesem Beispiel wird eine `IPCUtils` Klasse verwendet, um eine Verbindung zum AWS IoT Greengrass Core-IPC-Dienst herzustellen. Weitere Informationen finden Sie unter [Connect zum AWS IoT Greengrass Core IPC-Dienst her](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 Beispiel: Holen Sie sich ein Ding 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 Beispiel: Holen Sie sich einen Dingschatten**  

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

Aktualisiere den Schatten für das angegebene Ding. Wenn kein Schatten existiert, wird einer erstellt.

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

Die Anfrage dieser Operation hat die folgenden Parameter:

`thingName`(Python:`thing_name`)  <a name="ipc-local-shadows-thing-name"></a>
Der Name des Objekts.  
Typ: `string`

`shadowName`(Python:`shadow_name`)  <a name="ipc-local-shadows-shadow-name"></a>
Der Name des Schattens. Um den klassischen Schatten des Dings anzugeben, setzen Sie diesen Parameter auf eine leere Zeichenfolge (`""`).  
Der AWS IoT Greengrass Dienst verwendet den `AWSManagedGreengrassV2Deployment` benannten Shadow, um Bereitstellungen zu verwalten, die auf einzelne Kerngeräte abzielen. Dieser benannte Shadow ist für die Verwendung durch den AWS IoT Greengrass Dienst reserviert. Aktualisieren oder löschen Sie diesen benannten Schatten nicht.
Typ: `string`

`payload`  
Das Dokument mit dem Status der Anfrage als Blob.  
Typ: der `object` die folgenden Informationen enthält:    
`state`  
Die zu aktualisierenden Statusinformationen. Dieser IPC-Vorgang wirkt sich nur auf die angegebenen Felder aus.  
Dieses Objekt enthält die folgenden Informationen. In der Regel verwenden Sie entweder die `desired` Eigenschaft oder die `reported` Eigenschaft, aber nicht beide in derselben Anfrage.    
`desired`  
Die Statuseigenschaften und Werte, deren Aktualisierung im Gerät angefordert wurde.  
Typ: `map` von Schlüssel-Wert-Paaren  
`reported`  
Die vom Gerät gemeldeten Statuseigenschaften und Werte.  
Typ: `map` von Schlüssel-Wert-Paaren  
`clientToken`(Python:`client_token`)  
(Optional) Das Token, das verwendet wird, um die Anfrage und die entsprechende Antwort des Client-Tokens abzugleichen.  
Typ: `string`  
`version`  
(Optional) Die Version des lokalen Shadow-Dokuments, das aktualisiert werden soll. Der Shadow-Dienst verarbeitet das Update nur, wenn die angegebene Version mit der neuesten Version übereinstimmt.  
Typ: `integer`

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

Die Antwort dieses Vorgangs enthält die folgenden Informationen:

`payload`  
Das Dokument mit dem Antwortstatus als Blob.  
Typ: der `object` die folgenden Informationen enthält:    
`state`  
Die Informationen zum Bundesstaat.  
Dieses Objekt enthält die folgenden Informationen.    
`desired`  
Die Statuseigenschaften und Werte, deren Aktualisierung im Gerät angefordert wurde.  
Typ: `map` von Schlüssel-Wert-Paaren  
`reported`  
Die vom Gerät gemeldeten Statuseigenschaften und Werte.  
Typ: `map` von Schlüssel-Wert-Paaren  
`delta`  
Die vom Gerät gemeldeten Statuseigenschaften und Werte.  
Typ: `map` von Schlüssel-Wert-Paaren  
`metadata`  
Die Zeitstempel für jedes Attribut in den `reported` Abschnitten `desired` und, sodass Sie feststellen können, wann der Status aktualisiert wurde.   
Typ: `string`  
`timestamp`  
Datum und Uhrzeit der Generierung der Antwort aus der Epoche.  
Typ: `integer`  
`clientToken`(Python:`client_token`)  
Das Token, das verwendet wird, um die Anfrage und die entsprechende Antwort abzugleichen.  
Typ: `string`  
`version`  
Die Version des lokalen Shadow-Dokuments nach Abschluss der Aktualisierung.  
Typ: `integer`

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

Bei diesem Vorgang können die folgenden Fehler zurückgegeben werden.

`ConflictError`  
Der lokale Shadow-Dienst ist während des Aktualisierungsvorgangs auf einen Versionskonflikt gestoßen. Dieser Fehler tritt auf, wenn die Version in der Payload der Anforderung nicht mit der Version im neuesten verfügbaren lokalen Shadow-Dokument übereinstimmt.

`InvalidArgumentsError`  
<a name="ipc-invalidargumentserror-para"></a>Der lokale Shadow-Dienst kann die Anforderungsparameter nicht überprüfen. Dies kann vorkommen, wenn die Anfrage falsch formatiertes JSON oder nicht unterstützte Zeichen enthält.   
Ein gültiger Wert `payload` hat die folgenden Eigenschaften:  
+ Der `state` Knoten ist vorhanden und ist ein Objekt, das die `desired` `reported` Zustandsinformationen enthält. 
+ Die `reported` Knoten `desired` und sind entweder Objekte oder Null. Mindestens eines dieser Objekte muss gültige Statusinformationen enthalten. 
+ Die Tiefe der `reported` Objekte `desired` und darf acht Knoten nicht überschreiten. 
+ Die Länge des `clientToken` Werts darf 64 Zeichen nicht überschreiten. 
+  Der `version` Wert muss `1` mindestens so hoch sein. 

`ServiceError`  <a name="ipc-serviceerror"></a>
Ein interner Dienstfehler ist aufgetreten, oder die Anzahl der Anfragen an den IPC-Dienst hat die in den `maxTotalLocalRequestsRate` Konfigurationsparametern `maxLocalRequestsPerSecondPerThing` und in der Shadow Manager-Komponente angegebenen Grenzwerte überschritten.

`UnauthorizedError`  <a name="ipc-unauthorizederror"></a>
Die Autorisierungsrichtlinie der Komponente enthält keine erforderlichen Berechtigungen für diesen Vorgang.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang im benutzerdefinierten Komponentencode aufgerufen wird.

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

**Example Beispiel: Aktualisieren Sie einen Ding-Shadow**  
In diesem Beispiel wird eine `IPCUtils` Klasse verwendet, um eine Verbindung zum AWS IoT Greengrass Core-IPC-Dienst herzustellen. Weitere Informationen finden Sie unter [Connect zum AWS IoT Greengrass Core IPC-Dienst her](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 Beispiel: Aktualisiere einen Ding-Shadow**  

```
import awsiot.greengrasscoreipc
import awsiot.greengrasscoreipc.client as client
from awsiot.greengrasscoreipc.model import UpdateThingShadowRequest

TIMEOUT = 10

def sample_update_thing_shadow_request(thingName, shadowName, payload):
    try:
        # set up IPC client to connect to the IPC server
        ipc_client = awsiot.greengrasscoreipc.connect()
                
        # create the UpdateThingShadow request
        update_thing_shadow_request = UpdateThingShadowRequest()
        update_thing_shadow_request.thing_name = thingName
        update_thing_shadow_request.shadow_name = shadowName
        update_thing_shadow_request.payload = payload
                        
        # retrieve the UpdateThingShadow response after sending the request to the IPC server
        op = ipc_client.new_update_thing_shadow()
        op.activate(update_thing_shadow_request)
        fut = op.get_response()
        
        result = fut.result(TIMEOUT)
        return result.payload
        
    except InvalidArgumentsError as e:
        # add error handling
    ...
    # except ConflictError | UnauthorizedError | ServiceError
```

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

**Example Beispiel: Aktualisiere einen Dingschatten**  

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

Löscht das Schattengerät für das angegebene Objekt. 

Ab Shadow Manager v2.0.4 erhöht das Löschen eines Shadows die Versionsnummer. Wenn Sie beispielsweise den Schatten `MyThingShadow` in Version 1 löschen, ist die Version des gelöschten Schattens 2. Wenn Sie dann einen Schatten mit dem Namen neu erstellen`MyThingShadow`, ist die Version für diesen Schatten 3. 

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

Die Anforderung dieses Vorgangs hat die folgenden Parameter:

`thingName`(Python:`thing_name`)  <a name="ipc-local-shadows-thing-name"></a>
Der Name des Objekts.  
Typ: `string`

`shadowName`(Python:`shadow_name`)  <a name="ipc-local-shadows-shadow-name"></a>
Der Name des Schattens. Um den klassischen Schatten des Dings anzugeben, setzen Sie diesen Parameter auf eine leere Zeichenfolge (`""`).  
Der AWS IoT Greengrass Dienst verwendet den `AWSManagedGreengrassV2Deployment` benannten Shadow, um Bereitstellungen zu verwalten, die auf einzelne Kerngeräte abzielen. Dieser benannte Shadow ist für die Verwendung durch den AWS IoT Greengrass Dienst reserviert. Aktualisieren oder löschen Sie diesen benannten Schatten nicht.
Typ: `string`

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

Die Antwort dieses Vorgangs enthält die folgenden Informationen:

`payload`  
Ein leeres Dokument mit dem Antwortstatus.

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

Dieser Vorgang kann die folgenden Fehler zurückgeben.

`InvalidArgumentsError`  <a name="ipc-invalidargumentserror"></a>
<a name="ipc-invalidargumentserror-para"></a>Der lokale Shadow-Dienst kann die Anforderungsparameter nicht validieren. Dies kann vorkommen, wenn die Anfrage falsch formatiertes JSON oder nicht unterstützte Zeichen enthält. 

`ResourceNotFoundError`  <a name="ipc-resourcenotfounderror"></a>
Das angeforderte lokale Shadow-Dokument konnte nicht gefunden werden.

`ServiceError`  <a name="ipc-serviceerror"></a>
Ein interner Dienstfehler ist aufgetreten, oder die Anzahl der Anfragen an den IPC-Dienst hat die in den `maxTotalLocalRequestsRate` Konfigurationsparametern `maxLocalRequestsPerSecondPerThing` und in der Shadow-Manager-Komponente angegebenen Grenzwerte überschritten.

`UnauthorizedError`  <a name="ipc-unauthorizederror"></a>
Die Autorisierungsrichtlinie der Komponente enthält keine erforderlichen Berechtigungen für diesen Vorgang.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang im benutzerdefinierten Komponentencode aufgerufen wird.

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

**Example Beispiel: Löschen Sie einen Ding-Shadow**  
In diesem Beispiel wird eine `IPCUtils` Klasse verwendet, um eine Verbindung zum AWS IoT Greengrass Core-IPC-Dienst herzustellen. Weitere Informationen finden Sie unter [Connect zum AWS IoT Greengrass Core IPC-Dienst her](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 Beispiel: Lösche einen Dingschatten**  

```
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 Beispiel: Lösche einen Dingschatten**  

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

Listet die benannten Schatten für das angegebene Ding auf.

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

Die Anfrage dieser Operation hat die folgenden Parameter:

`thingName`(Python:`thing_name`)  <a name="ipc-local-shadows-thing-name"></a>
Der Name des Objekts.  
Typ: `string`

`pageSize`(Python:`page_size`)  
(Optional) Die Anzahl der Schattennamen, die bei jedem Aufruf zurückgegeben werden sollen.   
Typ: `integer`  
Standard: 25  
Maximum: 100

`nextToken`(Python:`next_token`)  
(Optional) Das Token zum Abrufen der nächsten Ergebnismenge. Dieser Wert wird für nach Seiten organisierte Ergebnisse zurückgegeben und in dem Aufruf verwendet, der die nächste Seite zurückgibt.  
Typ: `string`

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

Die Antwort dieses Vorgangs enthält die folgenden Informationen:

`results`  
Die Liste der Schattennamen.   
Typ: `array`

`timestamp`  
(Optional) Datum und Uhrzeit der Generierung der Antwort.   
Typ: `integer`

`nextToken`(Python:`next_token`)  
(Optional) Der Tokenwert, der in Seitenanfragen verwendet werden soll, um die nächste Seite in der Sequenz abzurufen. Dieses Token ist nicht vorhanden, wenn keine Shadow-Namen mehr zurückgegeben werden können.  
Typ: `string`  
Wenn die angeforderte Seitengröße genau der Anzahl der Schattennamen in der Antwort entspricht, ist dieses Token vorhanden. Wenn es verwendet wird, gibt es jedoch eine leere Liste zurück.

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

Dieser Vorgang kann die folgenden Fehler zurückgeben.

`InvalidArgumentsError`  <a name="ipc-invalidargumentserror"></a>
<a name="ipc-invalidargumentserror-para"></a>Der lokale Shadow-Dienst kann die Anforderungsparameter nicht validieren. Dies kann vorkommen, wenn die Anfrage falsch formatiertes JSON oder nicht unterstützte Zeichen enthält. 

`ResourceNotFoundError`  <a name="ipc-resourcenotfounderror"></a>
Das angeforderte lokale Shadow-Dokument konnte nicht gefunden werden.

`ServiceError`  <a name="ipc-serviceerror"></a>
Ein interner Dienstfehler ist aufgetreten, oder die Anzahl der Anfragen an den IPC-Dienst hat die in den `maxTotalLocalRequestsRate` Konfigurationsparametern `maxLocalRequestsPerSecondPerThing` und in der Shadow-Manager-Komponente angegebenen Grenzwerte überschritten.

`UnauthorizedError`  <a name="ipc-unauthorizederror"></a>
Die Autorisierungsrichtlinie der Komponente enthält keine erforderlichen Berechtigungen für diesen Vorgang.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang im benutzerdefinierten Komponentencode aufgerufen wird.

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

**Example Beispiel: Listet ein Ding auf, das Schatten heißt**  
In diesem Beispiel wird eine `IPCUtils` Klasse verwendet, um eine Verbindung zum AWS IoT Greengrass Core-IPC-Dienst herzustellen. Weitere Informationen finden Sie unter [Connect zum AWS IoT Greengrass Core IPC-Dienst her](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 Beispiel: Listet ein Ding auf, das Schatten heißt**  

```
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 Beispiel: Listet die Namen Schatten eines Dings auf**  

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

------

# Lokale Bereitstellungen und Komponenten verwalten
<a name="ipc-local-deployments-components"></a>

**Anmerkung**  
Diese Funktion ist für Version 2.6.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar.

Verwenden Sie den Greengrass CLI IPC-Dienst, um lokale Bereitstellungen und Greengrass-Komponenten auf dem Kerngerät zu verwalten.

Um diese IPC-Operationen zu verwenden, fügen Sie Version 2.6.0 oder höher der [Greengrass-CLI-Komponente](greengrass-cli-component.md) als Abhängigkeit in Ihre benutzerdefinierte Komponente ein. Sie können dann IPC-Operationen in Ihren benutzerdefinierten Komponenten verwenden, um Folgendes zu tun:
+ Erstellen Sie lokale Bereitstellungen, um Greengrass-Komponenten auf dem Kerngerät zu ändern und zu konfigurieren.
+ Starten Sie die Greengrass-Komponenten auf dem Kerngerät neu und beenden Sie sie.
+ Generieren Sie ein Passwort, mit dem Sie sich an der [lokalen Debug-Konsole](local-debug-console-component.md) anmelden können.

**Topics**
+ [Minimale SDK-Versionen](#ipc-local-deployments-components-sdk-versions)
+ [Autorisierung](#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)

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

In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie für die Interaktion mit dem Greengrass CLI IPC-Service verwenden müssen.


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

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

Um den Greengrass CLI IPC-Dienst in einer benutzerdefinierten Komponente zu verwenden, müssen Sie Autorisierungsrichtlinien definieren, die es Ihrer Komponente ermöglichen, lokale Bereitstellungen und Komponenten zu verwalten. Informationen zur Definition von Autorisierungsrichtlinien finden Sie unter. [Autorisieren Sie Komponenten zur Ausführung von IPC-Vorgängen](interprocess-communication.md#ipc-authorization-policies)

Autorisierungsrichtlinien für die Greengrass-CLI haben die folgenden Eigenschaften.

**IPC-Servicekennung:** `aws.greengrass.Cli`


| Operation | Description | Ressourcen | 
| --- | --- | --- | 
|  `aws.greengrass#CreateLocalDeployment`  |  Ermöglicht einer Komponente, eine lokale Bereitstellung auf dem Kerngerät zu erstellen.  |  `*`  | 
|  `aws.greengrass#ListLocalDeployments`  |  Ermöglicht einer Komponente, lokale Bereitstellungen auf dem Kerngerät aufzulisten.  |  `*`  | 
|  `aws.greengrass#GetLocalDeploymentStatus`  |  Ermöglicht einer Komponente, den Status einer lokalen Bereitstellung auf dem Kerngerät abzurufen.  |  Eine lokale Bereitstellungs-ID oder `*` um den Zugriff auf alle lokalen Bereitstellungen zu ermöglichen.  | 
|  `aws.greengrass#ListComponents`  |  Ermöglicht einer Komponente, Komponenten auf dem Kerngerät aufzulisten.  |  `*`  | 
|  `aws.greengrass#GetComponentDetails`  |  Ermöglicht einer Komponente, Details zu einer Komponente auf dem Kerngerät abzurufen.  |  Ein Komponentenname, z. B. oder`com.example.HelloWorld`, `*` um den Zugriff auf alle Komponenten zu ermöglichen.  | 
|  `aws.greengrass#RestartComponent`  |  Ermöglicht einer Komponente, eine Komponente auf dem Kerngerät neu zu starten.  |  Ein Komponentenname, z. B. oder`com.example.HelloWorld`, `*` um den Zugriff auf alle Komponenten zu ermöglichen.  | 
|  `aws.greengrass#StopComponent`  |  Ermöglicht einer Komponente, eine Komponente auf dem Kerngerät zu stoppen.  |  Ein Komponentenname, z. B. oder`com.example.HelloWorld`, `*` um den Zugriff auf alle Komponenten zu ermöglichen.  | 
|  `aws.greengrass#CreateDebugPassword`  |  Ermöglicht einer Komponente, ein Passwort zu generieren, mit dem sie sich bei der [lokalen Debug-Konsolenkomponente](local-debug-console-component.md) anmelden kann.  |  `*`  | 

**Example Beispiel für eine Autorisierungsrichtlinie**  
Das folgende Beispiel für Autorisierungsrichtlinien ermöglicht es einer Komponente, lokale Bereitstellungen zu erstellen, alle lokalen Bereitstellungen und Komponenten anzuzeigen und eine Komponente mit dem Namen neu zu starten und zu beenden. `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>

Erstellen oder aktualisieren Sie eine lokale Bereitstellung mithilfe bestimmter Komponentenrezepte, Artefakte und Laufzeitargumente.

Dieser Vorgang bietet dieselbe Funktionalität wie der [Befehl deployment create](gg-cli-deployment.md#deployment-create) in der Greengrass-CLI.

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

Die Anfrage dieses Vorgangs hat die folgenden Parameter:

`recipeDirectoryPath`(Python:`recipe_directory_path`)  
(Optional) Der absolute Pfad zu dem Ordner, der die Rezeptdateien für Komponenten enthält.

`artifactDirectoryPath`(Python:`artifact_directory_path`)  
(Optional) Der absolute Pfad zu dem Ordner, der die Artefaktdateien enthält, die in die Bereitstellung aufgenommen werden sollen. Der Ordner Artifacts muss die folgende Ordnerstruktur enthalten:  

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

`rootComponentVersionsToAdd`(Python:`root_component_versions_to_add`)  
(Optional) Die Komponentenversionen, die auf dem Kerngerät installiert werden sollen. Dieses Objekt,`ComponentToVersionMap`, ist eine Map, die die folgenden Schlüssel-Wert-Paare enthält:    
`key`  
Der Name der Komponente.  
`value`  
Die Version der Komponente.

`rootComponentsToRemove`(Python:`root_components_to_remove`)  
(Optional) Die Komponenten, die vom Kerngerät deinstalliert werden sollen. Geben Sie eine Liste an, in der jeder Eintrag dem Namen einer Komponente entspricht.

`componentToConfiguration`(Python:`component_to_configuration`)  
(Optional) Die Konfigurationsaktualisierungen für jede Komponente in der Bereitstellung. Dieses Objekt,`ComponentToConfiguration`, ist eine Map, die die folgenden Schlüssel-Wert-Paare enthält:    
`key`  
Der Name der Komponente.  
`value`  
Das JSON-Objekt für das Konfigurationsupdate für die Komponente. Das JSON-Objekt muss das folgende Format haben.  

```
{ 
  "MERGE": {
    "config-key": "config-value"
  },
  "RESET": [
    "path/to/reset/"
  ]
}
```
Weitere Informationen zu Konfigurationsupdates finden Sie unter[Komponentenkonfigurationen aktualisieren](update-component-configurations.md).

`componentToRunWithInfo`(Python:`component_to_run_with_info`)  
(Optional) Die Laufzeitkonfiguration für jede Komponente in der Bereitstellung. Diese Konfiguration umfasst den Systembenutzer, der für die Prozesse der einzelnen Komponenten verantwortlich ist, sowie die Systemlimits, die für jede Komponente gelten sollen. Dieses Objekt,`ComponentToRunWithInfo`, ist eine Map, die die folgenden Schlüssel-Wert-Paare enthält:    
`key`  
Der Name der Komponente.  
`value`  
Die Laufzeitkonfiguration für die Komponente. Wenn Sie einen Laufzeitkonfigurationsparameter weglassen, verwendet die AWS IoT Greengrass Core-Software die Standardwerte, die Sie auf dem [Greengrass-Nucleus](greengrass-nucleus-component.md) konfigurieren. Dieses Objekt,`RunWithInfo`, enthält die folgenden Informationen:    
`posixUser`(Python:`posix_user`)  
(Optional) <a name="deployment-posix-user-definition"></a>Der POSIX-Systembenutzer und optional die Gruppe, die verwendet werden sollen, um diese Komponente auf Linux-Kerngeräten auszuführen. Der Benutzer und die Gruppe, falls angegeben, müssen auf jedem Linux-Core-Gerät vorhanden sein. Geben Sie den Benutzer und die Gruppe durch einen Doppelpunkt (`:`) getrennt im folgenden Format an: `user:group`. Die Gruppe ist optional. Wenn Sie keine Gruppe angeben, verwendet die AWS IoT Greengrass Core-Software die primäre Gruppe für den Benutzer. Weitere Informationen finden Sie unter [Konfigurieren Sie den Benutzer, der die Komponenten ausführt](configure-greengrass-core-v2.md#configure-component-user).   
`windowsUser`(Python:`windows_user`)  
(Optional) <a name="deployment-windows-user-definition"></a>Der Windows-Benutzer, der für die Ausführung dieser Komponente auf Windows Core-Geräten verwendet werden soll. Der Benutzer muss auf jedem Windows Core-Gerät vorhanden sein, und sein Name und Passwort müssen in der Credentials Manager-Instanz des LocalSystem Kontos gespeichert sein. Weitere Informationen finden Sie unter [Konfigurieren Sie den Benutzer, der die Komponenten ausführt](configure-greengrass-core-v2.md#configure-component-user).   
`systemResourceLimits`(Python:`system_resource_limits`)  
(Optional) <a name="deployment-system-resource-limits-definition"></a>Die Systemressourcenlimits, die für die Prozesse dieser Komponente gelten sollen. Sie können Systemressourcenlimits auf generische und nicht containerisierte Lambda-Komponenten anwenden. Weitere Informationen finden Sie unter [Konfigurieren Sie die Systemressourcenlimits für Komponenten](configure-greengrass-core-v2.md#configure-component-system-resource-limits).   
AWS IoT Greengrass unterstützt diese Funktion derzeit nicht auf Windows-Core-Geräten.   
Dieses Objekt,`SystemResourceLimits`, enthält die folgenden Informationen:    
`cpus`  
(Optional) <a name="system-resource-limits-cpu-definition-this"></a>Die maximale Menge an CPU-Zeit, die die Prozesse dieser Komponente auf dem Kerngerät verwenden können. Die gesamte CPU-Zeit eines Core-Geräts entspricht der Anzahl der CPU-Kerne des Geräts. Auf einem Core-Gerät mit 4 CPU-Kernen können Sie diesen Wert beispielsweise auf festlegen, `2` um die Prozesse dieser Komponente auf 50 Prozent der Auslastung jedes CPU-Kerns zu beschränken. Auf einem Gerät mit einem CPU-Kern können Sie diesen Wert auf festlegen, `0.25` um die Prozesse dieser Komponente auf 25 Prozent der CPU-Auslastung zu beschränken. Wenn Sie diesen Wert auf eine Zahl festlegen, die größer als die Anzahl der CPU-Kerne ist, begrenzt die AWS IoT Greengrass Core-Software die CPU-Auslastung der Komponente nicht.   
`memory`  
(Optional) <a name="system-resource-limits-memory-definition-this"></a>Die maximale Menge an RAM (in Kilobyte), die die Prozesse dieser Komponente auf dem Kerngerät verwenden können. 

`groupName`(Python:`group_name`)  
(Optional) Der Name der Dinggruppe, auf die diese Bereitstellung abzielen soll.

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

Die Antwort dieses Vorgangs enthält die folgenden Informationen:

`deploymentId`(Python:`deployment_id`)  
Die ID der lokalen Bereitstellung, die durch die Anfrage erstellt wurde.

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

Ruft den Status der letzten 10 lokalen Bereitstellungen ab.

Dieser Vorgang bietet dieselbe Funktionalität wie der [Befehl deployment list](gg-cli-deployment.md#deployment-list) in der Greengrass-CLI.

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

Die Anfrage dieses Vorgangs hat keine Parameter.

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

Die Antwort dieser Operation enthält die folgenden Informationen:

`localDeployments`(Python:`local_deployments`)  
Die Liste der lokalen Bereitstellungen. Jedes Objekt in dieser Liste ist ein `LocalDeployment` Objekt, das die folgenden Informationen enthält:  <a name="ipc-local-deployment-object-shape"></a>  
`deploymentId`(Python:`deployment_id`)  
Die ID der lokalen Bereitstellung.  
`status`  
Der Status der lokalen Bereitstellung. Diese Aufzählung,`DeploymentStatus`, hat die folgenden Werte:  
+ `QUEUED`
+ `IN_PROGRESS`
+ `SUCCEEDED`
+ `FAILED`

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

Ruft den Status einer lokalen Bereitstellung ab.

Dieser Vorgang bietet dieselbe Funktionalität wie der [Befehl Deployment Status](gg-cli-deployment.md#deployment-status) in der Greengrass-CLI.

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

Die Anfrage dieses Vorgangs hat die folgenden Parameter:

`deploymentId`(Python:`deployment_id`)  
Die ID der lokalen Bereitstellung, die abgerufen werden soll.

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

Die Antwort dieses Vorgangs enthält die folgenden Informationen:

`deployment`  
Die lokale Bereitstellung. Dieses Objekt,`LocalDeployment`, enthält die folgenden Informationen:  <a name="ipc-local-deployment-object-shape"></a>  
`deploymentId`(Python:`deployment_id`)  
Die ID der lokalen Bereitstellung.  
`status`  
Der Status der lokalen Bereitstellung. Diese Aufzählung,`DeploymentStatus`, hat die folgenden Werte:  
+ `QUEUED`
+ `IN_PROGRESS`
+ `SUCCEEDED`
+ `FAILED`

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

Ruft den Namen, die Version, den Status und die Konfiguration jeder Stammkomponente auf dem Kerngerät ab. Eine *Stammkomponente* ist eine Komponente, die Sie in einer Bereitstellung angeben. Diese Antwort beinhaltet keine Komponenten, die als Abhängigkeiten von anderen Komponenten installiert werden.

Dieser Vorgang bietet dieselbe Funktionalität wie der [Befehl component list](gg-cli-component.md#component-list) in der Greengrass-CLI.

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

Die Anfrage dieser Operation hat keine Parameter.

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

Die Antwort dieser Operation enthält die folgenden Informationen:

`components`  
Die Liste der Root-Komponenten auf dem Core-Gerät. Jedes Objekt in dieser Liste ist ein `ComponentDetails` Objekt, das die folgenden Informationen enthält:  <a name="ipc-component-details-object-shape"></a>  
`componentName`(Python:`component_name`)  
Der Name der Komponente.  
`version`  
Die Version der Komponente.  
`state`  
Der Status der Komponente. Dieser Status kann einer der folgenden sein:  
+ `BROKEN`
+ `ERRORED`
+ `FINISHED`
+ `INSTALLED`
+ `NEW`
+ `RUNNING`
+ `STARTING`
+ `STOPPING`  
`configuration`  
Die Konfiguration der Komponente als JSON-Objekt.

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

Ruft die Version, den Status und die Konfiguration einer Komponente auf dem Kerngerät ab.

Dieser Vorgang bietet dieselbe Funktionalität wie der [Befehl Component Details](gg-cli-component.md#component-details) in der Greengrass-CLI.

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

Die Anfrage dieses Vorgangs hat die folgenden Parameter:

`componentName`(Python:`component_name`)  
Der Name der Komponente, die abgerufen werden soll.

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

Die Antwort dieser Operation enthält die folgenden Informationen:

`componentDetails`(Python:`component_details`)  
Die Details der Komponente. Dieses Objekt,`ComponentDetails`, enthält die folgenden Informationen:  <a name="ipc-component-details-object-shape"></a>  
`componentName`(Python:`component_name`)  
Der Name der Komponente.  
`version`  
Die Version der Komponente.  
`state`  
Der Status der Komponente. Dieser Status kann einer der folgenden sein:  
+ `BROKEN`
+ `ERRORED`
+ `FINISHED`
+ `INSTALLED`
+ `NEW`
+ `RUNNING`
+ `STARTING`
+ `STOPPING`  
`configuration`  
Die Konfiguration der Komponente als JSON-Objekt.

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

Startet eine Komponente auf dem Kerngerät neu.

**Anmerkung**  
Sie können zwar jede Komponente neu starten, wir empfehlen jedoch, nur [generische Komponenten](develop-greengrass-components.md#component-types) neu zu starten.

Dieser Vorgang bietet dieselbe Funktionalität wie der [Befehl zum Neustarten der Komponente](gg-cli-component.md#component-restart) in der Greengrass-CLI.

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

Die Anfrage dieses Vorgangs hat die folgenden Parameter:

`componentName`(Python:`component_name`)  
Der Name der Komponente.

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

Die Antwort dieser Operation enthält die folgenden Informationen:

`restartStatus`(Python:`restart_status`)  
Der Status der Neustartanfrage. Der Anforderungsstatus kann einer der folgenden sein:  
+ `SUCCEEDED`
+ `FAILED`

`message`  
Eine Meldung darüber, warum die Komponente nicht neu gestartet werden konnte, falls die Anfrage fehlgeschlagen ist.

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

Die folgenden Beispiele zeigen, wie dieser Vorgang in benutzerdefiniertem Komponentencode aufgerufen wird.

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

**Example Beispiel: Starten Sie eine Komponente neu**  

```
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 Beispiel: Starten Sie eine Komponente neu**  

```
#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 Beispiel: Starten Sie eine Komponente neu**  

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

Stoppt die Prozesse einer Komponente auf dem Kerngerät.

**Anmerkung**  
Sie können zwar jede Komponente beenden, wir empfehlen jedoch, nur [generische Komponenten](develop-greengrass-components.md#component-types) zu beenden.

Dieser Vorgang bietet dieselbe Funktionalität wie der [Befehl zum Stoppen der Komponente](gg-cli-component.md#component-stop) in der Greengrass-CLI.

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

Die Anfrage dieser Operation hat die folgenden Parameter:

`componentName`(Python:`component_name`)  
Der Name der Komponente.

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

Die Antwort dieser Operation enthält die folgenden Informationen:

`stopStatus`(Python:`stop_status`)  
Der Status der Stopp-Anfrage. Der Anforderungsstatus kann einer der folgenden sein:  
+ `SUCCEEDED`
+ `FAILED`

`message`  
Eine Meldung darüber, warum die Komponente nicht gestoppt werden konnte, falls die Anfrage fehlgeschlagen ist.

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

Generiert ein zufälliges Passwort, mit dem Sie sich bei der [lokalen Debug-Konsolenkomponente](local-debug-console-component.md) anmelden können. Das Passwort läuft 8 Stunden nach seiner Generierung ab.

Dieser Vorgang bietet dieselbe Funktionalität wie der [get-debug-password Befehl](gg-cli-get-debug-password.md) in der Greengrass-CLI.

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

Die Anfrage dieser Operation hat keine Parameter.

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

Die Antwort dieser Operation enthält die folgenden Informationen:

`username`  
Der Benutzername, mit dem Sie sich anmelden möchten.

`password`  
Das Passwort, mit dem Sie sich anmelden möchten.

`passwordExpiration`(Python:`password_expiration`)  
Die Zeit, zu der das Passwort abläuft.

`certificateSHA256Hash`(Python:`certificate_sha256_hash`)  
Der SHA-256-Fingerabdruck für das selbstsignierte Zertifikat, das die lokale Debug-Konsole verwendet, wenn HTTPS aktiviert ist. Verwenden Sie diesen Fingerabdruck, wenn Sie die lokale Debug-Konsole öffnen, um zu überprüfen, ob das Zertifikat legitim und die Verbindung sicher ist.

`certificateSHA1Hash`(Python:`certificate_sha1_hash`)  
Der SHA-1-Fingerabdruck für das selbstsignierte Zertifikat, das die lokale Debug-Konsole verwendet, wenn HTTPS aktiviert ist. Verwenden Sie diesen Fingerabdruck, wenn Sie die lokale Debug-Konsole öffnen, um zu überprüfen, ob das Zertifikat legitim und die Verbindung sicher ist.

# Client-Geräte authentifizieren und autorisieren
<a name="ipc-client-device-auth"></a>

**Anmerkung**  
Diese Funktion ist für Version 2.6.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar.

Verwenden Sie den IPC-Dienst für die Client-Geräteauthentifizierung, um eine benutzerdefinierte lokale Broker-Komponente zu entwickeln, mit der lokale IoT-Geräte, z. B. Client-Geräte, eine Verbindung herstellen können.

Um diese IPC-Operationen zu verwenden, fügen Sie Version 2.2.0 oder höher der Komponente für die [Client-Geräteauthentifizierung als Abhängigkeit in Ihre benutzerdefinierte Komponente](client-device-auth-component.md) ein. Anschließend können Sie IPC-Operationen in Ihren benutzerdefinierten Komponenten verwenden, um Folgendes zu tun:
+ Überprüfen Sie die Identität der Client-Geräte, die eine Verbindung zum Kerngerät herstellen.
+ Erstellen Sie eine Sitzung für ein Client-Gerät, um eine Verbindung zum Kerngerät herzustellen.
+ Überprüfen Sie, ob ein Client-Gerät berechtigt ist, eine Aktion auszuführen.
+ Sie erhalten eine Benachrichtigung, wenn das Serverzertifikat des Core-Geräts rotiert.

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

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

In der folgenden Tabelle sind die Mindestversionen von aufgeführt AWS IoT Device SDK , die Sie für die Interaktion mit dem IPC-Dienst für die Client-Geräteauthentifizierung verwenden müssen.


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

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

Um den IPC-Dienst für die Client-Geräteauthentifizierung in einer benutzerdefinierten Komponente zu verwenden, müssen Sie Autorisierungsrichtlinien definieren, die es Ihrer Komponente ermöglichen, diese Vorgänge auszuführen. Hinweise zur Definition von Autorisierungsrichtlinien finden Sie unter. [Autorisieren Sie Komponenten zur Ausführung von IPC-Vorgängen](interprocess-communication.md#ipc-authorization-policies)

Autorisierungsrichtlinien für die Authentifizierung und Autorisierung von Client-Geräten haben die folgenden Eigenschaften.

**IPC-Dienst-ID:** `aws.greengrass.clientdevices.Auth`


| Operation | Description | Ressourcen | 
| --- | --- | --- | 
|  `aws.greengrass#VerifyClientDeviceIdentity`  |  Ermöglicht einer Komponente, die Identität eines Client-Geräts zu überprüfen.  |  `*`  | 
|  `aws.greengrass#GetClientDeviceAuthToken`  |  Ermöglicht einer Komponente, die Anmeldeinformationen eines Client-Geräts zu überprüfen und eine Sitzung für dieses Client-Gerät zu erstellen.  |  `*`  | 
|  `aws.greengrass#AuthorizeClientDeviceAction`  |  Ermöglicht einer Komponente, zu überprüfen, ob ein Client-Gerät berechtigt ist, eine Aktion auszuführen.  |  `*`  | 
|  `aws.greengrass#SubscribeToCertificateUpdates`  |  Ermöglicht einer Komponente, Benachrichtigungen zu empfangen, wenn das Serverzertifikat des Kerngeräts rotiert.  |  `*`  | 
|  `*`  |  Ermöglicht einer Komponente, alle IPC-Authentifizierungsvorgänge des Client-Geräts auszuführen.  |  `*`  | 

### Beispiele für Autorisierungsrichtlinien
<a name="ipc-client-device-auth-authorization-policy-examples"></a>

Anhand des folgenden Beispiels für eine Autorisierungsrichtlinie können Sie Autorisierungsrichtlinien für Ihre Komponenten konfigurieren.

**Example Beispiel für eine Autorisierungsrichtlinie**  
Das folgende Beispiel für eine Autorisierungsrichtlinie ermöglicht es einer Komponente, alle IPC-Authentifizierungsvorgänge auf Clientgeräten durchzuführen.  

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

Überprüfen Sie die Identität eines Client-Geräts. Dieser Vorgang überprüft, ob es sich bei dem Client-Gerät um ein gültiges Gerät handelt AWS IoT .

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

Die Anfrage dieses Vorgangs hat die folgenden Parameter:

`credential`  
Die Anmeldeinformationen des Client-Geräts. Dieses Objekt,`ClientDeviceCredential`, enthält die folgenden Informationen:    
`clientDeviceCertificate`(Python:`client_device_certificate`)  
Das X.509-Gerätezertifikat des Client-Geräts.

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

Die Antwort dieses Vorgangs enthält die folgenden Informationen:

`isValidClientDevice`(Python:`is_valid_client_device`)  
Ob die Identität des Client-Geräts gültig ist.

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

Überprüft die Anmeldeinformationen eines Client-Geräts und erstellt eine Sitzung für das Client-Gerät. Dieser Vorgang gibt ein Sitzungstoken zurück, das Sie in nachfolgenden Anfragen verwenden können, um Aktionen auf dem [Client-Gerät zu autorisieren](#ipc-operation-authorizeclientdeviceaction).

Um ein Clientgerät erfolgreich zu verbinden, muss die [Authentifizierungskomponente für das Clientgerät](client-device-auth-component.md#client-device-auth-component-configuration) die `mqtt:connect` Genehmigung für die Client-ID erteilen, die das Clientgerät verwendet.

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

Die Anforderung dieses Vorgangs hat die folgenden Parameter:

`credential`  
Die Anmeldeinformationen des Client-Geräts. Dieses Objekt,`CredentialDocument`, enthält die folgenden Informationen:    
`mqttCredential`(Python:`mqtt_credential`)  
Die MQTT-Anmeldeinformationen des Client-Geräts. Geben Sie die Client-ID und das Zertifikat an, das das Client-Gerät für die Verbindung verwendet. Dieses Objekt,`MQTTCredential`, enthält die folgenden Informationen:    
`clientId`(Python:`client_id`)  
Die Client-ID, die für die Verbindung verwendet werden soll.  
`certificatePem`(Python:`certificate_pem`)  
Das X.509-Gerätezertifikat, das für die Verbindung verwendet werden soll.  
`username`  
Diese Eigenschaft wird derzeit nicht verwendet.  
`password`  
Diese Eigenschaft wird derzeit nicht verwendet.

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

Die Antwort dieses Vorgangs enthält die folgenden Informationen:

`clientDeviceAuthToken`(Python:`client_device_auth_token`)  
Das Sitzungstoken für das Client-Gerät. Sie können dieses Sitzungstoken in nachfolgenden Anfragen verwenden, um die Aktionen dieses Client-Geräts zu autorisieren.

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

Überprüfen Sie, ob ein Client-Gerät berechtigt ist, eine Aktion auf einer Ressource auszuführen. *Autorisierungsrichtlinien für Client-Geräte* spezifizieren die Berechtigungen, die Client-Geräte ausführen können, während sie mit einem Core-Gerät verbunden sind. Sie definieren Autorisierungsrichtlinien für Client-Geräte, wenn Sie die [Authentifizierungskomponente für Client-Geräte](client-device-auth-component.md#client-device-auth-component-configuration) konfigurieren.

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

Die Anfrage dieses Vorgangs hat die folgenden Parameter:

`clientDeviceAuthToken`(Python:`client_device_auth_token`)  
Das Sitzungstoken für das Client-Gerät.

`operation`  
Der zu autorisierende Vorgang.

`resource`  
Die Ressource, auf der das Client-Gerät den Vorgang ausführt.

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

Die Antwort dieses Vorgangs enthält die folgenden Informationen:

`isAuthorized`(Python:`is_authorized`)  
Ob das Client-Gerät autorisiert ist, den Vorgang auf der Ressource auszuführen.

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

Abonnieren Sie, um bei jedem Wechsel das neue Serverzertifikat des Core-Geräts zu erhalten. Wenn das Serverzertifikat rotiert, müssen die Broker das Serverzertifikat mit dem neuen Serverzertifikat neu laden.

Die [Authentifizierungskomponente für Clientgeräte](client-device-auth-component.md) rotiert die Serverzertifikate standardmäßig alle 7 Tage. Sie können das Rotationsintervall auf 2 bis 10 Tage konfigurieren.

<a name="ipc-subscribe-operation-note"></a>Bei diesem Vorgang handelt es sich um einen Abonnementvorgang, bei dem Sie einen Stream von Ereignisnachrichten abonnieren. Um diese Operation zu verwenden, definieren Sie einen Stream-Response-Handler mit Funktionen, die Ereignismeldungen, Fehler und das Schließen von Streams behandeln. Weitere Informationen finden Sie unter [Abonnieren Sie IPC-Event-Streams](interprocess-communication.md#ipc-subscribe-operations).

**Typ der Ereignisnachricht:** `CertificateUpdateEvent`

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

Die Anforderung dieses Vorgangs hat die folgenden Parameter:

`certificateOptions`(Python:`certificate_options`)  
Die Arten von Zertifikatsupdates, die abonniert werden sollen. Dieses Objekt,`CertificateOptions`, enthält die folgenden Informationen:    
`certificateType`(Python:`certificate_type`)  
Die Art der Zertifikatsupdates, die abonniert werden sollen. Wählen Sie die folgende Option:  
+ `SERVER`

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

Die Antwort dieses Vorgangs enthält die folgenden Informationen:

`messages`  
Der Nachrichtenstrom. Dieses Objekt,`CertificateUpdateEvent`, enthält die folgenden Informationen:    
`certificateUpdate`(Python:`certificate_update`)  
Die Informationen über das neue Zertifikat. Dieses Objekt,`CertificateUpdate`, enthält die folgenden Informationen:    
`certificate`  
Das Zertifikat.  
`privateKey`(Python:`private_key`)  
Der private Schlüssel des Zertifikats.  
`publicKey`(Python:`public_key`)  
Der öffentliche Schlüssel des Zertifikats.  
`caCertificates`(Python:`ca_certificates`)  
Die Liste der Zertifizierungsstellenzertifikate (CA) in der CA-Zertifikatskette des Zertifikats.