Hinweis zum Ende des Supports: Am 7. Oktober 2026 AWS wird der Support für eingestellt. AWS IoT Greengrass Version 1 Nach dem 7. Oktober 2026 können Sie nicht mehr auf die Ressourcen zugreifen. AWS IoT Greengrass V1 Weitere Informationen finden Sie unter [Migrieren von AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).
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.
# Datenströme auf dem AWS IoT Greengrass Core verwalten
AWS IoT Greengrass Stream Manager macht es einfacher und zuverlässiger, großvolumige IoT-Daten auf den AWS Cloud zu übertragen. Stream Manager verarbeitet Datenströme lokal und exportiert sie AWS Cloud automatisch in die. Diese Funktion lässt sich in gängige Szenarien wie maschinelles Lernen (ML) -Inferenz integrieren, bei der Daten lokal verarbeitet und analysiert werden, bevor sie an die AWS Cloud oder an lokale Speicherziele exportiert werden.
Der Stream-Manager vereinfacht die Anwendungsentwicklung. Ihre IoT-Anwendungen können einen standardisierten Mechanismus verwenden, um Datenstreams mit hohem Volumen zu verarbeiten und lokale Datenaufbewahrungsrichtlinien zu verwalten, anstatt benutzerdefinierte Funktionen für die Verwaltung von Streams zu erstellen. IoT-Anwendungen können Streams lesen und darin schreiben. Sie können Richtlinien für Speichertyp, Größe und Datenaufbewahrung pro Stream definieren, um zu steuern, wie der Stream-Manager Streams verarbeitet und exportiert.
Der Stream-Manager ist für den Einsatz in Umgebungen mit intermittierender oder eingeschränkter Konnektivität konzipiert. Sie können die Bandbreitenverwendung, das Timeoutverhalten und die Verarbeitung von Streamdaten definieren, wenn der Core verbunden oder getrennt ist. Für kritische Daten können Sie Prioritäten festlegen, um die Reihenfolge zu steuern, in der Streams in die AWS Cloud exportiert werden.
Sie können automatische Exporte in die zur Speicherung oder AWS Cloud zur weiteren Verarbeitung und Analyse konfigurieren. Stream Manager unterstützt den Export in die folgenden AWS Cloud Ziele.
+ Kanäle rein AWS IoT Analytics. AWS IoT Analytics ermöglicht es Ihnen, erweiterte Analysen Ihrer Daten durchzuführen, um Geschäftsentscheidungen zu treffen und Modelle für maschinelles Lernen zu verbessern. Weitere Informationen finden Sie unter [Was ist AWS IoT Analytics?](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) im *AWS IoT Analytics Benutzerhandbuch*.
+ Streams in Kinesis Data Streams. Kinesis Data Streams wird häufig verwendet, um große Datenmengen zu aggregieren und sie in ein Data Warehouse oder einen Map-Reduce-Cluster zu laden. Weitere Informationen finden Sie unter [Was ist Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/what-is-this-service.html)? im *Amazon Kinesis Developer Guide*.
+ Eigenschaften von Vermögenswerten in AWS IoT SiteWise. AWS IoT SiteWise ermöglicht das Sammeln, Organisieren und Analysieren von Daten aus Industrieanlagen in großem Maßstab. Weitere Informationen finden Sie unter [Was ist AWS IoT SiteWise?](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html) im *AWS IoT SiteWise Benutzerhandbuch*.
+ Objekte in Amazon S3. Sie können Amazon S3 verwenden, um große Datenmengen zu speichern und abzurufen. Weitere Informationen finden Sie unter [Was ist Amazon S3?](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html) im *Amazon Simple Storage Service Developer Guide*.
## Stream-Management-Workflow
Ihre IoT-Anwendungen interagieren über das AWS IoT Greengrass Core SDK mit dem Stream Manager. In einem einfachen Workflow verarbeitet eine benutzerdefinierte Lambda-Funktion, die auf dem Greengrass-Kern ausgeführt wird, IoT-Daten wie Temperatur- und Druckmesswerte in Zeitreihen. Die Lambda-Funktion könnte die Daten filtern oder komprimieren und dann das AWS IoT Greengrass Core SDK aufrufen, um die Daten in einen Stream im Stream Manager zu schreiben. Der Stream-Manager kann den Stream auf der Grundlage der für den Stream definierten Richtlinien AWS Cloud automatisch in den exportieren. Benutzerdefinierte Lambda-Funktionen können Daten auch direkt an lokale Datenbanken oder Speicher-Repositorys senden.
Ihre IoT-Anwendungen können mehrere benutzerdefinierte Lambda-Funktionen enthalten, die Streams lesen oder in sie schreiben. Diese lokalen Lambda-Funktionen können Streams lesen und in sie schreiben, um Daten lokal zu filtern, zu aggregieren und zu analysieren. Dies ermöglicht es, schnell auf lokale Ereignisse zu reagieren und wertvolle Informationen zu extrahieren, bevor die Daten vom Core in die Cloud oder lokale Ziele übertragen werden.
Ein Beispielworkflow ist im folgenden Diagramm dargestellt.
![\[Diagramm des Stream-Manager-Workflows.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/stream-manager-architecture.png)
Um Stream Manager zu verwenden, konfigurieren Sie zunächst die Stream-Manager-Parameter, um Laufzeiteinstellungen auf Gruppenebene zu definieren, die für alle Streams auf dem Greengrass-Kern gelten. Mit diesen anpassbaren Einstellungen können Sie steuern, wie Stream Manager Streams speichert, verarbeitet und exportiert, basierend auf Ihren Geschäftsanforderungen und Umgebungsbeschränkungen. Weitere Informationen finden Sie unter [AWS IoT Greengrass Streammanager konfigurieren](configure-stream-manager.md).
Nachdem Sie den Stream Manager konfiguriert haben, können Sie Ihre IoT-Anwendungen erstellen und bereitstellen. Dies sind in der Regel benutzerdefinierte Lambda-Funktionen, die `StreamManagerClient` im AWS IoT Greengrass Core SDK verwendet werden, um Streams zu erstellen und mit ihnen zu interagieren. Während der Stream-Erstellung definiert die Lambda-Funktion Richtlinien pro Stream, wie Exportziele, Priorität und Persistenz. Weitere Informationen, einschließlich Codeausschnitten für Operationen, finden Sie unter. `StreamManagerClient` [Wird verwendet StreamManagerClient , um mit Streams zu arbeiten](work-with-streams.md)
Tutorials zur Konfiguration eines einfachen Workflows finden Sie unter [Datenströme in die AWS Cloud (Konsole) exportieren](stream-manager-console.md) oder. [Datenströme in die AWS Cloud (CLI) exportieren](stream-manager-cli.md)
## Voraussetzungen
Die folgenden Anforderungen gelten für die Verwendung von Stream Manager:
+ Sie müssen die AWS IoT Greengrass Core-Software v1.10 oder höher mit aktiviertem Stream Manager verwenden. Weitere Informationen finden Sie unter [AWS IoT Greengrass Streammanager konfigurieren](configure-stream-manager.md).
Stream Manager wird auf OpenWrt Distributionen nicht unterstützt.
+ Die Java 8-Laufzeitumgebung (JDK 8) muss auf dem Core installiert sein.
+ Führen Sie für Debian-basierte Distributionen (einschließlich Raspbian) oder Ubuntu-basierte Distributionen den folgenden Befehl aus:
```
sudo apt install openjdk-8-jdk
```
+ Führen Sie für Red Hat-basierte Distributionen (einschließlich Amazon Linux) den folgenden Befehl aus:
```
sudo yum install java-1.8.0-openjdk
```
Weitere Informationen finden Sie unter [How to download and install prebuilt OpenJDK packages](https://openjdk.java.net/install/) in der OpenJDK-Dokumentation.
+ Stream Manager benötigt zusätzlich zu Ihrer Basissoftware AWS IoT Greengrass Core mindestens 70 MB RAM. Ihr gesamter Speicherbedarf hängt von Ihrer Arbeitslast ab.
+ Benutzerdefinierte Lambda-Funktionen müssen das [AWS IoT Greengrass Core SDK](lambda-functions.md#lambda-sdks-core) verwenden, um mit dem Stream Manager zu interagieren. Das AWS IoT Greengrass Core SDK ist in mehreren Sprachen verfügbar, aber nur die folgenden Versionen unterstützen Stream Manager-Operationen:
+ Java SDK (v1.4.0 oder höher)
+ Python SDK (v1.5.0 oder höher)
+ Node.js SDK (v1.6.0 oder höher)
Laden Sie die Version des SDK herunter, die Ihrer Lambda-Funktionslaufzeit entspricht, und nehmen Sie sie in Ihr Lambda-Funktionsbereitstellungspaket auf.
**Anmerkung**
Das AWS IoT Greengrass Core SDK für Python benötigt Python 3.7 oder höher und hat andere Paketabhängigkeiten. Weitere Informationen finden Sie unter [Erstellen eines Lambda-Funktionsbereitstellungspakets (Konsole)](stream-manager-console.md#stream-manager-console-create-deployment-package) oder [Erstellen eines Lambda-Funktionsbereitstellungspakets (CLI](stream-manager-cli.md#stream-manager-cli-create-deployment-package)).
+ Wenn Sie AWS Cloud Exportziele für einen Stream definieren, müssen Sie Ihre Exportziele erstellen und Zugriffsberechtigungen in der Greengrass-Gruppenrolle gewähren. Je nach Ziel können auch andere Anforderungen gelten. Weitere Informationen finden Sie unter:
+ [AWS IoT Analytics Kanäle](stream-export-configurations.md#export-to-iot-analytics)
+ [Amazon Kinesis Kinesis-Datenströme](stream-export-configurations.md#export-to-kinesis)
+ [AWS IoT SiteWise Eigenschaften von Vermögenswerten](stream-export-configurations.md#export-to-iot-sitewise)
+ [Amazon-S3-Objekte](stream-export-configurations.md#export-to-s3)
Sie sind für die Wartung dieser AWS Cloud Ressourcen verantwortlich.
## Datensicherheit
Beachten Sie bei der Verwendung des Stream-Managers die folgenden Sicherheitsüberlegungen.
### Lokale Datensicherheit
AWS IoT Greengrass verschlüsselt keine Stream-Daten im Ruhezustand oder bei der lokalen Übertragung zwischen Komponenten auf dem Kerngerät.
+ **Daten im Ruhezustand**. Stream-Daten werden lokal in einem Speicherverzeichnis auf dem Greengrass-Kern gespeichert. Verlässt sich aus Gründen der AWS IoT Greengrass Datensicherheit auf Unix-Dateiberechtigungen und vollständige Festplattenverschlüsselung, sofern aktiviert. Sie können den optionalen Parameter [STREAM\$1MANAGER\$1STORE\$1ROOT\$1DIR](configure-stream-manager.md#STREAM_MANAGER_STORE_ROOT_DIR) verwenden, um das Speicherverzeichnis anzugeben. Wenn Sie diesen Parameter später ändern, um ein anderes Speicherverzeichnis zu verwenden, werden das vorherige Speicherverzeichnis und sein Inhalt AWS IoT Greengrass nicht gelöscht.
+ **Daten werden lokal übertragen**. AWS IoT Greengrass verschlüsselt keine Stream-Daten bei der lokalen Übertragung auf dem Core zwischen Datenquellen, Lambda-Funktionen, dem AWS IoT Greengrass Core SDK und dem Stream Manager.
+ **Daten bei der Übertragung zum. AWS Cloud** Datenströme, die vom Stream Manager exportiert werden, AWS Cloud verwenden die standardmäßige AWS Service-Client-Verschlüsselung mit Transport Layer Security (TLS).
Weitere Informationen finden Sie unter [Datenverschlüsselung](data-encryption.md).
### Client-Authentifizierung
Stream Manager-Clients verwenden das AWS IoT Greengrass Core SDK, um mit dem Stream Manager zu kommunizieren. Wenn die Client-Authentifizierung aktiviert ist, können nur Lambda-Funktionen in der Greengrass-Gruppe mit Streams im Stream Manager interagieren. Wenn die Clientauthentifizierung deaktiviert ist, kann jeder auf dem Greengrass Core ausgeführte Prozess (z. B. [Docker-Container](docker-app-connector.md)) mit Streams im Stream-Manager interagieren. Sie sollten die Authentifizierung nur deaktivieren, wenn Ihr Geschäftsfall dies erfordert.
Sie verwenden den Parameter [STREAM\$1MANAGER\$1AUTHENTICATE\$1CLIENT](configure-stream-manager.md#STREAM_MANAGER_AUTHENTICATE_CLIENT), um den Clientauthentifizierungsmodus festzulegen. Sie können diesen Parameter über die Konsole oder AWS IoT Greengrass API konfigurieren. Änderungen werden wirksam, nachdem die Gruppe bereitgestellt wurde.
****
| | Enabled | Disabled |
| --- | --- | --- |
| Parameterwert | `true` (Standard und empfohlen) | `false` |
| Zulässige Clients | Benutzerdefinierte Lambda-Funktionen in der Greengrass-Gruppe | Benutzerdefinierte Lambda-Funktionen in der Greengrass-Gruppe Andere Prozesse, die auf dem Greengrass Core-Gerät ausgeführt werden |
## Weitere Informationen finden Sie auch unter
+ [AWS IoT Greengrass Streammanager konfigurieren](configure-stream-manager.md)
+ [Wird verwendet StreamManagerClient , um mit Streams zu arbeiten](work-with-streams.md)
+ [Konfigurationen für unterstützte AWS Cloud Ziele exportieren](stream-export-configurations.md)
+ [Datenströme in die AWS Cloud (Konsole) exportieren](stream-manager-console.md)
+ [Datenströme in die AWS Cloud (CLI) exportieren](stream-manager-cli.md)
# AWS IoT Greengrass Streammanager konfigurieren
Im AWS IoT Greengrass Kern kann Stream Manager IoT-Gerätedaten speichern, verarbeiten und exportieren. Der Stream-Manager stellt Parameter bereit, die Sie zum Konfigurieren von Laufzeiteinstellungen auf Gruppenebene verwenden. Diese Einstellungen gelten für alle Streams auf dem Greengrass-Core. Sie können die AWS IoT Konsole oder AWS IoT Greengrass API verwenden, um die Stream Manager-Einstellungen zu konfigurieren. Änderungen werden wirksam, nachdem die Gruppe bereitgestellt wurde.
**Anmerkung**
Nachdem Sie den Stream Manager konfiguriert haben, können Sie IoT-Anwendungen erstellen und bereitstellen, die auf dem Greengrass-Kern ausgeführt werden und mit dem Stream Manager interagieren. Bei diesen IoT-Anwendungen handelt es sich in der Regel um benutzerdefinierte Lambda-Funktionen. Weitere Informationen finden Sie unter [Wird verwendet StreamManagerClient , um mit Streams zu arbeiten](work-with-streams.md).
## Stream-Manager-Parameter
Der Stream-Manager stellt die folgenden Parameter bereit, mit denen Sie Einstellungen auf Gruppenebene definieren können. Alle Parameter sind optional.
**Speicherverzeichnis**
Parametername: `STREAM_MANAGER_STORE_ROOT_DIR`
Der absolute Pfad des lokalen Verzeichnisses, das zum Speichern von Streams verwendet wird. Dieser Wert muss mit einem Schrägstrich (z. B. `/data`) beginnen.
Hinweise zum Sichern von Streamdaten finden Sie unter [Lokale Datensicherheit](stream-manager.md#stream-manager-security-stream-data).
Minimale AWS IoT Greengrass Kernversion: 1.10.0
**Server port**
Parametername: `STREAM_MANAGER_SERVER_PORT`
Die lokale Portnummer, die für die Kommunikation mit dem Stream-Manager verwendet wird. Der Standardwert ist `8088`.
Minimale AWS IoT Greengrass Kernversion: 1.10.0
**Client authentifizieren**
Parametername: `STREAM_MANAGER_AUTHENTICATE_CLIENT`
Gibt an, ob Clients authentifiziert werden müssen, um mit dem Stream-Manager zu interagieren. Die gesamte Interaktion zwischen Clients und Stream Manager wird vom AWS IoT Greengrass Core SDK gesteuert. Dieser Parameter bestimmt, welche Clients das AWS IoT Greengrass Core SDK aufrufen können, um mit Streams zu arbeiten. Weitere Informationen finden Sie unter [Client-Authentifizierung](stream-manager.md#stream-manager-security-client-authentication).
Gültige Werte sind `true` oder `false`. Der Standardwert ist `true` (empfohlen).
+ `true`. Erlaubt nur Greengrass Lambda-Funktionen als Clients. Lambda-Funktionsclients verwenden interne AWS IoT Greengrass Kernprotokolle, um sich beim AWS IoT Greengrass Core SDK zu authentifizieren.
+ `false`. Ermöglicht es jedem Prozess, der auf dem AWS IoT Greengrass Core läuft, ein Client zu sein. Setzen Sie diese Einstellung nicht auf `false`, es sei denn, Ihr Geschäftsfall erfordert dies. Legen Sie diesen Wert beispielsweise `false` nur dann fest, wenn Nicht-Lambda-Prozesse auf dem Core-Gerät direkt mit dem Stream-Manager kommunizieren müssen, z. B. [Docker-Container](docker-app-connector.md), die auf dem Core ausgeführt werden.
Minimale AWS IoT Greengrass Core-Version: 1.10.0
**Maximale Bandbreite**
Parametername: `STREAM_MANAGER_EXPORTER_MAX_BANDWIDTH`
Die durchschnittliche maximale Bandbreite (in Kilobit pro Sekunde), die zum Exportieren von Daten verwendet werden kann. Die Standardeinstellung erlaubt die unbegrenzte Nutzung der verfügbaren Bandbreite.
Minimale AWS IoT Greengrass Kernversion: 1.10.0
**Größe des Threadpools**
Parametername: `STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE`
Die maximale Anzahl der aktiven Threads, die zum Exportieren von Daten verwendet werden können. Der Standardwert ist `5`.
Die optimale Größe hängt von der Hardware, dem Stream-Volume und der geplanten Anzahl der Exportstreams ab. Wenn die Exportgeschwindigkeit langsam ist, können Sie diese Einstellung anpassen, um die optimale Größe für Ihre Hardware und Ihren Geschäftsfall zu ermitteln. Die CPU und der Arbeitsspeicher Ihrer Core-Geräte-Hardware sind begrenzende Faktoren. Um zu starten, können Sie versuchen, diesen Wert gleich der Anzahl der Prozessorkerne auf dem Gerät festzulegen.
Achten Sie darauf, keine Größe festzulegen, die höher ist, als Ihre Hardware unterstützen kann. Jeder Stream verbraucht Hardwareressourcen, daher sollten Sie versuchen, die Anzahl der Exportstreams auf eingeschränkten Geräten zu begrenzen.
Minimale AWS IoT Greengrass Kernversion: 1.10.0
**JVM-Argumente**
Parametername: `JVM_ARGS`
Benutzerdefinierte Java Virtual Machine-Argumente, die beim Start an den Stream-Manager übergeben werden. Mehrere Argumente sollten durch Leerzeichen getrennt werden.
Verwenden Sie diesen Parameter nur, wenn Sie die von der JVM verwendeten Standardeinstellungen außer Kraft setzen müssen. Beispielsweise müssen Sie möglicherweise die Standard-Heap-Größe erhöhen, wenn Sie eine große Anzahl von Streams exportieren möchten.
Minimale AWS IoT Greengrass Kernversion: 1.10.0
**Schreibgeschützte Eingabedateiverzeichnisse**
Parametername: `STREAM_MANAGER_READ_ONLY_DIRS`
Eine durch Kommas getrennte Liste absoluter Pfade zu den Verzeichnissen außerhalb des Root-Dateisystems, in denen Eingabedateien gespeichert sind. Stream Manager liest und lädt die Dateien auf Amazon S3 hoch und mountet die Verzeichnisse schreibgeschützt. Weitere Informationen zum Exportieren nach Amazon S3 finden Sie unter[Amazon-S3-Objekte](stream-export-configurations.md#export-to-s3).
Verwenden Sie diesen Parameter nur, wenn die folgenden Bedingungen zutreffen:
+ Das Eingabedateiverzeichnis für einen Stream, der nach Amazon S3 exportiert wird, befindet sich an einem der folgenden Speicherorte:
+ Eine andere Partition als das Root-Dateisystem.
+ Unter `/tmp` im Root-Dateisystem.
+ **Die [Standardcontainerisierung](lambda-group-config.md#lambda-containerization-groupsettings) der Greengrass-Gruppe ist Greengrass-Container.**
Beispielwert: `/mnt/directory-1,/mnt/directory-2,/tmp`
Minimale Kernversion AWS IoT Greengrass : 1.11.0
**Mindestgröße für mehrteiligen Upload**
Parametername: `STREAM_MANAGER_EXPORTER_S3_DESTINATION_MULTIPART_UPLOAD_MIN_PART_SIZE_BYTES`
Die Mindestgröße (in Byte) eines Teils in einem mehrteiligen Upload auf Amazon S3. Stream Manager verwendet diese Einstellung und die Größe der Eingabedatei, um zu bestimmen, wie Daten in einer mehrteiligen PUT-Anfrage gebündelt werden. Der Standard- und Mindestwert ist `5242880` Byte (5 MB).
Stream Manager verwendet die `sizeThresholdForMultipartUploadBytes` Eigenschaft des Streams, um zu bestimmen, ob ein- oder mehrteiliger Upload nach Amazon S3 exportiert werden soll. Benutzerdefinierte Lambda-Funktionen legen diesen Schwellenwert fest, wenn sie einen Stream erstellen, der nach Amazon S3 exportiert wird. Der Standardschwellenwert ist 5 MB.
Minimale AWS IoT Greengrass Core-Version: 1.11.0
## Konfigurieren der Stream-Manager-Einstellungen (Konsole)
Sie können die AWS IoT Konsole für die folgenden Verwaltungsaufgaben verwenden:
+ [Überprüfen, ob der Stream-Manager aktiviert ist](#check-stream-manager-console)
+ [Aktivieren oder Deaktivieren des Stream-Managers während der Gruppenerstellung](#enable-stream-manager-console-new-group)
+ [Aktivieren oder Deaktivieren des Stream-Managers für eine vorhandene Gruppe](#enable-stream-manager-console-existing-group)
+ [Ändern der Einstellungen für den Stream Manager](#change-stream-manager-console)
Änderungen werden wirksam, nachdem die Greengrass-Gruppe bereitgestellt wurde. Ein Tutorial, das zeigt, wie Sie eine Greengrass-Gruppe bereitstellen, die eine Lambda-Funktion enthält, die mit dem Stream-Manager interagiert, finden Sie unter. [Datenströme in die AWS Cloud (Konsole) exportieren](stream-manager-console.md)
**Anmerkung**
Wenn Sie die Konsole verwenden, um den Stream Manager zu aktivieren und die Gruppe bereitzustellen, ist die Speichergröße für den Stream Manager standardmäßig auf 4194304 KB (4 GB) festgelegt. Wir empfehlen, die Speichergröße auf mindestens 128000 KB festzulegen.
### So prüfen Sie, ob der Stream-Manager aktiviert ist (Konsole)
1. Erweitern Sie im Navigationsbereich der AWS IoT Konsole unter **Verwalten** die Option **Greengrass-Geräte** und wählen Sie dann **Gruppen (V1)** aus.
1. Wählen Sie die Zielgruppe aus.
1. Wählen Sie die **Registerkarte Lambda-Funktionen**.
1. Wählen Sie unter **System Lambda-Funktionen** die Option **Stream Manager** und dann **Bearbeiten** aus.
1. Überprüfen Sie den Status „Aktiviert“ oder „Deaktiviert“. Alle konfigurierten benutzerdefinierten Stream-Manager-Einstellungen werden ebenfalls angezeigt.
### So aktivieren oder deaktivieren Sie den Stream-Manager während der Gruppenerstellung (Konsole)
1. Erweitern Sie im Navigationsbereich der AWS IoT Konsole unter **Verwalten** die Option **Greengrass-Geräte** und wählen Sie dann **Gruppen (V1)** aus.
1. Wählen Sie **Create Group**. Ihre Auswahl auf der nächsten Seite bestimmt, wie Sie den Stream-Manager für die Gruppe konfigurieren.
1. Gehen Sie unter **Name your Group** weiter und wählen Sie eine **Greengrass-Kernseite** aus.
1. Wählen Sie **Create group** (Gruppe erstellen) aus.
1. Wählen Sie auf der Gruppenkonfigurationsseite die Registerkarte **Lambda-Funktionen**, wählen Sie **Stream Manager** und dann **Bearbeiten** aus.
+ Um den Stream-Manager mit Standardeinstellungen zu aktivieren, wählen Sie **Mit Standardeinstellungen aktivieren**.
+ Um den Stream-Manager mit benutzerdefinierten Einstellungen zu aktivieren, wählen Sie **Einstellungen anpassen** aus.
1. Wählen Sie auf der Seite **Stream Manager konfigurieren** die Option **Mit benutzerdefinierten Einstellungen aktivieren** aus.
1. Geben Sie unter **Benutzerdefinierte Einstellungen** Werte für Stream-Manager-Parameter ein. Weitere Informationen finden Sie unter [Stream-Manager-Parameter](#stream-manager-parameters). Lassen Sie die Felder leer, AWS IoT Greengrass damit ihre Standardwerte verwendet werden können.
+ Um den Stream-Manager zu deaktivieren, wählen Sie **Disable**.
1. Wählen Sie auf der Seite **Stream-Manager konfigurieren** die Option **Deaktivieren** aus.
1. Wählen Sie **Speichern**.
1. Fahren Sie mit den verbleibenden Seiten fort, um Ihre Gruppe zu erstellen.
1. Laden Sie auf der Seite **Client-Geräte** Ihre Sicherheitsressourcen herunter, überprüfen Sie die Informationen und klicken Sie dann auf **Fertig stellen**.
**Anmerkung**
Wenn der Stream-Manager aktiviert ist, müssen Sie [die Java 8-Laufzeitumgebung](stream-manager.md#stream-manager-requirements) auf dem Core-Gerät installieren, bevor Sie die Gruppe bereitstellen.
### So aktivieren oder deaktivieren Sie den Stream-Manager für eine vorhandene Gruppe (Konsole)
1. Erweitern Sie im Navigationsbereich der AWS IoT Konsole unter **Verwalten** die Option **Greengrass-Geräte** und wählen Sie dann **Gruppen (V1)** aus.
1. Wählen Sie die Zielgruppe aus.
1. Wählen Sie die **Registerkarte Lambda-Funktionen**.
1. Wählen Sie unter **System Lambda-Funktionen** die Option **Stream Manager** und dann **Bearbeiten** aus.
1. Überprüfen Sie den Status „Aktiviert“ oder „Deaktiviert“. Alle konfigurierten benutzerdefinierten Stream-Manager-Einstellungen werden ebenfalls angezeigt.
### So ändern Sie die Einstellungen des Stream-Managers (Konsole)
1. Erweitern Sie im Navigationsbereich der AWS IoT Konsole unter **Verwalten** die Option **Greengrass-Geräte** und wählen Sie dann **Gruppen (V1)** aus.
1. Wählen Sie die Zielgruppe aus.
1. Wählen Sie die **Registerkarte Lambda-Funktionen**.
1. Wählen Sie unter **System Lambda-Funktionen** die Option **Stream Manager** und dann **Bearbeiten** aus.
1. Überprüfen Sie den Status „Aktiviert“ oder „Deaktiviert“. Alle konfigurierten benutzerdefinierten Stream-Manager-Einstellungen werden ebenfalls angezeigt.
1. Wählen Sie **Speichern**.
## Konfigurieren der Stream Manager-Einstellungen (CLI)
Verwenden Sie in der die AWS CLI`GGStreamManager` Lambda-Funktion des Systems, um den Stream-Manager zu konfigurieren. System-Lambda-Funktionen sind Bestandteile der AWS IoT Greengrass Core-Software. Für Stream Manager und einige andere Lambda-Systemfunktionen können Sie die Greengrass-Funktionalität konfigurieren, indem Sie die entsprechenden `Function` `FunctionDefinitionVersion` AND-Objekte in der Greengrass-Gruppe verwalten. Weitere Informationen finden Sie unter [Überblick über das AWS IoT Greengrass Gruppenobjektmodell](deployments.md#api-overview).
Sie können die API für die folgenden Verwaltungsaufgaben verwenden. Die Beispiele in diesem Abschnitt zeigen, wie Sie die verwenden AWS CLI, aber Sie können die AWS IoT Greengrass API auch direkt aufrufen oder ein AWS SDK verwenden.
+ [Überprüfen, ob der Stream-Manager aktiviert ist](#check-stream-manager-cli)
+ [Aktivieren, deaktivieren oder konfigurieren Sie den Stream Manager](#enable-stream-manager-cli)
Änderungen werden wirksam, nachdem die Gruppe bereitgestellt wurde. Ein Tutorial, das zeigt, wie Sie eine Greengrass-Gruppe mit einer Lambda-Funktion bereitstellen, die mit dem Stream-Manager interagiert, finden Sie unter. [Datenströme in die AWS Cloud (CLI) exportieren](stream-manager-cli.md)
**Tipp**
Um zu sehen, ob der Stream-Manager aktiviert ist und von Ihrem Kerngerät aus ausgeführt wird, können Sie den folgenden Befehl in einem Terminal auf dem Gerät ausführen.
```
ps aux | grep -i 'streammanager'
```
### So prüfen Sie, ob der Stream-Manager aktiviert ist (CLI)
Stream Manager ist aktiviert, wenn Ihre bereitgestellte Funktionsdefinitionsversion die `GGStreamManager` Lambda-Funktion des Systems enthält. Zur Überprüfung gehen Sie folgendermaßen vor:
1. Rufen Sie IDs die Greengrass-Zielgruppe und die Gruppenversion ab. Bei diesem Verfahren wird davon ausgegangen, dass es sich um die neueste Gruppen- und Gruppenversion handelt. Die folgende Abfrage gibt die zuletzt erstellte Gruppe zurück.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
Sie können auch nach Namen abfragen. Gruppennamen müssen nicht eindeutig sein, sodass mehrere Gruppen zurückgegeben werden können.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**Anmerkung**
Sie können diese Werte auch in der AWS IoT Konsole finden. Die Gruppen-ID wird auf der Seite **Einstellungen** der Gruppe angezeigt. Die Gruppenversion IDs wird auf der Registerkarte **Bereitstellungen** der Gruppe angezeigt.
1. Kopieren Sie die `LatestVersion`Werte und `Id` aus der Zielgruppe in die Ausgabe.
1. Rufen Sie die neueste Gruppenversion ab.
+ Ersetzen Sie *group-id* durch den `Id`, den Sie kopiert haben.
+ Ersetzen Sie *latest-group-version-id* durch den `LatestVersion`, den Sie kopiert haben.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. Rufen Sie aus `FunctionDefinitionVersionArn` der Ausgabe die Version IDs der Funktionsdefinition und der Funktionsdefinition ab.
+ Die Funktionsdefinitions-ID ist die GUID, die dem `functions` Segment im Amazon-Ressourcennamen (ARN) folgt.
+ Die ID der Funktionsdefinitionsversion ist die GUID, die dem `versions`-Segment im ARN folgt.
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/function-definition-id/versions/function-definition-version-id
```
1. Rufen Sie die ID der Funktionsdefinitionsversion ab.
+ Ersetzen Sie *function-definition-id* durch die Funktionsdefinitions-ID.
+ *function-definition-version-id*Ersetzen Sie durch die Versions-ID der Funktionsdefinition.
```
aws greengrass get-function-definition-version \
--function-definition-id function-definition-id \
--function-definition-version-id function-definition-version-id
```
Wenn das `functions`-Array in der Ausgabe die `GGStreamManager`-Funktion enthält, ist der Stream-Manager aktiviert. Alle Umgebungsvariablen, die für die Funktion definiert sind, stellen benutzerdefinierte Einstellungen für den Stream-Manager dar.
### Um den Stream Manager (CLI) zu aktivieren, zu deaktivieren oder zu konfigurieren
Verwenden Sie in der die AWS CLI`GGStreamManager` Lambda-Funktion des Systems, um den Stream-Manager zu konfigurieren. Änderungen werden wirksam, nachdem Sie die Gruppe bereitgestellt haben.
+ Um den Stream-Manager zu aktivieren, schließen Sie `GGStreamManager` in das `functions`-Array Ihrer Funktionsdefinitionsversion ein. Um benutzerdefinierte Einstellungen zu konfigurieren, definieren Sie Umgebungsvariablen für die entsprechenden [Stream-Manager-Parameter](#stream-manager-parameters).
+ Um den Stream-Manager zu deaktivieren, entfernen Sie `GGStreamManager` aus dem `functions`-Array Ihrer Funktionsdefinitionsversion.
**Stream-Manager mit Standardeinstellungen**
Die folgende Beispielkonfiguration aktiviert den Stream-Manager mit Standardeinstellungen. Sie setzt die beliebige Funktions-ID auf `streamManager`.
```
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
}
```
Was die `FunctionConfiguration` Eigenschaften angeht, wissen Sie vielleicht Folgendes:
+ `MemorySize`ist mit den Standardeinstellungen auf 4194304 KB (4 GB) eingestellt. Sie können diesen Wert jederzeit ändern. Wir empfehlen, dass Sie einen `MemorySize` Wert von mindestens 128000 KB angeben.
+ muss `Pinned` auf `true` festgelegt sein.
+ `Timeout` ist für die Funktionsdefinitionsversion erforderlich, wird vom `GGStreamManager` jedoch nicht verwendet.
**Stream-Manager mit benutzerdefinierten Einstellungen**
Die folgende Beispielkonfiguration aktiviert Stream Manager mit benutzerdefinierten Werten für die Parameter Speicherverzeichnis, Serverport und Threadpool-Größe.
```
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"Environment": {
"Variables": {
"STREAM_MANAGER_STORE_ROOT_DIR": "/data",
"STREAM_MANAGER_SERVER_PORT": "1234",
"STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE": "4"
}
},
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
}
```
AWS IoT Greengrass verwendet Standardwerte für [Stream-Manager-Parameter](#stream-manager-parameters), die nicht als Umgebungsvariablen angegeben sind.
**Stream-Manager mit benutzerdefinierten Einstellungen für Amazon S3 S3-Exporte**
Die folgende Beispielkonfiguration aktiviert den Stream-Manager mit benutzerdefinierten Werten für das Upload-Verzeichnis und Mindestparametern für die Größe mehrteiliger Uploads.
```
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"Environment": {
"Variables": {
"STREAM_MANAGER_READ_ONLY_DIRS": "/mnt/directory-1,/mnt/directory-2,/tmp",
"STREAM_MANAGER_EXPORTER_S3_DESTINATION_MULTIPART_UPLOAD_MIN_PART_SIZE_BYTES": "10485760"
}
},
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
}
```
**Um den Stream Manager (CLI) zu aktivieren, zu deaktivieren oder zu konfigurieren**
1. Rufen Sie IDs die Greengrass-Zielgruppe und die Gruppenversion ab. Bei diesem Verfahren wird davon ausgegangen, dass es sich um die neueste Gruppen- und Gruppenversion handelt. Die folgende Abfrage gibt die zuletzt erstellte Gruppe zurück.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
Sie können auch nach Namen abfragen. Gruppennamen müssen nicht eindeutig sein, sodass mehrere Gruppen zurückgegeben werden können.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**Anmerkung**
Sie können diese Werte auch in der AWS IoT Konsole finden. Die Gruppen-ID wird auf der Seite **Einstellungen** der Gruppe angezeigt. Die Gruppenversion IDs wird auf der Registerkarte **Bereitstellungen** der Gruppe angezeigt.
1. Kopieren Sie die `LatestVersion`Werte und `Id` aus der Zielgruppe in die Ausgabe.
1. Rufen Sie die neueste Gruppenversion ab.
+ Ersetzen Sie *group-id* durch den `Id`, den Sie kopiert haben.
+ Ersetzen Sie *latest-group-version-id* durch den `LatestVersion`, den Sie kopiert haben.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. Kopieren Sie die `CoreDefinitionVersionArn` und alle anderen Versionen ARNs aus der Ausgabe, außer`FunctionDefinitionVersionArn`. Sie verwenden diese Werte später, wenn Sie eine Gruppenversion erstellen.
1. Kopieren Sie die ID der Funktionsdefinition aus `FunctionDefinitionVersionArn`. Die ID ist die GUID, die dem `functions`-Segment im ARN folgt, wie im folgenden Beispiel gezeigt.
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/bcfc6b49-beb0-4396-b703-6dEXAMPLEcu5/versions/0f7337b4-922b-45c5-856f-1aEXAMPLEsf6
```
**Anmerkung**
Sie können auch eine Funktionsdefinition erstellen, indem Sie den [https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html)Befehl ausführen und dann die ID aus der Ausgabe kopieren.
1. Fügen Sie der Funktionsdefinition eine Funktionsdefinitionsversion hinzu.
+ *function-definition-id*Ersetzen Sie sie durch `Id` die, die Sie für die Funktionsdefinition kopiert haben.
+ Fügen Sie in das `functions` Array alle anderen Funktionen ein, die Sie auf dem Greengrass-Kern verfügbar machen möchten. Sie können den `get-function-definition-version`-Befehl verwenden, um die Liste der vorhandenen Funktionen abzurufen.
**Aktivieren des Stream-Managers mit Standardeinstellungen**
Im folgenden Beispiel wird der Stream-Manager aktiviert, indem die `GGStreamManager` Funktion in das `functions` Array aufgenommen wird. In diesem Beispiel werden Standardwerte für die [ Stream-Manager-Parameter](#stream-manager-parameters) verwendet.
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
},
{
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:MyLambdaFunction:MyAlias",
"FunctionConfiguration": {
"Executable": "myLambdaFunction.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
},
"Id": "myLambdaFunction"
},
... more user-defined functions
]
}'
```
Die `myLambdaFunction` Funktion in den Beispielen stellt eine Ihrer benutzerdefinierten Lambda-Funktionen dar.
**Aktivieren des Stream-Managers mit benutzerdefinierten Einstellungen**
Im folgenden Beispiel wird der Stream-Manager aktiviert, indem die `GGStreamManager`-Funktion in das `functions`-Array aufgenommen wird. Alle Stream-Manager-Einstellungen sind optional, es sei denn, Sie möchten die Standardwerte ändern. Dieses Beispiel zeigt, wie Umgebungsvariablen verwendet werden, um benutzerdefinierte Werte festzulegen.
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"Environment": {
"Variables": {
"STREAM_MANAGER_STORE_ROOT_DIR": "/data",
"STREAM_MANAGER_SERVER_PORT": "1234",
"STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE": "4"
}
},
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
},
{
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:MyLambdaFunction:MyAlias",
"FunctionConfiguration": {
"Executable": "myLambdaFunction.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
},
"Id": "myLambdaFunction"
},
... more user-defined functions
]
}'
```
Was die `FunctionConfiguration` Eigenschaften angeht, wissen Sie vielleicht Folgendes:
+ `MemorySize`ist mit den Standardeinstellungen auf 4194304 KB (4 GB) eingestellt. Sie können diesen Wert jederzeit ändern. Wir empfehlen, dass Sie einen `MemorySize` Wert von mindestens 128000 KB angeben.
+ muss `Pinned` auf `true` festgelegt sein.
+ `Timeout` ist für die Funktionsdefinitionsversion erforderlich, wird vom `GGStreamManager` jedoch nicht verwendet.
**Deaktivieren des Stream-Managers**
Im folgenden Beispiel wird die `GGStreamManager`-Funktion weggelassen, wodurch der Stream-Manager deaktiviert wird.
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[
{
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:MyLambdaFunction:MyAlias",
"FunctionConfiguration": {
"Executable": "myLambdaFunction.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
},
"Id": "myLambdaFunction"
},
... more user-defined functions
]
}'
```
Wenn Sie keine Lambda-Funktionen bereitstellen möchten, können Sie die Version der Funktionsdefinition vollständig weglassen.
1. Kopieren Sie den `Arn` der Funktionsdefinitionsversion aus der Ausgabe.
1. Erstellen Sie eine Gruppenversion, die die Lambda-Funktion des Systems enthält.
+ Ersetzen Sie *group-id* durch die `Id` für die Gruppe.
+ *core-definition-version-arn*Ersetzen Sie es durch `CoreDefinitionVersionArn` das, was Sie aus der neuesten Gruppenversion kopiert haben.
+ *function-definition-version-arn*Ersetzen Sie es durch `Arn` das, was Sie für die neue Version der Funktionsdefinition kopiert haben.
+ Ersetzen Sie die ARNs für andere Gruppenkomponenten (z. B. `SubscriptionDefinitionVersionArn` oder`DeviceDefinitionVersionArn`), die Sie aus der neuesten Gruppenversion kopiert haben.
+ Entfernen Sie alle nicht verwendeten Parameter. Entfernen Sie zum Beispiel `--resource-definition-version-arn`, wenn Ihre Gruppenversion keine Ressourcen enthält.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--device-definition-version-arn device-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn \
--resource-definition-version-arn resource-definition-version-arn \
--subscription-definition-version-arn subscription-definition-version-arn
```
1. Kopieren Sie die `Version` aus der Ausgabe. Dies ist die ID der neuen Gruppenversion.
1. Stellen Sie die Gruppe mit der neuen Gruppenversion bereit.
+ *group-id*Ersetzen Sie sie durch `Id` die, die Sie für die Gruppe kopiert haben.
+ *group-version-id*Ersetzen Sie es durch `Version` das, was Sie für die neue Gruppenversion kopiert haben.
```
aws greengrass create-deployment \
--group-id group-id \
--group-version-id group-version-id \
--deployment-type NewDeployment
```
Gehen Sie wie folgt vor, wenn Sie die Stream Manager-Einstellungen später erneut bearbeiten möchten. Stellen Sie sicher, dass Sie eine Version der Funktionsdefinition erstellen, die die `GGStreamManager` Funktion mit der aktualisierten Konfiguration enthält. Die Gruppenversion muss auf alle Komponentenversionen verweisen ARNs , die Sie im Core bereitstellen möchten. Änderungen werden wirksam, nachdem die Gruppe bereitgestellt wurde.
## Weitere Informationen finden Sie auch unter
+ [Datenströme auf dem AWS IoT Greengrass Core verwalten](stream-manager.md)
+ [Wird verwendet StreamManagerClient , um mit Streams zu arbeiten](work-with-streams.md)
+ [Konfigurationen für unterstützte AWS Cloud Ziele exportieren](stream-export-configurations.md)
+ [Datenströme in die AWS Cloud (Konsole) exportieren](stream-manager-console.md)
+ [Datenströme in die AWS Cloud (CLI) exportieren](stream-manager-cli.md)
# Wird verwendet StreamManagerClient , um mit Streams zu arbeiten
Benutzerdefinierte Lambda-Funktionen, die auf dem AWS IoT Greengrass Core ausgeführt werden, können das `StreamManagerClient` Objekt im [AWS IoT Greengrass Core SDK](lambda-functions.md#lambda-sdks) verwenden, um Streams im [Stream Manager](stream-manager.md) zu erstellen und dann mit den Streams zu interagieren. Wenn eine Lambda-Funktion einen Stream erstellt, definiert sie die AWS Cloud Ziele, die Priorisierung und andere Export- und Datenaufbewahrungsrichtlinien für den Stream. Um Daten an den Stream Manager zu senden, hängen Lambda-Funktionen die Daten an den Stream an. Wenn ein Exportziel für den Stream definiert ist, exportiert der Stream Manager den Stream automatisch.
**Anmerkung**
In der Regel handelt es sich bei den Clients von Stream Manager um benutzerdefinierte Lambda-Funktionen. Wenn Ihr Geschäftsszenario dies erfordert, können Sie auch zulassen, dass Nicht-Lambda-Prozesse, die auf dem Greengrass-Kern ausgeführt werden (z. B. ein Docker-Container), mit dem Stream Manager interagieren. Weitere Informationen finden Sie unter [Client-Authentifizierung](stream-manager.md#stream-manager-security-client-authentication).
Die Auszüge in diesem Thema zeigen Ihnen, wie Clients Methoden aufrufen`StreamManagerClient`, um mit Streams zu arbeiten. Implementierungsdetails zu den Methoden und ihren Argumenten finden Sie unter den Links zur SDK-Referenz, die hinter jedem Codeausschnitt aufgeführt sind. Tutorials, die eine vollständige Python-Lambda-Funktion enthalten, finden Sie unter [Datenströme in die AWS Cloud (Konsole) exportieren](stream-manager-console.md) oder[Datenströme in die AWS Cloud (CLI) exportieren](stream-manager-cli.md).
Ihre Lambda-Funktion sollte `StreamManagerClient` außerhalb des Funktionshandlers instanziiert werden. Wenn sie in dem Handler instanziiert wird, erstellt die Funktion bei jedem Aufruf eine `client` und eine Verbindung zum Stream-Manager.
**Anmerkung**
Wenn Sie `StreamManagerClient` in dem Handler instanziieren, müssen Sie die `close()`-Methode explizit aufrufen, wenn die `client` seine Arbeit abschließt. Andernfalls hält der `client` die Verbindung offen, und ein anderer Thread läuft, bis das Skript beendet wird.
`StreamManagerClient` unterstützt die folgenden Operationen:
+ [Erstellen eines Nachrichten-Streams](#streammanagerclient-create-message-stream)
+ [Anhängen einer Nachricht](#streammanagerclient-append-message)
+ [Lesen von Nachrichten](#streammanagerclient-read-messages)
+ [Auflisten von Streams](#streammanagerclient-list-streams)
+ [Beschreiben eines Nachrichten-Streams](#streammanagerclient-describe-message-stream)
+ [Nachrichtenstream aktualisieren](#streammanagerclient-update-message-stream)
+ [Löschen eines Nachrichten-Streams](#streammanagerclient-delete-message-stream)
## Erstellen eines Nachrichten-Streams
Um einen Stream zu erstellen, ruft eine benutzerdefinierte Lambda-Funktion die Methode create auf und übergibt ein `MessageStreamDefinition` Objekt. Dieses Objekt gibt den eindeutigen Namen für den Stream an und definiert, wie der Stream-Manager mit neuen Daten umgehen soll, wenn die maximale Streamgröße erreicht ist. Sie können mit `MessageStreamDefinition` seinen Datentypen (z. B. `ExportDefinition`, `StrategyOnFull`, und `Persistence`) andere Stream-Eigenschaften definieren. Dazu zählen:
+ Das Ziel AWS IoT Analytics, Kinesis Data Streams und Amazon S3 S3-Ziele für automatische Exporte. AWS IoT SiteWise Weitere Informationen finden Sie unter [Konfigurationen für unterstützte AWS Cloud Ziele exportieren](stream-export-configurations.md).
+ Export-Priorität. Stream-Manager exportiert Streams mit höherer Priorität vor Streams mit niedrigerer Priorität.
+ Maximale Batchgröße und Batch-Intervall für AWS IoT Analytics Kinesis Data Streams und AWS IoT SiteWise Ziele. Der Stream-Manager exportiert Nachrichten, wenn eine der Bedingungen erfüllt ist.
+ Time-to-live (TTL). Die Zeitspanne, um sicherzustellen, dass die Streamdaten für die Verarbeitung verfügbar sind. Sie sollten sicherstellen, dass die Daten innerhalb dieses Zeitraums verbraucht werden können. Dies ist keine Löschrichtlinie. Die Daten werden möglicherweise nicht unmittelbar nach dem TTL-Zeitraum gelöscht.
+ Streampersistenz. Wählen Sie, ob Streams im Dateisystem gespeichert werden sollen, um Daten über Core-Neustarts hinweg zu speichern oder Streams im Speicher zu speichern.
+ Startsequenznummer. Geben Sie die Sequenznummer der Nachricht an, die als Startnachricht im Export verwendet werden soll.
Weitere Informationen zu `MessageStreamDefinition` finden Sie in der SDK-Referenz für Ihre Zielsprache:
+ [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)im Java-SDK
+ [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)im SDK von Node.js
+ [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.MessageStreamDefinition)im Python-SDK
**Anmerkung**
`StreamManagerClient`bietet auch ein Zielziel, mit dem Sie Streams auf einen HTTP-Server exportieren können. Dieses Ziel dient nur zu Testzwecken. Es ist weder stabil noch wird es für die Verwendung in Produktionsumgebungen unterstützt.
Nachdem ein Stream erstellt wurde, können Ihre Lambda-Funktionen [Nachrichten an den Stream anhängen](#streammanagerclient-append-message), um Daten für den Export zu senden, und [Nachrichten aus dem Stream für die lokale Verarbeitung lesen](#streammanagerclient-append-message). Die Anzahl der Streams, die Sie erstellen, hängt von Ihren Hardwarefunktionen und Ihrem Geschäftsfall ab. Eine Strategie besteht darin, für jeden Zielkanal im AWS IoT Analytics oder Kinesis-Datenstream einen Stream zu erstellen. Sie können jedoch mehrere Ziele für einen Stream definieren. Ein Stream hat eine dauerhafte Lebensdauer.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Minimale AWS IoT Greengrass Core-Version: 1.10.0
+ Mindestversion des AWS IoT Greengrass Kern-SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
**Anmerkung**
Für das Erstellen von Streams mit einem AWS IoT SiteWise oder einem Amazon S3 S3-Exportziel gelten die folgenden Anforderungen:
Minimale AWS IoT Greengrass Core-Version: 1.11.0
Mindestversion des AWS IoT Greengrass Kern-SDK: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0
### Beispiele
Das folgende Snippet erstellt einen Stream mit dem Namen `StreamName`. Es definiert Stream-Eigenschaften in den `MessageStreamDefinition` und untergeordneten Datentypen.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
client.create_message_stream(MessageStreamDefinition(
name="StreamName", # Required.
max_size=268435456, # Default is 256 MB.
stream_segment_size=16777216, # Default is 16 MB.
time_to_live_millis=None, # By default, no TTL is enabled.
strategy_on_full=StrategyOnFull.OverwriteOldestData, # Required.
persistence=Persistence.File, # Default is File.
flush_on_write=False, # Default is false.
export_definition=ExportDefinition( # Optional. Choose where/how the stream is exported to the AWS Cloud.
kinesis=None,
iot_analytics=None,
iot_sitewise=None,
s3_task_executor=None
)
))
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [create\$1message\$1stream \$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.MessageStreamDefinition)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.create_message_stream)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
client.createMessageStream(
new MessageStreamDefinition()
.withName("StreamName") // Required.
.withMaxSize(268435456L) // Default is 256 MB.
.withStreamSegmentSize(16777216L) // Default is 16 MB.
.withTimeToLiveMillis(null) // By default, no TTL is enabled.
.withStrategyOnFull(StrategyOnFull.OverwriteOldestData) // Required.
.withPersistence(Persistence.File) // Default is File.
.withFlushOnWrite(false) // Default is false.
.withExportDefinition( // Optional. Choose where/how the stream is exported to the AWS Cloud.
new ExportDefinition()
.withKinesis(null)
.withIotAnalytics(null)
.withIotSitewise(null)
.withS3TaskExecutor(null)
)
);
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java-SDK-Referenz: \$1 [createMessageStream[MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#createMessageStream-com.amazonaws.greengrass.streammanager.model.MessageStreamDefinition-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
await client.createMessageStream(
new MessageStreamDefinition()
.withName("StreamName") // Required.
.withMaxSize(268435456) // Default is 256 MB.
.withStreamSegmentSize(16777216) // Default is 16 MB.
.withTimeToLiveMillis(null) // By default, no TTL is enabled.
.withStrategyOnFull(StrategyOnFull.OverwriteOldestData) // Required.
.withPersistence(Persistence.File) // Default is File.
.withFlushOnWrite(false) // Default is false.
.withExportDefinition( // Optional. Choose where/how the stream is exported to the AWS Cloud.
new ExportDefinition()
.withKinesis(null)
.withIotAnalytics(null)
.withIotSitewise(null)
.withS3TaskExecutor(null)
)
);
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
SDK-Referenz für Node.js: [createMessageStream](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#createMessageStream)\$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)
------
Weitere Informationen zur Konfiguration von Exportzielen finden Sie unter[Konfigurationen für unterstützte AWS Cloud Ziele exportieren](stream-export-configurations.md).
## Anhängen einer Nachricht
Um Daten zum Export an den Stream Manager zu senden, hängen Ihre Lambda-Funktionen die Daten an den Zielstream an. Das Exportziel bestimmt den Datentyp, der an diese Methode übergeben werden soll.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Minimale AWS IoT Greengrass Core-Version: 1.10.0
+ Mindestversion des AWS IoT Greengrass Kern-SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
**Anmerkung**
Für das Anhängen von Nachrichten mit einem AWS IoT SiteWise oder einem Amazon S3 S3-Exportziel gelten die folgenden Anforderungen:
Minimale AWS IoT Greengrass Kernversion: 1.11.0
Mindestversion des AWS IoT Greengrass Kern-SDK: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0
### Beispiele
#### AWS IoT Analytics oder Kinesis Data Streams Streams-Exportziele
Das folgende Snippet fügt eine Nachricht an den Stream namens `StreamName` an. Für AWS IoT Analytics unsere Kinesis Data Streams Streams-Ziele hängen Ihre Lambda-Funktionen einen Datenblob an.
Für dieses Snippet gelten die folgenden Anforderungen:
+ Minimale AWS IoT Greengrass Core-Version: 1.10.0
+ Mindestversion des AWS IoT Greengrass Kern-SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
------
#### [ Python ]
```
client = StreamManagerClient()
try:
sequence_number = client.append_message(stream_name="StreamName", data=b'Arbitrary bytes data')
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [append\$1message](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.append_message)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
long sequenceNumber = client.appendMessage("StreamName", "Arbitrary byte array".getBytes());
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java SDK-Referenz: [appendMessage](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const sequenceNumber = await client.appendMessage("StreamName", Buffer.from("Arbitrary byte array"));
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Node.js SDK-Referenz: [appendMessage](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage)
------
#### AWS IoT SiteWise Ziele exportieren
Das folgende Snippet fügt eine Nachricht an den Stream namens `StreamName` an. Für AWS IoT SiteWise Ziele hängen Ihre Lambda-Funktionen ein `PutAssetPropertyValueEntry` serialisiertes Objekt an. Weitere Informationen finden Sie unter [Exportieren nach AWS IoT SiteWise](stream-export-configurations.md#export-streams-to-sitewise).
**Anmerkung**
Wenn Sie Daten an senden AWS IoT SiteWise, müssen Ihre Daten die Anforderungen der Aktion erfüllen. `BatchPutAssetPropertyValue` Weitere Informationen finden Sie unter [BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html) in der *AWS IoT SiteWise -API-Referenz*.
Für dieses Snippet gelten die folgenden Anforderungen:
+ Minimale AWS IoT Greengrass Core-Version: 1.11.0
+ Mindestversion des AWS IoT Greengrass Kern-SDK: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0
------
#### [ Python ]
```
client = StreamManagerClient()
try:
# SiteWise requires unique timestamps in all messages. Add some randomness to time and offset.
# Note: To create a new asset property data, you should use the classes defined in the
# greengrasssdk.stream_manager module.
time_in_nanos = TimeInNanos(
time_in_seconds=calendar.timegm(time.gmtime()) - random.randint(0, 60), offset_in_nanos=random.randint(0, 10000)
)
variant = Variant(double_value=random.random())
asset = [AssetPropertyValue(value=variant, quality=Quality.GOOD, timestamp=time_in_nanos)]
putAssetPropertyValueEntry = PutAssetPropertyValueEntry(entry_id=str(uuid.uuid4()), property_alias="PropertyAlias", property_values=asset)
sequence_number = client.append_message(stream_name="StreamName", data=Util.validate_and_serialize_to_json_bytes(putAssetPropertyValueEntry))
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [append\$1message \$1 [PutAssetPropertyValueEntry](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.PutAssetPropertyValueEntry)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.append_message)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
Random rand = new Random();
// Note: To create a new asset property data, you should use the classes defined in the
// com.amazonaws.greengrass.streammanager.model.sitewise package.
List entries = new ArrayList<>() ;
// IoTSiteWise requires unique timestamps in all messages. Add some randomness to time and offset.
final int maxTimeRandomness = 60;
final int maxOffsetRandomness = 10000;
double randomValue = rand.nextDouble();
TimeInNanos timestamp = new TimeInNanos()
.withTimeInSeconds(Instant.now().getEpochSecond() - rand.nextInt(maxTimeRandomness))
.withOffsetInNanos((long) (rand.nextInt(maxOffsetRandomness)));
AssetPropertyValue entry = new AssetPropertyValue()
.withValue(new Variant().withDoubleValue(randomValue))
.withQuality(Quality.GOOD)
.withTimestamp(timestamp);
entries.add(entry);
PutAssetPropertyValueEntry putAssetPropertyValueEntry = new PutAssetPropertyValueEntry()
.withEntryId(UUID.randomUUID().toString())
.withPropertyAlias("PropertyAlias")
.withPropertyValues(entries);
long sequenceNumber = client.appendMessage("StreamName", ValidateAndSerialize.validateAndSerializeToJsonBytes(putAssetPropertyValueEntry));
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java SDK-Referenz: [appendMessage \$1 [PutAssetPropertyValueEntry](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/sitewise/PutAssetPropertyValueEntry.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const maxTimeRandomness = 60;
const maxOffsetRandomness = 10000;
const randomValue = Math.random();
// Note: To create a new asset property data, you should use the classes defined in the
// aws-greengrass-core-sdk StreamManager module.
const timestamp = new TimeInNanos()
.withTimeInSeconds(Math.round(Date.now() / 1000) - Math.floor(Math.random() - maxTimeRandomness))
.withOffsetInNanos(Math.floor(Math.random() * maxOffsetRandomness));
const entry = new AssetPropertyValue()
.withValue(new Variant().withDoubleValue(randomValue))
.withQuality(Quality.GOOD)
.withTimestamp(timestamp);
const putAssetPropertyValueEntry = new PutAssetPropertyValueEntry()
.withEntryId(`${ENTRY_ID_PREFIX}${i}`)
.withPropertyAlias("PropertyAlias")
.withPropertyValues([entry]);
const sequenceNumber = await client.appendMessage("StreamName", util.validateAndSerializeToJsonBytes(putAssetPropertyValueEntry));
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Node.js SDK-Referenz: [appendMessage \$1 [PutAssetPropertyValueEntry](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.PutAssetPropertyValueEntry.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage)
------
#### Amazon S3 S3-Exportziele
Das folgende Snippet hängt eine Exportaufgabe an den genannten Stream an. `StreamName` Für Amazon S3 S3-Ziele hängen Ihre Lambda-Funktionen ein serialisiertes `S3ExportTaskDefinition` Objekt an, das Informationen über die Quelleingabedatei und das Amazon S3 S3-Zielobjekt enthält. Wenn das angegebene Objekt nicht existiert, erstellt Stream Manager es für Sie. Weitere Informationen finden Sie unter [Exportieren nach Amazon S3](stream-export-configurations.md#export-streams-to-s3).
Für dieses Snippet gelten die folgenden Anforderungen:
+ Minimale AWS IoT Greengrass Core-Version: 1.11.0
+ Mindestversion des AWS IoT Greengrass Kern-SDK: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0
------
#### [ Python ]
```
client = StreamManagerClient()
try:
# Append an Amazon S3 Task definition and print the sequence number.
s3_export_task_definition = S3ExportTaskDefinition(input_url="URLToFile", bucket="BucketName", key="KeyName")
sequence_number = client.append_message(stream_name="StreamName", data=Util.validate_and_serialize_to_json_bytes(s3_export_task_definition))
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
[Python-SDK-Referenz: [append\$1message \$1 S3](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.append_message) ExportTaskDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.S3ExportTaskDefinition)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
// Append an Amazon S3 export task definition and print the sequence number.
S3ExportTaskDefinition s3ExportTaskDefinition = new S3ExportTaskDefinition()
.withBucket("BucketName")
.withKey("KeyName")
.withInputUrl("URLToFile");
long sequenceNumber = client.appendMessage("StreamName", ValidateAndSerialize.validateAndSerializeToJsonBytes(s3ExportTaskDefinition));
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
[Java-SDK-Referenz: [appendMessage \$1 S3](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-) ExportTaskDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/S3ExportTaskDefinition.html)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
// Append an Amazon S3 export task definition and print the sequence number.
const taskDefinition = new S3ExportTaskDefinition()
.withBucket("BucketName")
.withKey("KeyName")
.withInputUrl("URLToFile");
const sequenceNumber = await client.appendMessage("StreamName", util.validateAndSerializeToJsonBytes(taskDefinition)));
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
[SDK-Referenz für Node.js: [appendMessage \$1 S3](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage) ExportTaskDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.S3ExportTaskDefinition.html)
------
## Lesen von Nachrichten
Lesen Sie Nachrichten aus einem Stream.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Minimale AWS IoT Greengrass Core-Version: 1.10.0
+ Mindestversion des AWS IoT Greengrass Kern-SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
### Beispiele
Das folgende Snippet liest Nachrichten aus dem Stream namens `StreamName`. Die Read-Methode verwendet ein optionales `ReadMessagesOptions`-Objekt, das die Sequenznummer angibt, von der aus mit dem Lesen begonnen werden soll, die minimale und maximale Anzahl zu lesen und ein Timeout für das Lesen von Nachrichten.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
message_list = client.read_messages(
stream_name="StreamName",
# By default, if no options are specified, it tries to read one message from the beginning of the stream.
options=ReadMessagesOptions(
desired_start_sequence_number=100,
# Try to read from sequence number 100 or greater. By default, this is 0.
min_message_count=10,
# Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is raised. By default, this is 1.
max_message_count=100, # Accept up to 100 messages. By default this is 1.
read_timeout_millis=5000
# Try to wait at most 5 seconds for the min_messsage_count to be fulfilled. By default, this is 0, which immediately returns the messages or an exception.
)
)
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [read\$1messages \$1 [ReadMessagesOptions](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.ReadMessagesOptions)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.read_messages)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
List messages = client.readMessages("StreamName",
// By default, if no options are specified, it tries to read one message from the beginning of the stream.
new ReadMessagesOptions()
// Try to read from sequence number 100 or greater. By default this is 0.
.withDesiredStartSequenceNumber(100L)
// Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is raised. By default, this is 1.
.withMinMessageCount(10L)
// Accept up to 100 messages. By default this is 1.
.withMaxMessageCount(100L)
// Try to wait at most 5 seconds for the min_messsage_count to be fulfilled. By default, this is 0, which immediately returns the messages or an exception.
.withReadTimeoutMillis(Duration.ofSeconds(5L).toMillis())
);
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java SDK-Referenz: [readMessages \$1 [ReadMessagesOptions](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/ReadMessagesOptions.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#readMessages-java.lang.String-com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const messages = await client.readMessages("StreamName",
// By default, if no options are specified, it tries to read one message from the beginning of the stream.
new ReadMessagesOptions()
// Try to read from sequence number 100 or greater. By default this is 0.
.withDesiredStartSequenceNumber(100)
// Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is thrown. By default, this is 1.
.withMinMessageCount(10)
// Accept up to 100 messages. By default this is 1.
.withMaxMessageCount(100)
// Try to wait at most 5 seconds for the minMessageCount to be fulfilled. By default, this is 0, which immediately returns the messages or an exception.
.withReadTimeoutMillis(5 * 1000)
);
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Node.js SDK-Referenz: [readMessages \$1 [ReadMessagesOptions](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.ReadMessagesOptions.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#readMessages)
------
## Auflisten von Streams
Ruft die Liste der Streams im Stream-Manager ab.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Minimale AWS IoT Greengrass Core-Version: 1.10.0
+ Mindestversion des AWS IoT Greengrass Kern-SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
### Beispiele
Das folgende Snippet ruft eine Liste der Streams (nach Namen) im Stream-Manager ab.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
stream_names = client.list_streams()
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [list\$1streams](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.list_streams)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
List streamNames = client.listStreams();
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java-SDK-Referenz: [ListStreams](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#listStreams--)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const streams = await client.listStreams();
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Node.js SDK-Referenz: [ListStreams](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#listStreams)
------
## Beschreiben eines Nachrichten-Streams
Ruft Metadaten zu einem Stream ab, einschließlich der Stream-Definition, -Größe und des Exportstatus.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Minimale AWS IoT Greengrass Core-Version: 1.10.0
+ Mindestversion des AWS IoT Greengrass Kern-SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
### Beispiele
Das folgende Snippet ruft Metadaten über den Stream mit dem Namen `StreamName` ab, einschließlich Definition, Größe und Exporterstatus des Streams.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
stream_description = client.describe_message_stream(stream_name="StreamName")
if stream_description.export_statuses[0].error_message:
# The last export of export destination 0 failed with some error
# Here is the last sequence number that was successfully exported
stream_description.export_statuses[0].last_exported_sequence_number
if (stream_description.storage_status.newest_sequence_number >
stream_description.export_statuses[0].last_exported_sequence_number):
pass
# The end of the stream is ahead of the last exported sequence number
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [describe\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.describe_message_stream)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
MessageStreamInfo description = client.describeMessageStream("StreamName");
String lastErrorMessage = description.getExportStatuses().get(0).getErrorMessage();
if (lastErrorMessage != null && !lastErrorMessage.equals("")) {
// The last export of export destination 0 failed with some error.
// Here is the last sequence number that was successfully exported.
description.getExportStatuses().get(0).getLastExportedSequenceNumber();
}
if (description.getStorageStatus().getNewestSequenceNumber() >
description.getExportStatuses().get(0).getLastExportedSequenceNumber()) {
// The end of the stream is ahead of the last exported sequence number.
}
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java-SDK-Referenz: [describeMessageStream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#describeMessageStream-java.lang.String-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const description = await client.describeMessageStream("StreamName");
const lastErrorMessage = description.exportStatuses[0].errorMessage;
if (lastErrorMessage) {
// The last export of export destination 0 failed with some error.
// Here is the last sequence number that was successfully exported.
description.exportStatuses[0].lastExportedSequenceNumber;
}
if (description.storageStatus.newestSequenceNumber >
description.exportStatuses[0].lastExportedSequenceNumber) {
// The end of the stream is ahead of the last exported sequence number.
}
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
SDK-Referenz für Node.js: [describeMessageStream](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#describeMessageStream)
------
## Nachrichtenstream aktualisieren
Aktualisieren Sie die Eigenschaften eines vorhandenen Streams. Möglicherweise möchten Sie einen Stream aktualisieren, wenn sich Ihre Anforderungen nach der Erstellung des Streams ändern. Beispiel:
+ Fügen Sie eine neue [Exportkonfiguration](stream-export-configurations.md) für ein AWS Cloud Ziel hinzu.
+ Erhöhen Sie die maximale Größe eines Streams, um zu ändern, wie Daten exportiert oder aufbewahrt werden. Beispielsweise kann die Stream-Größe in Kombination mit Ihrer Strategie bei vollen Einstellungen dazu führen, dass Daten gelöscht oder zurückgewiesen werden, bevor der Stream-Manager sie verarbeiten kann.
+ Unterbrechen Sie Exporte und setzen Sie sie fort, z. B. wenn Exportaufgaben lange dauern und Sie Ihre Upload-Daten rationieren möchten.
Ihre Lambda-Funktionen folgen diesem allgemeinen Prozess, um einen Stream zu aktualisieren:
1. [Rufen Sie die Beschreibung des Streams ab.](#streammanagerclient-describe-message-stream)
1. Aktualisieren Sie die Zieleigenschaften der entsprechenden `MessageStreamDefinition` und untergeordneten Objekte.
1. Übergeben Sie das Aktualisierte`MessageStreamDefinition`. Stellen Sie sicher, dass Sie die vollständigen Objektdefinitionen für den aktualisierten Stream angeben. Undefinierte Eigenschaften werden auf die Standardwerte zurückgesetzt.
Sie können die Sequenznummer der Nachricht angeben, die als Startnachricht im Export verwendet werden soll.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Minimale AWS IoT Greengrass Core-Version: 1.11.0
+ Mindestversion des AWS IoT Greengrass Kern-SDK: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0
### Beispiele
Das folgende Snippet aktualisiert den Stream mit dem Namen. `StreamName` Es aktualisiert mehrere Eigenschaften eines Streams, der in Kinesis Data Streams exportiert wird.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
message_stream_info = client.describe_message_stream(STREAM_NAME)
message_stream_info.definition.max_size=536870912
message_stream_info.definition.stream_segment_size=33554432
message_stream_info.definition.time_to_live_millis=3600000
message_stream_info.definition.strategy_on_full=StrategyOnFull.RejectNewData
message_stream_info.definition.persistence=Persistence.Memory
message_stream_info.definition.flush_on_write=False
message_stream_info.definition.export_definition.kinesis=
[KinesisConfig(
# Updating Export definition to add a Kinesis Stream configuration.
identifier=str(uuid.uuid4()), kinesis_stream_name=str(uuid.uuid4()))]
client.update_message_stream(message_stream_info.definition)
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [updateMessageStream](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.update_message_stream)\$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.MessageStreamDefinition)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
MessageStreamInfo messageStreamInfo = client.describeMessageStream(STREAM_NAME);
// Update the message stream with new values.
client.updateMessageStream(
messageStreamInfo.getDefinition()
.withStrategyOnFull(StrategyOnFull.RejectNewData) // Required. Updating Strategy on full to reject new data.
// Max Size update should be greater than initial Max Size defined in Create Message Stream request
.withMaxSize(536870912L) // Update Max Size to 512 MB.
.withStreamSegmentSize(33554432L) // Update Segment Size to 32 MB.
.withFlushOnWrite(true) // Update flush on write to true.
.withPersistence(Persistence.Memory) // Update the persistence to Memory.
.withTimeToLiveMillis(3600000L) // Update TTL to 1 hour.
.withExportDefinition(
// Optional. Choose where/how the stream is exported to the AWS Cloud.
messageStreamInfo.getDefinition().getExportDefinition().
// Updating Export definition to add a Kinesis Stream configuration.
.withKinesis(new ArrayList() {{
add(new KinesisConfig()
.withIdentifier(EXPORT_IDENTIFIER)
.withKinesisStreamName("test"));
}})
);
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java-SDK-Referenz: [update\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#updateMessageStream-java.lang.String-) \$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const messageStreamInfo = await c.describeMessageStream(STREAM_NAME);
await client.updateMessageStream(
messageStreamInfo.definition
// Max Size update should be greater than initial Max Size defined in Create Message Stream request
.withMaxSize(536870912) // Default is 256 MB. Updating Max Size to 512 MB.
.withStreamSegmentSize(33554432) // Default is 16 MB. Updating Segment Size to 32 MB.
.withTimeToLiveMillis(3600000) // By default, no TTL is enabled. Update TTL to 1 hour.
.withStrategyOnFull(StrategyOnFull.RejectNewData) // Required. Updating Strategy on full to reject new data.
.withPersistence(Persistence.Memory) // Default is File. Update the persistence to Memory
.withFlushOnWrite(true) // Default is false. Updating to true.
.withExportDefinition(
// Optional. Choose where/how the stream is exported to the AWS Cloud.
messageStreamInfo.definition.exportDefinition
// Updating Export definition to add a Kinesis Stream configuration.
.withKinesis([new KinesisConfig().withIdentifier(uuidv4()).withKinesisStreamName(uuidv4())])
)
);
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
SDK-Referenz für Node.js: \$1 [updateMessageStream[MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#updateMessageStream)
------
### Einschränkungen für die Aktualisierung von Streams
Die folgenden Einschränkungen gelten für die Aktualisierung von Streams. Sofern in der folgenden Liste nicht anders angegeben, werden Aktualisierungen sofort wirksam.
+ Sie können die Persistenz eines Streams nicht aktualisieren. Um dieses Verhalten zu ändern, [löschen Sie den Stream](#streammanagerclient-delete-message-stream) und [erstellen Sie einen Stream](#streammanagerclient-create-message-stream), der die neue Persistenzrichtlinie definiert.
+ Sie können die maximale Größe eines Streams nur unter den folgenden Bedingungen aktualisieren:
+ Die maximale Größe muss größer oder gleich der aktuellen Größe des Streams sein. Um diese Informationen zu finden, [beschreiben Sie den Stream](#streammanagerclient-describe-message-stream) und überprüfen Sie dann den Speicherstatus des zurückgegebenen `MessageStreamInfo` Objekts.
+ Die maximale Größe muss größer oder gleich der Segmentgröße des Streams sein.
+ Sie können die Stream-Segmentgröße auf einen Wert aktualisieren, der unter der maximalen Größe des Streams liegt. Die aktualisierte Einstellung gilt für neue Segmente.
+ Aktualisierungen der Eigenschaft Time to Live (TTL) gelten für neue Anfügevorgänge. Wenn Sie diesen Wert verringern, löscht Stream Manager möglicherweise auch vorhandene Segmente, die die TTL überschreiten.
+ Aktualisierungen der Strategie für die vollständige Eigenschaft gelten auch für neue Anfügevorgänge. Wenn Sie die Strategie so einrichten, dass die ältesten Daten überschrieben werden, überschreibt Stream Manager möglicherweise auch bestehende Segmente, die auf der neuen Einstellung basieren.
+ Aktualisierungen der Eigenschaft „Flush on Write“ gelten für neue Nachrichten.
+ Aktualisierungen der Exportkonfigurationen gelten für neue Exporte. Die Aktualisierungsanforderung muss alle Exportkonfigurationen enthalten, die Sie unterstützen möchten. Andernfalls löscht der Stream Manager sie.
+ Wenn Sie eine Exportkonfiguration aktualisieren, geben Sie den Bezeichner der Ziel-Exportkonfiguration an.
+ Um eine Exportkonfiguration hinzuzufügen, geben Sie eine eindeutige Kennung für die neue Exportkonfiguration an.
+ Um eine Exportkonfiguration zu löschen, lassen Sie die Exportkonfiguration weg.
+ Um die Startsequenznummer einer Exportkonfiguration in einem Stream zu [aktualisieren](#streammanagerclient-update-message-stream), müssen Sie einen Wert angeben, der kleiner als die letzte Sequenznummer ist. Um diese Informationen zu finden, [beschreiben Sie den Stream](#streammanagerclient-describe-message-stream) und überprüfen Sie dann den Speicherstatus des zurückgegebenen `MessageStreamInfo` Objekts.
## Löschen eines Nachrichten-Streams
Löscht einen Stream. Wenn Sie einen Stream löschen, werden alle gespeicherten Daten für den Stream von der Festplatte gelöscht.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Minimale AWS IoT Greengrass Core-Version: 1.10.0
+ Mindestversion des AWS IoT Greengrass Kern-SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
### Beispiele
Das folgende Snippet löscht den Stream mit dem Namen `StreamName`.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
client.delete_message_stream(stream_name="StreamName")
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [deleteMessageStream](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.delete_message_stream)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
client.deleteMessageStream("StreamName");
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java-SDK-Referenz: [delete\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#deleteMessageStream-java.lang.String-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
await client.deleteMessageStream("StreamName");
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
SDK-Referenz für Node.js: [deleteMessageStream](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#deleteMessageStream)
------
## Weitere Informationen finden Sie auch unter
+ [Datenströme auf dem AWS IoT Greengrass Core verwalten](stream-manager.md)
+ [AWS IoT Greengrass Streammanager konfigurieren](configure-stream-manager.md)
+ [Konfigurationen für unterstützte AWS Cloud Ziele exportieren](stream-export-configurations.md)
+ [Datenströme in die AWS Cloud (Konsole) exportieren](stream-manager-console.md)
+ [Datenströme in die AWS Cloud (CLI) exportieren](stream-manager-cli.md)
+ `StreamManagerClient`in der AWS IoT Greengrass Core SDK-Referenz:
+ [Python](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html)
+ [Java](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html)
+ [Node.js](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html)
# Konfigurationen für unterstützte AWS Cloud Ziele exportieren
Benutzerdefinierte Lambda-Funktionen, die `StreamManagerClient` im AWS IoT Greengrass Core SDK verwendet werden, um mit dem Stream-Manager zu interagieren. Wenn eine Lambda-Funktion [einen Stream erstellt](work-with-streams.md#streammanagerclient-create-message-stream) oder [einen Stream aktualisiert](work-with-streams.md#streammanagerclient-create-message-stream), übergibt sie ein `MessageStreamDefinition` Objekt, das Stream-Eigenschaften darstellt, einschließlich der Exportdefinition. Das `ExportDefinition` Objekt enthält die für den Stream definierten Exportkonfigurationen. Stream Manager verwendet diese Exportkonfigurationen, um zu bestimmen, wo und wie der Stream exportiert werden soll.
![\[Objektmodelldiagramm des ExportDefinition Eigenschaftstyps.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/stream-manager-exportconfigs.png)
Sie können keine oder mehr Exportkonfigurationen für einen Stream definieren, einschließlich mehrerer Exportkonfigurationen für einen einzelnen Zieltyp. Sie können beispielsweise einen Stream in zwei AWS IoT Analytics Kanäle und einen Kinesis-Datenstream exportieren.
Bei fehlgeschlagenen Exportversuchen versucht Stream Manager kontinuierlich, Daten in Intervallen von bis zu fünf Minuten zu exportieren. AWS Cloud Für die Anzahl der Wiederholungsversuche gibt es keine Obergrenze.
**Anmerkung**
`StreamManagerClient`bietet auch ein Zielziel, mit dem Sie Streams auf einen HTTP-Server exportieren können. Dieses Ziel dient nur zu Testzwecken. Es ist weder stabil noch wird es für die Verwendung in Produktionsumgebungen unterstützt.
**Topics**
+ [AWS IoT Analytics Kanäle](#export-to-iot-analytics)
+ [Amazon Kinesis Kinesis-Datenströme](#export-to-kinesis)
+ [AWS IoT SiteWise Eigenschaften von Vermögenswerten](#export-to-iot-sitewise)
+ [Amazon-S3-Objekte](#export-to-s3)
Sie sind für die Wartung dieser AWS Cloud Ressourcen verantwortlich.
## AWS IoT Analytics Kanäle
Stream Manager unterstützt automatische Exporte nach AWS IoT Analytics. AWS IoT Analytics ermöglicht es Ihnen, erweiterte Analysen Ihrer Daten durchzuführen, um Geschäftsentscheidungen zu treffen und Modelle für maschinelles Lernen zu verbessern. Weitere Informationen finden Sie unter [Was ist AWS IoT Analytics?](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) im *AWS IoT Analytics Benutzerhandbuch*.
Im AWS IoT Greengrass Core SDK verwenden Ihre Lambda-Funktionen die, `IoTAnalyticsConfig` um die Exportkonfiguration für diesen Zieltyp zu definieren. Weitere Informationen finden Sie in der SDK-Referenz für Ihre Zielsprache:
+ [Io TAnalytics Config](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.IoTAnalyticsConfig) im Python-SDK
+ [Io TAnalytics Config](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTAnalyticsConfig.html) im Java SDK
+ [Io TAnalytics Config](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.IoTAnalyticsConfig.html) im SDK Node.js
### Voraussetzungen
Für dieses Exportziel gelten die folgenden Anforderungen:
+ Die Zielkanäle in AWS IoT Analytics müssen sich in derselben AWS-Konto und AWS-Region wie die Greengrass-Gruppe befinden.
+ Sie [Greengrass-Gruppenrolle.](group-role.md) müssen die `iotanalytics:BatchPutMessage` Erlaubnis erteilen, Kanäle gezielt anzusprechen. Beispiel:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iotanalytics:BatchPutMessage"
],
"Resource": [
"arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_1_name",
"arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_2_name"
]
}
]
}
```
------
Sie können detaillierten oder bedingten Zugriff auf Ressourcen gewähren, indem Sie beispielsweise ein `*` Platzhalter-Benennungsschema verwenden. Weitere Informationen finden Sie im IAM-Benutzerhandbuch unter [Hinzufügen und Entfernen von *IAM-Richtlinien*](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
### Exportieren nach AWS IoT Analytics
Um einen Stream zu erstellen, in den exportiert wird AWS IoT Analytics, [erstellen Ihre Lambda-Funktionen einen Stream](work-with-streams.md#streammanagerclient-create-message-stream) mit einer Exportdefinition, die ein oder mehrere `IoTAnalyticsConfig` Objekte enthält. Dieses Objekt definiert Exporteinstellungen wie den Zielkanal, die Batchgröße, das Batch-Intervall und die Priorität.
Wenn Ihre Lambda-Funktionen Daten von Geräten empfangen, [hängen sie Nachrichten](work-with-streams.md#streammanagerclient-append-message), die einen Datenblock enthalten, an den Zielstream an.
Anschließend exportiert der Stream Manager die Daten auf der Grundlage der Batch-Einstellungen und der Priorität, die in den Exportkonfigurationen des Streams definiert sind.
## Amazon Kinesis Kinesis-Datenströme
Stream Manager unterstützt automatische Exporte nach Amazon Kinesis Data Streams. Kinesis Data Streams wird häufig verwendet, um große Datenmengen zu aggregieren und sie in ein Data Warehouse oder einen Map-Reduce-Cluster zu laden. Weitere Informationen finden Sie unter [Was ist Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/what-is-this-service.html)? im *Amazon Kinesis Developer Guide*.
Im AWS IoT Greengrass Core SDK verwenden Ihre Lambda-Funktionen die, `KinesisConfig` um die Exportkonfiguration für diesen Zieltyp zu definieren. Weitere Informationen finden Sie in der SDK-Referenz für Ihre Zielsprache:
+ [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.KinesisConfig)im Python-SDK
+ [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/KinesisConfig.html)im Java-SDK
+ [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.KinesisConfig.html)im SDK von Node.js
### Voraussetzungen
Für dieses Exportziel gelten die folgenden Anforderungen:
+ Ziel-Streams in Kinesis Data Streams müssen sich in derselben AWS-Konto und AWS-Region wie die Greengrass-Gruppe befinden.
+ Sie [Greengrass-Gruppenrolle.](group-role.md) müssen die `kinesis:PutRecords` Erlaubnis erteilen, Datenstreams als Ziel zu verwenden. Beispiel:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:PutRecords"
],
"Resource": [
"arn:aws:kinesis:us-east-1:123456789012:stream/stream_1_name",
"arn:aws:kinesis:us-east-1:123456789012:stream/stream_2_name"
]
}
]
}
```
------
Sie können detaillierten oder bedingten Zugriff auf Ressourcen gewähren, indem Sie beispielsweise ein `*` Platzhalter-Benennungsschema verwenden. Weitere Informationen finden Sie im IAM-Benutzerhandbuch unter [Hinzufügen und Entfernen von *IAM-Richtlinien*](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
### In Kinesis Data Streams exportieren
Um einen Stream zu erstellen, der in Kinesis Data Streams exportiert wird, [erstellen Ihre Lambda-Funktionen einen Stream](work-with-streams.md#streammanagerclient-create-message-stream) mit einer Exportdefinition, die ein oder mehrere `KinesisConfig` Objekte enthält. Dieses Objekt definiert Exporteinstellungen wie den Zieldatenstream, die Batchgröße, das Batch-Intervall und die Priorität.
Wenn Ihre Lambda-Funktionen Daten von Geräten empfangen, [hängen sie Nachrichten](work-with-streams.md#streammanagerclient-append-message), die einen Datenblock enthalten, an den Zielstream an. Anschließend exportiert der Stream Manager die Daten auf der Grundlage der Batch-Einstellungen und der Priorität, die in den Exportkonfigurationen des Streams definiert sind.
Stream Manager generiert eine eindeutige, zufällige UUID als Partitionsschlüssel für jeden Datensatz, der auf Amazon Kinesis hochgeladen wird.
## AWS IoT SiteWise Eigenschaften von Vermögenswerten
Stream Manager unterstützt automatische Exporte nach AWS IoT SiteWise. AWS IoT SiteWise ermöglicht das Sammeln, Organisieren und Analysieren von Daten aus Industrieanlagen in großem Maßstab. Weitere Informationen finden Sie unter [Was ist AWS IoT SiteWise?](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html) im *AWS IoT SiteWise Benutzerhandbuch*.
Im AWS IoT Greengrass Core SDK verwenden Ihre Lambda-Funktionen die, `IoTSiteWiseConfig` um die Exportkonfiguration für diesen Zieltyp zu definieren. Weitere Informationen finden Sie in der SDK-Referenz für Ihre Zielsprache:
+ [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.IoTSiteWiseConfig) im Python-SDK
+ [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTSiteWiseConfig.html) im Java-SDK
+ [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.IoTSiteWiseConfig.html) im SDK von Node.js
**Anmerkung**
AWS bietet auch die[SiteWise IoT-Anschluss](iot-sitewise-connector.md), bei der es sich um eine vorgefertigte Lösung handelt, die Sie mit OPC-UA-Quellen verwenden können.
### Voraussetzungen
Für dieses Exportziel gelten die folgenden Anforderungen:
+ Die Immobilien des AWS IoT SiteWise Zielobjekts in müssen sich in derselben AWS-Konto und AWS-Region wie die Greengrass-Gruppe befinden.
**Anmerkung**
Eine Liste der Regionen, die AWS IoT SiteWise unterstützt werden, finden Sie in der *AWS allgemeinen AWS IoT SiteWise * [Referenz unter Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html#iot-sitewise_region).
+ Sie [Greengrass-Gruppenrolle.](group-role.md) müssen die `iotsitewise:BatchPutAssetPropertyValue` Erlaubnis erteilen, auf Objekteigenschaften zu zielen. In der folgenden Beispielrichtlinie wird der `iotsitewise:assetHierarchyPath` Bedingungsschlüssel verwendet, um Zugriff auf ein Zielstamm-Asset und dessen untergeordnete Objekte zu gewähren. Sie können das `Condition` aus der Richtlinie entfernen, um Zugriff auf alle Ihre AWS IoT SiteWise Ressourcen zu gewähren oder einzelne Ressourcen anzugeben ARNs .
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotsitewise:BatchPutAssetPropertyValue",
"Resource": "*",
"Condition": {
"StringLike": {
"iotsitewise:assetHierarchyPath": [
"/root node asset ID",
"/root node asset ID/*"
]
}
}
}
]
}
```
------
Sie können detaillierten oder bedingten Zugriff auf Ressourcen gewähren, indem Sie beispielsweise ein `*` Platzhalter-Benennungsschema verwenden. Weitere Informationen finden Sie im IAM-Benutzerhandbuch unter [Hinzufügen und Entfernen von *IAM-Richtlinien*](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
Wichtige Sicherheitsinformationen finden Sie im *AWS IoT SiteWise Benutzerhandbuch* unter [ BatchPutAssetPropertyValue Autorisierung](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies-batchputassetpropertyvalue-action).
### Exportieren nach AWS IoT SiteWise
Um einen Stream zu erstellen, in den exportiert wird AWS IoT SiteWise, [erstellen Ihre Lambda-Funktionen einen Stream](work-with-streams.md#streammanagerclient-create-message-stream) mit einer Exportdefinition, die ein oder mehrere `IoTSiteWiseConfig` Objekte enthält. Dieses Objekt definiert Exporteinstellungen wie Batchgröße, Batch-Intervall und Priorität.
Wenn Ihre Lambda-Funktionen Asset-Eigenschaftsdaten von Geräten empfangen, hängen sie Nachrichten, die die Daten enthalten, an den Zielstream an. Nachrichten sind JSON-serialisierte `PutAssetPropertyValueEntry` Objekte, die Eigenschaftswerte für eine oder mehrere Asset-Eigenschaften enthalten. Weitere Informationen finden Sie unter [Nachricht für Exportziele anhängen](work-with-streams.md#streammanagerclient-append-message-sitewise). AWS IoT SiteWise
**Anmerkung**
Wenn Sie Daten an senden AWS IoT SiteWise, müssen Ihre Daten die Anforderungen der `BatchPutAssetPropertyValue` Aktion erfüllen. Weitere Informationen finden Sie unter [BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html) in der *AWS IoT SiteWise -API-Referenz*.
Anschließend exportiert Stream Manager die Daten auf der Grundlage der Batch-Einstellungen und der Priorität, die in den Exportkonfigurationen des Streams definiert sind.
Sie können Ihre Stream-Manager-Einstellungen und die Lambda-Funktionslogik anpassen, um Ihre Exportstrategie zu entwerfen. Beispiel:
+ Für Exporte fast in Echtzeit sollten Sie niedrige Einstellungen für Batchgröße und Intervalle festlegen und die Daten an den Stream anhängen, wenn sie empfangen werden.
+ Um die Batchverarbeitung zu optimieren, Bandbreitenbeschränkungen zu verringern oder Kosten zu minimieren, können Ihre Lambda-Funktionen die für eine einzelne Anlageneigenschaft empfangenen timestamp-quality-value (TQV-) Datenpunkte bündeln, bevor sie an den Stream angehängt werden. Eine Strategie besteht darin, Einträge für bis zu 10 verschiedene Kombinationen von Eigenschaften und Vermögenswerten oder Eigenschaftsaliasnamen in einer Nachricht zu bündeln, anstatt mehr als einen Eintrag für dieselbe Immobilie zu senden. [Dies hilft dem Streammanager, die Kontingente einzuhalten.AWS IoT SiteWise](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/quotas.html)
## Amazon-S3-Objekte
Stream Manager unterstützt automatische Exporte nach Amazon S3. Sie können Amazon S3 verwenden, um große Datenmengen zu speichern und abzurufen. Weitere Informationen finden Sie unter [Was ist Amazon S3?](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html) im *Amazon Simple Storage Service Developer Guide*.
Im AWS IoT Greengrass Core SDK verwenden Ihre Lambda-Funktionen die, `S3ExportTaskExecutorConfig` um die Exportkonfiguration für diesen Zieltyp zu definieren. Weitere Informationen finden Sie in der SDK-Referenz für Ihre Zielsprache:
+ [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.S3ExportTaskExecutorConfig) im Python-SDK
+ [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/S3ExportTaskExecutorConfig.html) im Java-SDK
+ [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.S3ExportTaskExecutorConfig.html) im SDK von Node.js
### Voraussetzungen
Für dieses Exportziel gelten die folgenden Anforderungen:
+ Die Amazon S3 S3-Ziel-Buckets müssen sich in derselben Gruppe AWS-Konto wie die Greengrass-Gruppe befinden.
+ Wenn die [Standardcontainerisierung](lambda-group-config.md#lambda-containerization-groupsettings) für die Greengrass-Gruppe **Greengrass-Container** ist, müssen Sie den Parameter [STREAM\$1MANAGER\$1READ\$1ONLY\$1DIRS](configure-stream-manager.md#stream-manager-read-only-directories) so einstellen, dass ein Eingabedateiverzeichnis verwendet wird, das sich unter oder außerhalb des Root-Dateisystems befindet. `/tmp`
+ Wenn eine Lambda-Funktion, die im **Greengrass-Container-Modus** ausgeführt wird, Eingabedateien in das Eingabedateiverzeichnis schreibt, müssen Sie eine lokale Volume-Ressource für das Verzeichnis erstellen und das Verzeichnis mit Schreibberechtigungen in den Container einbinden. Dadurch wird sichergestellt, dass die Dateien in das Root-Dateisystem geschrieben und außerhalb des Containers sichtbar sind. Weitere Informationen finden Sie unter [Greifen Sie mit Lambda-Funktionen und Konnektoren auf lokale Ressourcen zu](access-local-resources.md).
+ Sie [Greengrass-Gruppenrolle.](group-role.md) müssen die folgenden Berechtigungen für die Ziel-Buckets gewähren. Beispiel:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:ListMultipartUploadParts"
],
"Resource": [
"arn:aws:s3:::bucket-1-name/*",
"arn:aws:s3:::bucket-2-name/*"
]
}
]
}
```
------
Sie können detaillierten oder bedingten Zugriff auf Ressourcen gewähren, indem Sie beispielsweise ein `*` Platzhalter-Benennungsschema verwenden. Weitere Informationen finden Sie im IAM-Benutzerhandbuch unter [Hinzufügen und Entfernen von *IAM-Richtlinien*](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
### Exportieren nach Amazon S3
Um einen Stream zu erstellen, der nach Amazon S3 exportiert, verwenden Ihre Lambda-Funktionen das `S3ExportTaskExecutorConfig` Objekt, um die Exportrichtlinie zu konfigurieren. Die Richtlinie definiert Exporteinstellungen, wie z. B. den Schwellenwert und die Priorität für mehrteilige Uploads. Für Amazon S3 S3-Exporte lädt der Stream Manager Daten hoch, die er aus lokalen Dateien auf dem Kerngerät liest. Um einen Upload zu initiieren, hängen Ihre Lambda-Funktionen eine Exportaufgabe an den Zielstream an. Die Exportaufgabe enthält Informationen über die Eingabedatei und das Amazon S3 S3-Zielobjekt. Stream Manager führt Aufgaben in der Reihenfolge aus, in der sie an den Stream angehängt werden.
**Anmerkung**
Der Ziel-Bucket muss bereits in Ihrem vorhanden sein. AWS-Konto Wenn ein Objekt für den angegebenen Schlüssel nicht existiert, erstellt Stream Manager das Objekt für Sie.
Dieser allgemeine Arbeitsablauf ist in der folgenden Abbildung dargestellt.
![\[Diagramm des Stream Manager-Workflows für Amazon S3 S3-Exporte.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/stream-manager-s3.png)
Stream Manager verwendet die Eigenschaft „Schwellenwert für mehrteilige Uploads“, die Einstellung für die [Mindestgröße von Teilen](configure-stream-manager.md#stream-manager-minimum-part-size) und die Größe der Eingabedatei, um zu bestimmen, wie Daten hochgeladen werden. Der Schwellenwert für mehrteilige Uploads muss größer oder gleich der Mindestgröße für Teile sein. Wenn Sie Daten parallel hochladen möchten, können Sie mehrere Streams erstellen.
Die Schlüssel, die Ihre Amazon S3 S3-Zielobjekte angeben, können gültige [ DateTimeFormatterJava-Zeichenfolgen](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html) in `!{timestamp:value}` Platzhaltern enthalten. Sie können diese Zeitstempel-Platzhalter verwenden, um Daten in Amazon S3 auf der Grundlage der Uhrzeit zu partitionieren, zu der die Eingabedateidaten hochgeladen wurden. Der folgende Schlüsselname wird beispielsweise in einen Wert wie aufgelöst. `my-key/2020/12/31/data.txt`
```
my-key/!{timestamp:YYYY}/!{timestamp:MM}/!{timestamp:dd}/data.txt
```
**Anmerkung**
Wenn Sie den Exportstatus für einen Stream überwachen möchten, erstellen Sie zuerst einen Status-Stream und konfigurieren Sie dann den Exportstream so, dass er ihn verwendet. Weitere Informationen finden Sie unter [Überwachen Sie die Exportaufgaben](#monitor-export-status-s3).
#### Eingabedaten verwalten
Sie können Code verfassen, den IoT-Anwendungen verwenden, um den Lebenszyklus der Eingabedaten zu verwalten. Der folgende Beispiel-Workflow zeigt, wie Sie Lambda-Funktionen verwenden können, um diese Daten zu verwalten.
1. Ein lokaler Prozess empfängt Daten von Geräten oder Peripheriegeräten und schreibt die Daten dann in Dateien in einem Verzeichnis auf dem Kerngerät. Dies sind die Eingabedateien für den Stream-Manager.
**Anmerkung**
Informationen darüber, ob Sie den Zugriff auf das Eingabedateiverzeichnis konfigurieren müssen, finden Sie im Parameter [STREAM\$1MANAGER\$1READ\$1ONLY\$1DIRS](configure-stream-manager.md#stream-manager-read-only-directories).
[Der Prozess, in dem Stream Manager ausgeführt wird, erbt alle Dateisystemberechtigungen der Standardzugriffsidentität für die Gruppe.](lambda-group-config.md#lambda-access-identity-groupsettings) Der Stream-Manager muss über die Zugriffsberechtigung für die Eingabedateien verfügen. Sie können den `chmod(1)` Befehl verwenden, um die Berechtigungen der Dateien bei Bedarf zu ändern.
1. Eine Lambda-Funktion scannt das Verzeichnis und [hängt eine Exportaufgabe](work-with-streams.md#streammanagerclient-append-message-export-task) an den Zielstream an, wenn eine neue Datei erstellt wird. Die Aufgabe ist ein JSON-serialisiertes `S3ExportTaskDefinition` Objekt, das die URL der Eingabedatei, den Amazon S3 S3-Ziel-Bucket und -Schlüssel sowie optionale Benutzermetadaten angibt.
1. Stream Manager liest die Eingabedatei und exportiert die Daten in der Reihenfolge der angehängten Aufgaben nach Amazon S3. Der Ziel-Bucket muss bereits in Ihrem AWS-Konto vorhanden sein. Wenn ein Objekt für den angegebenen Schlüssel nicht existiert, erstellt Stream Manager das Objekt für Sie.
1. Die Lambda-Funktion [liest Nachrichten](work-with-streams.md#streammanagerclient-read-messages) aus einem Status-Stream, um den Exportstatus zu überwachen. Nach Abschluss der Exportaufgaben kann die Lambda-Funktion die entsprechenden Eingabedateien löschen. Weitere Informationen finden Sie unter [Überwachen Sie die Exportaufgaben](#monitor-export-status-s3).
### Überwachen Sie die Exportaufgaben
Sie können Code verfassen, den IoT-Anwendungen verwenden, um den Status Ihrer Amazon S3 S3-Exporte zu überwachen. Ihre Lambda-Funktionen müssen einen Status-Stream erstellen und dann den Export-Stream so konfigurieren, dass Statusaktualisierungen in den Status-Stream geschrieben werden. Ein einziger Status-Stream kann Statusaktualisierungen von mehreren Streams empfangen, die nach Amazon S3 exportiert werden.
[Erstellen Sie zunächst einen Stream](work-with-streams.md#streammanagerclient-create-message-stream), der als Status-Stream verwendet werden soll. Sie können die Größe und die Aufbewahrungsrichtlinien für den Stream konfigurieren, um die Lebensdauer der Statusmeldungen zu steuern. Beispiel:
+ Stellen `Persistence` Sie `Memory` diese Option ein, wenn Sie die Statusmeldungen nicht speichern möchten.
+ Auf `StrategyOnFull` einstellen, `OverwriteOldestData` damit neue Statusmeldungen nicht verloren gehen.
Erstellen oder aktualisieren Sie dann den Exportstream, um den Status-Stream zu verwenden. Legen Sie insbesondere die Statuskonfigurationseigenschaft der `S3ExportTaskExecutorConfig` Exportkonfiguration des Streams fest. Dadurch wird der Stream-Manager angewiesen, Statusmeldungen über die Exportaufgaben in den Status-Stream zu schreiben. Geben Sie im `StatusConfig` Objekt den Namen des Status-Streams und den Grad der Ausführlichkeit an. Die folgenden unterstützten Werte reichen von der geringsten Ausführlichkeit (`ERROR`) bis zur höchsten Ausführlichkeit (). `TRACE` Der Standardwert ist `INFO`.
+ `ERROR`
+ `WARN`
+ `INFO`
+ `DEBUG`
+ `TRACE`
Der folgende Beispiel-Workflow zeigt, wie Lambda-Funktionen einen Status-Stream verwenden könnten, um den Exportstatus zu überwachen.
1. Wie im vorherigen Workflow beschrieben, [hängt eine Lambda-Funktion eine Exportaufgabe an einen](work-with-streams.md#streammanagerclient-append-message-export-task) Stream an, der so konfiguriert ist, dass Statusmeldungen über Exportaufgaben in einen Status-Stream geschrieben werden. Die Anfügeoperation gibt eine Sequenznummer zurück, die die Aufgaben-ID darstellt.
1. Eine Lambda-Funktion [liest Nachrichten](work-with-streams.md#streammanagerclient-read-messages) sequentiell aus dem Status-Stream und filtert die Nachrichten dann basierend auf dem Streamnamen und der Task-ID oder basierend auf einer Exportaufgabeneigenschaft aus dem Nachrichtenkontext. Die Lambda-Funktion kann beispielsweise nach der Eingabedatei-URL der Exportaufgabe filtern, die durch das `S3ExportTaskDefinition` Objekt im Nachrichtenkontext dargestellt wird.
Die folgenden Statuscodes geben an, dass eine Exportaufgabe den Status „Abgeschlossen“ erreicht hat:
+ `Success`. Der Upload wurde erfolgreich abgeschlossen.
+ `Failure`. Stream Manager ist auf einen Fehler gestoßen, z. B. ist der angegebene Bucket nicht vorhanden. Nachdem Sie das Problem behoben haben, können Sie die Exportaufgabe erneut an den Stream anhängen.
+ `Canceled`. Die Aufgabe wurde abgebrochen, weil die Stream- oder Exportdefinition gelöscht wurde oder der Zeitraum time-to-live (TTL) der Aufgabe abgelaufen ist.
**Anmerkung**
Die Aufgabe hat möglicherweise auch den Status oder. `InProgress` `Warning` Stream Manager gibt Warnungen aus, wenn ein Ereignis einen Fehler zurückgibt, der die Ausführung der Aufgabe nicht beeinträchtigt. Wenn beispielsweise ein abgebrochener teilweiser Upload nicht bereinigt werden kann, wird eine Warnung zurückgegeben.
1. Nach Abschluss der Exportaufgaben kann die Lambda-Funktion die entsprechenden Eingabedateien löschen.
Das folgende Beispiel zeigt, wie eine Lambda-Funktion Statusmeldungen lesen und verarbeiten könnte.
------
#### [ Python ]
```
import time
from greengrasssdk.stream_manager import (
ReadMessagesOptions,
Status,
StatusConfig,
StatusLevel,
StatusMessage,
StreamManagerClient,
)
from greengrasssdk.stream_manager.util import Util
client = StreamManagerClient()
try:
# Read the statuses from the export status stream
is_file_uploaded_to_s3 = False
while not is_file_uploaded_to_s3:
try:
messages_list = client.read_messages(
"StatusStreamName", ReadMessagesOptions(min_message_count=1, read_timeout_millis=1000)
)
for message in messages_list:
# Deserialize the status message first.
status_message = Util.deserialize_json_bytes_to_obj(message.payload, StatusMessage)
# Check the status of the status message. If the status is "Success",
# the file was successfully uploaded to S3.
# If the status was either "Failure" or "Cancelled", the server was unable to upload the file to S3.
# We will print the message for why the upload to S3 failed from the status message.
# If the status was "InProgress", the status indicates that the server has started uploading
# the S3 task.
if status_message.status == Status.Success:
logger.info("Successfully uploaded file at path " + file_url + " to S3.")
is_file_uploaded_to_s3 = True
elif status_message.status == Status.Failure or status_message.status == Status.Canceled:
logger.info(
"Unable to upload file at path " + file_url + " to S3. Message: " + status_message.message
)
is_file_uploaded_to_s3 = True
time.sleep(5)
except StreamManagerException:
logger.exception("Exception while running")
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [read\$1messages \$1 [StatusMessage](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.StatusMessage)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.read_messages)
------
#### [ Java ]
```
import com.amazonaws.greengrass.streammanager.client.StreamManagerClient;
import com.amazonaws.greengrass.streammanager.client.utils.ValidateAndSerialize;
import com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions;
import com.amazonaws.greengrass.streammanager.model.Status;
import com.amazonaws.greengrass.streammanager.model.StatusConfig;
import com.amazonaws.greengrass.streammanager.model.StatusLevel;
import com.amazonaws.greengrass.streammanager.model.StatusMessage;
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
try {
boolean isS3UploadComplete = false;
while (!isS3UploadComplete) {
try {
// Read the statuses from the export status stream
List messages = client.readMessages("StatusStreamName",
new ReadMessagesOptions().withMinMessageCount(1L).withReadTimeoutMillis(1000L));
for (Message message : messages) {
// Deserialize the status message first.
StatusMessage statusMessage = ValidateAndSerialize.deserializeJsonBytesToObj(message.getPayload(), StatusMessage.class);
// Check the status of the status message. If the status is "Success", the file was successfully uploaded to S3.
// If the status was either "Failure" or "Canceled", the server was unable to upload the file to S3.
// We will print the message for why the upload to S3 failed from the status message.
// If the status was "InProgress", the status indicates that the server has started uploading the S3 task.
if (Status.Success.equals(statusMessage.getStatus())) {
System.out.println("Successfully uploaded file at path " + FILE_URL + " to S3.");
isS3UploadComplete = true;
} else if (Status.Failure.equals(statusMessage.getStatus()) || Status.Canceled.equals(statusMessage.getStatus())) {
System.out.println(String.format("Unable to upload file at path %s to S3. Message %s",
statusMessage.getStatusContext().getS3ExportTaskDefinition().getInputUrl(),
statusMessage.getMessage()));
sS3UploadComplete = true;
}
}
} catch (StreamManagerException ignored) {
} finally {
// Sleep for sometime for the S3 upload task to complete before trying to read the status message.
Thread.sleep(5000);
}
} catch (e) {
// Properly handle errors.
}
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java SDK-Referenz: [readMessages \$1 [StatusMessage](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/StatusMessage.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#readMessages-java.lang.String-com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions-)
------
#### [ Node.js ]
```
const {
StreamManagerClient, ReadMessagesOptions,
Status, StatusConfig, StatusLevel, StatusMessage,
util,
} = require('aws-greengrass-core-sdk').StreamManager;
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
let isS3UploadComplete = false;
while (!isS3UploadComplete) {
try {
// Read the statuses from the export status stream
const messages = await c.readMessages("StatusStreamName",
new ReadMessagesOptions()
.withMinMessageCount(1)
.withReadTimeoutMillis(1000));
messages.forEach((message) => {
// Deserialize the status message first.
const statusMessage = util.deserializeJsonBytesToObj(message.payload, StatusMessage);
// Check the status of the status message. If the status is 'Success', the file was successfully uploaded to S3.
// If the status was either 'Failure' or 'Cancelled', the server was unable to upload the file to S3.
// We will print the message for why the upload to S3 failed from the status message.
// If the status was "InProgress", the status indicates that the server has started uploading the S3 task.
if (statusMessage.status === Status.Success) {
console.log(`Successfully uploaded file at path ${FILE_URL} to S3.`);
isS3UploadComplete = true;
} else if (statusMessage.status === Status.Failure || statusMessage.status === Status.Canceled) {
console.log(`Unable to upload file at path ${FILE_URL} to S3. Message: ${statusMessage.message}`);
isS3UploadComplete = true;
}
});
// Sleep for sometime for the S3 upload task to complete before trying to read the status message.
await new Promise((r) => setTimeout(r, 5000));
} catch (e) {
// Ignored
}
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Node.js SDK-Referenz: [readMessages \$1 [StatusMessage](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StatusMessage.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#readMessages)
------
# Datenströme in die AWS Cloud (Konsole) exportieren
Dieses Tutorial zeigt Ihnen, wie Sie die AWS IoT Konsole verwenden, um eine AWS IoT Greengrass Gruppe mit aktiviertem Stream-Manager zu konfigurieren und bereitzustellen. Die Gruppe enthält eine benutzerdefinierte Lambda-Funktion, die in einen Stream im Stream-Manager schreibt, der dann automatisch in den exportiert wird. AWS Cloud
Stream Manager macht die Aufnahme, Verarbeitung und den Export von Datenströmen mit hohem Volumen effizienter und zuverlässiger. In diesem Tutorial erstellen Sie eine `TransferStream` Lambda-Funktion, die IoT-Daten verbraucht. Die Lambda-Funktion verwendet das AWS IoT Greengrass Core SDK, um einen Stream im Stream Manager zu erstellen und dann in ihn zu lesen und zu schreiben. Stream Manager exportiert den Stream dann nach Kinesis Data Streams. Im folgenden Diagramm wird dieser Workflow veranschaulicht.
![\[Diagramm des Stream-Management-Workflows.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/stream-manager-scenario.png)
Der Schwerpunkt dieses Tutorials liegt darauf, zu zeigen, wie benutzerdefinierte Lambda-Funktionen das `StreamManagerClient` Objekt im AWS IoT Greengrass Core SDK verwenden, um mit dem Stream Manager zu interagieren. Der Einfachheit halber generiert die Python-Lambda-Funktion, die Sie für dieses Tutorial erstellen, simulierte Gerätedaten.
## Voraussetzungen
Zum Durchführen dieses Tutorials benötigen Sie Folgendes:
+ Eine Greengrass-Gruppe und ein Greengrass-Kern (v1.10 oder höher). Informationen zum Erstellen einer Greengrass-Gruppe und eines Greengrass-Kerns finden Sie unter[Erste Schritte mit AWS IoT Greengrass](gg-gs.md). Das Tutorial „Erste Schritte“ enthält auch Schritte zur Installation der AWS IoT Greengrass Core-Software.
**Anmerkung**
Stream Manager wird auf OpenWrt Distributionen nicht unterstützt.
+ Die Java 8-Laufzeitumgebung (JDK 8) muss auf dem Core-Gerät installiert sein.
+ Führen Sie für Debian-basierte Distributionen (einschließlich Raspbian) oder Ubuntu-basierte Distributionen den folgenden Befehl aus:
```
sudo apt install openjdk-8-jdk
```
+ Führen Sie für Red Hat-basierte Distributionen (einschließlich Amazon Linux) den folgenden Befehl aus:
```
sudo yum install java-1.8.0-openjdk
```
Weitere Informationen finden Sie unter [How to download and install prebuilt OpenJDK packages](https://openjdk.java.net/install/) in der OpenJDK-Dokumentation.
+ AWS IoT Greengrass Core SDK für Python v1.5.0 oder höher. Um es `StreamManagerClient` im AWS IoT Greengrass Core SDK für Python zu verwenden, müssen Sie:
+ Installieren Sie Python 3.7 oder höher auf dem Core-Gerät.
+ Nehmen Sie das SDK und seine Abhängigkeiten in Ihr Lambda-Funktionsbereitstellungspaket auf. Anweisungen finden Sie in diesem Tutorial.
**Tipp**
Sie können `StreamManagerClient` mit Java oder NodeJS verwenden. Beispielcode finden Sie unter dem [AWS IoT Greengrass Core SDK for Java](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) und dem [AWS IoT Greengrass Core SDK für Node.js](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) GitHub.
+ Ein Zielstream mit dem Namen, der in Amazon Kinesis Data Streams in derselben AWS-Region Greengrass-Gruppe **MyKinesisStream** erstellt wurde. Weitere Informationen finden Sie unter [Create a Stream](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#create-stream) im *Amazon Kinesis Developer Guide*.
**Anmerkung**
In diesem Tutorial exportiert Stream Manager Daten in Kinesis Data Streams, was zu Gebühren für Sie AWS-Konto führt. Preisinformationen finden Sie unter Preise für [Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/).
Um Kosten zu vermeiden, können Sie dieses Lernprogramm ausführen, ohne einen Kinesis-Datenstream zu erstellen. In diesem Fall überprüfen Sie die Protokolle, um festzustellen, dass der Stream-Manager versucht hat, den Stream nach Kinesis Data Streams zu exportieren.
+ Dem wurde eine IAM-Richtlinie hinzugefügt[Greengrass-Gruppenrolle.](group-role.md), die die `kinesis:PutRecords` Aktion für den Zieldatenstream ermöglicht, wie im folgenden Beispiel gezeigt:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:PutRecords"
],
"Resource": [
"arn:aws:kinesis:us-east-1:123456789012:stream/MyKinesisStream"
]
}
]
}
```
------
Das Tutorial enthält die folgenden allgemeinen Schritte:
1. [Erstellen Sie ein Bereitstellungspaket für Lambda-Funktionen](#stream-manager-console-create-deployment-package)
1. [Erstellen einer Lambda-Funktion](#stream-manager-console-create-function)
1. [Hinzufügen einer Funktion zur Gruppe](#stream-manager-console-create-gg-function)
1. [Aktivieren des Stream-Managers](#stream-manager-console-enable-stream-manager)
1. [Konfigurieren der lokalen Protokollierung](#stream-manager-console-configure-logging)
1. [Bereitstellen der Gruppe](#stream-manager-console-create-deployment)
1. [Testen der Anwendung](#stream-manager-console-test-application)
Für dieses Tutorial benötigen Sie ungefähr 20 Minuten.
## Schritt 1: Erstellen Sie ein Lambda-Funktions-Bereitstellungspaket
In diesem Schritt erstellen Sie ein Paket zur Bereitstellung von Lambda-Funktionen, das Python-Funktionscode und Abhängigkeiten enthält. Sie laden dieses Paket später hoch, wenn Sie die Lambda-Funktion in AWS Lambda erstellen. Die Lambda-Funktion verwendet das AWS IoT Greengrass Core SDK, um lokale Streams zu erstellen und mit ihnen zu interagieren.
**Anmerkung**
Ihre benutzerdefinierten Lambda-Funktionen müssen das [AWS IoT Greengrass Core SDK](lambda-functions.md#lambda-sdks-core) verwenden, um mit dem Stream Manager zu interagieren. Weitere Informationen zu den Anforderungen für den Greengrass Stream-Manager finden Sie im Artikel über die [Voraussetzungen für Greengrass Stream-Manager](stream-manager.md#stream-manager-requirements).
1. Laden Sie das [AWS IoT Greengrass Core SDK für Python](lambda-functions.md#lambda-sdks-core) v1.5.0 oder höher herunter.
1. Entpacken Sie das heruntergeladene Paket, um das SDK zu erhalten. Das SDK ist der `greengrasssdk`-Ordner.
1. Installieren Sie Paketabhängigkeiten, die mit dem SDK in Ihr Lambda-Funktionsbereitstellungspaket aufgenommen werden sollen.
1. Navigieren Sie zum SDK-Verzeichnis, das die `requirements.txt`-Datei enthält. Diese Datei listet die Abhängigkeiten auf.
1. Installieren Sie die SDK-Abhängigkeiten. Führen Sie beispielsweise den folgenden `pip`-Befehl aus, um sie im aktuellen Verzeichnis zu installieren:
```
pip install --target . -r requirements.txt
```
1. Speichern Sie die folgende Pythoncode-Funktion in einer lokalen Datei namens `transfer_stream.py`.
**Tipp**
Beispielcode, der Java und NodeJS verwendet, finden Sie im [AWS IoT Greengrass Core SDK for Java](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) und [AWS IoT Greengrass Core SDK for Node.js](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) unter. GitHub
```
import asyncio
import logging
import random
import time
from greengrasssdk.stream_manager import (
ExportDefinition,
KinesisConfig,
MessageStreamDefinition,
ReadMessagesOptions,
ResourceNotFoundException,
StrategyOnFull,
StreamManagerClient,
)
# This example creates a local stream named "SomeStream".
# It starts writing data into that stream and then stream manager automatically exports
# the data to a customer-created Kinesis data stream named "MyKinesisStream".
# This example runs forever until the program is stopped.
# The size of the local stream on disk will not exceed the default (which is 256 MB).
# Any data appended after the stream reaches the size limit continues to be appended, and
# stream manager deletes the oldest data until the total stream size is back under 256 MB.
# The Kinesis data stream in the cloud has no such bound, so all the data from this script is
# uploaded to Kinesis and you will be charged for that usage.
def main(logger):
try:
stream_name = "SomeStream"
kinesis_stream_name = "MyKinesisStream"
# Create a client for the StreamManager
client = StreamManagerClient()
# Try deleting the stream (if it exists) so that we have a fresh start
try:
client.delete_message_stream(stream_name=stream_name)
except ResourceNotFoundException:
pass
exports = ExportDefinition(
kinesis=[KinesisConfig(identifier="KinesisExport" + stream_name, kinesis_stream_name=kinesis_stream_name)]
)
client.create_message_stream(
MessageStreamDefinition(
name=stream_name, strategy_on_full=StrategyOnFull.OverwriteOldestData, export_definition=exports
)
)
# Append two messages and print their sequence numbers
logger.info(
"Successfully appended message to stream with sequence number %d",
client.append_message(stream_name, "ABCDEFGHIJKLMNO".encode("utf-8")),
)
logger.info(
"Successfully appended message to stream with sequence number %d",
client.append_message(stream_name, "PQRSTUVWXYZ".encode("utf-8")),
)
# Try reading the two messages we just appended and print them out
logger.info(
"Successfully read 2 messages: %s",
client.read_messages(stream_name, ReadMessagesOptions(min_message_count=2, read_timeout_millis=1000)),
)
logger.info("Now going to start writing random integers between 0 and 1000 to the stream")
# Now start putting in random data between 0 and 1000 to emulate device sensor input
while True:
logger.debug("Appending new random integer to stream")
client.append_message(stream_name, random.randint(0, 1000).to_bytes(length=4, signed=True, byteorder="big"))
time.sleep(1)
except asyncio.TimeoutError:
logger.exception("Timed out while executing")
except Exception:
logger.exception("Exception while running")
def function_handler(event, context):
return
logging.basicConfig(level=logging.INFO)
# Start up this sample code
main(logger=logging.getLogger())
```
1. Packen Sie die folgenden Elemente in einer ZIP-Datei mit dem Namen `transfer_stream_python.zip`. Dies ist Ihr Lambda-Funktionsbereitstellungspaket.
+ **transfer\$1stream.py**. App-Logik.
+ **greengrasssdk**. Erforderliche Bibliothek für Python Greengrass Lambda-Funktionen, die MQTT-Nachrichten veröffentlichen.
[Stream Manager-Operationen](work-with-streams.md) sind in Version 1.5.0 oder höher des AWS IoT Greengrass Core SDK für Python verfügbar.
+ Die Abhängigkeiten, die Sie für das AWS IoT Greengrass Core SDK für Python installiert haben (z. B. die `cbor2` Verzeichnisse).
Wenn Sie die `zip`-Datei erstellen, schließen Sie nur diese Elemente ein, nicht den enthaltenen Ordner.
## Schritt 2: Erstellen einer Lambda-Funktion
In diesem Schritt verwenden Sie die AWS Lambda Konsole, um eine Lambda-Funktion zu erstellen und sie für die Verwendung Ihres Bereitstellungspakets zu konfigurieren. Anschließend veröffentlichen Sie eine Funktionsversion und erstellen einen Alias.
1. Erstellen Sie zunächst die Lambda-Funktion.
1. Wählen Sie in der AWS-Managementkonsole**Dienste** aus und öffnen Sie die AWS Lambda Konsole.
1. Wählen Sie „**Funktion erstellen**“ und anschließend „**Von Grund auf neu erstellen**“.
1. Verwenden Sie im Abschnitt **Basic information (Basisinformationen)** folgende Werte:
+ Geben Sie für **Function name** (Funktionsname) **TransferStream** ein.
+ Wählen Sie für **Runtime (Laufzeit)** die Option **Python 3.7** aus.
+ Behalten Sie für **Berechtigungen** die Standardeinstellung bei. Dadurch wird eine Ausführungsrolle erstellt, die grundlegende Lambda-Berechtigungen gewährt. Diese Rolle wird nicht verwendet von AWS IoT Greengrass.
1. Klicken Sie unten auf der Seite auf **Create function**.
1. Registrieren Sie als Nächstes den Handler und laden Sie Ihr Lambda-Funktionsbereitstellungspaket hoch.
1. Wählen Sie auf der Registerkarte **Code** unter **Codequelle** die Option **Upload von aus**. Wählen Sie in der Dropdownliste die **ZIP-Datei** aus.
![\[Das Drop-down-Menü „Von hochladen“, wobei die ZIP-Datei hervorgehoben ist.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png)
1. Wählen Sie **Hochladen** und dann Ihr `transfer_stream_python.zip` Bereitstellungspaket aus. Wählen Sie dann **Save (Speichern)** aus.
1. Wählen Sie auf der Registerkarte **Code** für die Funktion unter **Laufzeiteinstellungen** die Option **Bearbeiten** aus, und geben Sie dann die folgenden Werte ein.
+ Wählen Sie für **Runtime (Laufzeit)** die Option **Python 3.7** aus.
+ Geben Sie unter **Handler** **transfer\$1stream.function\$1handler** ein.
1. Wählen Sie **Speichern**.
**Anmerkung**
Die **Testtaste** auf der AWS Lambda Konsole funktioniert mit dieser Funktion nicht. Das AWS IoT Greengrass Core SDK enthält keine Module, die erforderlich sind, um Ihre Greengrass Lambda-Funktionen unabhängig in der AWS Lambda Konsole auszuführen. Diese Module (zum Beispiel`greengrass_common`) werden den Funktionen zur Verfügung gestellt, nachdem sie auf Ihrem Greengrass-Kern bereitgestellt wurden.
1. Veröffentlichen Sie jetzt die erste Version Ihrer Lambda-Funktion und erstellen Sie einen [Alias für die Version](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html).
**Anmerkung**
Greengrass-Gruppen können eine Lambda-Funktion nach Alias (empfohlen) oder nach Version referenzieren. Die Verwendung eines Alias erleichtert die Verwaltung von Codeaktualisierungen, da Sie Ihre Abonnementtabelle oder Gruppendefinition nicht ändern müssen, wenn der Funktionscode aktualisiert wird. Stattdessen verweisen Sie einfach mit dem Alias auf die neue Funktionsversion.
1. Wählen Sie im Menü **Actions** die Option **Publish new version** aus.
1. Geben Sie unter **Version description (Versionsbeschreibung)** den Wert **First version** ein und wählen Sie dann **Publish (Veröffentlichen)** aus.
1. Wählen Sie auf der Konfigurationsseite **TransferStream: 1** im Menü **Aktionen** die Option **Alias erstellen** aus.
1. Geben Sie auf der Seite **Create a new alias** folgende Werte an:
+ Geben Sie unter **Name** **GG\$1TransferStream** ein.
+ Wählen Sie für **Version** die Option **1**.
**Anmerkung**
AWS IoT Greengrass unterstützt keine Lambda-Aliase für **\$1LATEST-Versionen**.
1. Wählen Sie **Erstellen** aus.
Jetzt sind Sie bereit, die Lambda-Funktion zu Ihrer Greengrass-Gruppe hinzuzufügen.
## Schritt 3: Fügen Sie der Greengrass-Gruppe eine Lambda-Funktion hinzu
In diesem Schritt fügen Sie der Gruppe die Lambda-Funktion hinzu und konfigurieren dann ihre Lebenszyklus- und Umgebungsvariablen. Weitere Informationen finden Sie unter [Steuerung der Ausführung von Greengrass Lambda-Funktionen mithilfe einer gruppenspezifischen Konfiguration](lambda-group-config.md).
1. Erweitern Sie im Navigationsbereich der AWS IoT Konsole unter **Verwalten** die Option **Greengrass-Geräte** und wählen Sie dann **Gruppen (V1)** aus.
1. Wählen Sie die Zielgruppe aus.
1. Wählen Sie auf der Gruppenkonfigurationsseite die Registerkarte **Lambda-Funktionen** aus.
1. Wählen Sie unter **Meine Lambda-Funktionen** die Option **Hinzufügen** aus.
1. Wählen Sie auf der Seite **Lambda-Funktion hinzufügen** die **Lambda-Funktion für Ihre Lambda-Funktion** aus.
1. Wählen Sie für die **Lambda-Version TransferStream** **Alias:GG\$1**.
Konfigurieren Sie nun Eigenschaften, die das Verhalten der Lambda-Funktion in der Greengrass-Gruppe bestimmen.
1. Nehmen Sie im Abschnitt **Lambda-Funktionskonfiguration** die folgenden Änderungen vor:
+ Legen Sie die **Speichergrenze** auf 32 MB fest.
+ **Wählen Sie für **Pinned die** Option True aus.**
**Anmerkung**
Eine *langlebige* (oder *fixierte*) Lambda-Funktion wird nach dem Start automatisch AWS IoT Greengrass gestartet und läuft in ihrem eigenen Container weiter. Dies steht im Gegensatz zu einer *On-Demand-Lambda-Funktion*, die startet, wenn sie aufgerufen wird, und stoppt, wenn keine Aufgaben mehr zur Ausführung übrig sind. Weitere Informationen finden Sie unter [Lebenszykluskonfiguration für Greengrass Lambda-Funktionen](lambda-functions.md#lambda-lifecycle).
1. Wählen Sie **Lambda-Funktion hinzufügen**.
## Schritt 4: Aktivieren des Stream-Managers
In diesem Schritt stellen Sie sicher, dass der Stream-Manager aktiviert ist.
1. Wählen Sie auf der Gruppenkonfigurationsseite die Registerkarte **Lambda-Funktionen** aus.
1. Wählen Sie unter **System Lambda functions** die Option **Stream Manager** aus und überprüfen Sie den Status. Wenn diese Option deaktiviert ist, wählen Sie **Bearbeiten** aus. Wählen Sie dann **Aktivieren** und **Speichern** aus. Sie können die Standardparametereinstellungen für dieses Tutorial verwenden. Weitere Informationen finden Sie unter [AWS IoT Greengrass Streammanager konfigurieren](configure-stream-manager.md).
**Anmerkung**
Wenn Sie die Konsole verwenden, um Stream Manager zu aktivieren und die Gruppe bereitzustellen, ist die Speichergröße für Stream Manager standardmäßig auf 4194304 KB (4 GB) festgelegt. Wir empfehlen, die Speichergröße auf mindestens 128000 KB festzulegen.
## Schritt 5: Konfigurieren der lokalen Protokollierung
In diesem Schritt konfigurieren Sie AWS IoT Greengrass Systemkomponenten, benutzerdefinierte Lambda-Funktionen und Konnektoren in der Gruppe, um Protokolle in das Dateisystem des Kerngeräts zu schreiben. Sie können Protokolle verwenden, um Probleme zu beheben, die auftreten können. Weitere Informationen finden Sie unter [Überwachung mit AWS IoT Greengrass Protokollen](greengrass-logs-overview.md).
1. Überprüfen Sie unter **Konfiguration der lokalen Protokolle**, ob die lokale Protokollierung konfiguriert ist.
1. **Wenn Logs nicht für Greengrass-Systemkomponenten oder benutzerdefinierte Lambda-Funktionen konfiguriert sind, wählen Sie Bearbeiten.**
1. Wählen Sie die Protokollebene der **Benutzerlambda-Funktionen und die Protokollebene** des **Greengrass-Systems** aus.
1. Behalten Sie die Standardwerte für die Protokollierungsebene und Kontingentsgrenze bei. Wählen Sie anschließend **Save (Speichern)** aus.
## Schritt 6: Bereitstellen der Greengrass-Gruppe
Stellen Sie die Gruppe auf dem Core-Gerät bereit.
1. Stellen Sie sicher, dass der AWS IoT Greengrass Core läuft. Führen Sie im Raspberry Pi-Terminal die folgenden Befehle aus, falls nötig.
1. So prüfen Sie, ob der Daemon ausgeführt wird:
```
ps aux | grep -E 'greengrass.*daemon'
```
Wenn die Ausgabe einen `root`-Eintrag für `/greengrass/ggc/packages/ggc-version/bin/daemon` enthält, dann wird der Daemon ausgeführt.
**Anmerkung**
Die Version im Pfad hängt von der AWS IoT Greengrass Core-Softwareversion ab, die auf Ihrem Core-Gerät installiert ist.
1. Um den Daemon zu starten:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. Wählen Sie auf der Seite mit der Gruppenkonfiguration die Option **Deploy** aus.
1.
1. **Wählen Sie auf der Registerkarte **Lambda-Funktionen** im Abschnitt **System-Lambda-Funktionen** die Option **IP-Detektor** und dann Bearbeiten aus.**
1. Wählen **Sie im Dialogfeld IP-Detektoreinstellungen bearbeiten** die Option **MQTT-Broker-Endpunkte automatisch erkennen und überschreiben** aus.
1. Wählen Sie **Speichern**.
Damit können Geräte automatisch Core-Verbindungsinformationen abrufen, z. B. die IP-Adresse, DNS und die Portnummer. Eine automatische Erkennung wird empfohlen, unterstützt aber AWS IoT Greengrass auch manuell angegebene Endpunkte. Sie werden nur bei der ersten Bereitstellung der Gruppe zur Angabe der Ermittlungsmethode aufgefordert.
**Anmerkung**
Wenn Sie dazu aufgefordert werden, erteilen Sie die Erlaubnis, die [Greengrass-Servicerolle zu erstellen und sie Ihrer AWS-Konto aktuellen AWS-Region Rolle](service-role.md) zuzuordnen. Diese Rolle ermöglicht AWS IoT Greengrass den Zugriff auf Ihre Ressourcen in AWS Diensten.
Auf der Seite **Deployments** werden der Zeitstempel, die Versions-ID und der Status der Bereitstellung angegeben. Nach Abschluss sollte der für die Bereitstellung angezeigte Status **Abgeschlossen** lauten.
Hilfe zur Problembehebung finden Sie unter [Problembehebung AWS IoT Greengrass](gg-troubleshooting.md).
## Schritt 7: Testen der Anwendung
Die `TransferStream` Lambda-Funktion generiert simulierte Gerätedaten. Sie schreibt Daten in einen Stream, den der Stream-Manager in den Kinesis-Zieldatenstream exportiert.
1. Wählen Sie in der Amazon Kinesis Kinesis-Konsole unter **Kinesis-Datenstreams** die Option. **MyKinesisStream**
**Anmerkung**
Wenn Sie das Lernprogramm ohne Kinesis-Zieldatenstream ausgeführt haben, [suchen Sie in der Protokolldatei](stream-manager-cli.md#stream-manager-cli-logs) nach dem Stream-Manager (`GGStreamManager`). Wenn `export stream MyKinesisStream doesn't exist` in einer Fehlermeldung enthalten ist, ist der Test erfolgreich. Dieser Fehler bedeutet, dass der Service versucht hat, in den Stream zu exportieren, der Stream jedoch nicht existiert.
1. **Wählen Sie auf der **MyKinesisStream**Seite Monitoring aus.** Wenn der Test erfolgreich ist, sollten Sie die Daten in den **Put Records (Datensätze übergeben)**-Diagrammen sehen. Je nach Verbindung kann es eine Minute dauern, bis die Daten angezeigt werden.
**Wichtig**
Löschen Sie nach Abschluss des Tests den Kinesis-Datenstream, um zusätzliche Kosten zu vermeiden.
Oder führen Sie die folgenden Befehle aus, um den Greengrass-Daemon zu stoppen. Dadurch wird verhindert, dass der Core Nachrichten sendet, bis Sie bereit sind, den Test fortzusetzen.
```
cd /greengrass/ggc/core/
sudo ./greengrassd stop
```
1. Entfernen Sie die **TransferStream**Lambda-Funktion aus dem Kern.
1. Erweitern Sie im Navigationsbereich der AWS IoT Konsole unter **Verwalten** die Option **Greengrass-Geräte** und wählen Sie dann **Gruppen (V1)** aus.
1. Wählen Sie unter **Greengrass-Gruppen** Ihre Gruppe aus.
1. **Wählen Sie auf der **Lambdas-Seite** die Ellipsen (**...**) für die **TransferStream**Funktion aus, und wählen Sie dann Funktion entfernen aus.**
1. Wählen Sie unter **Actions (Aktionen)** die Option **Deploy (Bereitstellen)** aus.
Um Protokollierungsinformationen anzuzeigen oder Probleme mit Streams zu beheben, suchen Sie in den Protokollen nach den Funktionen `TransferStream` und `GGStreamManager`. Sie müssen über `root` Berechtigungen zum Lesen von AWS IoT Greengrass Protokollen im Dateisystem verfügen.
+ `TransferStream` schreibt Protokolleinträge in `greengrass-root/ggc/var/log/user/region/account-id/TransferStream.log`.
+ `GGStreamManager` schreibt Protokolleinträge in `greengrass-root/ggc/var/log/system/GGStreamManager.log`.
Wenn Sie weitere Informationen zur Fehlerbehebung benötigen, können Sie [die Protokollierungsebene für **Benutzer-Lambda-Protokolle** auf **Debug-Protokolle** festlegen](#stream-manager-console-configure-logging) und die Gruppe dann erneut bereitstellen.
## Weitere Informationen finden Sie auch unter
+ [Datenströme auf dem AWS IoT Greengrass Core verwalten](stream-manager.md)
+ [AWS IoT Greengrass Streammanager konfigurieren](configure-stream-manager.md)
+ [Wird verwendet StreamManagerClient , um mit Streams zu arbeiten](work-with-streams.md)
+ [Konfigurationen für unterstützte AWS Cloud Ziele exportieren](stream-export-configurations.md)
+ [Datenströme in die AWS Cloud (CLI) exportieren](stream-manager-cli.md)
# Datenströme in die AWS Cloud (CLI) exportieren
In diesem Tutorial erfahren Sie, wie Sie mit AWS CLI dem eine AWS IoT Greengrass Gruppe mit aktiviertem Stream-Manager konfigurieren und bereitstellen. Die Gruppe enthält eine benutzerdefinierte Lambda-Funktion, die in einen Stream im Stream-Manager schreibt, der dann automatisch in den exportiert wird. AWS Cloud
Stream Manager macht die Aufnahme, Verarbeitung und den Export von Datenströmen mit hohem Volumen effizienter und zuverlässiger. In diesem Tutorial erstellen Sie eine `TransferStream` Lambda-Funktion, die IoT-Daten verbraucht. Die Lambda-Funktion verwendet das AWS IoT Greengrass Core SDK, um einen Stream im Stream Manager zu erstellen und dann in ihn zu lesen und zu schreiben. Stream Manager exportiert den Stream dann nach Kinesis Data Streams. Im folgenden Diagramm wird dieser Workflow veranschaulicht.
![\[Diagramm des Stream-Management-Workflows.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/stream-manager-scenario.png)
Der Schwerpunkt dieses Tutorials liegt darauf, zu zeigen, wie benutzerdefinierte Lambda-Funktionen das `StreamManagerClient` Objekt im AWS IoT Greengrass Core SDK verwenden, um mit dem Stream Manager zu interagieren. Der Einfachheit halber generiert die Python-Lambda-Funktion, die Sie für dieses Tutorial erstellen, simulierte Gerätedaten.
Wenn Sie die AWS IoT Greengrass API verwenden, die die Greengrass-Befehle in der enthält AWS CLI, um eine Gruppe zu erstellen, ist der Stream-Manager standardmäßig deaktiviert. Um den Stream Manager auf Ihrem Core zu aktivieren, [erstellen Sie eine Funktionsdefinitionsversion](#stream-manager-cli-create-function-definition), die die `GGStreamManager` Lambda-Systemfunktion enthält, und eine Gruppenversion, die auf die neue Funktionsdefinitionsversion verweist. Anschließend stellen Sie die Gruppe bereit.
## Voraussetzungen
Zum Durchführen dieses Tutorials benötigen Sie Folgendes:
+ Eine Greengrass-Gruppe und ein Greengrass-Kern (v1.10 oder höher). Informationen zum Erstellen einer Greengrass-Gruppe und eines Greengrass-Kerns finden Sie unter[Erste Schritte mit AWS IoT Greengrass](gg-gs.md). Das Tutorial „Erste Schritte“ enthält auch Schritte zur Installation der AWS IoT Greengrass Core-Software.
**Anmerkung**
Stream Manager wird auf OpenWrt Distributionen nicht unterstützt.
+ Die Java 8-Laufzeitumgebung (JDK 8) muss auf dem Core-Gerät installiert sein.
+ Führen Sie für Debian-basierte Distributionen (einschließlich Raspbian) oder Ubuntu-basierte Distributionen den folgenden Befehl aus:
```
sudo apt install openjdk-8-jdk
```
+ Führen Sie für Red Hat-basierte Distributionen (einschließlich Amazon Linux) den folgenden Befehl aus:
```
sudo yum install java-1.8.0-openjdk
```
Weitere Informationen finden Sie unter [How to download and install prebuilt OpenJDK packages](https://openjdk.java.net/install/) in der OpenJDK-Dokumentation.
+ AWS IoT Greengrass Core SDK für Python v1.5.0 oder höher. Um es `StreamManagerClient` im AWS IoT Greengrass Core SDK für Python zu verwenden, müssen Sie:
+ Installieren Sie Python 3.7 oder höher auf dem Core-Gerät.
+ Nehmen Sie das SDK und seine Abhängigkeiten in Ihr Lambda-Funktionsbereitstellungspaket auf. Anweisungen finden Sie in diesem Tutorial.
**Tipp**
Sie können `StreamManagerClient` mit Java oder NodeJS verwenden. Beispielcode finden Sie unter [AWS IoT Greengrass Core SDK for Java](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) und [AWS IoT Greengrass Core SDK für Node.js](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) GitHub.
+ Ein Zielstream mit dem Namen, der in Amazon Kinesis Data Streams in derselben AWS-Region Greengrass-Gruppe **MyKinesisStream** erstellt wurde. Weitere Informationen finden Sie unter [Create a Stream](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#create-stream) im *Amazon Kinesis Developer Guide*.
**Anmerkung**
In diesem Tutorial exportiert Stream Manager Daten in Kinesis Data Streams, was zu Gebühren für Sie AWS-Konto führt. Preisinformationen finden Sie unter Preise für [Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/).
Um Kosten zu vermeiden, können Sie dieses Lernprogramm ausführen, ohne einen Kinesis-Datenstream zu erstellen. In diesem Fall überprüfen Sie die Protokolle, um festzustellen, dass der Stream-Manager versucht hat, den Stream nach Kinesis Data Streams zu exportieren.
+ Dem wurde eine IAM-Richtlinie hinzugefügt[Greengrass-Gruppenrolle.](group-role.md), die die `kinesis:PutRecords` Aktion für den Zieldatenstream ermöglicht, wie im folgenden Beispiel gezeigt:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:PutRecords"
],
"Resource": [
"arn:aws:kinesis:us-east-1:123456789012:stream/MyKinesisStream"
]
}
]
}
```
------
+ Das AWS CLI ist auf Ihrem Computer installiert und konfiguriert. Weitere Informationen finden Sie [unter Installation AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) und [Konfiguration von AWS CLI im AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) *Benutzerhandbuch*.
Die Beispielbefehle in diesem Tutorial sind für Linux und andere Unix-basierte Systeme geschrieben. Wenn Sie Windows verwenden, finden Sie unter [Angeben von Parameterwerten für die AWS Befehlszeilenschnittstelle](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html) weitere Informationen zu Unterschieden in der Syntax.
Wenn der Befehl eine JSON-Zeichenkette enthält, zeigt das Tutorial ein Beispiel, das das JSON auf einer einzigen Zeile hat. Auf einigen Systemen ist es möglicherweise effizienter, Befehle in diesem Format zu bearbeiten und auszuführen.
Das Tutorial enthält die folgenden allgemeinen Schritte:
1. [Erstellen Sie ein Bereitstellungspaket für Lambda-Funktionen](#stream-manager-cli-create-deployment-package)
1. [Erstellen einer Lambda-Funktion](#stream-manager-cli-create-function)
1. [Erstellen einer Funktionsdefinition und -version](#stream-manager-cli-create-function-definition)
1. [Erstellen einer Logger-Definition und -Version](#stream-manager-cli-create-logger-definition)
1. [Abrufen des ARN der Core-Definitionsversion](#stream-manager-cli-get-core-definition-version-arn)
1. [Erstellen einer Gruppenversion](#stream-manager-cli-create-group-version)
1. [Eine Bereitstellung auswählen](#stream-manager-cli-create-deployment)
1. [Testen der Anwendung](#stream-manager-cli-test-application)
Für dieses Tutorial benötigen Sie ungefähr 30 Minuten.
## Schritt 1: Erstellen Sie ein Lambda-Funktionsbereitstellungspaket
In diesem Schritt erstellen Sie ein Paket zur Bereitstellung von Lambda-Funktionen, das Python-Funktionscode und Abhängigkeiten enthält. Sie laden dieses Paket später hoch, wenn Sie die Lambda-Funktion in AWS Lambda erstellen. Die Lambda-Funktion verwendet das AWS IoT Greengrass Core SDK, um lokale Streams zu erstellen und mit ihnen zu interagieren.
**Anmerkung**
Ihre benutzerdefinierten Lambda-Funktionen müssen das [AWS IoT Greengrass Core SDK](lambda-functions.md#lambda-sdks-core) verwenden, um mit dem Stream Manager zu interagieren. Weitere Informationen zu den Anforderungen für den Greengrass Stream-Manager finden Sie im Artikel über die [Voraussetzungen für Greengrass Stream-Manager](stream-manager.md#stream-manager-requirements).
1. Laden Sie das [AWS IoT Greengrass Core SDK für Python](lambda-functions.md#lambda-sdks-core) v1.5.0 oder höher herunter.
1. Entpacken Sie das heruntergeladene Paket, um das SDK zu erhalten. Das SDK ist der `greengrasssdk`-Ordner.
1. Installieren Sie Paketabhängigkeiten, die mit dem SDK in Ihr Lambda-Funktionsbereitstellungspaket aufgenommen werden sollen.
1. Navigieren Sie zum SDK-Verzeichnis, das die `requirements.txt`-Datei enthält. Diese Datei listet die Abhängigkeiten auf.
1. Installieren Sie die SDK-Abhängigkeiten. Führen Sie beispielsweise den folgenden `pip`-Befehl aus, um sie im aktuellen Verzeichnis zu installieren:
```
pip install --target . -r requirements.txt
```
1. Speichern Sie die folgende Pythoncode-Funktion in einer lokalen Datei namens `transfer_stream.py`.
**Tipp**
Beispielcode, der Java und NodeJS verwendet, finden Sie im [AWS IoT Greengrass Core SDK for Java](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) und [AWS IoT Greengrass Core SDK for Node.js](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) unter. GitHub
```
import asyncio
import logging
import random
import time
from greengrasssdk.stream_manager import (
ExportDefinition,
KinesisConfig,
MessageStreamDefinition,
ReadMessagesOptions,
ResourceNotFoundException,
StrategyOnFull,
StreamManagerClient,
)
# This example creates a local stream named "SomeStream".
# It starts writing data into that stream and then stream manager automatically exports
# the data to a customer-created Kinesis data stream named "MyKinesisStream".
# This example runs forever until the program is stopped.
# The size of the local stream on disk will not exceed the default (which is 256 MB).
# Any data appended after the stream reaches the size limit continues to be appended, and
# stream manager deletes the oldest data until the total stream size is back under 256 MB.
# The Kinesis data stream in the cloud has no such bound, so all the data from this script is
# uploaded to Kinesis and you will be charged for that usage.
def main(logger):
try:
stream_name = "SomeStream"
kinesis_stream_name = "MyKinesisStream"
# Create a client for the StreamManager
client = StreamManagerClient()
# Try deleting the stream (if it exists) so that we have a fresh start
try:
client.delete_message_stream(stream_name=stream_name)
except ResourceNotFoundException:
pass
exports = ExportDefinition(
kinesis=[KinesisConfig(identifier="KinesisExport" + stream_name, kinesis_stream_name=kinesis_stream_name)]
)
client.create_message_stream(
MessageStreamDefinition(
name=stream_name, strategy_on_full=StrategyOnFull.OverwriteOldestData, export_definition=exports
)
)
# Append two messages and print their sequence numbers
logger.info(
"Successfully appended message to stream with sequence number %d",
client.append_message(stream_name, "ABCDEFGHIJKLMNO".encode("utf-8")),
)
logger.info(
"Successfully appended message to stream with sequence number %d",
client.append_message(stream_name, "PQRSTUVWXYZ".encode("utf-8")),
)
# Try reading the two messages we just appended and print them out
logger.info(
"Successfully read 2 messages: %s",
client.read_messages(stream_name, ReadMessagesOptions(min_message_count=2, read_timeout_millis=1000)),
)
logger.info("Now going to start writing random integers between 0 and 1000 to the stream")
# Now start putting in random data between 0 and 1000 to emulate device sensor input
while True:
logger.debug("Appending new random integer to stream")
client.append_message(stream_name, random.randint(0, 1000).to_bytes(length=4, signed=True, byteorder="big"))
time.sleep(1)
except asyncio.TimeoutError:
logger.exception("Timed out while executing")
except Exception:
logger.exception("Exception while running")
def function_handler(event, context):
return
logging.basicConfig(level=logging.INFO)
# Start up this sample code
main(logger=logging.getLogger())
```
1. Packen Sie die folgenden Elemente in einer ZIP-Datei mit dem Namen `transfer_stream_python.zip`. Dies ist Ihr Lambda-Funktionsbereitstellungspaket.
+ **transfer\$1stream.py**. App-Logik.
+ **greengrasssdk**. Erforderliche Bibliothek für Python Greengrass Lambda-Funktionen, die MQTT-Nachrichten veröffentlichen.
[Stream Manager-Operationen](work-with-streams.md) sind in Version 1.5.0 oder höher des AWS IoT Greengrass Core SDK für Python verfügbar.
+ Die Abhängigkeiten, die Sie für das AWS IoT Greengrass Core SDK für Python installiert haben (z. B. die `cbor2` Verzeichnisse).
Wenn Sie die `zip`-Datei erstellen, schließen Sie nur diese Elemente ein, nicht den enthaltenen Ordner.
## Schritt 2: Erstellen einer Lambda-Funktion
1. Erstellen Sie eine IAM-Rolle, damit Sie den Rollen-ARN bei der Erstellung der Funktion übergeben können.
------
#### [ JSON Expanded ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Principal": {"Service": "lambda.amazonaws.com"},"Action": "sts:AssumeRole"}]}'
```
------
**Anmerkung**
AWS IoT Greengrass verwendet diese Rolle nicht, da die Berechtigungen für Ihre Greengrass Lambda-Funktionen in der Greengrass-Gruppenrolle angegeben sind. Für dieses Tutorial erstellen Sie eine leere Rolle.
1. Kopieren Sie die `Arn` aus der Ausgabe.
1. Verwenden Sie die AWS Lambda API, um die Funktion zu erstellen. `TransferStream` Der folgende Befehl geht davon aus, dass sich die Zip-Datei im aktuellen Verzeichnis befindet.
+ Ersetzen Sie *role-arn* durch den `Arn`, den Sie kopiert haben.
```
aws lambda create-function \
--function-name TransferStream \
--zip-file fileb://transfer_stream_python.zip \
--role role-arn \
--handler transfer_stream.function_handler \
--runtime python3.7
```
1. Veröffentlichen einer Version der Funktion.
```
aws lambda publish-version --function-name TransferStream --description 'First version'
```
1. Erstellen Sie einen Alias für die veröffentlichte Version.
Greengrass-Gruppen können eine Lambda-Funktion nach Alias (empfohlen) oder nach Version referenzieren. Die Verwendung eines Alias erleichtert die Verwaltung von Codeaktualisierungen, da Sie Ihre Abonnementtabelle oder Gruppendefinition nicht ändern müssen, wenn der Funktionscode aktualisiert wird. Stattdessen verweisen Sie einfach mit dem Alias auf die neue Funktionsversion.
```
aws lambda create-alias --function-name TransferStream --name GG_TransferStream --function-version 1
```
**Anmerkung**
AWS IoT Greengrass unterstützt keine Lambda-Aliase für **\$1LATEST-Versionen**.
1. Kopieren Sie die `AliasArn` aus der Ausgabe. Sie verwenden diesen Wert, wenn Sie die Funktion für konfigurieren. AWS IoT Greengrass
Jetzt sind Sie bereit, die Funktion für zu konfigurieren AWS IoT Greengrass.
## Schritt 3: Erstellen einer Funktionsdefinition und -version
In diesem Schritt wird eine Funktionsdefinitionsversion erstellt, die auf die `GGStreamManager` Lambda-Funktion des Systems und Ihre benutzerdefinierte `TransferStream` Lambda-Funktion verweist. Um den Stream Manager zu aktivieren, wenn Sie die AWS IoT Greengrass API verwenden, muss Ihre Funktionsdefinitionsversion die Funktion enthalten. `GGStreamManager`
1. Erstellen Sie eine Funktionsdefinition mit einer ersten Version, die die System- und benutzerdefinierten Lambda-Funktionen enthält.
Die folgende Definitionsversion aktiviert den Stream-Manager mit [Standardparametereinstellungen](configure-stream-manager.md). Um benutzerdefinierte Einstellungen zu konfigurieren, müssen Sie Umgebungsvariablen für die entsprechenden Stream-Manager-Parameter definieren. Ein Beispiel finden Sie unter[Um den Stream Manager (CLI) zu aktivieren, zu deaktivieren oder zu konfigurieren](configure-stream-manager.md#enable-stream-manager-cli). AWS IoT Greengrass verwendet Standardeinstellungen für Parameter, die weggelassen wurden. `MemorySize`sollte mindestens sein`128000`. `Pinned`muss auf eingestellt sein`true`.
**Anmerkung**
Eine *langlebige* (oder *fixierte*) Lambda-Funktion wird nach dem Start automatisch AWS IoT Greengrass gestartet und läuft in einem eigenen Container weiter. Dies steht im Gegensatz zu einer *On-Demand-Lambda-Funktion*, die startet, wenn sie aufgerufen wird, und stoppt, wenn keine Aufgaben mehr zur Ausführung übrig sind. Weitere Informationen finden Sie unter [Lebenszykluskonfiguration für Greengrass Lambda-Funktionen](lambda-functions.md#lambda-lifecycle).
+ *arbitrary-function-id*Ersetzen Sie es durch einen Namen für die Funktion, z. B. **stream-manager**
+ *alias-arn*Ersetzen Sie es durch den`AliasArn`, den Sie kopiert haben, als Sie den Alias für die `TransferStream` Lambda-Funktion erstellt haben.
------
#### [ JSON expanded ]
```
aws greengrass create-function-definition --name MyGreengrassFunctions --initial-version '{
"Functions": [
{
"Id": "arbitrary-function-id",
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 128000,
"Pinned": true,
"Timeout": 3
}
},
{
"Id": "TransferStreamFunction",
"FunctionArn": "alias-arn",
"FunctionConfiguration": {
"Executable": "transfer_stream.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
}
}
]
}'
```
------
#### [ JSON single ]
```
aws greengrass create-function-definition \
--name MyGreengrassFunctions \
--initial-version '{"Functions": [{"Id": "arbitrary-function-id","FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1", "FunctionConfiguration": {"Environment": {"Variables":{"STREAM_MANAGER_STORE_ROOT_DIR": "/data","STREAM_MANAGER_SERVER_PORT": "1234","STREAM_MANAGER_EXPORTER_MAX_BANDWIDTH": "20000"}},"MemorySize": 128000,"Pinned": true,"Timeout": 3}},{"Id": "TransferStreamFunction", "FunctionArn": "alias-arn", "FunctionConfiguration": {"Executable": "transfer_stream.function_handler", "MemorySize": 16000,"Pinned": true,"Timeout": 5}}]}'
```
------
**Anmerkung**
`Timeout` ist für die Funktionsdefinitionsversion erforderlich, wird vom `GGStreamManager` jedoch nicht verwendet. Weitere Informationen zu `Timeout` und anderen Einstellungen auf Gruppenebene finden Sie unter. [Steuerung der Ausführung von Greengrass Lambda-Funktionen mithilfe einer gruppenspezifischen Konfiguration](lambda-group-config.md)
1. Kopieren Sie die `LatestVersionArn` aus der Ausgabe. Mit diesem Wert fügen Sie die Version der Funktionsdefinition der Gruppenversion hinzu, die Sie im Core bereitstellen.
## Schritt 4: Erstellen einer Logger-Definition und -Version
Konfigurieren Sie die Einstellungen für die Protokollierung der Gruppe. In diesem Tutorial konfigurieren Sie AWS IoT Greengrass Systemkomponenten, benutzerdefinierte Lambda-Funktionen und Konnektoren, um Protokolle in das Dateisystem des Kerngeräts zu schreiben. Sie können Protokolle verwenden, um Probleme zu beheben, die auftreten können. Weitere Informationen finden Sie unter [Überwachung mit AWS IoT Greengrass Protokollen](greengrass-logs-overview.md).
1. Erstellen Sie eine Logger-Definition, die eine Erstversion enthält.
------
#### [ JSON Expanded ]
```
aws greengrass create-logger-definition --name "LoggingConfigs" --initial-version '{
"Loggers": [
{
"Id": "1",
"Component": "GreengrassSystem",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
},
{
"Id": "2",
"Component": "Lambda",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws greengrass create-logger-definition \
--name "LoggingConfigs" \
--initial-version '{"Loggers":[{"Id":"1","Component":"GreengrassSystem","Level":"INFO","Space":10240,"Type":"FileSystem"},{"Id":"2","Component":"Lambda","Level":"INFO","Space":10240,"Type":"FileSystem"}]}'
```
------
1. Kopieren Sie den `LatestVersionArn` der Logger-Definition aus der Ausgabe. Mit diesem Wert fügen Sie die Version der Logger-Definition der Gruppenversion hinzu, die Sie im Core bereitstellen.
## Schritt 5: Abrufen des ARN der Core-Definitionsversion
Rufen Sie den ARN der Core-Definitionsversion ab, die Sie Ihrer neuen Gruppenversion hinzufügen möchten. Um eine Gruppenversion bereitzustellen, muss sie auf eine Core-Definitionsversion verweisen, die genau einen Core enthält.
1. Rufen Sie IDs die Greengrass-Zielgruppe und die Gruppenversion ab. Bei diesem Verfahren wird davon ausgegangen, dass es sich um die neueste Gruppen- und Gruppenversion handelt. Die folgende Abfrage gibt die zuletzt erstellte Gruppe zurück.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
Sie können auch nach Namen abfragen. Gruppennamen müssen nicht eindeutig sein, sodass mehrere Gruppen zurückgegeben werden können.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**Anmerkung**
Sie finden diese Werte auch in der AWS IoT Konsole. Die Gruppen-ID wird auf der Seite **Einstellungen** der Gruppe angezeigt. Die Gruppenversion IDs wird auf der Registerkarte **Bereitstellungen** der Gruppe angezeigt.
1. Kopieren Sie die `Id` der Zielgruppe aus der Ausgabe. Sie verwenden sie, um die Core-Definitionsversion zu erhalten, und wenn Sie die Gruppe bereitstellen.
1. Kopieren Sie die `LatestVersion` aus der Ausgabe, d. h. die ID der letzten Version, die der Gruppe hinzugefügt wurde. Damit erhalten Sie die Core-Definitionsversion.
1. Abrufen des ARN der Core-Definitionsversion:
1. Abrufen der Gruppenversion.
+ *group-id*Ersetzen Sie es durch `Id` das, was Sie für die Gruppe kopiert haben.
+ *group-version-id*Ersetzen Sie es durch `LatestVersion` das, was Sie für die Gruppe kopiert haben.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id group-version-id
```
1. Kopieren Sie die `CoreDefinitionVersionArn` aus der Ausgabe. Mit diesem Wert fügen Sie die Core-Definitionsversion der Gruppenversion hinzu, die Sie im Core bereitstellen.
## Schritt 6: Erstellen einer Gruppenversion
Jetzt können Sie eine Gruppenversion erstellen, die die Entitäten enthält, die Sie bereitstellen möchten. Dazu legen Sie eine Gruppenversion an, die auf die Zielversion jedes Komponententyps verweist. In diesem Lernprogramm schließen Sie eine Core-Definitionsversion, eine Funktionsdefinitionsversion und eine Logger-Definitionsversion ein.
1. Erstellen einer Gruppenversion
+ *group-id*Ersetzen Sie es durch `Id` das, was Sie für die Gruppe kopiert haben.
+ *core-definition-version-arn*Ersetzen Sie es durch `CoreDefinitionVersionArn` das, was Sie für die Version der Kerndefinition kopiert haben.
+ *function-definition-version-arn*Ersetzen Sie es durch `LatestVersionArn` das, was Sie für Ihre neue Version der Funktionsdefinition kopiert haben.
+ *logger-definition-version-arn*Ersetzen Sie es durch `LatestVersionArn` das, was Sie für Ihre neue Logger-Definitionsversion kopiert haben.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn
```
1. Kopieren Sie die `Version` aus der Ausgabe. Dies ist die ID der neuen Gruppenversion.
## Schritt 7: Erstellen einer Bereitstellung
Stellen Sie die Gruppe auf dem Core-Gerät bereit.
1. Stellen Sie sicher, dass der AWS IoT Greengrass Core läuft. Führen Sie im Raspberry Pi-Terminal die folgenden Befehle aus, falls nötig.
1. So prüfen Sie, ob der Daemon ausgeführt wird:
```
ps aux | grep -E 'greengrass.*daemon'
```
Wenn die Ausgabe einen `root`-Eintrag für `/greengrass/ggc/packages/ggc-version/bin/daemon` enthält, dann wird der Daemon ausgeführt.
**Anmerkung**
Die Version im Pfad hängt von der AWS IoT Greengrass Core-Softwareversion ab, die auf Ihrem Core-Gerät installiert ist.
1. Um den Daemon zu starten:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. Erstellen einer -Bereitstellung.
+ Ersetze es *group-id* durch `Id` das, was du für die Gruppe kopiert hast.
+ *group-version-id*Ersetzen Sie es durch `Version` das, was Sie für die neue Gruppenversion kopiert haben.
```
aws greengrass create-deployment \
--deployment-type NewDeployment \
--group-id group-id \
--group-version-id group-version-id
```
1. Kopieren Sie die `DeploymentId` aus der Ausgabe.
1. Abrufen des Bereitstellungsstatus.
+ *group-id*Ersetzen Sie es durch `Id` das, was Sie für die Gruppe kopiert haben.
+ *deployment-id*Ersetzen Sie es durch `DeploymentId` das, was Sie für die Bereitstellung kopiert haben.
```
aws greengrass get-deployment-status \
--group-id group-id \
--deployment-id deployment-id
```
Wenn der Status lautet`Success`, war die Bereitstellung erfolgreich. Hilfe zur Problembehebung finden Sie unter [Problembehebung AWS IoT Greengrass](gg-troubleshooting.md).
## Schritt 8: Testen der Anwendung
Die `TransferStream` Lambda-Funktion generiert simulierte Gerätedaten. Sie schreibt Daten in einen Stream, den der Stream-Manager in den Kinesis-Zieldatenstream exportiert.
1. Wählen Sie in der Amazon Kinesis Kinesis-Konsole unter **Kinesis-Datenstreams** die Option. **MyKinesisStream**
**Anmerkung**
Wenn Sie das Lernprogramm ohne Kinesis-Zieldatenstream ausgeführt haben, [suchen Sie in der Protokolldatei](#stream-manager-cli-logs) nach dem Stream-Manager (`GGStreamManager`). Wenn `export stream MyKinesisStream doesn't exist` in einer Fehlermeldung enthalten ist, ist der Test erfolgreich. Dieser Fehler bedeutet, dass der Service versucht hat, in den Stream zu exportieren, der Stream jedoch nicht existiert.
1. **Wählen Sie auf der **MyKinesisStream**Seite Monitoring aus.** Wenn der Test erfolgreich ist, sollten Sie die Daten in den **Put Records (Datensätze übergeben)**-Diagrammen sehen. Je nach Verbindung kann es eine Minute dauern, bis die Daten angezeigt werden.
**Wichtig**
Löschen Sie nach Abschluss des Tests den Kinesis-Datenstream, um zusätzliche Kosten zu vermeiden.
Oder führen Sie die folgenden Befehle aus, um den Greengrass-Daemon zu stoppen. Dadurch wird verhindert, dass der Core Nachrichten sendet, bis Sie bereit sind, den Test fortzusetzen.
```
cd /greengrass/ggc/core/
sudo ./greengrassd stop
```
1. Entfernen Sie die **TransferStream**Lambda-Funktion aus dem Kern.
1. Folgen Sie [Schritt 6: Erstellen einer Gruppenversion](#stream-manager-cli-create-group-version), um eine neue Gruppenversion zu erstellen. Entfernen Sie jedoch die `--function-definition-version-arn`-Option im `create-group-version`-Befehl. Oder erstellen Sie eine Funktionsdefinitionsversion, die die **TransferStream**Lambda-Funktion nicht enthält.
**Anmerkung**
Indem Sie die `GGStreamManager` Lambda-Funktion des Systems in der bereitgestellten Gruppenversion weglassen, deaktivieren Sie die Streamverwaltung auf dem Core.
1. Folgen Sie [Schritt 7: Erstellen einer Bereitstellung](#stream-manager-cli-create-deployment), um die neue Gruppenversion bereitzustellen.
Um Protokollierungsinformationen anzuzeigen oder Probleme mit Streams zu beheben, suchen Sie in den Protokollen nach den Funktionen `TransferStream` und `GGStreamManager`. Sie müssen über `root` Berechtigungen zum Lesen von AWS IoT Greengrass Protokollen im Dateisystem verfügen.
+ `TransferStream` schreibt Protokolleinträge in `greengrass-root/ggc/var/log/user/region/account-id/TransferStream.log`.
+ `GGStreamManager` schreibt Protokolleinträge in `greengrass-root/ggc/var/log/system/GGStreamManager.log`.
Wenn Sie weitere Informationen zur Problembehandlung benötigen, können Sie die `Lambda`-Protokollierungsebene auf `DEBUG` festlegen und dann eine neue Gruppenversion erstellen und bereitstellen.
## Weitere Informationen finden Sie auch unter
+ [Datenströme auf dem AWS IoT Greengrass Core verwalten](stream-manager.md)
+ [Wird verwendet StreamManagerClient , um mit Streams zu arbeiten](work-with-streams.md)
+ [Konfigurationen für unterstützte AWS Cloud Ziele exportieren](stream-export-configurations.md)
+ [AWS IoT Greengrass Streammanager konfigurieren](configure-stream-manager.md)
+ [Datenströme in die AWS Cloud (Konsole) exportieren](stream-manager-console.md)
+ [AWS Identity and Access Management (IAM) -Befehle](https://docs.aws.amazon.com/cli/latest/reference/iam) in der *AWS CLI Befehlsreferenz*
+ [AWS Lambda Befehle](https://docs.aws.amazon.com/cli/latest/reference/lambda) in der *AWS CLI Befehlsreferenz*
+ [AWS IoT Greengrass Befehle](https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html) in der *AWS CLI Befehlsreferenz*