자습서: Amazon DocumentDB Streams와 함께 AWS Lambda 사용

1. Amazon DocumentDB 콘솔을 엽니다. 클러스터에서 생성을 선택합니다.

2. 다음 구성을 사용하여 클러스터를 생성합니다.

   • 클러스터 유형에서 인스턴스 기반 클러스터를 선택합니다. 이는 기본 옵션입니다.

   • 클러스터 구성에서 엔진 버전 5.0.0이 선택되어 있는지 확인합니다. 이는 기본 옵션입니다.

   • 인스턴스 구성에서

     • DB 인스턴스 클래스에서 메모리 최적화 클래스를 선택합니다. 이는 기본 옵션입니다.

     • 일반 복제본 인스턴스 수에서 1을 선택합니다.

     • 인스턴스 클래스에서 기본 선택을 사용합니다.

   • 인증에 기본 사용자 이름을 입력하고 자체 관리형을 선택합니다. 암호를 입력한 다음 확인합니다.

   • 다른 기본 설정을 모두 유지합니다.

3. 클러스터 생성을 선택합니다.

Secrets Manager에서 보안 암호 생성

1. Secrets Manager 콘솔을 열고 새 보안 암호 저장을 선택합니다.

2. 보안 암호 유형 선택)에서 다음 옵션을 선택합니다.

   • 기본 세부 정보에서

     • 보안 암호 유형: Amazon DocumentDB 데이터베이스의 자격 증명

     • 자격 증명에 Amazon DocumentDB 클러스터를 생성하는 데 사용한 동일한 사용자 이름과 암호를 입력합니다.

     • 데이터베이스: Amazon DocumentDB 클러스터를 선택합니다.

     • 다음을 선택합니다.

3. 보안 암호 구성에서 다음 옵션을 선택합니다.

   • 비밀 이름: DocumentDBSecret

   • 다음을 선택합니다.

4. 다음을 선택합니다.

5. 저장(Store)을 선택합니다.

6. 콘솔을 새로 고쳐 DocumentDBSecret 보안 암호가 성공적으로 저장되었는지 확인합니다.

AWS CloudShell을 사용하여 Amazon DocumentDB 클러스터에 연결

1. Amazon DocumentDB 관리 콘솔의 클러스터에서 생성한 클러스터를 찾습니다. 클러스터 옆의 확인란을 클릭하여 클러스터를 선택합니다.

2. 클러스터에 연결을 선택합니다. CloudShell 명령 실행 화면이 나타납니다.

3. 새 환경 이름 필드에 ‘테스트’와 같은 고유한 이름을 입력하고 생성 및 실행을 선택합니다.

4. 메시지가 표시되면 암호를 입력합니다. 프롬프트가 rs0 [direct: primary] <env-name>>이 되면 Amazon DocumentDB 클러스터에 성공적으로 연결된 것입니다.

클러스터 내에 새 데이터베이스 생성

1. 다음 명령을 실행하여 docdbdemo이라는 새 데이터베이스를 생성합니다.

   use docdbdemo

2. 터미널 창에서 다음 명령을 사용하여 docdbdemo에 레코드를 삽입합니다.

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

   다음과 같이 출력되어야 합니다.

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

3. 그리고 다음 명령을 사용하여 docdbdemo 데이터베이스의 products 컬렉션에서 변경 스트림을 활성화합니다.

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

   다음과 유사한 출력 화면이 표시되어야 합니다.

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

인터페이스 VPC 엔드포인트 생성

1. VPC 콘솔을 엽니다. 왼쪽 메뉴의 Virtual Private Cloud에서 엔드포인트를 선택합니다.

2. Create endpoint(엔드포인트 생성)을 선택합니다. 다음 구성으로 엔드포인트를 생성합니다.

   • 이름 태그에 lambda-default-vpc를 입력합니다.

   • 서비스 범주에서 AWS 서비스를 선택합니다.

   • 서비스 검색 상자에 lambda를 입력합니다. com.amazonaws.<region>.lambda 형식의 서비스를 선택합니다.

   • VPC에서 Amazon DocumentDB 클러스터가 있는 VPC를 선택합니다. 이는 일반적으로 기본 VPC입니다.

   • 서브넷에서 각 가용 영역 옆의 확인란을 선택합니다. 각 가용 영역에 대한 올바른 서브넷 ID를 선택합니다.

   • IP 주소 유형에서 IPv4를 선택합니다.

   • 보안 그룹에서 Amazon DocumentDB 클러스터가 사용하는 보안 그룹을 선택합니다. 이는 일반적으로 default 보안 그룹입니다.

   • 다른 기본 설정을 모두 유지합니다.

   • Create endpoint(엔드포인트 생성)을 선택합니다.

3. 다시 엔드포인트 생성을 선택합니다. 다음 구성으로 엔드포인트를 생성합니다.

   • 이름 태그에 secretsmanager-default-vpc를 입력합니다.

   • 서비스 범주에서 AWS 서비스를 선택합니다.

   • 서비스 검색 상자에 secretsmanager를 입력합니다. com.amazonaws.<region>.secretsmanager 형식의 서비스를 선택합니다.

   • VPC에서 Amazon DocumentDB 클러스터가 있는 VPC를 선택합니다. 이는 일반적으로 기본 VPC입니다.

   • 서브넷에서 각 가용 영역 옆의 확인란을 선택합니다. 각 가용 영역에 대한 올바른 서브넷 ID를 선택합니다.

   • IP 주소 유형에서 IPv4를 선택합니다.

   • 보안 그룹에서 Amazon DocumentDB 클러스터가 사용하는 보안 그룹을 선택합니다. 이는 일반적으로 default 보안 그룹입니다.

   • 다른 기본 설정을 모두 유지합니다.

   • Create endpoint(엔드포인트 생성)을 선택합니다.

IAM 정책 생성

1. IAM 콘솔에서 정책 페이지를 열고 정책 생성을 선택합니다.

2. JSON 탭을 선택합니다. 다음 정책에서 명령문의 마지막 줄에 있는 Secrets Manager 리소스 ARN을 이전의 보안 암호 ARN으로 바꾸고 정책을 편집기에 복사합니다.

   {
       "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. 다음: 태그를 선택하고 다음: 검토를 선택합니다.

4. 이름에서 AWSDocumentDBLambdaPolicy을 입력합니다.

5. Create policy(정책 생성)를 선택합니다.

IAM 역할을 만들려면

1. IAM 콘솔에서 역할 페이지를 열고 역할 생성을 선택합니다.

2. 신뢰할 수 있는 엔터티 선택에서 다음 옵션을 선택합니다.

   • 신뢰할 수 있는 엔티티 유형: AWS 서비스

   • 서비스 또는 사용 사례: Lambda

   • 다음을 선택합니다.

3. 권한 추가에서 방금 생성한 AWSDocumentDBLambdaPolicy 정책과 AWSLambdaBasicExecutionRole을 선택하여 함수에 Amazon CloudWatch Logs에 쓸 수 있는 권한을 부여합니다.

4. 다음을 선택합니다.

5. 역할 이름에 AWSDocumentDBLambdaExecutionRole을 입력합니다.

6. 역할 생성을 선택합니다.

Lambda 함수를 만들려면

1. Lambda 콘솔의 함수 페이지를 엽니다.

2. 함수 생성을 선택합니다.

3. 새로 작성을 선택합니다.

4. 기본 정보에서 다음과 같이 합니다.

   1. 함수 이름에 ProcessDocumentDBRecords을 입력합니다.

   2. 런타임에서 Python 3.13을 선택합니다.

   3. 아키텍처에서는 x86_64를 선택합니다.

5. 기본 실행 역할 변경 탭에서 다음을 수행합니다.

   1. 탭을 확장한 다음 기존 역할 사용을 선택합니다.

   2. 이전에 생성한 AWSDocumentDBLambdaExecutionRole을 선택합니다.

6. 함수 생성을 선택합니다.

함수 코드 배포

1. 다음 상자에서 Python 탭을 선택하고 코드를 복사합니다.

   .NET

   SDK for .NET

   참고

   GitHub에 더 많은 내용이 있습니다. 서버리스 예제 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.

   .NET을 사용하여 Lambda로 Amazon DocumentDB 이벤트 소비

   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 for Go V2

   참고

   GitHub에 더 많은 내용이 있습니다. 서버리스 예제 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.

   Go를 사용하여 Lambda로 Amazon DocumentDB 이벤트 소비

   
   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 for Java 2.x

   참고

   GitHub에 더 많은 내용이 있습니다. 서버리스 예제 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.

   Java를 사용하여 Lambda로 Amazon DocumentDB 이벤트 소비

   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 for JavaScript (v3)

   참고

   GitHub에 더 많은 내용이 있습니다. 서버리스 예제 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.

   JavaScript를 사용하여 Lambda로 Amazon DocumentDB 이벤트 소비

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

   TypeScript를 사용하여 Lambda로 Amazon DocumentDB 이벤트 소비

   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 for PHP

   참고

   GitHub에 더 많은 내용이 있습니다. 서버리스 예제 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.

   PHP를 사용하여 Lambda로 Amazon DocumentDB 이벤트 소비

   <?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 for Python (Boto3)

   참고

   GitHub에 더 많은 내용이 있습니다. 서버리스 예제 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.

   Python을 사용하여 Lambda로 Amazon DocumentDB 이벤트 소비

   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 for Ruby

   참고

   GitHub에 더 많은 내용이 있습니다. 서버리스 예제 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.

   Ruby를 사용하여 Lambda로 Amazon DocumentDB 이벤트 소비

   require 'json'
   
   def lambda_handler(event:, context:)
     event['events'].each do |record|
       log_document_db_event(record)
     end
     'OK'
   end
   
   def log_document_db_event(record)
     event_data = record['event'] || {}
     operation_type = event_data['operationType'] || 'Unknown'
     db = event_data.dig('ns', 'db') || 'Unknown'
     collection = event_data.dig('ns', 'coll') || 'Unknown'
     full_document = event_data['fullDocument'] || {}
   
     puts "Operation type: #{operation_type}"
     puts "db: #{db}"
     puts "collection: #{collection}"
     puts "Full document: #{JSON.pretty_generate(full_document)}"
   end
   

   Rust

   SDK for Rust

   참고

   GitHub에 더 많은 내용이 있습니다. 서버리스 예제 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.

   Rust를 사용하여 Lambda로 Amazon DocumentDB 이벤트 소비

   
   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. Lambda 콘솔의 코드 소스 창에서 코드 편집기에 코드를 붙여넣고 Lambda가 생성한 코드를 바꿉니다.

3. 배포 섹션에서 배포를 선택하여 함수의 코드를 업데이트하세요.

   

이벤트 소스 매핑 생성

1. Lambda 콘솔에서 함수 페이지를 엽니다.

2. 앞에서 생성한 ProcessDocumentDBRecords 함수를 선택합니다.

3. 구성 탭을 선택한 다음 왼쪽 메뉴에서 트리거를 선택합니다.

4. 트리거 추가를 선택합니다.

5. 트리거 구성에서 소스로 Amazon DocumentDB를 선택합니다.

6. 다음 구성으로 이벤트 소스 매핑을 생성합니다.

   • Amazon DocumentDB 클러스터: 이전에 생성한 클러스터를 선택합니다.

   • 데이터베이스 이름: docdbdemo

   • 컬렉션 이름: 제품

   • 배치 크기: 1

   • 시작 위치: 최신

   • 인증: BASIC_AUTH

   • Secrets Manager 키: Amazon DocumentDB 클러스터의 보안 암호를 선택합니다. 예를 들어, rds!cluster-12345678-a6f0-52c0-b290-db4aga89274f라고 합니다.

   • 배치 창: 1

   • 전체 문서 구성: UpdateLookup

7. 추가를 선택합니다. 이벤트 소스 매핑을 생성하는 데 몇 분 정도 걸릴 수 있습니다.

1. CloudShell 환경에서 Amazon DocumentDB 클러스터에 다시 연결합니다.

2. 다음 명령을 실행하여 docdbdemo 데이터베이스를 사용하고 있는지 확인합니다.

   use docdbdemo

Lambda 함수를 삭제하려면

1. Lambda 콘솔의 함수 페이지를 엽니다.

2. 생성한 함수를 선택합니다.

3. 작업, 삭제를 선택합니다.

4. 텍스트 입력 필드에 confirm를 입력하고 Delete(삭제)를 선택합니다.

집행 역할 삭제

1. IAM 콘솔에서 역할 페이지를 엽니다.

2. 생성한 실행 역할을 선택합니다.

3. 삭제를 선택합니다.

4. 텍스트 입력 필드에 역할의 이름을 입력하고 Delete(삭제)를 선택합니다.

VPC 엔드포인트 삭제

1. VPC 콘솔을 엽니다. 왼쪽 메뉴의 Virtual Private Cloud에서 엔드포인트를 선택합니다.

2. 생성한 엔드포인트를 선택합니다.

3. 작업(Actions), VPC 엔드포인트 삭제(Delete VPC endpoints)를 차례로 선택합니다.

4. 텍스트 입력 필드에 delete을 입력합니다.

5. 삭제를 선택합니다.

Amazon DocumentDB 클러스터 삭제

1. Amazon DocumentDB 콘솔을 엽니다.

2. 이 자습서용으로 생성한 Amazon DocumentDB 클러스터를 선택하고 삭제 방지를 비활성화합니다.

3. 기본 클러스터 페이지에서 Amazon DocumentDB 클러스터를 다시 선택합니다.

4. 작업, 삭제를 선택합니다.

5. 최종 클러스터 스냅샷 생성에서 아니요를 선택합니다.

6. 텍스트 입력 필드에 delete을 입력합니다.

7. 삭제를 선택합니다.

Secrets Manager에서 보안 암호 삭제

1. Secrets Manager 콘솔을 엽니다.

2. 이 자습서용으로 생성한 보안 암호를 선택합니다.

3. 작업, 보안 암호 삭제를 선택합니다.

4. 삭제 예약(Schedule deletion)을 선택합니다.