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. # Amazon DocumentDB-Ereignisse mit Lambda verarbeiten Sie können eine Lambda-Funktion verwenden, um Ereignisse in einem [Änderungsstream von Amazon DocumentDB (mit MongoDB-Kompatibilität)](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html) zu verarbeiten, indem Sie einen Amazon-DocumentDB-Cluster als Ereignisquelle konfigurieren. Anschließend können Sie ereignisgesteuerte Workloads automatisieren, indem Sie Ihre Lambda-Funktion jedes Mal aufrufen, wenn sich Daten in Ihrem Amazon-DocumentDB-Cluster ändern. **Anmerkung** Lambda unterstützt nur die Versionen 4.0 und 5.0 von Amazon DocumentDB. Lambda unterstützt Version 3.6 nicht. Für die Zuordnung von Ereignisquellen unterstützt Lambda außerdem nur Instance-basierte Cluster und regionale Cluster. Lambda unterstützt keine [elastischen Cluster](https://docs.aws.amazon.com/documentdb/latest/developerguide/docdb-using-elastic-clusters.html) oder [globalen Cluster](https://docs.aws.amazon.com/documentdb/latest/developerguide/global-clusters.html). Diese Einschränkung gilt nicht, wenn Lambda als Client verwendet wird, um eine Verbindung mit Amazon DocumentDB herzustellen. Lambda kann eine Verbindung mit allen Clustertypen herstellen, um CRUD-Vorgänge auszuführen. Lambda verarbeitet Ereignisse aus Amazon-DocumentDB-Änderungsstreams sequentiell in der Reihenfolge, in der sie ankommen. Aus diesem Grund kann Ihre Funktion jeweils nur einen Aufruf von Amazon DocumentDB gleichzeitig verarbeiten. Sie können Ihre Funktion anhand ihrer [Gleichzeitigkeitsmetriken](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-concurrency.html) überwachen. **Warnung** Zuordnung von Lambda-Ereignisquellen verarbeiten jedes Ereignis mindestens einmal und es kann zu einer doppelten Verarbeitung von Datensätzen kommen. Um mögliche Probleme im Zusammenhang mit doppelten Ereignissen zu vermeiden, empfehlen wir Ihnen dringend, Ihren Funktionscode idempotent zu machen. Weitere Informationen finden Sie im Knowledge Center unter [Wie mache ich meine Lambda-Funktion idempotent](https://repost.aws/knowledge-center/lambda-function-idempotent)?. AWS **Topics** + [Beispiel für Amazon-DocumentDB-Ereignis](#docdb-sample-event) + [Voraussetzungen und Berechtigungen](#docdb-prereqs) + [Konfigurieren Sie die Netzwerksicherheit](#docdb-network) + [Erstellen einer Zuordnung von Ereignisquellen von Amazon DocumentDB (Konsole)](#docdb-configuration) + [Erstellen einer Zuordnung von Ereignisquellen von Amazon DocumentDB (SDK oder CLI)](#docdb-api) + [Startpositionen für Abfragen und Streams](#docdb-stream-polling) + [Überwachen Ihrer Amazon-DocumentDB-Ereignisquelle](#docdb-monitoring) + [Tutorial: Verwendung AWS Lambda mit Amazon DocumentDB DocumentDB-Streams](with-documentdb-tutorial.md) ## Beispiel für Amazon-DocumentDB-Ereignis ``` { "eventSourceArn": "arn:aws:rds:us-east-1:123456789012:cluster:canaryclusterb2a659a2-qo5tcmqkcl03", "events": [ { "event": { "_id": { "_data": "0163eeb6e7000000090100000009000041e1" }, "clusterTime": { "$timestamp": { "t": 1676588775, "i": 9 } }, "documentKey": { "_id": { "$oid": "63eeb6e7d418cd98afb1c1d7" } }, "fullDocument": { "_id": { "$oid": "63eeb6e7d418cd98afb1c1d7" }, "anyField": "sampleValue" }, "ns": { "db": "test_database", "coll": "test_collection" }, "operationType": "insert" } } ], "eventSource": "aws:docdb" } ``` Weitere Informationen zu den Ereignissen in diesem Beispiel und den zugehörigen Formen finden Sie unter [Änderungsereignisse](https://www.mongodb.com/docs/manual/reference/change-events/) auf der MongoDB-Dokumentationswebsite. ## Voraussetzungen und Berechtigungen Bevor Sie Amazon DocumentDB als Ereignisquelle für Ihre Lambda-Funktion verwenden können, beachten Sie die folgenden Voraussetzungen. Folgendes muss zutreffen: + **Haben Sie einen vorhandenen Amazon DocumentDB-Cluster in derselben AWS-Konto und AWS-Region wie Ihre Funktion.** Wenn Sie über keinen bestehenden Cluster verfügen, können Sie anhand der Anleitung in [Erste Schritte mit Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/get-started-guide.html) im *Amazon-DocumentDB-Entwicklerhandbuch* einen erstellen. Alternativ dazu führen Sie die ersten Schritte in [Tutorial: Verwendung AWS Lambda mit Amazon DocumentDB DocumentDB-Streams](with-documentdb-tutorial.md) durch die Erstellung eines Amazon DocumentDB-Clusters mit allen erforderlichen Voraussetzungen. + **Sie müssen Lambda den Zugriff auf die Ressourcen von Amazon Virtual Private Cloud (Amazon VPC) erlauben, die Ihrem Amazon-DocumentDB-Cluster zugeordnet sind.** Weitere Informationen finden Sie unter [Konfigurieren Sie die Netzwerksicherheit](#docdb-network). + **Aktivieren Sie TLS in Ihrem Amazon-DocumentDB-Cluster.** Dies ist die Standardeinstellung. Wenn Sie TLS deaktivieren, kann Lambda nicht mit Ihrem Cluster kommunizieren. + **Aktivieren Sie Änderungsstreams in Ihrem Amazon-DocumentDB-Cluster.** Weitere Informationen finden Sie unter [Verwenden von Änderungsstreams mit Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html) im *Amazon-DocumentDB-Entwicklerhandbuch*. + **Stellen Sie Lambda Anmeldeinformationen für den Zugriff auf Ihren Amazon-DocumentDB-Cluster zur Verfügung.** Geben Sie bei der Einrichtung der Ereignisquelle den [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)-Schlüssel mit den Authentifizierungsdetails (Benutzername und Passwort) an, die für den Zugriff auf Ihren Cluster erforderlich sind. Um diesen Schlüssel während der Einrichtung bereitzustellen, haben Sie die folgenden Möglichkeiten: + Wenn Sie die Lambda-Konsole für die Einrichtung verwenden, geben Sie diesen Schlüssel in das Feld **Secrets-Manager-Schlüssel** ein. + Wenn Sie das AWS Command Line Interface (AWS CLI) für die Einrichtung verwenden, geben Sie diesen Schlüssel in der `source-access-configurations` Option an. Sie können diese Option entweder in den [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-event-source-mapping.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-event-source-mapping.html)-Befehl oder in den [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-event-source-mapping.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-event-source-mapping.html)-Befehl einschließen. Beispiel: ``` aws lambda create-event-source-mapping \ ... --source-access-configurations '[{"Type":"BASIC_AUTH","URI":"arn:aws:secretsmanager:us-west-2:123456789012:secret:DocDBSecret-AbC4E6"}]' \ ... ``` + **Sie müssen Lambda Berechtigungen zur Verwaltung von Ressourcen gewähren, die zu Ihrem Amazon-DocumentDB-Stream gehören.** Fügen Sie der zu der [Ausführungsrolle](lambda-intro-execution-role.md) Ihrer Funktion manuell die folgenden Berechtigungen hinzu: + [RDS: Beschreiben DBClusters](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBClusters.html) + [RDS:Parameter beschreiben DBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBClusterParameters.html) + [RDS:Gruppen DBSubnet beschreiben](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBSubnetGroups.html) + [ec2: CreateNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateNetworkInterface.html) + [ec2: DescribeNetworkInterfaces](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeNetworkInterfaces.html) + [ec2: DescribeVpcs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVpcs.html) + [ec2: DeleteNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteNetworkInterface.html) + [ec2: DescribeSubnets](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSubnets.html) + [ec2: DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html) + [kms:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) + [Verwalter von Geheimnissen: GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html) + **Halten Sie die Größe der Amazon-DocumentDB-Änderungsstream-Ereignisse, die Sie an Lambda senden, bei unter 6 MB.** Lambda unterstützt Nutzlasten mit einer Größe von bis zu 6 MB. Wenn Ihr Änderungsstream versucht, Lambda ein Ereignis zu senden, das größer als 6 MB ist, löscht Lambda die Nachricht und gibt die `OversizedRecordCount`-Metrik aus. Lambda gibt alle Metriken auf die bestmögliche Weise aus. **Anmerkung** Während Lambda-Funktionen in der Regel ein maximales Timeout-Limit von 15 Minuten haben, unterstützen Ereignisquellenzuordnungen für Amazon MSK, selbstverwaltetes Apache Kafka, Amazon DocumentDB, Amazon MQ für ActiveMQ und RabbitMQ nur Funktionen mit einem maximalen Timeout-Limit von 14 Minuten. Diese Einschränkung stellt sicher, dass die Ereignisquellenzuordnung Funktionsfehler und Wiederholungsversuche ordnungsgemäß verarbeiten kann. ## Konfigurieren Sie die Netzwerksicherheit Um Lambda vollen Zugriff auf Amazon DocumentDB über Ihre Zuordnung von Ereignisquellen zu ermöglichen, muss Ihr Cluster entweder einen öffentlichen Endpunkt (öffentliche IP-Adresse) verwenden oder Sie müssen Zugriff auf die Amazon VPC gewähren, in der Sie den Cluster erstellt haben. Wenn Sie Amazon DocumentDB mit Lambda verwenden, erstellen Sie [AWS PrivateLink VPC-Endpunkte](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html), die Ihrer Funktion Zugriff auf die Ressourcen in Ihrer Amazon VPC bieten. **Anmerkung** AWS PrivateLink VPC-Endpunkte sind für Funktionen mit Ereignisquellenzuordnungen erforderlich, die den Standardmodus (auf Abruf) für Ereignisabfragen verwenden. Wenn Ihre Ereignisquellenzuordnung den [Bereitstellungsmodus](invocation-eventsourcemapping.md#invocation-eventsourcemapping-provisioned-mode) verwendet, müssen Sie keine AWS PrivateLink VPC-Endpunkte konfigurieren. Erstellen Sie einen Endpunkt, der den Zugriff auf die folgenden Ressourcen ermöglicht: + Lambda – Erstellen Sie einen Endpunkt für den Lambda-Serviceprinzipal. + AWS STS — Erstellen Sie einen Endpunkt für den, damit ein Service Principal eine Rolle AWS STS in Ihrem Namen übernehmen kann. + Secrets Manager – Wenn Ihr Cluster Secrets Manager zum Speichern von Anmeldeinformationen verwendet, erstellen Sie einen Endpunkt für Secrets Manager. Alternativ konfigurieren Sie ein NAT-Gateway auf jedem öffentlichen Subnetz in der Amazon-VPC. Weitere Informationen finden Sie unter [Aktivieren Sie den Internetzugang für VPC-verbundene Lambda-Funktionen](configuration-vpc-internet.md). Wenn Sie eine Ereignisquellenzuordnung für Amazon DocumentDB erstellen, prüft Lambda, ob Elastic Network Interfaces (ENIs) bereits für die für Ihre Amazon VPC konfigurierten Subnetze und Sicherheitsgruppen vorhanden sind. Wenn Lambda feststellt, dass sie vorhanden ENIs sind, versucht es, sie wiederzuverwenden. Andernfalls erstellt Lambda neue, ENIs um eine Verbindung zur Ereignisquelle herzustellen und Ihre Funktion aufzurufen. **Anmerkung** Lambda-Funktionen werden immer intern ausgeführt, die dem Lambda-Dienst VPCs gehören. Die VPC-Konfiguration Ihrer Funktion hat keinen Einfluss auf die Zuordnung von Ereignisquellen. Nur die Netzwerkkonfiguration der Ereignisquelle bestimmt, wie Lambda sich mit Ihrer Ereignisquelle verbindet. Konfigurieren Sie die Sicherheitsgruppen für die Amazon VPC, die Ihren Cluster enthält. Standardmäßig verwendet Amazon DocumentDB die folgenden Ports: `27017`. + Eingehende Regeln – Erlauben Sie den gesamten Datenverkehr auf dem Standard-Broker-Port für die Sicherheitsgruppe, die mit Ihrer Ereignisquelle verbunden ist. Alternativ können Sie eine selbstreferenzierende Regel für Sicherheitsgruppen verwenden, um den Zugriff von Instances innerhalb derselben Sicherheitsgruppe zuzulassen. + Regeln für ausgehenden Datenverkehr — Erlauben Sie den gesamten Datenverkehr auf dem Port `443` für externe Ziele, wenn Ihre Funktion mit Diensten kommunizieren muss. AWS Alternativ können Sie auch eine selbstreferenzierende Sicherheitsgruppenregel verwenden, um den Zugriff auf den Broker einzuschränken, wenn Sie nicht mit anderen Diensten kommunizieren müssen. AWS + Regeln für eingehenden Datenverkehr auf Amazon-VPC-Endpunkten – Wenn Sie einen Amazon-VPC-Endpunkt verwenden, muss die Sicherheitsgruppe, die mit Ihrem Amazon-VPC-Endpunkt verbunden ist, eingehenden Verkehr auf Port `443` von der Cluster-Sicherheitsgruppe zulassen. Wenn Ihr Cluster eine Authentifizierung verwendet, können Sie auch die Endpunktrichtlinie für den Secrets-Manager-Endpunkt einschränken. Für den Aufruf der Secrets-Manager-API verwendet Lambda Ihre Funktionsrolle und nicht den Lambda-Serviceprinzipal. **Example VPC-Endpunktrichtlinie – Secrets Manager-Endpunkt** ``` { "Statement": [ { "Action": "secretsmanager:GetSecretValue", "Effect": "Allow", "Principal": { "AWS": [ "arn:aws::iam::123456789012:role/my-role" ] }, "Resource": "arn:aws::secretsmanager:us-west-2:123456789012:secret:my-secret" } ] } ``` Wenn Sie Amazon VPC-Endpunkte verwenden, AWS leitet Ihre API-Aufrufe zum Aufrufen Ihrer Funktion über das Elastic Network Interface (ENI) des Endpunkts weiter. Der Lambda-Serviceprinzipal muss alle Rollen und Funktionen aufrufen`lambda:InvokeFunction`, die diese ENIs verwenden. Standardmäßig verfügen Amazon VPC-Endpunkte über offene IAM-Richtlinien, die einen umfassenden Zugriff auf Ressourcen ermöglichen. Es empfiehlt sich, diese Richtlinien auf die Durchführung der erforderlichen Aktionen über diesen Endpunkt zu beschränken. Um sicherzustellen, dass Ihre Zuordnung von Ereignisquellen Ihre Lambda-Funktion aufrufen kann, muss die VPC-Endpunktrichtlinie dem Lambda-Serviceprinzipal erlauben, `sts:AssumeRole` und `lambda:InvokeFunction` aufzurufen. Wenn Sie Ihre VPC-Endpunktrichtlinien so einschränken, dass nur API-Aufrufe zugelassen werden, die aus Ihrem Unternehmen stammen, kann die Zuordnung von Ereignisquellen nicht richtig funktionieren, weshalb in diesen Richtlinien `"Resource": "*"` erforderlich ist. Die folgenden Beispiel-VPC-Endpunktrichtlinien zeigen, wie der erforderliche Zugriff auf den Lambda-Serviceprinzipal für die AWS STS - und Lambda-Endpunkte gewährt wird. **Example VPC-Endpunktrichtlinie — AWS STS Endpunkt** ``` { "Statement": [ { "Action": "sts:AssumeRole", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com" ] }, "Resource": "*" } ] } ``` **Example VPC-Endpunktrichtlinie – Lambda-Endpunkt** ``` { "Statement": [ { "Action": "lambda:InvokeFunction", "Effect": "Allow", "Principal": { "Service": [ "lambda.amazonaws.com" ] }, "Resource": "*" } ] } ``` ## Erstellen einer Zuordnung von Ereignisquellen von Amazon DocumentDB (Konsole) Erstellen Sie für eine Funktion zum Lesen aus dem Änderungsstream eines Amazon-DocumentDB-Clusters eine [Zuordnung von Ereignisquellen](invocation-eventsourcemapping.md). In diesem Abschnitt wird die entsprechende Vorgehensweise über die Lambda-Konsole beschrieben. AWS SDK und AWS CLI Anweisungen finden Sie unter[Erstellen einer Zuordnung von Ereignisquellen von Amazon DocumentDB (SDK oder CLI)](#docdb-api). **So erstellen Sie eine Zuordnung von Ereignisquellen von Amazon DocumentDB (Konsole)** 1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole. 1. Wählen Sie den Namen einer Funktion aus. 1. Wählen Sie unter **Function overview (Funktionsübersicht)** die Option **Add trigger (Trigger hinzufügen)**. 1. Wählen Sie unter **Auslöserkonfiguration** in der Dropdown-Liste die Option **DocumentDB** aus. 1. Konfigurieren Sie die erforderlichen Optionen und wählen Sie dann **Add** (Hinzufügen) aus. Lambda unterstützt die folgenden Optionen für Amazon-DocumentDB-Ereignisquellen: + **DocumentDB-Cluster** – Wählen Sie einen Amazon-DocumentDB-Cluster aus. + **Auslöser aktivieren** – Wählen Sie aus, ob Sie den Auslöser sofort aktivieren möchten. Wenn Sie dieses Kontrollkästchen aktivieren, beginnt Ihre Funktion sofort, Datenverkehr aus dem angegebenen Amazon-DocumentDB-Änderungsstream zu empfangen, sobald die Zuordnung von Ereignisquellen erstellt wurde. Wir empfehlen, das Kontrollkästchen zu deaktivieren, um die Zuordnung von Ereignisquellen zu Testzwecken in einem deaktivierten Zustand zu erstellen. Nach der Erstellung können Sie die Zuordnung von Ereignisquellen jederzeit aktivieren. + **Datenbankname –** Geben Sie den Namen einer Datenbank innerhalb des Clusters ein, die verwendet werden soll. + (Optional) **Sammlungsname** – Geben Sie den Namen einer Sammlung in der Datenbank ein, die verwendet werden soll. Wenn Sie keine Sammlung angeben, hört Lambda auf alle Ereignisse aus jeder Sammlung in der Datenbank. + **Batchgröße –** Legen Sie die maximale Anzahl von Nachrichten fest, die in einem einzelnen Batch abgerufen werden sollen bis zu 10 000. Die Standardgröße beträgt 100. + **Startposition –** Wählen Sie die Position im Stream aus, von der aus das Lesen von Datensätzen beginnen. + **Neueste –** Verarbeiten Sie Datensätze, die neu zum Stream hinzugefügt wurden. Ihre Funktion beginnt erst mit der Verarbeitung von Datensätzen, nachdem Lambda die Erstellung Ihrer Ereignisquelle abgeschlossen hat. Das bedeutet, dass einige Datensätze gelöscht werden können, bis Ihre Ereignisquelle erfolgreich erstellt wurde. + **Horizont trimmen** – Verarbeiten Sie alle Datensätze im Stream. Lambda verwendet die Protokollspeicherdauer Ihres Clusters, um zu bestimmen, ab wo mit dem Lesen von Ereignissen begonnen werden soll. Insbesondere beginnt Lambda mit dem Lesen von `current_time - log_retention_duration`. Ihr Änderungsstream muss bereits vor diesem Zeitstempel aktiv sein, damit Lambda alle Ereignisse korrekt lesen kann. + **Am Zeitstempel** – Verarbeiten Sie Datensätze ab einem bestimmten Zeitpunkt. Ihr Änderungsstream muss bereits vor dem angegebenen Zeitstempel aktiv sein, damit Lambda alle Ereignisse korrekt lesen kann. + **Authentifizierung –** Wählen Sie unter Authentifizierungsmethode den Zugriff auf den Broker in Ihrem Cluster aus. + **BASIC\$1AUTH –** Bei der Standardauthentifizierung müssen Sie den Secrets-Manager-Schlüssel angeben, der die Anmeldeinformationen für den Zugriff auf Ihren Cluster enthält. + **Secrets-Manager-Schlüssel** – Wählen Sie den Secrets-Manager-Schlüssel aus, der die Authentifizierungsdetails (Benutzername und Passwort) enthält, die für den Zugriff auf Ihren Amazon-DocumentDB-Cluster erforderlich sind. + (Optional) **Batch-Fenster** – Legen Sie die maximale Zeitspanne zur Erfassung von Datensätzen vor dem Aufruf der Funktion in Sekunden fest (bis zu 300). + (Optional) **Vollständige Dokumentkonfiguration** – Wählen Sie für Dokumentaktualisierungsvorgänge aus, was Sie an den Stream senden möchten. Der Standardwert ist `Default`, was bedeutet, dass Amazon DocumentDB für jedes Änderungsstream-Ereignis nur ein Delta sendet, das die vorgenommenen Änderungen beschreibt. Weitere Informationen zu diesem Feld finden Sie [FullDocument](https://mongodb.github.io/mongo-java-driver/3.9/javadoc/com/mongodb/client/model/changestream/FullDocument.html#DEFAULT)in der MongoDB Javadoc-API-Dokumentation. + **Standard –** Lambda sendet nur ein Teildokument, das die vorgenommenen Änderungen beschreibt. + **UpdateLookup**— Lambda sendet ein Delta, das die Änderungen beschreibt, zusammen mit einer Kopie des gesamten Dokuments. ## Erstellen einer Zuordnung von Ereignisquellen von Amazon DocumentDB (SDK oder CLI) Um eine Zuordnung von Ereignisquellen von Amazon DocumentDB mit einem [AWS SDK](https://aws.amazon.com/developer/tools/) zu verwalten, können Sie die folgenden API-Operationen verwenden: + [CreateEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_CreateEventSourceMapping.html) + [ListEventSourceMappings](https://docs.aws.amazon.com/lambda/latest/api/API_ListEventSourceMappings.html) + [GetEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_GetEventSourceMapping.html) + [UpdateEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateEventSourceMapping.html) + [DeleteEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteEventSourceMapping.html) Verwenden Sie den [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-event-source-mapping.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-event-source-mapping.html)Befehl, um die Zuordnung der AWS CLI Ereignisquelle mit dem zu erstellen. Im folgenden Beispiel wird dieser Befehl verwendet, um eine Funktion namens `my-function` einem Amazon-DocumentDB-Änderungsstream zuzuordnen. Der Ereignisquelle wird mit dem Amazon-Ressourcennamen (ARN) angegeben, mit einer Batchgröße von 500, beginnend ab dem Zeitstempel in Unix-Zeit. Der Befehl gibt auch den Secrets-Manager-Schlüssel an, den Lambda verwendet, um eine Verbindung zu Amazon DocumentDB herzustellen. Darüber hinaus enthält er `document-db-event-source-config`-Parameter, die die Datenbank und die Sammlung angeben, aus der gelesen werden soll. ``` aws lambda create-event-source-mapping --function-name my-function \ --event-source-arn arn:aws:rds:us-west-2:123456789012:cluster:privatecluster7de2-epzcyvu4pjoy --batch-size 500 \ --starting-position AT_TIMESTAMP \ --starting-position-timestamp 1541139109 \ --source-access-configurations '[{"Type":"BASIC_AUTH","URI":"arn:aws:secretsmanager:us-east-1:123456789012:secret:DocDBSecret-BAtjxi"}]' \ --document-db-event-source-config '{"DatabaseName":"test_database", "CollectionName": "test_collection"}' \ ``` Die Ausgabe sollte in etwa wie folgt aussehen: ``` { "UUID": "2b733gdc-8ac3-cdf5-af3a-1827b3b11284", "BatchSize": 500, "DocumentDBEventSourceConfig": { "CollectionName": "test_collection", "DatabaseName": "test_database", "FullDocument": "Default" }, "MaximumBatchingWindowInSeconds": 0, "EventSourceArn": "arn:aws:rds:us-west-2:123456789012:cluster:privatecluster7de2-epzcyvu4pjoy", "FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function", "LastModified": 1541348195.412, "LastProcessingResult": "No records processed", "State": "Creating", "StateTransitionReason": "User action" } ``` Nach der Erstellung können Sie den [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-event-source-mapping.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-event-source-mapping.html)-Befehl verwenden, um die Einstellungen für Ihre Amazon-DocumentDB-Ereignisquelle zu aktualisieren. Im folgenden Beispiel werden die Batchgröße auf 1 000 und das Batchfenster auf 10 Sekunden aktualisiert. Für diesen Befehl benötigen Sie die UUID Ihrer Zuordnung von Ereignisquellen, die Sie über den `list-event-source-mapping`-Befehl oder die Lambda-Konsole abrufen können. ``` aws lambda update-event-source-mapping --function-name my-function \ --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b \ --batch-size 1000 \ --batch-window 10 ``` Die Ausgabe sollte in etwa wie folgt aussehen: ``` { "UUID": "2b733gdc-8ac3-cdf5-af3a-1827b3b11284", "BatchSize": 500, "DocumentDBEventSourceConfig": { "CollectionName": "test_collection", "DatabaseName": "test_database", "FullDocument": "Default" }, "MaximumBatchingWindowInSeconds": 0, "EventSourceArn": "arn:aws:rds:us-west-2:123456789012:cluster:privatecluster7de2-epzcyvu4pjoy", "FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function", "LastModified": 1541359182.919, "LastProcessingResult": "OK", "State": "Updating", "StateTransitionReason": "User action" } ``` Da Lambda die Einstellungen asynchron aktualisiert, werden Sie diese Änderungen möglicherweise erst nach Abschluss des Vorgangs in der Ausgabe sehen. Verwenden Sie den [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/get-event-source-mapping.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/get-event-source-mapping.html)-Befehl, um die aktuellen Einstellungen Ihrer Zuordnung von Ereignisquellen anzuzeigen. ``` aws lambda get-event-source-mapping --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b ``` Die Ausgabe sollte in etwa wie folgt aussehen: ``` { "UUID": "2b733gdc-8ac3-cdf5-af3a-1827b3b11284", "DocumentDBEventSourceConfig": { "CollectionName": "test_collection", "DatabaseName": "test_database", "FullDocument": "Default" }, "BatchSize": 1000, "MaximumBatchingWindowInSeconds": 10, "EventSourceArn": "arn:aws:rds:us-west-2:123456789012:cluster:privatecluster7de2-epzcyvu4pjoy", "FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function", "LastModified": 1541359182.919, "LastProcessingResult": "OK", "State": "Enabled", "StateTransitionReason": "User action" } ``` Um Ihre Zuordnung von Ereignisquellen von Amazon DocumentDB zu löschen, verwenden Sie den [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/delete-event-source-mapping.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/delete-event-source-mapping.html)-Befehl. ``` aws lambda delete-event-source-mapping \ --uuid 2b733gdc-8ac3-cdf5-af3a-1827b3b11284 ``` ## Startpositionen für Abfragen und Streams Beachten Sie, dass die Stream-Abfrage bei der Erstellung und Aktualisierung der Zuordnung von Ereignisquellen letztendlich konsistent ist. + Bei der Erstellung der Zuordnung von Ereignisquellen kann es mehrere Minuten dauern, bis mit der Abfrage von Ereignissen aus dem Stream begonnen wird. + Bei Aktualisierungen der Zuordnung von Ereignisquellen kann es mehrere Minuten dauern, bis die Abfrage von Ereignissen aus dem Stream gestoppt und neu gestartet wird. Dieses Verhalten bedeutet, dass, wenn Sie `LATEST` als Startposition für den Stream angeben, die Zuordnung von Ereignisquellen bei der Erstellung oder Aktualisierung möglicherweise Ereignisse übersieht. Um sicherzustellen, dass keine Ereignisse übersehen werden, geben Sie die Startposition des Streams als `TRIM_HORIZON` oder `AT_TIMESTAMP` an. ## Überwachen Ihrer Amazon-DocumentDB-Ereignisquelle Um Sie bei der Überwachung Ihrer Amazon-DocumentDB-Ereignisquelle zu unterstützen, gibt Lambda die Metrik `IteratorAge` aus, wenn die Funktion das Verarbeiten von Datensätzen abgeschlossen hat. Das *Iterator-Alter* ist der Unterschied zwischen dem Zeitstempel des letzten Ereignisses und dem aktuellen Zeitstempel. Im Wesentlichen gibt die Metrik `IteratorAge` an, wie alt der letzte Datensatz im Batch bei Fertigstellung der Verarbeitung war. Wenn Ihre Funktion derzeit neue Ereignisse verarbeitet, können Sie mit dem Iterator-Alter die Latenz zwischen dem Zeitpunkt, zu dem ein Datensatz hinzugefügt wird, und dem Zeitpunkt, zu dem die Funktion verarbeitet wird, schätzen. Eine ansteigende Tendenz bei `IteratorAge` kann auf Probleme mit Ihrer Funktion hindeuten. Weitere Informationen finden Sie unter [Verwendung von CloudWatch-Metriken mit Lambda](monitoring-metrics.md). Amazon DocumentDB-Change-Streams sind nicht für die Bewältigung großer Zeitlücken zwischen Ereignissen optimiert. Wenn Ihre Amazon DocumentDB-Ereignisquelle über einen längeren Zeitraum keine Ereignisse empfängt, kann Lambda die Zuordnung von Ereignisquellen deaktivieren. Die Dauer dieses Zeitraums kann je nach Größe des Clusters und anderen Workloads zwischen einigen Wochen und einigen Monaten variieren. Lambda unterstützt Nutzlasten von bis zu 6 MB. Änderungsstream-Ereignisse von Amazon DocumentDB können jedoch bis zu 16 MB groß sein. Wenn Ihr Änderungsstream versucht, Lambda ein Änderungsstream-Ereignis zu senden, das größer als 6 MB ist, löscht Lambda die Nachricht und gibt die Metrik `OversizedRecordCount` aus. Lambda gibt alle Metriken auf die bestmögliche Weise aus. # Tutorial: Verwendung AWS Lambda mit Amazon DocumentDB DocumentDB-Streams In diesem Tutorial erstellen Sie eine einfache Lambda-Funktion, die Ereignisse aus einem Amazon DocumentDB (mit MongoDB-Kompatibilität) Change-Stream konsumiert. Um dieses Tutorial abzuschließen, werden Sie die folgenden Phasen durchlaufen: + Richten Sie Ihren Amazon-DocumentDB-Cluster ein, stellen Sie eine Verbindung zu ihm her und aktivieren Sie Change-Streams darauf. + Erstellen Sie Ihre Lambda-Funktion und konfigurieren Sie Ihren Amazon-DocumentDB-Cluster als Ereignisquelle für Ihre Funktion. + Testen Sie die Einrichtung, indem Sie Elemente in Ihre Amazon-DocumentDB-Datenbank einfügen. ## Erstellen Sie den Amazon DocumentDB-Cluster 1. Öffnen Sie die [Amazon DocumentDB-Konsole](https://console.aws.amazon.com/docdb/home#). Wählen Sie unter **Cluster** die Option **Erstellen** aus. 1. Erstellen Sie einen Cluster mit der folgenden Konfiguration: + Wählen Sie als **Cluster-Typ** die Option **Instance-basierter Cluster** aus. Dies ist die Standardoption. + Stellen Sie sicher, dass unter **Clusterkonfiguration** die **Engine-Version** 5.0.0 ausgewählt ist. Dies ist die Standardoption. + Unter **Instance-Konfiguration**: + Wählen Sie für **DB-Instance-Klasse** die Option **Speicheroptimierte Klassen** aus. Dies ist die Standardoption. + Wählen Sie für **Anzahl der regulären Replikat-Instances** den Wert 1 aus. + Verwenden Sie für **Instance-Klasse** die Standardauswahl. + Geben Sie unter **Authentifizierung** einen Benutzernamen für den Hauptbenutzer ein und wählen Sie dann **Selbstverwaltet** aus. Geben Sie ein Passwort ein und bestätigen Sie es. + Behalten Sie die alle Standardeinstellung bei. 1. Wählen Sie **Cluster erstellen**. ## Erstellen des Secrets in Secrets Manager Während Amazon DocumentDB Ihren Cluster erstellt, erstellen Sie ein AWS Secrets Manager Geheimnis, um Ihre Datenbankanmeldedaten zu speichern. Sie geben diesen geheimen Schlüssel an, wenn Sie in einem späteren Schritt die Zuordnung von Ereignisquellen in Lambda erstellen. **Um das Secret in Secrets Manager zu erstellen** 1. Öffnen Sie die [Secrets-Manager-Konsole](https://console.aws.amazon.com/secretsmanager/home#) und wählen Sie **Neues Secret speichern**. 1. Wählen Sie für **Secret-Typ auswählen** eine der folgenden Optionen aus: + Unter **Grundlegende Details**: + **Secret-Typ**: Anmeldeinformationen für die Amazon-DocumentDB-Datenbank + Geben Sie unter **Anmeldeinformationen** den Benutzernamen und das Passwort ein, den bzw. das Sie zum Erstellen Ihres Amazon-DocumentDB-Clusters verwendet haben. + **Datenbank**: Wählen Sie Ihren Amazon DocumentDB-Cluster aus. + Wählen Sie **Weiter** aus. 1. Wählen Sie unter **Secret konfigurieen** eine der folgenden Optionen aus: + **Geheimer Name:** `DocumentDBSecret` + Wählen Sie **Weiter** aus. 1. Wählen Sie **Weiter** aus. 1. Wählen Sie **Store** (Speichern) aus. 1. Aktualisieren Sie die Konsole, um zu überprüfen, ob Sie das `DocumentDBSecret`-Secret erfolgreich gespeichert haben. Notieren Sie sich den **geheimen ARN**. Sie werden es in einem späteren Schritt noch benötigen. ## Verbinden mit dem Cluster **Connect zu Ihrem Amazon DocumentDB-Cluster her mit AWS CloudShell** 1. Suchen Sie in der Amazon-DocumentDB-Verwaltungskonsole unter **Cluster** den von Ihnen erstellten Cluster. Wählen Sie Ihren Cluster aus, indem Sie das Kontrollkästchen daneben aktivieren. 1. Wählen Sie **Mit Cluster verbinden** aus. Der **Befehlsbildschirm CloudShell Ausführen** wird angezeigt. 1. Geben Sie im Feld **Neuer Umgebungsname** einen eindeutigen Namen ein, z. B. „Test“, und wählen Sie **Erstellen und ausführen** aus. 1. Geben Sie bei der Aufforderung Ihr Passwort ein. Wenn der Prompt zu `rs0 [direct: primary] >` wechselt, sind Sie erfolgreich mit Ihrem Amazon-DocumentDB-Cluster verbunden. ## Change-Streams aktivieren In diesem Tutorial verfolgen Sie Änderungen an der `products`-Sammlung der `docdbdemo`-Datenbank in Ihrem Amazon DocumentDB-Cluster. Sie tun dies, indem Sie [Change-Streams](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html) aktivieren. **Um eine neue Datenbank in Ihrem Cluster zu erstellen** 1. Führen Sie den folgenden Befehl aus, um eine neue Datenbank mit dem Namen `docdbdemo` zu erstellen: ``` use docdbdemo ``` 1. Geben Sie im Terminalfenster den folgenden Befehl ein, um einen Datensatz in `docdbdemo` einzufügen: ``` db.products.insertOne({"hello":"world"}) ``` Sie sollten eine Ausgabe wie die Folgende sehen: ``` { acknowledged: true, insertedId: ObjectId('67f85066ca526410fd531d59') } ``` 1. Dann aktivieren Sie mit dem folgenden Befehl Change-Streams für die `products`-Sammlung der `docdbdemo`-Datenbank: ``` db.adminCommand({modifyChangeStreams: 1, database: "docdbdemo", collection: "products", enable: true}); ``` Die Ausgabe sollte in etwa wie folgt aussehen: ``` { "ok" : 1, "operationTime" : Timestamp(1680126165, 1) } ``` ## Schnittstellen-VPC-Endpunkte erstellen Erstellen Sie als Nächstes [Schnittstellen-VPC-Endpunkte](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws), um sicherzustellen, dass Lambda und Secrets Manager (der später zum Speichern unserer Cluster-Anmeldeinformationen verwendet wird) eine Verbindung zu Ihrer Standard-VPC herstellen können. **Um Schnittstellen-VPC-Endpunkte zu erstellen** 1. Öffnen Sie die [VPC;-Konsole](https://console.aws.amazon.com/vpc/home#). Wählen Sie im linken Menü unter **Virtual Private Cloud** die Option **Endpunkte** aus. 1. Wählen Sie **Endpunkt erstellen** aus. Erstellen Sie einen Endpunkt mit der folgenden Konfiguration: + Geben Sie für **Name Tag** `lambda-default-vpc` ein. + Wählen Sie als **Dienstkategorie** die Option AWS Dienste aus. + Geben Sie unter **Services** `lambda` in das Suchfeld ein. Wählen Sie den Service im Format `com.amazonaws..lambda`. + Wählen Sie für **VPC** die VPC aus, in der sich Ihr Amazon-DocumentDB-Cluster befindet. Dies ist in der Regel die [Standard-VPC](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html). + Aktivieren Sie für **Subnetze** die Kästchen neben jeder Availability Zone. Wählen Sie die richtige Subnetz-ID für jede Availability Zone. + Wählen Sie als **IP-Adresstyp** die Option aus IPv4. + Wählen Sie für **Sicherheitsgruppen** die Sicherheitsgruppe aus, die Ihr Amazon-DocumentDB-Cluster verwendet. Dies ist in der Regel die `default`-Sicherheitsgruppe. + Behalten Sie die alle Standardeinstellung bei. + Wählen Sie **Endpunkt erstellen** aus. 1. Wählen Sie erneut **Endpunkt erstellen**. Erstellen Sie einen Endpunkt mit der folgenden Konfiguration: + Geben Sie für **Name Tag** `secretsmanager-default-vpc` ein. + Wählen Sie als **Dienstkategorie** die Option AWS Dienste aus. + Geben Sie unter **Services** `secretsmanager` in das Suchfeld ein. Wählen Sie den Service im Format `com.amazonaws..secretsmanager`. + Wählen Sie für **VPC** die VPC aus, in der sich Ihr Amazon-DocumentDB-Cluster befindet. Dies ist in der Regel die [Standard-VPC](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html). + Aktivieren Sie für **Subnetze** die Kästchen neben jeder Availability Zone. Wählen Sie die richtige Subnetz-ID für jede Availability Zone. + Wählen Sie als **IP-Adresstyp** die Option aus IPv4. + Wählen Sie für **Sicherheitsgruppen** die Sicherheitsgruppe aus, die Ihr Amazon-DocumentDB-Cluster verwendet. Dies ist in der Regel die `default`-Sicherheitsgruppe. + Behalten Sie die alle Standardeinstellung bei. + Wählen Sie **Endpunkt erstellen** aus. Damit ist der Abschnitt zur Einrichtung eines Clusters in diesem Tutorial abgeschlossen. ## Erstellen der Ausführungsrolle In den nächsten Schritten erstellen Sie Ihre Lambda-Funktion. Zunächst müssen Sie die Ausführungsrolle erstellen, die Ihrer Funktion die Berechtigung zum Zugriff auf Ihren Cluster gibt. Dazu erstellen Sie zunächst eine IAM-Richtlinie und verknüpfen diese dann mit einer IAM-Rolle. **So erstellen Sie eine IAM-Richtlinie** 1. Öffnen Sie in der IAM-Konsole die Seite [Richtlinien](https://console.aws.amazon.com/iam/home#/policies) und wählen Sie dann **Richtlinie erstellen** aus. 1. Wählen Sie den Tab **JSON**. Ersetzen Sie in der folgenden Richtlinie den ARN der Secrets-Manager-Ressource in der letzten Zeile der Anweisung durch Ihren geheimen ARN von zuvor, und kopieren Sie die Richtlinie in den Editor. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "LambdaESMNetworkingAccess", "Effect": "Allow", "Action": [ "ec2:CreateNetworkInterface", "ec2:DescribeNetworkInterfaces", "ec2:DescribeVpcs", "ec2:DeleteNetworkInterface", "ec2:DescribeSubnets", "ec2:DescribeSecurityGroups", "kms:Decrypt" ], "Resource": "*" }, { "Sid": "LambdaDocDBESMAccess", "Effect": "Allow", "Action": [ "rds:DescribeDBClusters", "rds:DescribeDBClusterParameters", "rds:DescribeDBSubnetGroups" ], "Resource": "*" }, { "Sid": "LambdaDocDBESMGetSecretValueAccess", "Effect": "Allow", "Action": [ "secretsmanager:GetSecretValue" ], "Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:DocumentDBSecret" } ] } ``` ------ 1. Wählen Sie **Weiter: Tags** und dann **Weiter: Prüfen** aus. 1. Geben Sie unter **Name** `AWSDocumentDBLambdaPolicy` ein. 1. Wählen Sie **Richtlinie erstellen** aus. **So erstellen Sie die IAM-Rolle** 1. Öffnen Sie die Seite [Rollen](https://console.aws.amazon.com/iam/home#/roles) in der IAM-Konsole und wählen Sie **Rolle erstellen**. 1. Wählen Sie für **Vertrauenswürdige Entität auswählen** die folgenden Optionen: + **Typ der vertrauenswürdigen Entität**: AWS Dienst + **Service oder Anwendungsfall**: Lambda + Wählen Sie **Weiter** aus. 1. Wählen **Sie für Berechtigungen hinzufügen** die `AWSDocumentDBLambdaPolicy` Richtlinie aus, die Sie gerade erstellt haben, sowie die, `AWSLambdaBasicExecutionRole` um Ihrer Funktion Berechtigungen zum Schreiben in Amazon CloudWatch Logs zu erteilen. 1. Wählen Sie **Weiter** aus. 1. Geben Sie für **Role name (Rollenname)** den Namen `AWSDocumentDBLambdaExecutionRole` ein. 1. Wählen Sie **Rolle erstellen** aus. ## So erstellen Sie die Lambda-Funktion: Dieses Tutorial verwendet die Python 3.14-Laufzeit, aber wir haben auch Beispielcodedateien für andere Laufzeiten bereitgestellt. Sie können die Registerkarte im folgenden Feld auswählen, um den Code für die gewünschte Laufzeit anzusehen. Der Code empfängt eine Amazon-DocumentDB-Ereigniseingabe und verarbeitet die darin enthaltene Nachricht. **So erstellen Sie die Lambda-Funktion:** 1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole. 1. Wählen Sie **Funktion erstellen**. 1. Wählen Sie **Ohne Vorgabe erstellen** aus. 1. Führen Sie unter **Basic information** (Grundlegende Informationen) die folgenden Schritte aus: 1. Geben Sie unter **Funktionsname** `ProcessDocumentDBRecords` ein. 1. Wählen Sie für **Runtime** **Python 3.14**. 1. Wählen Sie für **Architektur** **x86\$164** aus. 1. Gehen Sie auf der Registerkarte **Standard-Ausführungsrolle ändern** wie folgt vor: 1. Erweitern Sie die Registerkarte und wählen Sie dann **Verwenden einer vorhandenen Rolle** aus. 1. Wählen Sie die zuvor erstellte `AWSDocumentDBLambdaExecutionRole` aus. 1. Wählen Sie **Funktion erstellen**. **So stellen Sie den Funktionscode bereit** 1. Wählen Sie im folgenden Feld die Registerkarte **Python** und kopieren Sie den Code. ------ #### [ .NET ] **SDK für .NET** Es gibt noch mehr dazu. GitHub Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Nutzen eines Amazon DocumentDB-Ereignisses mit Lambda unter Verwendung von .NET. ``` using Amazon.Lambda.Core; using System.Text.Json; using System; using System.Collections.Generic; using System.Text.Json.Serialization; //Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class. [assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))] namespace LambdaDocDb; public class Function { /// /// Lambda function entry point to process Amazon DocumentDB events. /// /// The Amazon DocumentDB event. /// The Lambda context object. /// A string to indicate successful processing. public string FunctionHandler(Event evnt, ILambdaContext context) { foreach (var record in evnt.Events) { ProcessDocumentDBEvent(record, context); } return "OK"; } private void ProcessDocumentDBEvent(DocumentDBEventRecord record, ILambdaContext context) { var eventData = record.Event; var operationType = eventData.OperationType; var databaseName = eventData.Ns.Db; var collectionName = eventData.Ns.Coll; var fullDocument = JsonSerializer.Serialize(eventData.FullDocument, new JsonSerializerOptions { WriteIndented = true }); context.Logger.LogLine($"Operation type: {operationType}"); context.Logger.LogLine($"Database: {databaseName}"); context.Logger.LogLine($"Collection: {collectionName}"); context.Logger.LogLine($"Full document:\n{fullDocument}"); } public class Event { [JsonPropertyName("eventSourceArn")] public string EventSourceArn { get; set; } [JsonPropertyName("events")] public List Events { get; set; } [JsonPropertyName("eventSource")] public string EventSource { get; set; } } public class DocumentDBEventRecord { [JsonPropertyName("event")] public EventData Event { get; set; } } public class EventData { [JsonPropertyName("_id")] public IdData Id { get; set; } [JsonPropertyName("clusterTime")] public ClusterTime ClusterTime { get; set; } [JsonPropertyName("documentKey")] public DocumentKey DocumentKey { get; set; } [JsonPropertyName("fullDocument")] public Dictionary FullDocument { get; set; } [JsonPropertyName("ns")] public Namespace Ns { get; set; } [JsonPropertyName("operationType")] public string OperationType { get; set; } } public class IdData { [JsonPropertyName("_data")] public string Data { get; set; } } public class ClusterTime { [JsonPropertyName("$timestamp")] public Timestamp Timestamp { get; set; } } public class Timestamp { [JsonPropertyName("t")] public long T { get; set; } [JsonPropertyName("i")] public int I { get; set; } } public class DocumentKey { [JsonPropertyName("_id")] public Id Id { get; set; } } public class Id { [JsonPropertyName("$oid")] public string Oid { get; set; } } public class Namespace { [JsonPropertyName("db")] public string Db { get; set; } [JsonPropertyName("coll")] public string Coll { get; set; } } } ``` ------ #### [ Go ] **SDK für Go V2** Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Nutzen eines Amazon DocumentDB-Ereignisses mit Lambda unter Verwendung von Go. ``` package main import ( "context" "encoding/json" "fmt" "github.com/aws/aws-lambda-go/lambda" ) type Event struct { Events []Record `json:"events"` } type Record struct { Event struct { OperationType string `json:"operationType"` NS struct { DB string `json:"db"` Coll string `json:"coll"` } `json:"ns"` FullDocument interface{} `json:"fullDocument"` } `json:"event"` } func main() { lambda.Start(handler) } func handler(ctx context.Context, event Event) (string, error) { fmt.Println("Loading function") for _, record := range event.Events { logDocumentDBEvent(record) } return "OK", nil } func logDocumentDBEvent(record Record) { fmt.Printf("Operation type: %s\n", record.Event.OperationType) fmt.Printf("db: %s\n", record.Event.NS.DB) fmt.Printf("collection: %s\n", record.Event.NS.Coll) docBytes, _ := json.MarshalIndent(record.Event.FullDocument, "", " ") fmt.Printf("Full document: %s\n", string(docBytes)) } ``` ------ #### [ Java ] **SDK für Java 2.x** Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Nutzen eines Amazon DocumentDB-Ereignisses mit Lambda unter Verwendung von Java. ``` import java.util.List; import java.util.Map; import com.amazonaws.services.lambda.runtime.Context; import com.amazonaws.services.lambda.runtime.RequestHandler; public class Example implements RequestHandler, String> { @SuppressWarnings("unchecked") @Override public String handleRequest(Map event, Context context) { List> events = (List>) event.get("events"); for (Map record : events) { Map eventData = (Map) record.get("event"); processEventData(eventData); } return "OK"; } @SuppressWarnings("unchecked") private void processEventData(Map eventData) { String operationType = (String) eventData.get("operationType"); System.out.println("operationType: %s".formatted(operationType)); Map ns = (Map) eventData.get("ns"); String db = (String) ns.get("db"); System.out.println("db: %s".formatted(db)); String coll = (String) ns.get("coll"); System.out.println("coll: %s".formatted(coll)); Map fullDocument = (Map) eventData.get("fullDocument"); System.out.println("fullDocument: %s".formatted(fullDocument)); } } ``` ------ #### [ JavaScript ] **SDK für JavaScript (v3)** Es gibt noch mehr dazu GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Verwenden eines Amazon DocumentDB DocumentDB-Ereignisses mit Lambda. JavaScript ``` console.log('Loading function'); exports.handler = async (event, context) => { event.events.forEach(record => { logDocumentDBEvent(record); }); return 'OK'; }; const logDocumentDBEvent = (record) => { console.log('Operation type: ' + record.event.operationType); console.log('db: ' + record.event.ns.db); console.log('collection: ' + record.event.ns.coll); console.log('Full document:', JSON.stringify(record.event.fullDocument, null, 2)); }; ``` Ein Amazon DocumentDB DocumentDB-Ereignis mit Lambda verwenden TypeScript ``` import { DocumentDBEventRecord, DocumentDBEventSubscriptionContext } from 'aws-lambda'; console.log('Loading function'); export const handler = async ( event: DocumentDBEventSubscriptionContext, context: any ): Promise => { event.events.forEach((record: DocumentDBEventRecord) => { logDocumentDBEvent(record); }); return 'OK'; }; const logDocumentDBEvent = (record: DocumentDBEventRecord): void => { console.log('Operation type: ' + record.event.operationType); console.log('db: ' + record.event.ns.db); console.log('collection: ' + record.event.ns.coll); console.log('Full document:', JSON.stringify(record.event.fullDocument, null, 2)); }; ``` ------ #### [ PHP ] **SDK für PHP** Es gibt noch mehr dazu. GitHub Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Nutzen eines Amazon DocumentDB-Ereignisses mit Lambda unter Verwendung von PHP. ``` logDocumentDBEvent($record['event']); } return 'OK'; } private function logDocumentDBEvent($event): void { // Extract information from the event record $operationType = $event['operationType'] ?? 'Unknown'; $db = $event['ns']['db'] ?? 'Unknown'; $collection = $event['ns']['coll'] ?? 'Unknown'; $fullDocument = $event['fullDocument'] ?? []; // Log the event details echo "Operation type: $operationType\n"; echo "Database: $db\n"; echo "Collection: $collection\n"; echo "Full document: " . json_encode($fullDocument, JSON_PRETTY_PRINT) . "\n"; } } return new DocumentDBEventHandler(); ``` ------ #### [ Python ] **SDK für Python (Boto3)** Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Nutzen eines Amazon DocumentDB-Ereignisses mit Lambda unter Verwendung von Python. ``` import json def lambda_handler(event, context): for record in event.get('events', []): log_document_db_event(record) return 'OK' def log_document_db_event(record): event_data = record.get('event', {}) operation_type = event_data.get('operationType', 'Unknown') db = event_data.get('ns', {}).get('db', 'Unknown') collection = event_data.get('ns', {}).get('coll', 'Unknown') full_document = event_data.get('fullDocument', {}) print(f"Operation type: {operation_type}") print(f"db: {db}") print(f"collection: {collection}") print("Full document:", json.dumps(full_document, indent=2)) ``` ------ #### [ Ruby ] **SDK für Ruby** Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Nutzen eines Amazon DocumentDB-Ereignisses mit Lambda unter Verwendung von Ruby. ``` require 'json' def lambda_handler(event:, context:) event['events'].each do |record| log_document_db_event(record) end 'OK' end def log_document_db_event(record) event_data = record['event'] || {} operation_type = event_data['operationType'] || 'Unknown' db = event_data.dig('ns', 'db') || 'Unknown' collection = event_data.dig('ns', 'coll') || 'Unknown' full_document = event_data['fullDocument'] || {} puts "Operation type: #{operation_type}" puts "db: #{db}" puts "collection: #{collection}" puts "Full document: #{JSON.pretty_generate(full_document)}" end ``` ------ #### [ Rust ] **SDK für Rust** Es gibt noch mehr dazu GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda). Nutzen eines Amazon DocumentDB-Ereignisses mit Lambda unter Verwendung von Rust. ``` use lambda_runtime::{service_fn, tracing, Error, LambdaEvent}; use aws_lambda_events::{ event::documentdb::{DocumentDbEvent, DocumentDbInnerEvent}, }; // Built with the following dependencies: //lambda_runtime = "0.11.1" //serde_json = "1.0" //tokio = { version = "1", features = ["macros"] } //tracing = { version = "0.1", features = ["log"] } //tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] } //aws_lambda_events = "0.15.0" async fn function_handler(event: LambdaEvent) ->Result<(), Error> { tracing::info!("Event Source ARN: {:?}", event.payload.event_source_arn); tracing::info!("Event Source: {:?}", event.payload.event_source); let records = &event.payload.events; if records.is_empty() { tracing::info!("No records found. Exiting."); return Ok(()); } for record in records{ log_document_db_event(record); } tracing::info!("Document db records processed"); // Prepare the response Ok(()) } fn log_document_db_event(record: &DocumentDbInnerEvent)-> Result<(), Error>{ tracing::info!("Change Event: {:?}", record.event); Ok(()) } #[tokio::main] async fn main() -> Result<(), Error> { tracing_subscriber::fmt() .with_max_level(tracing::Level::INFO) .with_target(false) .without_time() .init(); let func = service_fn(function_handler); lambda_runtime::run(func).await?; Ok(()) } ``` ------ 1. Fügen Sie den Code im **Code-Quell**bereich der Lambda-Konsole in den Code-Editor ein und ersetzen Sie dabei den von Lambda erstellten Code. 1. Wählen Sie im Abschnitt **DEPLOY** die Option **Deploy** aus, um den Code Ihrer Funktion zu aktualisieren: ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png) ## Erstellen Sie die Zuordnung von Ereignisquellen in Lambda Erstellen Sie die Zuordnung von Ereignisquellen, die Ihren Amazon DocumentDB-Change-Stream mit Ihrer Lambda-Funktion verknüpft. Nachdem Sie diese Ereignisquellenzuordnung erstellt haben, wird AWS Lambda sofort mit der Abfrage des Streams begonnen. **Die Zuordnung von Ereignisquellen erstellen** 1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) in der Lambda-Konsole. 1. Wählen Sie die `ProcessDocumentDBRecords`-Funktion aus, die Sie zuvor erstellt haben. 1. Wählen Sie die Registerkarte **Konfiguration** und dann im linken Menü die Option **Auslöser** aus. 1. Wählen Sie **Add trigger**. 1. Wählen Sie unter **Trigger-Konfiguration** als Quelle die Option **Amazon DocumentDB** aus. 1. Erstellen Sie die Zuordnung von Ereignisquellen mit der folgenden Konfiguration: + **Amazon-DocumentDB-Cluster**: Wählen Sie den Cluster aus, den Sie zuvor erstellt haben. + **Datenbankname**: docdbdemo + **Name der Kollektion**:Produkte + **Chargengröße**: 1 + **Startposition**: Neueste + **Authentifizierung**: BASIC\$1AUTH + **Secrets-Manager-Schlüssel**: Wählen Sie das Secret für Ihren Amazon-DocumentDB-Cluster aus. Der Name ist ähnlich wie `rds!cluster-12345678-a6f0-52c0-b290-db4aga89274f`. + **Batchfenster**: 1 + **Vollständige Konfiguration des Dokuments**: UpdateLookup 1. Wählen Sie **Hinzufügen** aus. Die Erstellung Ihrer Zuordnung von Ereignisquellen kann einige Minuten dauern. ## Testen der -Funktion Warten Sie, bis die Zuordnung von Ereignisquellen den Status **Aktiviert** erreicht hat. Dies kann mehrere Minuten dauern. Testen Sie dann das end-to-end Setup, indem Sie Datenbankeinträge einfügen, aktualisieren und löschen. Bevor Sie beginnen: 1. [Stellen Sie erneut eine Verbindung zu Ihrem Amazon DocumentDB-Cluster](#docdb-connect-to-cluster) in Ihrer CloudShell Umgebung her. 1. Führen Sie den folgenden Befehl aus, um sicherzustellen, dass Sie die `docdbdemo`-Datenbank verwenden: ``` use docdbdemo ``` ### Einfügen eines Datensatzes Fügen Sie einen Datensatz in die `products`-Sammlung der `docdbdemo`-Datenbank ein: ``` db.products.insertOne({"name":"Pencil", "price": 1.00}) ``` [Überprüfen Sie anhand von Logs, ob Ihre Funktion dieses Ereignis erfolgreich verarbeitet hat. CloudWatch ](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console) Sie sollten einen Protokolleintrag wie diesen sehen: ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/documentdb-insert-log.png) ### Aktualisieren von Datensätzen Aktualisieren Sie den gerade eingefügten Datensatz mit dem folgenden Befehl: ``` db.products.updateOne( { "name": "Pencil" }, { $set: { "price": 0.50 }} ) ``` Überprüfen Sie, ob Ihre Funktion dieses Ereignis erfolgreich verarbeitet hat, indem [Sie die Option CloudWatch Logs überprüfen](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console). Sie sollten einen Protokolleintrag wie diesen sehen: ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/documentdb-update-log.png) ### Einen Datensatz löschen Löschen Sie den Datensatz, den Sie gerade aktualisiert haben, mit dem folgenden Befehl: ``` db.products.deleteOne( { "name": "Pencil" } ) ``` Überprüfen Sie anhand von [ CloudWatch Logs](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console), ob Ihre Funktion dieses Ereignis erfolgreich verarbeitet hat. Sie sollten einen Protokolleintrag wie diesen sehen: ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/documentdb-delete-log.png) ## Fehlerbehebung Wenn Sie in den CloudWatch Protokollen Ihrer Funktion keine Datenbankereignisse sehen, überprüfen Sie Folgendes: + Stellen Sie sicher, dass sich die Zuordnung von Ereignisquellen in Lambda (auch als Auslöser bezeichnet) im Status **Aktiviert** befindet. Die Zuordnung von Ereignisquellen kann mehrere Minuten in Anspruch nehmen. + Wenn die Zuordnung der Ereignisquellen **aktiviert** ist, Sie aber immer noch keine Datenbankereignisse sehen in CloudWatch: + Stellen Sie sicher, dass der **Datenbankname** in der Zuordnung von Ereignisquellen auf `docdbdemo` eingestellt ist. ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/documentdb-trigger.png) + Überprüfen Sie das Feld **Letztes Verarbeitungsergebnis** der Zuordnung von Ereignisquellen auf die folgende Meldung: „PROBLEM: Verbindungsfehler. Ihre VPC muss eine Verbindung zu Lambda und STS sowie zu Secrets Manager herstellen können, wenn eine Authentifizierung erforderlich ist.“ Wenn diese Fehlermeldung angezeigt wird, stellen Sie sicher, dass Sie die [Lambda- und Secrets-Manager-VPC-Schnittstellenendpunkte](#docdb-create-interface-vpc-endpoints) erstellt haben und dass die Endpunkte dieselbe VPC und dieselben Subnetze verwenden wie Ihr Amazon-DocumentDB-Cluster. ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/documentdb-lastprocessingresult.png) ## Bereinigen Ihrer Ressourcen Sie können jetzt die Ressourcen, die Sie für dieses Tutorial erstellt haben, löschen, es sei denn, Sie möchten sie behalten. Durch das Löschen von AWS -Ressourcen, die Sie nicht mehr verwenden, können Sie verhindern, dass unnötige Gebühren in Ihrem AWS-Konto-Konto anfallen. **So löschen Sie die Lambda-Funktion:** 1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole. 1. Wählen Sie die Funktion aus, die Sie erstellt haben. 1. Wählen Sie **Aktionen**, **Löschen** aus. 1. Geben Sie **confirm** in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus. **So löschen Sie die Ausführungsrolle** 1. Öffnen Sie die Seite [Roles](https://console.aws.amazon.com/iam/home#/roles) in der IAM-Konsole. 1. Wählen Sie die von Ihnen erstellte Ausführungsrolle aus. 1. Wählen Sie **Löschen** aus. 1. Geben Sie den Namen der Rolle in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus. **Löschen von VPC-Endpunkten** 1. Öffnen Sie die [VPC;-Konsole](https://console.aws.amazon.com/vpc/home#). Wählen Sie im linken Menü unter **Virtual Private Cloud** die Option **Endpunkte** aus. 1. Wählen Sie die Endpunkte aus, die Sie erstellt haben. 1. Wählen Sie **Actions** (Aktionen), **Delete VPC Endpoint** (VPC-Endpunkte löschen). 1. Geben Sie **delete** in das Texteingabefeld ein. 1. Wählen Sie **Löschen** aus. **So löschen Sie den Amazon DocumentDB-Cluster** 1. Öffnen Sie die [Amazon DocumentDB-Konsole](https://console.aws.amazon.com/docdb/home#). 1. Wählen Sie den Amazon DocumentDB-Cluster aus, den Sie für dieses Tutorial erstellt haben, und deaktivieren Sie den Löschschutz. 1. Wählen Sie auf der **Cluster-Hauptseite** erneut Ihren Amazon DocumentDB-Cluster aus. 1. Wählen Sie **Aktionen**, **Löschen** aus. 1. Wählen Sie für **Finalen Cluster-Snapshot erstellen** die Option **Nein** aus. 1. Geben Sie **delete** in das Texteingabefeld ein. 1. Wählen Sie **Löschen** aus. **So löschen Sie das Secret im Secrets Manager** 1. Öffnen Sie die [Secrets Manager-Konsole](https://console.aws.amazon.com/secretsmanager/home#). 1. Wählen Sie das Secret aus, das Sie für dieses Tutorial erstellt haben. 1. Wählen Sie **Aktionen**, **Secret löschen**. 1. Wählen Sie **Schedule deletion**.