Tutorial: Utilizzo AWS Lambda con Amazon DocumentDB Streams - AWS Lambda

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Tutorial: Utilizzo AWS Lambda con Amazon DocumentDB Streams

In questo tutorial creerai una funzione Lambda di base che utilizza gli eventi provenienti da un flusso di modifica Amazon DocumentDB (compatibile con MongoDB). Per completare questo tutorial, saranno completate le seguenti fasi:

  • Configura il tuo cluster Amazon DocumentDB, connettiti a esso e attiva i flussi di modifica su di esso.

  • Crea la funzione Lambda e configura il cluster Amazon DocumentDB come origine degli eventi Amazon DocumentDB come origine degli eventi per la funzione.

  • Verifica la end-to-end configurazione inserendo elementi nel tuo database Amazon DocumentDB.

Prerequisiti

Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.

Per iscriverti a un Account AWS
  1. Apri la https://portal.aws.amazon.com/billing/registrazione.

  2. Segui le istruzioni online.

    Nel corso della procedura di registrazione riceverai una telefonata, durante la quale sarà necessario inserire un codice di verifica attraverso la tastiera del telefono.

    Quando ti iscrivi a un Account AWS, Utente root dell'account AWSviene creato un. L'utente root dispone dell'accesso a tutte le risorse e tutti i Servizi AWS nell'account. Come best practice di sicurezza, assegna l'accesso amministrativo a un utente e utilizza solo l'utente root per eseguire attività che richiedono l'accesso di un utente root.

AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a https://aws.amazon.com/e scegliendo Il mio account.

Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.

Proteggi i tuoi Utente root dell'account AWS
  1. Accedi AWS Management Consolecome proprietario dell'account scegliendo Utente root e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.

    Per informazioni sull'accesso utilizzando un utente root, consulta la pagina Signing in as the root user della Guida per l'utente di Accedi ad AWS .

  2. Attiva l'autenticazione a più fattori (MFA) per il tuo utente root.

    Per istruzioni, consulta Abilitare un MFA dispositivo virtuale per l'utente Account AWS root (console) nella Guida per l'IAMutente.

Crea un utente con accesso amministrativo
  1. Abilita IAM Identity Center.

    Per istruzioni, consulta Abilitazione di AWS IAM Identity Center nella Guida per l'utente di AWS IAM Identity Center .

  2. In IAM Identity Center, concedi l'accesso amministrativo a un utente.

    Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta Configurare l'accesso utente con i valori predefiniti IAM Identity Center directory nella Guida per l'AWS IAM Identity Center utente.

Accesso come utente amministratore
  • Per accedere con l'utente dell'IAMIdentity Center, utilizza l'accesso URL che è stato inviato al tuo indirizzo e-mail quando hai creato l'utente IAM Identity Center.

    Per informazioni sull'accesso tramite un utente di IAM Identity Center, consulta Accesso al portale di AWS accesso nella Guida per l'Accedi ad AWS utente.

Assegna l'accesso a ulteriori utenti
  1. In IAM Identity Center, crea un set di autorizzazioni che segua la migliore pratica di applicazione delle autorizzazioni con privilegi minimi.

    Segui le istruzioni riportate nella pagina Creazione di un set di autorizzazioni nella Guida per l'utente di AWS IAM Identity Center .

  2. Assegna al gruppo prima gli utenti e poi l'accesso con autenticazione unica (Single Sign-On).

    Per istruzioni, consulta Aggiungere gruppi nella Guida per l'utente di AWS IAM Identity Center .

Se non l'hai ancora installato AWS Command Line Interface, segui i passaggi indicati in Installazione o aggiornamento della versione più recente di AWS CLI per installarlo.

Per eseguire i comandi nel tutorial, sono necessari un terminale a riga di comando o una shell (interprete di comandi). In Linux e macOS, utilizza la shell (interprete di comandi) e il gestore pacchetti preferiti.

Nota

In Windows, alcuni CLI comandi Bash che usi comunemente con Lambda (zipcome) non sono supportati dai terminali integrati del sistema operativo. Per ottenere una versione integrata su Windows di Ubuntu e Bash, installa il sottosistema Windows per Linux.

Crea l'ambiente AWS Cloud9

Fase 1: creare un AWS Cloud9 ambiente

Prima di creare la funzione Lambda, devi creare e configurare il cluster Amazon DocumentDB. I passaggi per configurare il cluster di questo tutorial si basano sulla procedura descritta nella Guida introduttiva ad Amazon DocumentDB.

Nota

Se disponi già di un cluster Amazon DocumentDB configurato, assicurati di attivare i flussi di modifica e di creare gli endpoint di interfaccia necessari. VPC Dopodiché, puoi passare direttamente ai passaggi di creazione della funzione.

Innanzitutto, crea un ambiente. AWS Cloud9 Utilizzerai questo ambiente durante questo tutorial per connetterti e interrogare il tuo cluster Amazon DocumentDB.

Per creare un ambiente AWS Cloud9
  1. Apri la AWS Cloud9 console e scegli Crea ambiente.

  2. Crea un ambiente con la seguente configurazione:

    • In Dettagli:

      • Nome: DocumentDBCloud9Environment

      • Tipo di ambiente: nuova EC2 istanza

    • In Nuova EC2 istanza:

      • Tipo di istanza: t2.micro (1 RAM GiB+ 1 v) CPU

      • Piattaforma: Amazon Linux 2

      • Timeout: 30 minuti

    • In Impostazioni di rete:

      • Connessione: AWS Systems Manager () SSM

      • Espandi il menu a discesa VPCdelle impostazioni.

      • Amazon Virtual Private Cloud (VPC) :Scegli il tuo valore predefinito. VPC

      • Subnet: nessuna preferenza

    • Mantieni tutte le altre impostazioni predefinite.

  3. Scegli Create (Crea) . Il provisioning del nuovo AWS Cloud9 ambiente può richiedere diversi minuti.

Crea il gruppo EC2 di sicurezza Amazon

Fase 2: creare un gruppo EC2 di sicurezza Amazon

Successivamente, crea un gruppo EC2 di sicurezza Amazon con regole che consentano il traffico tra il cluster Amazon DocumentDB e il tuo AWS Cloud9 ambiente.

Per creare un gruppo EC2 di sicurezza
  1. Apri la EC2console. In Rete e sicurezza, scegli Gruppi di sicurezza.

  2. Scegliere Create Security Group (Crea gruppo di sicurezza).

  3. Crea un gruppo di sicurezza con la seguente configurazione:

    • In Dettagli di base:

      • Security group name: (Nome del gruppo di sicurezza: DocDBTutorial

      • Descrizione: gruppo di sicurezza per il traffico tra AWS Cloud9 e Amazon DocumentDB.

      • VPC: Scegli il tuo valore predefinito VPC.

    • Per Inbound rules (Regole in entrata), scegliere Add rule (Aggiungi regola). Creare una regola con la seguente configurazione:

      • Tipo: Personalizzato TCP

      • Intervallo di porte: 27017

      • Source (Origine): personalizzata

      • Nella casella di ricerca accanto a Source, scegli il gruppo di sicurezza per l' AWS Cloud9 ambiente creato nel passaggio precedente. Per visualizzare un elenco dei gruppi di sicurezza disponibili, inserisci cloud9 nella casella di ricerca. Scegli il gruppo di sicurezza denominato aws-cloud9-<environment_name>.

    • Mantieni tutte le altre impostazioni predefinite.

  4. Scegliere Create Security Group (Crea gruppo di sicurezza).

Crea il cluster Amazon DocumentDB

Fase 3: creare un cluster Amazon DocumentDB

In questo passaggio, creerai un cluster Amazon DocumentDB utilizzando il gruppo di sicurezza del passaggio precedente.

Per creare un cluster Amazon DocumentDB
  1. Apri la console Amazon DocumentDB. In Cluster, scegli Crea.

  2. Crea un cluster con la seguente configurazione:

    • Per Tipo di cluster, scegli Cluster basato su istanze.

    • In Configurazione:

      • Versione del motore: 5.0.0

      • Classe di istanza: db.t3.medium (idonea alla prova gratuita)

      • Numero di istanze: 1

    • In Autenticazione:

      • Inserisci il nome utente e la password necessari per connetterti al cluster (le stesse credenziali utilizzate per creare il segreto nel passaggio precedente). In Conferma password, conferma la password.

    • Attiva Mostra impostazioni avanzate.

    • In Impostazioni di rete:

      • Virtual Private Cloud (VPC): scegli il tuo valore predefinito VPC.

      • Gruppo di sottoreti: predefinito

      • VPCgruppi di sicurezza: inoltredefault (VPC), scegli il gruppo DocDBTutorial (VPC) di sicurezza creato nel passaggio precedente.

    • Mantieni tutte le altre impostazioni predefinite.

  3. Scegli Create cluster (Crea cluster). Il provisioning del cluster Amazon DocumentDB può richiedere diversi minuti.

Creazione del segreto di Gestione dei segreti

Passaggio 4: creare un segreto in Secrets Manager

Per accedere manualmente al cluster Amazon DocumentDB, devi fornire credenziali di nome utente e password. Affinché Lambda possa accedere al cluster, è necessario fornire un segreto di Gestione dei segreti che contenga le stesse credenziali di accesso utilizzate durante la configurazione della mappatura dell'origine degli eventi. In questo passaggio, creerai questo segreto.

Creazione del segreto in Gestione dei segreti
  1. Apri la console Gestione dei segreti e scegli Archivia un nuovo segreto.

  2. In Scegli il tipo di segreto, scegli una delle seguenti opzioni:

    • In Dettagli di base:

      • Tipo segreto: credenziali per il tuo database Amazon DocumentDB

      • In Credenziali, inserisci il nome utente e la password che utilizzerai per accedere al tuo cluster Amazon DocumentDB.

      • Database: scegli il tuo cluster Amazon DocumentDB.

      • Scegli Next (Successivo).

  3. Per Configura segreto, scegli tra le seguenti opzioni:

    • Nome segreto: DocumentDBSecret

    • Scegli Next (Successivo).

  4. Scegli Next (Successivo).

  5. Scegli Store.

  6. Aggiorna la console per verificare di aver archiviato correttamente il segreto DocumentDBSecret.

Annota il segreto ARN del tuo segreto. Lo utilizzerai in un passaggio successivo.

Installazione della shell Mongo

Passaggio 5: installazione della shell (interprete di comandi) mongo

In questo passaggio, installerai la shell mongo nel tuo AWS Cloud9 ambiente. La mongo shell è un'utilità da riga di comando che puoi utilizzare per connetterti e interrogare il tuo cluster Amazon DocumentDB.

Per installare la shell mongo nel tuo ambiente AWS Cloud9
  1. Apri la AWS Cloud9 console. Accanto all'DocumentDBCloud9Environmentambiente che hai creato in precedenza, fai clic sul link Apri sotto la AWS Cloud9 IDEcolonna.

  2. In una finestra del terminale, crea il file di repository MongoDB con il comando seguente:

    echo -e "[mongodb-org-5.0] \nname=MongoDB Repository\nbaseurl=https://repo.mongodb.org/yum/amazon/2/mongodb-org/5.0/x86_64/\ngpgcheck=1 \nenabled=1 \ngpgkey=https://www.mongodb.org/static/pgp/server-5.0.asc" | sudo tee /etc/yum.repos.d/mongodb-org-5.0.repo
  3. Quindi, installa la shell mongo con il comando seguente:

    sudo yum install -y mongodb-org-shell
  4. Per crittografare i dati in transito, scarica la chiave pubblica per Amazon DocumentDB. Il comando seguente scarica un file denominato global-bundle.pem:

    wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem

Connect al cluster Amazon DocumentDB

Fase 6: connessione al cluster Amazon DocumentDB

Ora sei pronto per connetterti al tuo cluster Amazon DocumentDB utilizzando la shell mongo.

Per connetterti al tuo cluster Amazon DocumentDB
  1. Apri la console Amazon DocumentDB. In Cluster, scegli il cluster selezionando il relativo identificatore.

  2. Nella scheda Connettività e sicurezza, in Connetti a questo cluster con la shell mongo, scegli Copia.

  3. Nel tuo AWS Cloud9 ambiente, incolla questo comando nel terminale. Sostituisci <insertYourPassword> con la password corretta.

Dopo aver inserito questo comando, se il prompt dei comandi diventa rs0:PRIMARY>, allora la connessione al cluster Amazon DocumentDB è stata stabilita.

Attivazione dei flussi di modifica

Passaggio 7: attivazione dei flussi di modifica

In questo tutorial, monitorerai le modifiche alla products raccolta del docdbdemo database nel tuo cluster Amazon DocumentDB. Puoi farlo attivando i flussi di modifica. Innanzitutto, crea il database docdbdemo e testalo inserendo un record.

Creazione di un nuovo database all'interno del cluster
  1. Nel tuo AWS Cloud9 ambiente, assicurati di essere ancora connesso al cluster Amazon DocumentDB.

  2. In una finestra del terminale, utilizza il comando seguente per creare un nuovo database denominato docdbdemo:

    use docdbdemo
  3. Quindi, utilizza il comando seguente per inserire un record in docdbdemo:

    db.products.insert({"hello":"world"})

    L'output visualizzato dovrebbe essere di questo tipo:

    WriteResult({ "nInserted" : 1 })
  4. Utilizza il seguente comando per elencare tutti i database:

    show dbs

    Assicurati che l'output contenga il database docdbdemo:

    docdbdemo 0.000GB

Quindi, attiva i flussi di modifica sulla raccolta products del database docdbdemo utilizzando il comando seguente:

db.adminCommand({modifyChangeStreams: 1, database: "docdbdemo", collection: "products", enable: true});

L'output visualizzato dovrebbe essere di questo tipo:

{ "ok" : 1, "operationTime" : Timestamp(1680126165, 1) }

Crea endpoint di interfaccia VPC

Fase 8: creazione degli endpoint di interfaccia VPC

Successivamente, crea VPCendpoint di interfaccia per assicurarti che Lambda e Secrets Manager (utilizzati in seguito per archiviare le nostre credenziali di accesso al cluster) possano connettersi ai tuoi valori predefiniti. VPC

Per creare endpoint di interfaccia VPC
  1. Apri la VPCconsole. Nel menu a sinistra, in Cloud privato virtuale, scegli Endpoint.

  2. Seleziona Crea endpoint. Crea un endpoint con la seguente configurazione:

    • Per Nome tag, inserisci lambda-default-vpc.

    • Per Categoria di servizio, scegli AWS servizi.

    • Per Servizi, digita lambda nella casella di ricerca. Scegli il servizio con il formato com.amazonaws.<region>.lambda.

    • Per VPC, scegli il tuo valore predefinito VPC.

    • Per Sottoreti, seleziona le caselle accanto a ciascuna zona di disponibilità. Scegli l'ID della sottorete corretta per ogni zona di disponibilità.

    • Per il tipo di indirizzo IP, selezionaIPv4.

    • Per i gruppi di sicurezza, scegli il gruppo di VPC sicurezza predefinito (nome del gruppo didefault) e il gruppo di sicurezza creato in precedenza (nome del gruppo diDocDBTutorial).

    • Mantieni tutte le altre impostazioni predefinite.

    • Seleziona Crea endpoint.

  3. Seleziona di nuovo Crea endpoint. Crea un endpoint con la seguente configurazione:

    • Per Nome tag, inserisci secretsmanager-default-vpc.

    • Per la categoria Servizi, scegli AWS servizi.

    • Per Servizi, digita secretsmanager nella casella di ricerca. Scegli il servizio con il formato com.amazonaws.<region>.secretsmanager.

    • Per VPC, scegli il tuo valore predefinito VPC.

    • Per Sottoreti, seleziona le caselle accanto a ciascuna zona di disponibilità. Scegli l'ID della sottorete corretta per ogni zona di disponibilità.

    • Per il tipo di indirizzo IP, selezionaIPv4.

    • Per i gruppi di sicurezza, scegli il gruppo di VPC sicurezza predefinito (nome del gruppo didefault) e il gruppo di sicurezza creato in precedenza (nome del gruppo diDocDBTutorial).

    • Mantieni tutte le altre impostazioni predefinite.

    • Seleziona Crea endpoint.

Questo completa la sezione del tutorial dedicata alla configurazione del cluster.

Creazione del ruolo di esecuzione

Passaggio 9: creazione del ruolo di esecuzione

Nella serie di passaggi successiva, creerai la funzione Lambda. Innanzitutto, devi creare il ruolo di esecuzione che fornisce alla funzione l'autorizzazione per accedere al cluster. A tale scopo, è necessario creare prima una IAM politica, quindi associarla a un IAM ruolo.

Per creare una politica IAM
  1. Apri la pagina Politiche nella IAM console e scegli Crea policy.

  2. Scegli la JSONscheda. Nella seguente politica, sostituisci la risorsa Secrets Manager ARN nella riga finale dell'istruzione con il tuo segreto ARN di prima e copia la politica nell'editor.

    { "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" } ] }
  3. Scegli Successivo: Tag, quindi Successivo: Verifica.

  4. In Nome, inserisci AWSDocumentDBLambdaPolicy.

  5. Scegli Create Policy (Crea policy).

Per creare il ruolo IAM
  1. Apri la pagina Ruoli nella IAM console e scegli Crea ruolo.

  2. Per Seleziona un'entità attendibile, scegli le seguenti opzioni:

    • Tipo di entità affidabile: AWS servizio

    • Caso d'uso: Lambda

    • Scegli Next (Successivo).

  3. Per Aggiungi autorizzazioni, scegli la AWSDocumentDBLambdaPolicy policy che hai appena creato e AWSLambdaBasicExecutionRole autorizza la funzione a scrivere su Amazon CloudWatch Logs.

  4. Scegli Next (Successivo).

  5. Per Nome ruolo, inserisci AWSDocumentDBLambdaExecutionRole.

  6. Scegliere Crea ruolo.

Creazione della funzione Lambda

Passaggio 10: creazione della funzione Lambda

Il codice di esempio seguente riceve l'input di un evento Amazon DocumentDB ed elabora il messaggio in esso contenuto.

Go
SDKper Go V2
Nota

C'è altro da fare. GitHub Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di Esempi serverless.

Consumo di un evento Amazon DocumentDB con Lambda utilizzando 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)) }
JavaScript
SDKper JavaScript (v3)
Nota

C'è di più su. GitHub Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di Esempi serverless.

Consumo di un evento Amazon DocumentDB con Lambda utilizzando. 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)); };

Consumo di un evento Amazon DocumentDB con Lambda utilizzando 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 per PHP
Nota

C'è altro da fare. GitHub Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di Esempi serverless.

Consumo di un evento Amazon DocumentDB con Lambda utilizzando. 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
SDKper Python (Boto3)
Nota

C'è di più su. GitHub Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di Esempi serverless.

Consumo di un evento Amazon DocumentDB con Lambda utilizzando 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
SDKper Ruby
Nota

c'è altro da fare. GitHub Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di Esempi serverless.

Consumo di un evento Amazon DocumentDB con Lambda utilizzando 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
SDKper Rust
Nota

c'è altro da fare GitHub. Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di Esempi serverless.

Consumo di un evento Amazon DocumentDB con Lambda utilizzando 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(()) }
Creazione della funzione Lambda
  1. Copiare il codice di esempio in un file denominato index.js.

  2. Crea un pacchetto di implementazione utilizzando il seguente comando.

    zip function.zip index.js
  3. Usa il seguente CLI comando per creare la funzione. Sostituisci us-east-1 Regione AWS con e 123456789012 con l'ID del tuo account.

    aws lambda create-function \ --function-name ProcessDocumentDBRecords \ --zip-file fileb://function.zip --handler index.handler --runtime nodejs20.x \ --region us-east-1 \ --role arn:aws:iam::123456789012:role/AWSDocumentDBLambdaExecutionRole

Creazione della mappatura dell'origine degli eventi Lambda

Passaggio 11: creazione della mappatura dell'origine degli eventi Lambda

Crea la mappatura delle sorgenti degli eventi che associ il flusso di modifiche di Amazon DocumentDB alla tua funzione Lambda. Dopo aver creato questa mappatura delle sorgenti degli eventi, inizia AWS Lambda immediatamente il polling dello stream.

Creazione di una mappatura dell'origine degli eventi
  1. Apri la pagina Funzioni della console Lambda.

  2. Scegli la funzione ProcessDocumentDBRecords creata in precedenza.

  3. Scegli la scheda Configurazione, quindi scegli Triggers nel menu a sinistra.

  4. Selezionare Add trigger (Aggiungi trigger).

  5. In Configurazione Trigger, come sorgente, seleziona Amazon DocumentDB.

  6. Crea la mappatura dell'origine degli eventi con la seguente configurazione:

    • Cluster Amazon DocumentDB: scegli il cluster creato in precedenza.

    • Nome del database: docdbdemo

    • Nome della collezione: prodotti

    • Dimensione del batch: 1

    • Posizione di partenza: più recente

    • Autenticazione — BASIC _ AUTH

    • Chiave Secrets Manager: scegli quella DocumentDBSecret che hai appena creato.

    • Finestra Batch — 1

    • Configurazione completa del documento — UpdateLookup

  7. Scegli Aggiungi. La creazione della mappatura dell'origine degli eventi può richiedere alcuni minuti.

Test della funzione: richiamo manuale

Passaggio 12: test della funzione con un richiamo manuale

Per verificare di aver creato correttamente la funzione e la mappatura dell'origine degli eventi, richiama la funzione utilizzando il comando invoke. Per fare ciò, prima copia il seguente evento JSON in un file chiamatoinput.txt:

{ "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": "docdbdemo", "coll": "products" }, "operationType": "insert" } } ], "eventSource": "aws:docdb" }

Dopodiché, utilizza il comando seguente per richiamare la funzione con questo evento:

aws lambda invoke \ --function-name ProcessDocumentDBRecords \ --cli-binary-format raw-in-base64-out \ --region us-east-1 \ --payload file://input.txt out.txt

La risposta visualizzata sarà simile alla seguente:

{ "StatusCode": 200, "ExecutedVersion": "$LATEST" }

È possibile verificare che la funzione abbia elaborato correttamente l'evento controllando CloudWatch Logs.

Per verificare la chiamata manuale tramite Logs CloudWatch
  1. Apri la pagina Funzioni della console Lambda.

  2. Scegli la scheda Monitor, quindi scegli Visualizza registri. CloudWatch Questo ti porta al gruppo di log specifico associato alla tua funzione nella CloudWatch console.

  3. Scegli il flusso di log più recente. All'interno dei messaggi di registro, dovresti vedere l'eventoJSON.

Test della funzione: inserimento di un record

Passaggio 13: test della funzione inserendo un record.

Testa la tua end-to-end configurazione interagendo direttamente con il tuo database Amazon DocumentDB. Nella serie di passaggi successiva, inserirai un record, lo aggiornerai e quindi lo eliminerai.

Inserimento di un record
  1. Riconnettiti al cluster Amazon DocumentDB nel AWS Cloud9 tuo ambiente.

  2. Utilizza questo comando per verificare che stai attualmente utilizzando il database docdbdemo:

    use docdbdemo
  3. Inserisci un record nella raccolta products del database docdbdemo:

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

Test della funzione: aggiornamento di un record

Passaggio 14: test della funzione aggiornando un record.

Successivamente, aggiorna il record appena inserito con il comando seguente:

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

Verifica che la tua funzione abbia elaborato correttamente questo evento CloudWatch controllando i log.

Test della funzione: eliminazione di un record

Passaggio 15: test della funzione eliminando un record.

Infine, elimina il record appena aggiornato con il seguente comando:

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

Verifica che la tua funzione abbia elaborato correttamente questo evento controllando CloudWatch Logs.

Pulizia delle risorse

Ora è possibile eliminare le risorse create per questo tutorial, a meno che non si voglia conservarle. Eliminando le risorse AWS che non si utilizzano più, è possibile evitare addebiti superflui sul proprio account Account AWS.

Per eliminare la funzione Lambda
  1. Aprire la pagina Functions (Funzioni) della console Lambda.

  2. Selezionare la funzione creata.

  3. Scegliere Operazioni, Elimina.

  4. Inserisci delete nel campo di immissione del testo, quindi scegli Elimina.

Come eliminare il ruolo di esecuzione
  1. Apri la pagina Ruoli della IAM console.

  2. Selezionare il ruolo di esecuzione creato.

  3. Scegliere Elimina.

  4. Inserisci il nome del ruolo nel campo di immissione testo e seleziona Elimina.

Per eliminare gli VPC endpoint
  1. Apri la VPCconsole. Nel menu a sinistra, in Cloud privato virtuale, scegli Endpoint.

  2. Seleziona gli endpoint creati.

  3. Scegli Azioni, Elimina VPC endpoint.

  4. Inserisci delete nel campo di immissione del testo.

  5. Scegli Elimina.

Eliminazione del cluster Amazon DocumentDB
  1. Apri la console Amazon DocumentDB.

  2. Scegli il cluster Amazon DocumentDB che hai creato per questo tutorial e disabilita la protezione da eliminazione.

  3. Nella pagina principale Clusters, scegli nuovamente il tuo cluster Amazon DocumentDB.

  4. Scegli Operazioni > Elimina.

  5. Per Crea snapshot finale del cluster, seleziona No.

  6. Inserisci delete nel campo di immissione del testo.

  7. Scegli Elimina.

Eliminazione del segreto in Gestione dei segreti
  1. Apri la console Secrets Manager.

  2. Scegli il segreto creato per questo tutorial.

  3. Scegli Operazioni, Elimina segreto.

  4. Scegliere Schedule deletion (Pianifica eliminazione).

Per eliminare il gruppo EC2 di sicurezza Amazon
  1. Apri la EC2console. In Rete e sicurezza, scegli Gruppi di sicurezza.

  2. Seleziona il gruppo di sicurezza creato per questo tutorial.

  3. Scegli Operazioni, Elimina gruppi di sicurezza.

  4. Scegli Elimina.

Per eliminare l' AWS Cloud9 ambiente
  1. Apri la AWS Cloud9 console.

  2. Seleziona l'ambiente creato per questo tutorial.

  3. Scegli Elimina.

  4. Inserisci delete nel campo di immissione del testo.

  5. Scegli Delete (Elimina).