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