Tutorial: Utilizzo AWS Lambda con Amazon DocumentDB Streams

1. Apri la console Amazon DocumentDB. In Cluster, scegli Crea.

2. Crea un cluster con la seguente configurazione:

   • Per il tipo di cluster, scegli Instance-based cluster. Questa è l’opzione predefinita.

   • In Configurazione del cluster, assicurati che sia selezionata la versione 5.0.0 del motore. Questa è l’opzione predefinita.

   • In Configurazione dell'istanza:

     • Per la classe di istanza DB, seleziona Classi ottimizzate per la memoria. Questa è l’opzione predefinita.

     • Per Numero di istanze di replica regolari, scegli 1.

     • Per la classe Instance, utilizzate la selezione predefinita.

   • In Autenticazione, inserisci un nome utente per l'utente principale, quindi scegli Gestito autonomamente. Inserisci una password, quindi confermala.

   • Mantieni tutte le altre impostazioni predefinite.

3. Scegli Crea cluster.

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 di segreto: credenziali per il database Amazon DocumentDB

     • In Credenziali, inserisci lo stesso nome utente e password che hai usato per creare il 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.

Connettiti al tuo cluster Amazon DocumentDB utilizzando AWS CloudShell

1. Nella console di gestione Amazon DocumentDB, in Clusters, individua il cluster che hai creato. Scegli il tuo cluster selezionando la casella di controllo accanto ad esso.

2. Scegli Connetti al cluster. Viene visualizzata la schermata del comando CloudShell Esegui.

3. Nel campo Nome nuovo ambiente, inserisci un nome univoco, ad esempio «test» e scegli Crea ed esegui.

4. Specifica la password, quando richiesto. Quando viene visualizzato il promptrs0 [direct: primary] <env-name>>, la connessione al cluster Amazon DocumentDB è stata completata.

Creazione di un nuovo database all'interno del cluster

1. Esegui il comando seguente per creare un nuovo database chiamatodocdbdemo:

   use docdbdemo

2. Nella finestra del terminale, usa il seguente comando per inserire un record indocdbdemo:

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

   Dovresti vedere un output come questo:

   {
     acknowledged: true,
     insertedId: ObjectId('67f85066ca526410fd531d59')
   }

3. 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) }

Creazione di endpoint VPC dell'interfaccia

1. Apri la console VPC. 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 la categoria Servizi, 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 VPC in cui si trova il tuo cluster Amazon DocumentDB. Questo è in genere il VPC predefinito.

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

   • Per Tipo di indirizzo IP, seleziona IPv4.

   • Per i gruppi di sicurezza, scegli il gruppo di sicurezza utilizzato dal tuo cluster Amazon DocumentDB. Questo è in genere il gruppo default di sicurezza.

   • 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 VPC in cui si trova il tuo cluster Amazon DocumentDB. Questo è in genere il VPC predefinito.

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

   • Per Tipo di indirizzo IP, seleziona IPv4.

   • Per i gruppi di sicurezza, scegli il gruppo di sicurezza utilizzato dal tuo cluster Amazon DocumentDB. Questo è in genere il gruppo default di sicurezza.

   • Mantieni tutte le altre impostazioni predefinite.

   • Seleziona Crea endpoint.

Creazione di una policy IAM

1. Nella console IAM, apri la pagina Policy, quindi scegli Crea policy.

2. Scegli la scheda JSON. Nella policy seguente, sostituisci l'ARN della risorsa Gestione dei segreti nell'ultima riga dell'istruzione con l'ARN del segreto utilizzato in precedenza e copia la policy nell'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"
           }
       ]
   }
   

3. Scegli Successivo: Tag, quindi Successivo: Verifica.

4. In Nome, inserisci AWSDocumentDBLambdaPolicy.

5. Scegli Create Policy (Crea policy).

Per creare il ruolo IAM

1. Nella console IAM, apri la pagina Ruoli, quindi scegli Crea ruolo.

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

   • Tipo di entità attendibile: servizio AWS

   • Servizio o caso d'uso: Lambda

   • Scegli Next (Successivo).

3. Per Aggiungi autorizzazioni, scegli la AWSDocumentDBLambdaPolicy policy che hai appena creato e quella AWSLambdaBasicExecutionRole per assegnare alla tua funzione i permessi di scrittura su Amazon Logs. CloudWatch

4. Scegli Next (Successivo).

5. Per Nome ruolo, inserisci AWSDocumentDBLambdaExecutionRole.

6. Scegli Crea ruolo.

Creazione della funzione Lambda

1. Aprire la pagina Funzioni della console Lambda.

2. Scegli Crea funzione.

3. Scegli Crea da zero.

4. In Basic information (Informazioni di base) eseguire queste operazioni:

   1. Nel campo Nome funzione, inserisci ProcessDocumentDBRecords.

   2. Per Runtime, scegli Python 3.14.

   3. In Architecture (Architettura), scegli x86_64.

5. Nella scheda Modifica ruolo di esecuzione predefinito, effettua le seguenti operazioni:

   1. Espandi la scheda, quindi scegli Utilizza un ruolo esistente.

   2. Seleziona il AWSDocumentDBLambdaExecutionRole che hai creato in precedenza.

6. Scegli Crea funzione.

Implementazione del codice della funzione

1. Scegli la scheda Python nella casella seguente e copia il codice.

   .NET

   SDK per .NET

   Nota

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

   Utilizzo di un evento Amazon DocumentDB con Lambda tramite .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 per Go V2

   Nota

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

   Utilizzo di un evento Amazon DocumentDB con Lambda tramite 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 per Java 2.x

   Nota

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

   Utilizzo di un evento Amazon DocumentDB con Lambda tramite 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 per JavaScript (v3)

   Nota

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

   Consumare un evento Amazon DocumentDB utilizzando 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));
   };
   
   
   

   Consumare 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 su. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di Esempi serverless.

   Utilizzo di un evento Amazon DocumentDB con Lambda tramite 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 per Python (Boto3)

   Nota

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

   Utilizzo di un evento Amazon DocumentDB con Lambda tramite 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 per Ruby

   Nota

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

   Utilizzo di un evento Amazon DocumentDB con Lambda tramite 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 per Rust

   Nota

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

   Utilizzo di un evento Amazon DocumentDB con Lambda tramite Ruby.

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

2. Nel riquadro Codice sorgente della console Lambda, incolla il codice nell'editor di codice, sostituendo il codice creato da Lambda.

3. Nella sezione DEPLOY, scegli Implementa per aggiornare il codice della tua funzione:

   

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 Trigger nel menu a sinistra.

4. Selezionare Add trigger (Aggiungi trigger).

5. In Configurazione del trigger, per l'origine seleziona Amazon DocumentDB.

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

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

   • Nome del database: docdbdemo

   • Nome della collezione: prodotti

   • Dimensione del lotto: 1

   • Posizione di partenza: Ultima

   • Autenticazione: BASIC_AUTH

   • Chiave Secrets Manager: scegli il segreto per il tuo cluster Amazon DocumentDB. Si chiama qualcosa del genererds!cluster-12345678-a6f0-52c0-b290-db4aga89274f.

   • Finestra batch: 1

   • Configurazione completa del documento: UpdateLookup

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

1. Riconnettiti al cluster Amazon DocumentDB nel tuo ambiente. CloudShell

2. Esegui il comando seguente per assicurarti di utilizzare il docdbdemo database:

   use docdbdemo

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 confirm nel campo di immissione del testo, quindi scegli Elimina.

Come eliminare il ruolo di esecuzione

1. Aprire la pagina Ruoli della console IAM.

2. Selezionare il ruolo di esecuzione creato.

3. Scegliere Elimina.

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

Eliminazione degli endpoint VPC

1. Apri la console VPC. Nel menu a sinistra, in Cloud privato virtuale, scegli Endpoint.

2. Seleziona gli endpoint creati.

3. Seleziona Actions (Operazioni), Delete VPC endpoints (Eliminazione di endpoint VPC).

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 dall'eliminazione.

3. Nella pagina principale Cluster, 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).