Tutorial: Uso de AWS Lambda con Amazon DocumentDB Streams

1. Abra la consola de Amazon DocumentDB. En Clústeres, elija Crear.

2. Cree un clúster con la siguiente configuración:

   • En Tipo de clúster, elija Clúster basado en instancias. Esta es la opción predeterminada.

   • En Configuración del clúster, asegúrese de haber seleccionado la Versión del motor 5.0.0. Esta es la opción predeterminada.

   • En Configuración de la instancia:

     • En Clase de la instancia de base de datos, seleccione Clases optimizadas para memoria. Esta es la opción predeterminada.

     • En Número de instancias de réplicas regulares, elija 1.

     • En Clase de instancia, use la selección predeterminada.

   • En Autenticación, ingrese un nombre de usuario para el usuario principal y, a continuación, elija Autoadministrado. Ingrese una contraseña y, a continuación, confírmela.

   • Conserve todas las otras opciones de configuración predeterminadas.

3. Elija Create cluster.

Para crear un secreto en Secrets Manager

1. Abra la consola de Secrets Manager y elija Almacenar un nuevo secreto.

2. En Elegir tipo de secreto, elija las siguientes opciones:

   • En Detalles básicos:

     • Tipo de secreto: credenciales para la base de datos de Amazon DocumentDB

     • En Credenciales, ingrese el mismo nombre de usuario y la contraseña que usó para crear el clúster de Amazon DocumentDB.

     • Base de datos: elija su clúster de Amazon DocumentDB.

     • Elija Siguiente.

3. En Configurar secreto, elija las siguientes opciones:

   • Nombre del secreto: DocumentDBSecret

   • Elija Siguiente.

4. Elija Siguiente.

5. Elija Almacenar.

6. Actualice la consola para comprobar que ha guardado correctamente el secreto DocumentDBSecret.

Conexión al clúster de Amazon DocumentDB con AWS CloudShell

1. En la consola de administración de Amazon DocumentDB, en Clústeres, localice el clúster que ha creado. Para elegir el clúster, haga clic en la casilla de verificación situada junto a él.

2. Elija Conectarse al clúster. Aparece la pantalla Ejecutar comando de CloudShell.

3. En el campo Nombre del nuevo entorno, ingrese un nombre único, como “prueba” y elija Crear y ejecutar.

4. Escriba la contraseña cuando se le solicite. Cuando la petición se convierte en rs0 [direct: primary] <env-name>>, significa que se ha conectado correctamente al clúster de Amazon DocumentDB.

Para crear una nueva base de datos dentro del clúster

1. Ejecute el siguiente comando para crear una nueva base de datos denominada docdbdemo:

   use docdbdemo

2. En la ventana del terminal, use el siguiente comando para insertar un registro en docdbdemo:

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

   Debería ver una salida similar a esta:

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

3. A continuación, active los flujos de cambios en la colección products de la base de datos docdbdemo con el siguiente comando:

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

   Debería ver un resultado con un aspecto similar al siguiente:

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

Cómo crear puntos de conexión de VPC de interfaz

1. Abra la consola de VPC. En el menú de la izquierda, en Nube privada virtual, seleccione Puntos de conexión.

2. Elija Crear punto de conexión. Cree un punto de conexión con la siguiente configuración:

   • En Etiqueta de nombre, ingrese lambda-default-vpc.

   • En Categoría de servicios, elija Servicios de AWS.

   • En Servicios, ingrese lambda en el cuadro de búsqueda. Elija el servicio con formato com.amazonaws.<region>.lambda.

   • En VPC, elija la VPC en la que se encuentra su clúster de Amazon DocumentDB. Suele ser la VPC predeterminada.

   • En Subredes, marque las casillas situadas junto a cada zona de disponibilidad. Elija el ID de subred correcto para cada zona de disponibilidad.

   • En Tipo de dirección IP, seleccione IPv4.

   • En Grupos de seguridad, elija el grupo de seguridad que utiliza su clúster de Amazon DocumentDB. Suele ser el grupo de seguridad default.

   • Conserve todas las otras opciones de configuración predeterminadas.

   • Elija Crear punto de conexión.

3. Elija nuevamente Crear punto de conexión. Cree un punto de conexión con la siguiente configuración:

   • En Etiqueta de nombre, ingrese secretsmanager-default-vpc.

   • En Categoría de servicios, elija Servicios de AWS.

   • En Servicios, ingrese secretsmanager en el cuadro de búsqueda. Elija el servicio con formato com.amazonaws.<region>.secretsmanager.

   • En VPC, elija la VPC en la que se encuentra su clúster de Amazon DocumentDB. Suele ser la VPC predeterminada.

   • En Subredes, marque las casillas situadas junto a cada zona de disponibilidad. Elija el ID de subred correcto para cada zona de disponibilidad.

   • En Tipo de dirección IP, seleccione IPv4.

   • En Grupos de seguridad, elija el grupo de seguridad que utiliza su clúster de Amazon DocumentDB. Suele ser el grupo de seguridad default.

   • Conserve todas las otras opciones de configuración predeterminadas.

   • Elija Crear punto de conexión.

Para crear una política de IAM

1. En la consola de IAM, abra la página Políticas, y, a continuación, elija Crear política.

2. Seleccione la pestaña JSON. En la siguiente política, sustituya el ARN del recurso de Secrets Manager en la última línea de la instrucción por el ARN secreto anterior y copie la política en el 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. Elija Siguiente: Etiquetas y, a continuación, seleccione Siguiente: Revisar.

4. En Name (Nombre), ingrese AWSDocumentDBLambdaPolicy.

5. Seleccione Crear política.

Creación del rol de IAM

1. Abra la página Roles en la consola de IAM y elija Crear rol.

2. En Seleccionar entidad de confianza, elija las siguientes opciones:

   • Tipo de entidad de confianza: servicio de AWS

   • Servicio o caso de uso: Lambda

   • Elija Siguiente.

3. En Agregar permisos, elija la política AWSDocumentDBLambdaPolicy que acaba de crear y también AWSLambdaBasicExecutionRole para conceder a su función permisos para escribir en los Registros de Amazon CloudWatch.

4. Elija Siguiente.

5. En Role name (Nombre del rol), introduzca AWSDocumentDBLambdaExecutionRole.

6. Elija Create role (Crear rol).

Para crear la función de Lambda

1. Abra la página de Functions (Funciones) en la consola de Lambda.

2. Seleccione Creación de función.

3. Elija Crear desde cero.

4. Bajo Información básica, haga lo siguiente:

   1. En Nombre de la función, ingrese ProcessDocumentDBRecords.

   2. En Tiempo de ejecución, seleccione Python 3.12.

   3. En Arquitectura, elija x86_64.

5. En la pestaña Cambiar rol de ejecución predeterminado, haga lo siguiente:

   1. Amplíe la pestaña y, a continuación, elija Utilizar un rol existente.

   2. Seleccione el AWSDocumentDBLambdaExecutionRole que creó anteriormente.

6. Seleccione Creación de función.

Para implementar el código de la función

1. Seleccione la pestaña Python en el siguiente cuadro y copie el código.

   .NET

   SDK para .NET

   nota

   Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos de tecnología sin servidor.

   Consumo de un evento de Amazon DocumentDB con Lambda mediante .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 para Go V2

   nota

   Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos de tecnología sin servidor.

   Consumir un evento de Amazon DocumentDB con Lambda utilizando 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 para Java 2.x

   nota

   Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos de tecnología sin servidor.

   Cómo consumir un evento de Amazon DocumentDB con Lambda mediante 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 para JavaScript (v3)

   nota

   Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos de tecnología sin servidor.

   Consumo de un evento de Amazon DocumentDB con Lambda mediante 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 de un evento de Amazon DocumentDB con Lambda mediante 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 para PHP

   nota

   Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos de tecnología sin servidor.

   Consumo de un evento de Amazon DocumentDB con Lambda mediante 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 para Python (Boto3)

   nota

   Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos de tecnología sin servidor.

   Consumo de un evento de Amazon DocumentDB con Lambda mediante 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 para Ruby

   nota

   Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos de tecnología sin servidor.

   Consumo de un evento de Amazon DocumentDB con Lambda mediante 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 para Rust

   nota

   Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de ejemplos de tecnología sin servidor.

   Consumo de un evento de Amazon DocumentDB con Lambda mediante 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(())
       
   }
   
   

2. En el panel Código fuente de la consola de Lambda, pegue el siguiente código en el editor de código y sustituya el código creado por Lambda.

3. En la sección IMPLEMENTAR elija Implementar para actualizar el código de la función:

   

Para crear la asignación de orígenes de eventos

1. Abra la página Funciones en la consola de Lambda.

2. Elija la función ProcessDocumentDBRecords que creó anteriormente.

3. Elija la pestaña Configuración y, a continuación, elija Desencadenadores en el menú de la izquierda.

4. Elija Add trigger (Añadir disparador).

5. En Configuración del desencadenador, para el origen, seleccione Amazon DocumentDB.

6. Cree la asignación de orígenes de eventos con la siguiente configuración:

   • Clúster de Amazon DocumentDB: elija el clúster que creó anteriormente.

   • Nombre de la base de datos: docdbdemo

   • Nombre de la colección: productos

   • Tamaño del lote: 1

   • Posición inicial: más reciente

   • Autenticación: BASIC_AUTH

   • Clave de Secrets Manager: elija el secreto de su clúster de Amazon DocumentDB. Tendrá un nombre similar a rds!cluster-12345678-a6f0-52c0-b290-db4aga89274f.

   • Intervalo del lote: 1

   • Configuración de documentos completa: UpdateLookup

7. Elija Agregar. Crear la asignación de orígenes de eventos puede tardar unos minutos.

1. Vuelva a conectarse al clúster de Amazon DocumentDB en su entorno de CloudShell.

2. Ejecute el siguiente comando para asegurarse de que utiliza la base de datos docdbdemo:

   use docdbdemo

Cómo eliminar la función de Lambda

1. Abra la página de Funciones en la consola de Lambda.

2. Seleccione la función que ha creado.

3. Elija Acciones, Eliminar.

4. Escriba confirm en el campo de entrada de texto y elija Delete(Eliminar).

Cómo eliminar el rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Seleccione el rol de ejecución que creó.

3. Elija Eliminar.

4. Si desea continuar, escriba el nombre del rol en el campo de entrada de texto y elija Delete (Eliminar).

Para eliminar los puntos de conexión de VPC

1. Abra la consola de VPC. En el menú de la izquierda, en Nube privada virtual, seleccione Puntos de conexión.

2. Seleccione los puntos de conexión que ha creado.

3. Elija Acciones, Eliminar puntos de conexión de VPC.

4. Introduzca delete en el campo de entrada de texto.

5. Elija Eliminar.

Para eliminar el clúster de Amazon DocumentDB

1. Abra la consola de Amazon DocumentDB.

2. Elija el clúster de Amazon DocumentDB que creó para este tutorial y deshabilite la protección contra la eliminación.

3. En la página principal Clústeres, vuelva a elegir el clúster de Amazon DocumentDB.

4. Elija Acciones, Eliminar.

5. En Crear instantánea final del clúster, seleccione No.

6. Introduzca delete en el campo de entrada de texto.

7. Elija Eliminar.

Para eliminar el secreto en Secrets Manager

1. Abra la consola de Secrets Manager.

2. Elija el secreto que ha creado para este tutorial.

3. Elija Acciones, Eliminar secreto.

4. Elija Schedule deletion.