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. # Streaming-Daten in Amazon OpenSearch Service laden Sie können OpenSearch Ingestion verwenden, um [Streaming-Daten](https://aws.amazon.com/streaming-data/) direkt in Ihre Amazon OpenSearch Service-Domain zu laden, ohne Lösungen von Drittanbietern verwenden zu müssen. Um Daten an OpenSearch Ingestion zu senden, konfigurieren Sie Ihre Datenproduzenten und der Service liefert die Daten automatisch an die von Ihnen angegebene Domain oder Sammlung. Informationen zu den ersten Schritten mit OpenSearch Ingestion finden Sie unter. [Tutorial: Daten mit Amazon OpenSearch Ingestion in eine Sammlung aufnehmen](osis-serverless-get-started.md) Sie können weiterhin andere Quellen zum Laden von Streaming-Daten verwenden, z. B. Amazon Data Firehose und Amazon CloudWatch Logs, die über eine integrierte Unterstützung für OpenSearch Service verfügen. Andere, wie z. B. Amazon S3, Amazon Kinesis Data Streams und Amazon DynamoDB, verwenden AWS Lambda -Funktionen als Ereignis-Handler. Die Lambda-Funktionen reagieren auf neue Daten, indem Sie sie verarbeiten und zu Ihrer Domain streamen. **Anmerkung** Lambda unterstützt verschiedene gängige Programmiersprachen und ist in den meisten AWS-Regionen verfügbar. Weitere Informationen finden Sie unter [Getting started with Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-app.html) im *AWS Lambda Developer Guide* und unter [AWS Service Endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#lambda_region) im. *Allgemeine AWS-Referenz* # Streaming-Daten aus Ingestion werden geladen OpenSearch Sie können Amazon OpenSearch Ingestion verwenden, um Daten in eine OpenSearch Service-Domain zu laden. Sie konfigurieren Ihre Datenproduzenten so, dass sie Daten an OpenSearch Ingestion senden, und Ingestion übermittelt die Daten automatisch an die von Ihnen angegebene Sammlung. Sie können OpenSearch Ingestion auch so konfigurieren, dass Ihre Daten vor der Bereitstellung transformiert werden. Weitere Informationen finden Sie unter [Überblick über Amazon OpenSearch Ingestion](ingestion.md). # So laden Sie Streaming-Daten aus Amazon S3 Sie können Lambda verwenden, um Daten von Amazon S3 an Ihre OpenSearch Service-Domain zu senden. Neue in einem S3-Bucket eintreffende Daten lösen eine Ereignisbenachrichtigung an Lambda aus, wodurch Ihr benutzerdefinierter Code zum Durchführen der Indizierung ausgeführt wird. Diese Methode zum Streamen von Daten ist ausgesprochen flexibel. Sie können [Objekt-Metadaten indizieren](https://aws.amazon.com/blogs/database/indexing-metadata-in-amazon-elasticsearch-service-using-aws-lambda-and-python/) oder einige Elemente des Objekttextes analysieren und indizieren, sofern das Objekt Klartext ist. Dieser Abschnitt enthält unkomplizierten Python-Beispielcode für die Verwendung von regulären Ausdrücken zum Analysieren einer Protokolldatei und Indizieren der Übereinstimmungen. ## Voraussetzungen Zum Fortfahren benötigen Sie die folgenden Ressourcen. **** | Voraussetzung | Description | | --- | --- | | Amazon-S3-Bucket | Weitere Informationen finden Sie unter [Erstellen Ihres ersten S3 Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) im Benutzerhandbuch für Amazon Simple Storage Service. Der Bucket muss sich in derselben Region wie Ihre OpenSearch Service-Domain befinden. | | OpenSearch Dienstdomäne | Das Ziel für die Daten, nachdem sie durch Ihre Lambda-Funktion verarbeitet wurden. Weitere Informationen finden Sie unter [OpenSearch Dienstdomänen erstellen](createupdatedomains.md#createdomains). | ## Erstellen des Lambda-Bereitstellungspakets Bereitstellungspakete sind ZIP- oder JAR-Dateien, die Ihren Code und seine Abhängigkeiten enthalten. Dieser Abschnitt enthält Python-Beispielcode. Informationen zu anderen Programmiersprachen finden Sie unter [Lambda-Bereitstellungspakete](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) im *AWS Lambda -Entwicklerhandbuch*. 1. Erstellen Sie ein Verzeichnis. In diesem Beispiel verwenden wir den Namen `s3-to-opensearch`. 1. Erstellen Sie im Verzeichnis eine Datei mit dem Namen `sample.py`: ``` import boto3 import re import requests from requests_aws4auth import AWS4Auth region = '' # e.g. us-west-1 service = 'es' credentials = boto3.Session().get_credentials() awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token) host = '' # the OpenSearch Service domain, e.g. https://search-mydomain.us-west-1.es.amazonaws.com index = 'lambda-s3-index' datatype = '_doc' url = host + '/' + index + '/' + datatype headers = { "Content-Type": "application/json" } s3 = boto3.client('s3') # Regular expressions used to parse some simple log lines ip_pattern = re.compile('(\d+\.\d+\.\d+\.\d+)') time_pattern = re.compile('\[(\d+\/\w\w\w\/\d\d\d\d:\d\d:\d\d:\d\d\s-\d\d\d\d)\]') message_pattern = re.compile('\"(.+)\"') # Lambda execution starts here def handler(event, context): for record in event['Records']: # Get the bucket name and key for the new file bucket = record['s3']['bucket']['name'] key = record['s3']['object']['key'] # Get, read, and split the file into lines obj = s3.get_object(Bucket=bucket, Key=key) body = obj['Body'].read() lines = body.splitlines() # Match the regular expressions to each line and index the JSON for line in lines: line = line.decode("utf-8") ip = ip_pattern.search(line).group(1) timestamp = time_pattern.search(line).group(1) message = message_pattern.search(line).group(1) document = { "ip": ip, "timestamp": timestamp, "message": message } r = requests.post(url, auth=awsauth, json=document, headers=headers) ``` Bearbeiten Sie die Variablen für `region` und `host`. 1. [Installieren Sie pip](https://pip.pypa.io/en/stable/installation/), falls noch nicht geschehen, und installieren Sie dann die Abhängigkeiten in einem neuen `package`-Verzeichnis: ``` cd s3-to-opensearch pip install --target ./package requests pip install --target ./package requests_aws4auth ``` Da in allen Lambda-Ausführungsumgebungen [Boto3](https://aws.amazon.com/sdk-for-python/) installiert ist, müssen Sie es nicht in Ihr Bereitstellungspaket einschließen. 1. Paket mit Anwendungscode und Abhängigkeiten: ``` cd package zip -r ../lambda.zip . cd .. zip -g lambda.zip sample.py ``` ## So erstellen Sie die Lambda-Funktion: Nachdem Sie das Bereitstellungspaket erstellt haben, können Sie die Lambda-Funktion erstellen. Wenn Sie eine Funktion erstellen, wählen Sie einen Namen, eine Laufzeit (z. B. Python 3.8) und eine IAM-Rolle aus. Die IAM-Rolle definiert die Berechtigungen der Funktion. Detaillierte Anweisungen finden Sie unter [Erstellen einer einfachen Lambda-Funktion](https://docs.aws.amazon.com/lambda/latest/dg/get-started-create-function.html) im *AWS Lambda -Entwicklerhandbuch*. In diesem Beispiel wird davon ausgegangen, dass Sie die Konsole verwenden. Wählen Sie Python 3.9 und eine Rolle mit S3-Leseberechtigungen und OpenSearch Service-Schreibberechtigungen, wie im folgenden Screenshot gezeigt: ![\[Beispielkonfiguration für eine Lambda-Funktion\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/lambda-function.png) Nachdem Sie die Funktion erstellt haben, müssen Sie einen Auslöser hinzufügen. In diesem Beispiel soll der Code immer dann ausgeführt werden, wenn im S3-Bucket ein Protokoll eintrifft: 1. Klicken Sie auf **Auslöser hinzufügen** und wählen Sie **S3** aus. 1. Wählen Sie Ihren Bucket aus. 1. Wählen Sie unter **Event type (Ereignistyp)** die Option **PUT** aus. 1. Geben Sie für **Prefix (Präfix)** den Wert `logs/` ein. 1. Geben Sie für **Suffix** `.log` ein. 1. Bestätigen Sie die Warnung für rekursive Aufrufe und wählen Sie **Hinzufügen** aus. Schließlich können Sie Ihr Bereitstellungs-Paket hochladen: 1. Wählen Sie **Hochladen von** und **.zip-Datei** und befolgen Sie dann die Anweisungen zum Hochladen Ihres Bereitstellungspakets. 1. Nachdem der Upload abgeschlossen ist, bearbeiten Sie die **Laufzeit-Einstellungen** und ändern Sie den **Handler** auf `sample.handler`. Diese Einstellung teilt Lambda die Datei (`sample.py`) und Methode (`handler`) mit, die es nach einem Auslöser ausführen soll. Zu diesem Zeitpunkt verfügen Sie über einen vollständigen Satz von Ressourcen: einen Bucket für Protokolldateien, eine Funktion, die immer dann ausgeführt wird, wenn dem Bucket eine Protokolldatei hinzugefügt wird, Code, der das Parsen und Indizieren durchführt, und eine OpenSearch Service-Domain für die Suche und Visualisierung. ## Testen der Lambda-Funktion Nachdem Sie die Funktion erstellt haben, können Sie sie durch Hochladen einer Datei in den Amazon-S3-Bucket testen. Erstellen Sie anhand der folgenden Beispielprotokollzeilen eine Datei mit dem Namen `sample.log`: ``` 12.345.678.90 - [10/Oct/2000:13:55:36 -0700] "PUT /some-file.jpg" 12.345.678.91 - [10/Oct/2000:14:56:14 -0700] "GET /some-file.jpg" ``` Laden Sie die Datei in den Ordner `logs` Ihres S3-Buckets hoch. Anweisungen finden Sie unter [Hochladen eines Objekts in Ihren Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PuttingAnObjectInABucket.html) im *Benutzerhandbuch für Amazon Simple Storage Service*. Überprüfen Sie anschließend mithilfe der OpenSearch Servicekonsole oder der OpenSearch Dashboards, ob der `lambda-s3-index` Index zwei Dokumente enthält. Sie können auch eine Standard-Suchabfrage durchführen: ``` GET https://domain-name/lambda-s3-index/_search?pretty { "hits" : { "total" : 2, "max_score" : 1.0, "hits" : [ { "_index" : "lambda-s3-index", "_type" : "_doc", "_id" : "vTYXaWIBJWV_TTkEuSDg", "_score" : 1.0, "_source" : { "ip" : "12.345.678.91", "message" : "GET /some-file.jpg", "timestamp" : "10/Oct/2000:14:56:14 -0700" } }, { "_index" : "lambda-s3-index", "_type" : "_doc", "_id" : "vjYmaWIBJWV_TTkEuCAB", "_score" : 1.0, "_source" : { "ip" : "12.345.678.90", "message" : "PUT /some-file.jpg", "timestamp" : "10/Oct/2000:13:55:36 -0700" } } ] } } ``` # So laden Sie Streaming-Daten aus Amazon Kinesis Data Streams Sie können Streaming-Daten von Kinesis Data Streams in den OpenSearch Service laden. Neue im Daten-Stream eintreffende Daten lösen eine Ereignisbenachrichtigung an Lambda aus, wodurch Ihr benutzerdefinierter Code zum Durchführen der Indizierung ausgeführt wird. Dieser Abschnitt enthält unkomplizierten Python-Beispielcode. ## Voraussetzungen Zum Fortfahren benötigen Sie die folgenden Ressourcen. | Voraussetzung | Description | | --- | --- | | Amazon Kinesis Data Stream | Die Ereignisquelle für Ihre Lambda-Funktion. Weitere Informationen finden Sie unter [Kinesis Data Streams](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html). | | OpenSearch Dienstdomäne | Das Ziel für die Daten, nachdem sie durch Ihre Lambda-Funktion verarbeitet wurden. Weitere Informationen finden Sie unter [OpenSearch Dienstdomänen erstellen](createupdatedomains.md#createdomains) | | IAM Role (IAM-Rolle) | Diese Rolle muss über grundlegende OpenSearch Service-, Kinesis- und Lambda-Berechtigungen verfügen, z. B. die folgenden: JSON **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "es:ESHttpPost", "es:ESHttpPut", "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents", "kinesis:GetShardIterator", "kinesis:GetRecords", "kinesis:DescribeStream", "kinesis:ListStreams" ], "Resource": "*" } ] } ``` Die Rolle muss über die folgende Vertrauensstellung verfügen: JSON **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "lambda.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` Weitere Informationen finden Sie unter [Erstellen von IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html) im *IAM-Benutzerhandbuch*. | # So erstellen Sie die Lambda-Funktion: Befolgen Sie die Anweisungen in [Erstellen des Lambda-Bereitstellungspakets](integrations-s3-lambda.md#integrations-s3-lambda-deployment-package). Erstellen Sie jedoch ein Verzeichnis mit dem Namen `kinesis-to-opensearch` und verwenden Sie den folgenden Code für `sample.py`: ``` import base64 import boto3 import json import requests from requests_aws4auth import AWS4Auth region = '' # e.g. us-west-1 service = 'es' credentials = boto3.Session().get_credentials() awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token) host = '' # the OpenSearch Service domain, e.g. https://search-mydomain.us-west-1.es.amazonaws.com index = 'lambda-kine-index' datatype = '_doc' url = host + '/' + index + '/' + datatype + '/' headers = { "Content-Type": "application/json" } def handler(event, context): count = 0 for record in event['Records']: id = record['eventID'] timestamp = record['kinesis']['approximateArrivalTimestamp'] # Kinesis data is base64-encoded, so decode here message = base64.b64decode(record['kinesis']['data']) # Create the JSON document document = { "id": id, "timestamp": timestamp, "message": message } # Index the document r = requests.put(url + id, auth=awsauth, json=document, headers=headers) count += 1 return 'Processed ' + str(count) + ' items.' ``` Bearbeiten Sie die Variablen für `region` und `host`. [Installieren Sie pip](https://pip.pypa.io/en/stable/installation/), falls noch nicht geschehen, und verwenden Sie dann die folgenden Befehle, um Ihre Abhängigkeiten zu installieren: ``` cd kinesis-to-opensearch pip install --target ./package requests pip install --target ./package requests_aws4auth ``` Befolgen Sie dann die Anweisungen in [So erstellen Sie die Lambda-Funktion:](integrations-s3-lambda.md#integrations-s3-lambda-create). Geben Sie jedoch die IAM-Rolle aus [Voraussetzungen](integrations-kinesis.md#integrations-kinesis-lambda-prereq) und die folgenden Einstellungen für den Auslöser an: + **Kinesis-Stream**: Ihr Kinesis-Stream + **Stapelgröße**: 100 + **Startposition**: Horizont trimmen Weitere Informationen finden Sie unter [Was ist Amazon Kinesis Data Streams?](https://docs.aws.amazon.com/streams/latest/dev/working-with-kinesis.html) im *Entwicklerhandbuch für Amazon Kinesis Data Streams*. Zu diesem Zeitpunkt verfügen Sie über einen vollständigen Satz von Ressourcen: einen Kinesis-Datenstream, eine Funktion, die ausgeführt wird, nachdem der Stream neue Daten empfangen und diese Daten indexiert hat, und eine OpenSearch Service-Domäne für die Suche und Visualisierung. # Lambda-Funktion testen Nachdem Sie die Funktion erstellt haben, können Sie sie testen, indem Sie den Data-Stream mithilfe der AWS CLI aufzeichnen: ``` aws kinesis put-record --stream-name test --data "My test data." --partition-key partitionKey1 --region us-west-1 ``` Verwenden Sie dann die OpenSearch Servicekonsole oder die OpenSearch Dashboards, um zu überprüfen, ob das Dokument ein `lambda-kine-index` Dokument enthält. Sie können außerdem die folgenden Anforderung verwenden: ``` GET https://domain-name/lambda-kine-index/_search { "hits" : [ { "_index": "lambda-kine-index", "_type": "_doc", "_id": "shardId-000000000000:49583511615762699495012960821421456686529436680496087042", "_score": 1, "_source": { "timestamp": 1523648740.051, "message": "My test data.", "id": "shardId-000000000000:49583511615762699495012960821421456686529436680496087042" } } ] } ``` # So laden Sie Streaming-Daten aus Amazon DynamoDB Sie können AWS Lambda es verwenden, um Daten von Amazon DynamoDB an Ihre OpenSearch Service-Domain zu senden. Neue in der Datenbanktabelle eintreffende Daten lösen eine Ereignisbenachrichtigung an Lambda aus, wodurch Ihr benutzerdefinierte Code zum Durchführen der Indizierung ausgeführt wird. ## Voraussetzungen Zum Fortfahren benötigen Sie die folgenden Ressourcen. | Voraussetzung | Description | | --- | --- | | DynamoDB-Tabelle | Die Tabelle enthält Ihre Quelldaten. Weitere Informationen finden Sie unter [Grundlegende Operationen in DynamoDB-Tabellen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) im *Amazon-DynamoDB-Entwicklerhandbuch*.**Die Tabelle muss sich in derselben Region wie Ihre OpenSearch Service-Domain befinden und einen Stream haben, der auf Neues Bild gesetzt ist.** Weitere Informationen finden Sie unter [Aktivieren eines Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html#Streams.Enabling). | | OpenSearch Dienstdomäne | Das Ziel für die Daten, nachdem sie durch Ihre Lambda-Funktion verarbeitet wurden. Weitere Informationen finden Sie unter [OpenSearch Dienstdomänen erstellen](createupdatedomains.md#createdomains). | | IAM role (IAM-Rolle) | Diese Rolle muss über grundlegende OpenSearch Service-, DynamoDB- und Lambda-Ausführungsberechtigungen verfügen, z. B. die folgenden: JSON **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "es:ESHttpPost", "es:ESHttpPut", "dynamodb:DescribeStream", "dynamodb:GetRecords", "dynamodb:GetShardIterator", "dynamodb:ListStreams", "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], "Resource": "*" } ] } ``` Die Rolle muss über die folgende Vertrauensstellung verfügen: JSON **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "lambda.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` Weitere Informationen finden Sie unter [Erstellen von IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html) im *IAM-Benutzerhandbuch*. | ## So erstellen Sie die Lambda-Funktion: Befolgen Sie die Anweisungen in [Erstellen des Lambda-Bereitstellungspakets](integrations-s3-lambda.md#integrations-s3-lambda-deployment-package). Erstellen Sie jedoch ein Verzeichnis mit dem Namen `ddb-to-opensearch` und verwenden Sie den folgenden Code für `sample.py`: ``` import boto3 import requests from requests_aws4auth import AWS4Auth region = '' # e.g. us-east-1 service = 'es' credentials = boto3.Session().get_credentials() awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token) host = '' # the OpenSearch Service domain, e.g. https://search-mydomain.us-west-1.es.amazonaws.com index = 'lambda-index' datatype = '_doc' url = host + '/' + index + '/' + datatype + '/' headers = { "Content-Type": "application/json" } def handler(event, context): count = 0 for record in event['Records']: # Get the primary key for use as the OpenSearch ID id = record['dynamodb']['Keys']['id']['S'] if record['eventName'] == 'REMOVE': r = requests.delete(url + id, auth=awsauth) else: document = record['dynamodb']['NewImage'] r = requests.put(url + id, auth=awsauth, json=document, headers=headers) count += 1 return str(count) + ' records processed.' ``` Bearbeiten Sie die Variablen für `region` und `host`. [Installieren Sie pip](https://pip.pypa.io/en/stable/installation/), falls noch nicht geschehen, und verwenden Sie dann die folgenden Befehle, um Ihre Abhängigkeiten zu installieren: ``` cd ddb-to-opensearch pip install --target ./package requests pip install --target ./package requests_aws4auth ``` Befolgen Sie dann die Anweisungen in [So erstellen Sie die Lambda-Funktion:](integrations-s3-lambda.md#integrations-s3-lambda-create). Geben Sie jedoch die IAM-Rolle aus [Voraussetzungen](#integrations-dynamodb-prereq) und die folgenden Einstellungen für den Auslöser an: + **Tabelle**: Ihre DynamoDB-Tabelle + **Stapelgröße**: 100 + **Startposition**: Horizont trimmen Weitere Informationen finden Sie unter [Verarbeiten neuer Elemente mit DynamoDB-Streams und Lambda](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.Lambda.Tutorial.html) im *Amazon-DynamoDB-Entwicklerhandbuch*. Zu diesem Zeitpunkt verfügen Sie über einen vollständigen Satz von Ressourcen: eine DynamoDB-Tabelle für Ihre Quelldaten, einen DynamoDB-Stream mit Änderungen an der Tabelle, eine Funktion, die nach Änderungen Ihrer Quelldaten ausgeführt wird und diese Änderungen indexiert, und eine OpenSearch Dienstdomäne für die Suche und Visualisierung. ## Lambda-Funktion testen Nachdem Sie die Funktion erstellt haben, können Sie sie testen, indem Sie ein neues Element zur DynamoDB-Tabelle mithilfe der AWS CLI hinzufügen: ``` aws dynamodb put-item --table-name test --item '{"director": {"S": "Kevin Costner"},"id": {"S": "00001"},"title": {"S": "The Postman"}}' --region us-west-1 ``` Überprüfen Sie dann mithilfe der OpenSearch Servicekonsole oder der OpenSearch Dashboards, ob das Dokument ein Dokument enthält. `lambda-index` Sie können außerdem die folgenden Anforderung verwenden: ``` GET https://domain-name/lambda-index/_doc/00001 { "_index": "lambda-index", "_type": "_doc", "_id": "00001", "_version": 1, "found": true, "_source": { "director": { "S": "Kevin Costner" }, "id": { "S": "00001" }, "title": { "S": "The Postman" } } } ``` # Streaming-Daten von Amazon Data Firehose laden Firehose unterstützt OpenSearch Service als Lieferziel. Anweisungen zum Laden von Streaming-Daten in OpenSearch Service finden Sie unter [Creating a Kinesis Data Firehose Delivery Stream](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) and [Choose OpenSearch Service for Your Destination](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-elasticsearch) im *Amazon Data Firehose* Developer Guide. Bevor Sie Daten in OpenSearch Service laden, müssen Sie möglicherweise Transformationen an den Daten durchführen. Weitere Informationen über die Verwendung von Lambda-Funktionen zur Ausführung dieser Aufgabe finden Sie unter [Amazon Kinesis Data Firehose Datentransformation](https://docs.aws.amazon.com/firehose/latest/dev/data-transformation.html) im selben Handbuch. Wenn Sie einen Lieferstream konfigurieren, verfügt Firehose über eine IAM-Rolle mit nur einem Klick, die dem Unternehmen den Ressourcenzugriff gewährt, den es benötigt, um Daten an OpenSearch Service zu senden, Daten auf Amazon S3 zu sichern und Daten mit Lambda zu transformieren. Aufgrund der Komplexität bei der manuellen Erstellung einer solchen Rolle empfehlen wir die Verwendung der bereitgestellten Rolle. # Streaming-Daten von Amazon laden CloudWatch Sie können Streaming-Daten von CloudWatch Logs in Ihre OpenSearch Service-Domain laden, indem Sie ein CloudWatch Logs-Abonnement verwenden. Informationen zu CloudWatch Amazon-Abonnements finden Sie unter [Echtzeitverarbeitung von Protokolldaten mit Abonnements](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/Subscriptions.html). Informationen zur Konfiguration finden Sie unter [Streaming CloudWatch Logs data to Amazon OpenSearch Service](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_OpenSearch_Stream.html) im *Amazon CloudWatch Developer Guide*. ## Streaming-Daten werden geladen von AWS IoT Sie können Daten AWS IoT mithilfe von [Regeln](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rules.html) senden. Weitere Informationen finden Sie in der entsprechenden [OpenSearch](https://docs.aws.amazon.com/iot/latest/developerguide/opensearch-rule-action.html)Aktion im *AWS IoT Entwicklerhandbuch*.