Tutorial: utilizzo di AWS Lambda con flussi 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. Questa è l'opzione predefinita.

   • In Configurazione del cluster, assicurati che sia selezionata la versione 5.0.0 di Engine. 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, usa la selezione predefinita.

   • In Autenticazione, inserisci un nome utente per l'utente principale, quindi scegli Autogestito. Immettere una password, quindi confermarla.

   • Mantieni tutte le altre impostazioni predefinite.

3. Scegliere 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 il nome utente e la password che utilizzerai per accedere al cluster Amazon DocumentDB.

     • Database: scegli il tuo cluster Amazon DocumentDB.

     • Scegli Next (Successivo).

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

   • Nome del 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.

Per connettersi al cluster Amazon DocumentDB

1. Nella console di gestione di Amazon DocumentDB, in Clusters, individua il cluster che hai creato. Scegli il cluster facendo clic sulla casella di controllo accanto ad esso.

2. Scegli Connect to cluster. Viene visualizzata la schermata dei comandi CloudShell Run.

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

4. Specifica la password, quando richiesto. Quando viene richiestors0 [direct: primary] <env-name>>, la connessione al cluster Amazon DocumentDB è avvenuta correttamente.

Creazione di un nuovo database all'interno del cluster

1. Esegui il comando seguente per creare un argomento chiamato docdbdemo.

   use docdbdemo

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

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

   L'output visualizzato dovrebbe essere di questo tipo:

   {
     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 Categoria servizio, scegli Servizi AWS.

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

   • Per VPC, scegliere quello in cui si trova il cluster Amazon DocumentDB. Si tratta in genere del 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 Categoria servizio, scegli Servizi AWS.

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

   • Per VPC, scegliere quello in cui si trova il cluster Amazon DocumentDB. Si tratta in genere del 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à affidabile: servizio di AWS

   • Servizio o caso d'uso: Lambda

   • Scegli Next (Successivo).

3. In Aggiungi autorizzazioni, scegli la policy AWSDocumentDBLambdaPolicy che hai appena creato e il AWSLambdaBasicExecutionRole per concedere alla tua funzione le autorizzazioni per scrivere in Amazon CloudWatch Logs.

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. In Runtime, scegli Python 3.13.

   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

   Ulteriori informazioni 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

   Ulteriori informazioni 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 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

   Ulteriori informazioni 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 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

   Ulteriori informazioni 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 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));
   };
   
   
   

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

   Ulteriori informazioni 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

   Ulteriori informazioni 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 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

   Ulteriori informazioni 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.

   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

   Ulteriori informazioni 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 raccolta: prodotti

   • Dimensione batch: 1

   • Posizione di partenza: ultima

   • Autenticazione: BASIC_AUTH

   • Chiave Secrets Manager: scegli il segreto per il tuo cluster Amazon DocumentDB. Avrà un nome tipo rds!cluster-12345678-a6f0-52c0-b290-db4aga89274f.

   • Finestra batch: 1

   • Configurazione completa del documento: UpdateLookup

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

1. Riconnettiti al cluster Amazon DocumentDB nel tuo ambiente .

2. Esegui il comando seguente per verificare che si sta utilizzando 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).