Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Tutorial: Menggunakan AWS Lambda dengan Amazon DocumentDB Streams
Dalam tutorial ini, Anda membuat fungsi Lambda dasar yang menggunakan peristiwa dari aliran perubahan Amazon DocumentDB (dengan kompatibilitas MongoDB). Untuk menyelesaikan tutorial ini, Anda akan melalui tahapan berikut:
+ Siapkan cluster Amazon DocumentDB Anda, sambungkan ke sana, dan aktifkan aliran perubahan di dalamnya.
+ Buat fungsi Lambda Anda, dan konfigurasikan cluster Amazon DocumentDB Anda sebagai sumber peristiwa untuk fungsi Anda.
+ Uji penyiapan dengan memasukkan item ke dalam database Amazon DocumentDB Anda.
## Buat cluster Amazon DocumentDB
1. Buka konsol [Amazon DocumentDB](https://console.aws.amazon.com/docdb/home#). Di bawah **Cluster**, pilih **Buat**.
1. Buat cluster dengan konfigurasi berikut:
+ Untuk **tipe Cluster**, pilih cluster **berbasis Instance**. Ini adalah pilihan default.
+ Di bawah **konfigurasi Cluster**, pastikan bahwa **Engine versi** 5.0.0 dipilih. Ini adalah pilihan default.
+ Di bawah **konfigurasi Instance**:
+ Untuk **kelas instans DB, pilih kelas** yang **dioptimalkan memori**. Ini adalah pilihan default.
+ Untuk **Jumlah contoh replika biasa**, pilih 1.
+ Untuk **kelas Instance**, gunakan pilihan default.
+ Di bawah **Autentikasi**, masukkan nama pengguna untuk pengguna utama, lalu pilih **Self managed**. Masukkan kata sandi, lalu konfirmasikan.
+ Simpan semua pengaturan default lainnya.
1. Pilih **Buat klaster**.
## Buat rahasia di Secrets Manager
Saat Amazon DocumentDB membuat klaster Anda, buat rahasia untuk menyimpan AWS Secrets Manager kredensi database Anda. Anda akan memberikan rahasia ini saat membuat pemetaan sumber peristiwa Lambda di langkah selanjutnya.
**Untuk membuat rahasia di Secrets Manager**
1. Buka konsol [Secrets Manager](https://console.aws.amazon.com/secretsmanager/home#) dan pilih **Simpan rahasia baru**.
1. Untuk **Pilih jenis rahasia**, pilih opsi berikut:
+ Di bawah **rincian dasar**:
+ **Jenis rahasia**: Kredensi untuk database Amazon DocumentDB Anda
+ Di bawah **Kredensial**, masukkan nama pengguna dan kata sandi yang sama dengan yang Anda gunakan untuk membuat klaster Amazon DocumentDB Anda.
+ **Database**: Pilih cluster Amazon DocumentDB Anda.
+ Pilih **Berikutnya**.
1. Untuk **Konfigurasi rahasia**, pilih opsi berikut:
+ **Nama rahasia**: `DocumentDBSecret`
+ Pilih **Berikutnya**.
1. Pilih **Berikutnya**.
1. Pilih **Toko**.
1. Segarkan konsol untuk memverifikasi bahwa Anda berhasil menyimpan `DocumentDBSecret` rahasia.
Perhatikan **Rahasia ARN**. Anda akan membutuhkannya di langkah selanjutnya.
## Menyambungkan ke klaster
**Connect ke cluster Amazon DocumentDB Anda menggunakan AWS CloudShell**
1. Di konsol manajemen Amazon DocumentDB, **di bawah** Clusters, temukan klaster yang Anda buat. Pilih klaster Anda dengan mengklik kotak centang di sebelahnya.
1. Pilih **Connect to cluster**. Layar **perintah CloudShell Jalankan** muncul.
1. Di bidang **Nama lingkungan baru**, masukkan nama unik, seperti “uji” dan pilih **Buat dan jalankan**.
1. Saat diminta, masukkan kata sandi Anda. Ketika prompt menjadi`rs0 [direct: primary] >`, Anda berhasil terhubung ke cluster Amazon DocumentDB Anda.
## Aktifkan aliran perubahan
Untuk tutorial ini, Anda akan melacak perubahan pada `products` koleksi `docdbdemo` database di cluster Amazon DocumentDB Anda. Anda melakukan ini dengan mengaktifkan [aliran perubahan](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html).
**Untuk membuat database baru di dalam klaster Anda**
1. Jalankan perintah berikut untuk membuat database baru yang disebut`docdbdemo`:
```
use docdbdemo
```
1. Di jendela terminal, gunakan perintah berikut untuk memasukkan catatan ke`docdbdemo`:
```
db.products.insertOne({"hello":"world"})
```
Anda akan melihat output seperti ini:
```
{
acknowledged: true,
insertedId: ObjectId('67f85066ca526410fd531d59')
}
```
1. Selanjutnya, aktifkan aliran perubahan pada `products` koleksi `docdbdemo` database menggunakan perintah berikut:
```
db.adminCommand({modifyChangeStreams: 1,
database: "docdbdemo",
collection: "products",
enable: true});
```
Anda akan melihat output seperti ini:
```
{ "ok" : 1, "operationTime" : Timestamp(1680126165, 1) }
```
## Buat antarmuka VPC endpoint
Selanjutnya, buat [titik akhir VPC antarmuka](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws) untuk memastikan bahwa Lambda dan Secrets Manager (digunakan nanti untuk menyimpan kredenal akses cluster kami) dapat terhubung ke VPC default Anda.
**Untuk membuat titik akhir VPC antarmuka**
1. Buka konsol [VPC](https://console.aws.amazon.com/vpc/home#). Di menu sebelah kiri, di bawah **Virtual Private Cloud**, pilih **Endpoints**.
1. Pilih **Buat titik akhir**. Buat titik akhir dengan konfigurasi berikut:
+ Untuk **tag Nama**, masukkan`lambda-default-vpc`.
+ Untuk **kategori Layanan**, pilih AWS layanan.
+ Untuk **Layanan**, masukkan `lambda` di kotak pencarian. Pilih layanan dengan format`com.amazonaws..lambda`.
+ Untuk **VPC, pilih VPC** tempat cluster Amazon DocumentDB Anda berada. Ini biasanya [VPC default](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html).
+ Untuk **Subnet**, centang kotak di sebelah setiap zona ketersediaan. Pilih subnet ID yang benar untuk setiap zona ketersediaan.
+ Untuk **jenis alamat IP**, pilih IPv4.
+ Untuk **grup Keamanan**, pilih grup keamanan yang digunakan cluster Amazon DocumentDB Anda. Ini biasanya kelompok `default` keamanan.
+ Simpan semua pengaturan default lainnya.
+ Pilih **Buat titik akhir**.
1. Sekali lagi, pilih **Buat titik akhir**. Buat titik akhir dengan konfigurasi berikut:
+ Untuk **tag Nama**, masukkan`secretsmanager-default-vpc`.
+ Untuk **kategori Layanan**, pilih AWS layanan.
+ Untuk **Layanan**, masukkan `secretsmanager` di kotak pencarian. Pilih layanan dengan format`com.amazonaws..secretsmanager`.
+ Untuk **VPC, pilih VPC** tempat cluster Amazon DocumentDB Anda berada. Ini biasanya [VPC default](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html).
+ Untuk **Subnet**, centang kotak di sebelah setiap zona ketersediaan. Pilih subnet ID yang benar untuk setiap zona ketersediaan.
+ Untuk **jenis alamat IP**, pilih IPv4.
+ Untuk **grup Keamanan**, pilih grup keamanan yang digunakan cluster Amazon DocumentDB Anda. Ini biasanya kelompok `default` keamanan.
+ Simpan semua pengaturan default lainnya.
+ Pilih **Buat titik akhir**.
Ini melengkapi bagian pengaturan cluster dari tutorial ini.
## Buat peran eksekusi
Pada rangkaian langkah berikutnya, Anda akan membuat fungsi Lambda Anda. Pertama, Anda perlu membuat peran eksekusi yang memberikan izin fungsi Anda untuk mengakses klaster Anda. Anda melakukannya dengan membuat kebijakan IAM terlebih dahulu, lalu melampirkan kebijakan ini ke peran IAM.
**Untuk membuat kebijakan IAM**
1. Buka [halaman Kebijakan](https://console.aws.amazon.com/iam/home#/policies) di konsol IAM dan pilih **Buat kebijakan**.
1. Pilih tab **JSON**. Dalam kebijakan berikut, ganti ARN sumber daya Secrets Manager di baris terakhir pernyataan dengan ARN rahasia Anda dari sebelumnya, dan salin kebijakan ke 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. Pilih **Berikutnya: Tag**, lalu pilih **Berikutnya: Tinjau**.
1. Untuk **Nama**, masukkan `AWSDocumentDBLambdaPolicy`.
1. Pilih **Buat kebijakan**.
**Untuk membuat peran IAM**
1. Buka [halaman Peran](https://console.aws.amazon.com/iam/home#/roles) di konsol IAM dan pilih **Buat peran**.
1. Untuk **Pilih entitas tepercaya**, pilih opsi berikut:
+ **Jenis entitas tepercaya**: AWS layanan
+ **Kasus layanan atau penggunaan**: Lambda
+ Pilih **Berikutnya**.
1. Untuk **Menambahkan izin**, pilih `AWSDocumentDBLambdaPolicy` kebijakan yang baru saja Anda buat, serta `AWSLambdaBasicExecutionRole` untuk memberikan izin fungsi Anda untuk menulis ke Amazon CloudWatch Logs.
1. Pilih **Berikutnya**.
1. Untuk **Nama peran**, masukkan `AWSDocumentDBLambdaExecutionRole`.
1. Pilih **Buat peran**.
## Buat fungsi Lambda
Tutorial ini menggunakan runtime Python 3.14, tetapi kami juga menyediakan contoh file kode untuk runtime lainnya. Anda dapat memilih tab di kotak berikut untuk melihat kode runtime yang Anda minati.
Kode menerima input peristiwa Amazon DocumentDB dan memproses pesan yang dikandungnya.
**Untuk membuat fungsi Lambda**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.
1. Pilih **Buat fungsi**.
1. Pilih **Penulis dari awal**
1. Di bagian **Informasi dasar**, lakukan hal berikut:
1. Untuk **nama Fungsi**, masukkan `ProcessDocumentDBRecords`
1. Untuk **Runtime**, pilih **Python 3.14**.
1. Untuk **Arsitektur**, pilih **x86\$164**.
1. Di tab **Ubah peran eksekusi default**, lakukan hal berikut:
1. Perluas tab, lalu pilih **Gunakan peran yang ada**.
1. Pilih yang `AWSDocumentDBLambdaExecutionRole` Anda buat sebelumnya.
1. Pilih **Buat fungsi**.
**Untuk menyebarkan kode fungsi**
1. Pilih tab **Python** di kotak berikut dan salin kodenya.
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Mengkonsumsi acara Amazon DocumentDB dengan Lambda menggunakan.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 untuk Go V2**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Mengkonsumsi acara Amazon DocumentDB dengan Lambda menggunakan 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 untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Mengkonsumsi acara Amazon DocumentDB dengan Lambda menggunakan 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 untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Mengkonsumsi acara Amazon DocumentDB dengan menggunakan 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));
};
```
Mengkonsumsi acara Amazon DocumentDB dengan Lambda menggunakan 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 untuk PHP**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Mengkonsumsi acara Amazon DocumentDB dengan Lambda menggunakan 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 untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Mengkonsumsi acara Amazon DocumentDB dengan Lambda menggunakan 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 untuk Ruby**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Mengkonsumsi acara Amazon DocumentDB dengan Lambda menggunakan 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 for Rust**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Mengkonsumsi acara Amazon DocumentDB dengan Lambda menggunakan 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. Di panel **Sumber kode** di konsol Lambda, tempelkan kode ke editor kode, ganti kode yang dibuat Lambda.
1. Di bagian **DEPLOY**, pilih **Deploy** untuk memperbarui kode fungsi Anda:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
## Buat pemetaan sumber acara Lambda
Buat pemetaan sumber peristiwa yang mengaitkan aliran perubahan Amazon DocumentDB Anda dengan fungsi Lambda Anda. Setelah Anda membuat pemetaan sumber acara ini, AWS Lambda segera mulai polling aliran.
**Untuk membuat pemetaan sumber acara**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.
1. Pilih `ProcessDocumentDBRecords` fungsi yang Anda buat sebelumnya.
1. Pilih tab **Konfigurasi**, lalu pilih **Pemicu** di menu sebelah kiri.
1. Pilih **Tambahkan pemicu**.
1. Di bawah **konfigurasi Trigger**, untuk sumbernya, pilih **Amazon DocumentDB**.
1. Buat pemetaan sumber acara dengan konfigurasi berikut:
+ Cluster **Amazon DocumentDB**: Pilih cluster yang Anda buat sebelumnya.
+ **Nama database**: docdbdemo
+ **Nama koleksi**: produk
+ **Ukuran Batch**: 1
+ **Posisi awal**: Terbaru
+ **Otentikasi: BASIC\$1AUTH**
+ **Kunci Secrets Manager**: Pilih rahasia untuk cluster Amazon DocumentDB Anda. Itu akan disebut sesuatu seperti`rds!cluster-12345678-a6f0-52c0-b290-db4aga89274f`.
+ **Jendela Batch**: 1
+ **Konfigurasi dokumen lengkap**: UpdateLookup
1. Pilih **Tambahkan**. Membuat pemetaan sumber acara Anda dapat memakan waktu beberapa menit.
## Uji fungsi Anda
Tunggu pemetaan sumber acara mencapai status **Diaktifkan**. Ini dapat memakan waktu beberapa menit. Kemudian, uji end-to-end pengaturan dengan memasukkan, memperbarui, dan menghapus catatan database. Sebelum Anda memulai:
1. [Sambungkan kembali ke cluster Amazon DocumentDB di lingkungan Anda](#docdb-connect-to-cluster). CloudShell
1. Jalankan perintah berikut untuk memastikan bahwa Anda menggunakan `docdbdemo` database:
```
use docdbdemo
```
### Menyisipkan catatan
Masukkan catatan ke dalam `products` koleksi `docdbdemo` database:
```
db.products.insertOne({"name":"Pencil", "price": 1.00})
```
Verifikasi bahwa fungsi Anda berhasil memproses peristiwa ini dengan [memeriksa CloudWatch Log](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console). Anda akan melihat entri log seperti ini:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/documentdb-insert-log.png)
### Perbarui catatan
Perbarui catatan yang baru saja Anda masukkan dengan perintah berikut:
```
db.products.updateOne(
{ "name": "Pencil" },
{ $set: { "price": 0.50 }}
)
```
Verifikasi bahwa fungsi Anda berhasil memproses peristiwa ini dengan [memeriksa CloudWatch Log](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console). Anda akan melihat entri log seperti ini:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/documentdb-update-log.png)
### Hapus catatan
Hapus catatan yang baru saja Anda perbarui dengan perintah berikut:
```
db.products.deleteOne( { "name": "Pencil" } )
```
Verifikasi bahwa fungsi Anda berhasil memproses peristiwa ini dengan [memeriksa CloudWatch Log](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-console). Anda akan melihat entri log seperti ini:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/documentdb-delete-log.png)
## Pemecahan masalah
Jika Anda tidak melihat peristiwa database apa pun di CloudWatch log fungsi Anda, periksa hal berikut:
+ **Pastikan bahwa pemetaan sumber peristiwa Lambda (juga dikenal sebagai pemicu) dalam status Diaktifkan.** Pemetaan sumber acara dapat memakan waktu beberapa menit untuk dibuat.
+ Jika pemetaan sumber peristiwa **Diaktifkan** tetapi Anda masih tidak melihat peristiwa database di CloudWatch:
+ Pastikan bahwa **nama Database** dalam pemetaan sumber peristiwa diatur ke`docdbdemo`.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/documentdb-trigger.png)
+ Periksa bidang pemetaan sumber peristiwa **Hasil pemrosesan terakhir** untuk pesan berikut “MASALAH: Kesalahan koneksi. VPC Anda harus dapat terhubung ke Lambda dan STS, serta Secrets Manager jika diperlukan otentikasi. Jika Anda melihat kesalahan ini, pastikan Anda [membuat titik akhir antarmuka VPC Lambda dan Secrets Manager, dan titik akhir menggunakan VPC](#docdb-create-interface-vpc-endpoints) dan subnet yang sama dengan yang digunakan cluster Amazon DocumentDB Anda.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/documentdb-lastprocessingresult.png)
## Bersihkan sumber daya Anda
Sekarang Anda dapat menghapus sumber daya yang Anda buat untuk tutorial ini, kecuali Anda ingin mempertahankannya. Dengan menghapus sumber daya AWS yang tidak lagi Anda gunakan, Anda mencegah biaya yang tidak perlu untuk Akun AWS Anda.
**Untuk menghapus fungsi Lambda**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.
1. Pilih fungsi yang Anda buat.
1. Pilih **Tindakan**, **Hapus**.
1. Ketik **confirm** kolom input teks dan pilih **Hapus**.
**Untuk menghapus peran eksekusi**
1. Buka [halaman Peran](https://console.aws.amazon.com/iam/home#/roles) dari konsol IAM.
1. Pilih peran eksekusi yang Anda buat.
1. Pilih **Hapus**.
1. Masukkan nama peran di bidang input teks dan pilih **Hapus**.
**Untuk menghapus titik akhir VPC**
1. Buka konsol [VPC](https://console.aws.amazon.com/vpc/home#). Di menu sebelah kiri, di bawah **Virtual Private Cloud**, pilih **Endpoints**.
1. Pilih titik akhir yang Anda buat.
1. Pilih **Tindakan**, **Hapus titik akhir VPC**.
1. Masukkan **delete** di bidang input teks.
1. Pilih **Hapus**.
**Untuk menghapus cluster Amazon DocumentDB**
1. Buka konsol [Amazon DocumentDB](https://console.aws.amazon.com/docdb/home#).
1. Pilih cluster Amazon DocumentDB yang Anda buat untuk tutorial ini, dan nonaktifkan perlindungan penghapusan.
1. Di halaman utama **Clusters**, pilih kembali cluster Amazon DocumentDB Anda.
1. Pilih **Tindakan**, **Hapus**.
1. Untuk **Buat snapshot klaster akhir**, pilih **No**.
1. Masukkan **delete** di bidang input teks.
1. Pilih **Hapus**.
**Untuk menghapus rahasia di Secrets Manager**
1. Buka konsol [Secrets Manager](https://console.aws.amazon.com/secretsmanager/home#).
1. Pilih rahasia yang Anda buat untuk tutorial ini.
1. Pilih **Tindakan**, **Hapus rahasia**.
1. Pilih **Jadwalkan penghapusan**.