Den Cluster erstellen Erstellen des Secrets in Secrets Manager Verbinden mit dem Cluster Change-Streams aktivieren Schnittstellen-VPC-Endpunkte erstellen Erstellen der Ausführungsrolle So erstellen Sie die Lambda-Funktion:Erstellen Sie die Zuordnung von Ereignisquellen in Lambda Testen der -Funktion Fehlerbehebung Bereinigen Ihrer Ressourcen

Tutorial: Verwenden von AWS Lambda mit Amazon 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

Öffnen Sie die Amazon DocumentDB-Konsole. Wählen Sie unter Cluster die Option Erstellen aus.
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.
Wählen Sie Cluster erstellen.

Erstellen des Secrets in Secrets Manager

Während Amazon DocumentDB Ihren Cluster erstellt, erstellen Sie einen geheimen AWS Secrets Manager-Schlüssel, um Ihre Datenbank-Anmeldeinformationen 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

Öffnen Sie die Secrets-Manager-Konsole und wählen Sie Neues Secret speichern.
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.
Wählen Sie unter Secret konfigurieen eine der folgenden Optionen aus:
- Secret-Name: DocumentDBSecret
- Wählen Sie Weiter aus.
Wählen Sie Weiter aus.
Wählen Sie Store (Speichern) aus.
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

Verbinden mit dem Amazon-DocumentDB-Cluster mithilfe von AWS CloudShell

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.
Wählen Sie Mit Cluster verbinden aus. Der CloudShell-Bildschirm Befehl ausführen wird angezeigt.
Geben Sie im Feld Neuer Umgebungsname einen eindeutigen Namen ein, z. B. „Test“, und wählen Sie Erstellen und ausführen aus.
Geben Sie bei der Aufforderung Ihr Passwort ein. Wenn der Prompt zu rs0 [direct: primary] <env-name>> 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 aktivieren.

Um eine neue Datenbank in Ihrem Cluster zu erstellen

Führen Sie den folgenden Befehl aus, um eine neue Datenbank mit dem Namen docdbdemo zu erstellen:
```
use docdbdemo
```
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')
}
```

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

Öffnen Sie die VPC;-Konsole. Wählen Sie im linken Menü unter Virtual Private Cloud die Option Endpunkte aus.
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 unter Servicekategorie die Option AWS-Services aus.
- Geben Sie unter Services lambda in das Suchfeld ein. Wählen Sie den Service im Format com.amazonaws.<region>.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.
- 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 unter IP-Adresstyp IPv4 aus.
- 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.
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 unter Servicekategorie die Option AWS-Services aus.
- Geben Sie unter Services secretsmanager in das Suchfeld ein. Wählen Sie den Service im Format com.amazonaws.<region>.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.
- 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 unter IP-Adresstyp IPv4 aus.
- 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

Öffnen Sie in der IAM-Konsole die Seite Richtlinien und wählen Sie dann Richtlinie erstellen aus.

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.

Wählen Sie Weiter: Tags und dann Weiter: Prüfen aus.
Geben Sie unter Name AWSDocumentDBLambdaPolicy ein.
Wählen Sie Richtlinie erstellen aus.

So erstellen Sie die IAM-Rolle

Öffnen Sie die Seite Rollen in der IAM-Konsole und wählen Sie Rolle erstellen.
Wählen Sie für Vertrauenswürdige Entität auswählen die folgenden Optionen:
- Vertrauenswürdiger Entitätstyp: AWS-Service
- Service oder Anwendungsfall: Lambda
- Wählen Sie Weiter aus.
Wählen Sie unter 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 geben.
Wählen Sie Weiter aus.
Geben Sie für Role name (Rollenname) den Namen AWSDocumentDBLambdaExecutionRole ein.
Wählen Sie Create role (Rolle erstellen) aus.

So erstellen Sie die Lambda-Funktion:

In diesem Tutorial wird die Python 3.13-Laufzeit verwendet. Es stehen aber auch Beispielcodedateien für andere Laufzeiten zur Verfügung. 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:

Öffnen Sie die Seite Funktionen der Lambda-Konsole.
Wählen Sie Funktion erstellen.
Wählen Sie Ohne Vorgabe erstellen aus.
Führen Sie unter Basic information (Grundlegende Informationen) die folgenden Schritte aus:
1. Geben Sie unter Funktionsname ProcessDocumentDBRecords ein.
2. Wählen Sie für Runtime (Laufzeit) die Option Python 3.13 aus.
3. Wählen Sie für Architektur x86_64 aus.
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.
2. Wählen Sie die zuvor erstellte AWSDocumentDBLambdaExecutionRole aus.
Wählen Sie Funktion erstellen.

So stellen Sie den Funktionscode bereit

Wählen Sie im folgenden Feld die Registerkarte Python und kopieren Sie den Code.

.NET

SDK für .NET

Anmerkung

Auf GitHub finden Sie noch mehr. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit Serverless-Beispielen.

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
{
    
     /// <summary>
    /// Lambda function entry point to process Amazon DocumentDB events.
    /// </summary>
    /// <param name="event">The Amazon DocumentDB event.</param>
    /// <param name="context">The Lambda context object.</param>
    /// <returns>A string to indicate successful processing.</returns>
    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<DocumentDBEventRecord> 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<string, object> 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

Anmerkung

Auf GitHub finden Sie noch mehr. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit Serverless-Beispielen.

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

Anmerkung

Auf GitHub finden Sie noch mehr. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit Serverless-Beispielen.

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<Map<String, Object>, String> {

    @SuppressWarnings("unchecked")
    @Override
    public String handleRequest(Map<String, Object> event, Context context) {
        List<Map<String, Object>> events = (List<Map<String, Object>>) event.get("events");
        for (Map<String, Object> record : events) {
            Map<String, Object> eventData = (Map<String, Object>) record.get("event");
            processEventData(eventData);
        }

        return "OK";
    }

    @SuppressWarnings("unchecked")
    private void processEventData(Map<String, Object> eventData) {
        String operationType = (String) eventData.get("operationType");
        System.out.println("operationType: %s".formatted(operationType));

        Map<String, Object> ns = (Map<String, Object>) 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<String, Object> fullDocument = (Map<String, Object>) eventData.get("fullDocument");
        System.out.println("fullDocument: %s".formatted(fullDocument));
    }

}

JavaScript

SDK für JavaScript (v3)

Anmerkung

Auf GitHub finden Sie noch mehr. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit Serverless-Beispielen.

Nutzen eines Amazon DocumentDB-Ereignisses mit Lambda unter Verwendung von 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));
};

Nutzen eines Amazon DocumentDB-Ereignisses mit Lambda unter Verwendung von TypeScript


import { DocumentDBEventRecord, DocumentDBEventSubscriptionContext } from 'aws-lambda';

console.log('Loading function');

export const handler = async (
  event: DocumentDBEventSubscriptionContext,
  context: any
): Promise<string> => {
  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

Anmerkung

Auf GitHub finden Sie noch mehr. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit Serverless-Beispielen.

Nutzen eines Amazon DocumentDB-Ereignisses mit Lambda unter Verwendung von PHP.


<?php

require __DIR__.'/vendor/autoload.php';

use Bref\Context\Context;
use Bref\Event\Handler;

class DocumentDBEventHandler implements Handler
{
    public function handle($event, Context $context): string
    {

        $events = $event['events'] ?? [];
        foreach ($events as $record) {
            $this->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)

Anmerkung

Auf GitHub finden Sie noch mehr. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit Serverless-Beispielen.

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

Anmerkung

Auf GitHub finden Sie noch mehr. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit Serverless-Beispielen.

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

Anmerkung

Auf GitHub finden Sie noch mehr. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit Serverless-Beispielen.

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<DocumentDbEvent>) ->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(())
    
}

Fügen Sie den Code im Code-Quellbereich der Lambda-Konsole in den Code-Editor ein und ersetzen Sie dabei den von Lambda erstellten Code.
Wählen Sie im Abschnitt DEPLOY die Option Deploy aus, um den Code Ihrer Funktion zu aktualisieren:

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. Nach dem Erstellen dieser Zuordnung von Ereignisquellen beginnt AWS Lambda sofort mit der Abfrage des Streams.

Die Zuordnung von Ereignisquellen erstellen

Öffnen Sie die Seite Funktionen in der Lambda-Konsole.
Wählen Sie die ProcessDocumentDBRecords-Funktion aus, die Sie zuvor erstellt haben.
Wählen Sie die Registerkarte Konfiguration und dann im linken Menü die Option Auslöser aus.
Wählen Sie Add trigger.
Wählen Sie unter Trigger-Konfiguration als Quelle die Option Amazon DocumentDB aus.
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
- Stapelgröße: 1
- Startposition: Neueste
- Authentifizierung: BASIC_AUTH
- 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 Dokumentenkonfiguration: UpdateLookup
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 anschließend die End-to-End-Konfiguration, indem Sie Datenbankdatensätze einfügen, aktualisieren und löschen. Bevor Sie beginnen:

Stellen Sie in Ihrer CloudShell-Umgebung erneut eine Verbindung zu Ihrem Amazon-DocumentDB-Cluster her.
Führen Sie den folgenden Befehl aus, um sicherzustellen, dass Sie die docdbdemo-Datenbank verwenden:
```
use docdbdemo
```

Fügen Sie einen Datensatz in die products-Sammlung der docdbdemo-Datenbank ein:


db.products.insertOne({"name":"Pencil", "price": 1.00})

Überprüfen Sie in den CloudWatch-Protokollen, ob Ihre Funktion dieses Ereignis erfolgreich verarbeitet hat. Sie sollten einen Protokolleintrag wie diesen sehen:

CloudWatch-Protokollstream zum Einfügen von Datenbankdatensätzen

Aktualisieren Sie den gerade eingefügten Datensatz mit dem folgenden Befehl:


db.products.updateOne(
    { "name": "Pencil" },
    { $set: { "price": 0.50 }}
)

Überprüfen Sie in den CloudWatch-Protokollen, ob Ihre Funktion dieses Ereignis erfolgreich verarbeitet hat. Sie sollten einen Protokolleintrag wie diesen sehen:

CloudWatch-Protokollstream zum Aktualisieren von Datenbankdatensätzen

Löschen Sie den Datensatz, den Sie gerade aktualisiert haben, mit dem folgenden Befehl:


db.products.deleteOne( { "name": "Pencil" } )

Überprüfen Sie in den CloudWatch-Protokollen, ob Ihre Funktion dieses Ereignis erfolgreich verarbeitet hat. Sie sollten einen Protokolleintrag wie diesen sehen:

CloudWatch-Protokollstream zum Löschen von Datenbankdatensätzen

Fehlerbehebung

Wenn in den CloudWatch-Protokollen Ihrer Funktion keine Datenbankereignisse angezeigt werden, prü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 von Ereignisquellen aktiviert ist, Sie aber immer noch keine Datenbankereignisse in CloudWatch sehen:
- Stellen Sie sicher, dass der Datenbankname in der Zuordnung von Ereignisquellen auf docdbdemo eingestellt ist.
- Ü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 erstellt haben und dass die Endpunkte dieselbe VPC und dieselben Subnetze verwenden wie Ihr Amazon-DocumentDB-Cluster.

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:

Öffnen Sie die Seite Funktionen der Lambda-Konsole.
Wählen Sie die Funktion aus, die Sie erstellt haben.
Wählen Sie Actions, Delete.
Geben Sie confirm in das Texteingabefeld ein und wählen Sie Delete (Löschen) aus.

So löschen Sie die Ausführungsrolle

Öffnen Sie die Seite Roles in der IAM-Konsole.
Wählen Sie die von Ihnen erstellte Ausführungsrolle aus.
Wählen Sie Löschen aus.
Geben Sie den Namen der Rolle in das Texteingabefeld ein und wählen Sie Delete (Löschen) aus.

Löschen von VPC-Endpunkten

Öffnen Sie die VPC;-Konsole. Wählen Sie im linken Menü unter Virtual Private Cloud die Option Endpunkte aus.
Wählen Sie die Endpunkte aus, die Sie erstellt haben.
Wählen Sie Actions (Aktionen), Delete VPC Endpoint (VPC-Endpunkte löschen).
Geben Sie delete in das Texteingabefeld ein.
Wählen Sie Löschen aus.

So löschen Sie den Amazon DocumentDB-Cluster

Öffnen Sie die Amazon DocumentDB-Konsole.
Wählen Sie den Amazon DocumentDB-Cluster aus, den Sie für dieses Tutorial erstellt haben, und deaktivieren Sie den Löschschutz.
Wählen Sie auf der Cluster-Hauptseite erneut Ihren Amazon DocumentDB-Cluster aus.
Wählen Sie Aktionen, Löschen aus.
Wählen Sie für Finalen Cluster-Snapshot erstellen die Option Nein aus.
Geben Sie delete in das Texteingabefeld ein.
Wählen Sie Löschen aus.

So löschen Sie das Secret im Secrets Manager

Öffnen Sie die Secrets Manager-Konsole.
Wählen Sie das Secret aus, das Sie für dieses Tutorial erstellt haben.
Wählen Sie Aktionen, Secret löschen.
Wählen Sie Schedule deletion.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Amazon DocumentDB

DynamoDB