AWS Lambda + EventBridge를 사용한 S3 리소스 관리

import { S3Client, ListObjectsV2Command, DeleteObjectsCommand } from '@aws-sdk/client-s3';
import https from 'https';

// S3 클라이언트 초기화
const s3 = new S3Client({ region: 'ap-northeast-2' }); // S3 리전 설정
const SLACK_WEBHOOK_URL = '...'; // Slack 웹훅 URL

/**
 * Lambda 핸들러 함수
 */
export const handler = async () => {
  const bucketName = 'acg-rtc'; // S3 버킷 이름
  const prefixes = ['NEW_ACG/', 'ACG/', 'SK/', 'CJ/', 'NEW_LG/', 'LG/']; // S3 접두어 목록

  // 오늘 기준 30일 전 날짜를 계산하여 cutoffDateString 생성 (YYYY-MM-DD 형식)
  const getCutoffDateString = () => {
    const now = new Date(); // 현재 날짜 가져오기
    now.setDate(now.getDate() - 30); // 30일 전으로 이동
    return now.toISOString().split('T')[0]; // YYYY-MM-DD 형식으로 변환
  };

  const cutoffDateString = getCutoffDateString(); // 기준 날짜 계산

  let totalDeletedSize = 0; // 총 삭제한 리소스 크기 합산
  const allDeletedKeys = []; // 삭제된 키 목록
  const deletedClients = []; // 삭제된 고객사 목록 및 정보

/**
   * 숫자에 1,000 단위로 콤마 추가
   * @param {number} number - 포맷할 숫자
   * @returns {string} 콤마가 추가된 숫자 문자열
   */
  const formatNumberWithCommas = (number) => {
    return new Intl.NumberFormat('ko-KR').format(number);
  };
  
  /**
   * 크기를 적절한 단위로 변환 (MB, GB, TB 등)
   * @param {number} sizeInBytes - 크기 (바이트)
   * @returns {string} 적절한 단위로 변환된 크기 문자열
   */
  const formatSize = (sizeInBytes) => {
    if (sizeInBytes < 1024 ** 2) {
      return `${(sizeInBytes / 1024).toFixed(2)} KB`;
    } else if (sizeInBytes < 1024 ** 3) {
      return `${(sizeInBytes / 1024 ** 2).toFixed(2)} MB`;
    } else if (sizeInBytes < 1024 ** 4) {
      return `${(sizeInBytes / 1024 ** 3).toFixed(2)} GB`;
    } else {
      return `${(sizeInBytes / 1024 ** 4).toFixed(2)} TB`;
    }
  };

  /**
   * S3 객체 삭제 함수
   * 특정 prefix와 cutoffDateString에 따라 삭제할 객체를 필터링하여 삭제
   */
  const deleteObjectsByDate = async (prefix, cutoffDateString) => {
    const deletedKeys = [];
    let prefixDeletedSize = 0; // 특정 prefix에서 삭제한 크기 합산
    let continuationToken = null;

    do {
      const response = await s3.send(
        new ListObjectsV2Command({
          Bucket: bucketName,
          Prefix: prefix, // 탐색할 접두어
          MaxKeys: 1000, // 한 번에 최대 1000개 객체 반환
          ContinuationToken: continuationToken, // 페이징 토큰
        })
      );

      if (!response.Contents || response.Contents.length === 0) {
        break; // 더 이상 처리할 객체가 없음
      }

      // 기준 날짜 이전의 객체 필터링
      const objectsToDelete = response.Contents.filter((obj) => {
        const keyParts = obj.Key.split('/');
        const datePart = keyParts[1]; // 키에서 YYYYMMDD 추출

        return /^\d{8}$/.test(datePart) && datePart < cutoffDateString.replace(/-/g, ''); // 날짜 조건 확인
      });

      // 삭제 요청 수행 (1,000개 단위로 나누어서 삭제)
      for (let i = 0; i < objectsToDelete.length; i += 1000) {
        const batchToDelete = objectsToDelete.slice(i, i + 1000); // 1,000개씩 분할

        await s3.send(
          new DeleteObjectsCommand({
            Bucket: bucketName,
            Delete: {
              Objects: batchToDelete.map((obj) => ({ Key: obj.Key })),
            },
          })
        );

        // 삭제된 객체 키 및 크기 합산
        deletedKeys.push(...batchToDelete.map((obj) => obj.Key));
        const batchDeletedSize = batchToDelete.reduce((sum, obj) => sum + obj.Size, 0);
        prefixDeletedSize += batchDeletedSize;
        totalDeletedSize += batchDeletedSize; // 전체 삭제 크기 합산
      }

      continuationToken = response.NextContinuationToken; // 다음 페이지를 위한 토큰 설정
    } while (continuationToken); // 더 이상 페이지가 없을 때까지 반복

    return { deletedKeys, prefixDeletedSize };
  };

  // 모든 Prefix에 대해 삭제 작업 수행
  const deletePromises = prefixes.map(async (prefix) => {
    try {
      const { deletedKeys, prefixDeletedSize } = await deleteObjectsByDate(prefix, cutoffDateString);
      allDeletedKeys.push(...deletedKeys);

      if (deletedKeys.length > 0) {
        deletedClients.push({
          prefix: prefix.replace('/', ''), // 접두어 이름
          count: deletedKeys.length, // 삭제된 객체 수
          size: prefixDeletedSize, // 삭제된 크기
        });
      }
    } catch (error) {
      console.error(`Failed to process prefix: ${prefix} - ${error.message}`);
    }
  });

  await Promise.all(deletePromises);

  if (allDeletedKeys.length === 0) {
    return { statusCode: 200, body: JSON.stringify({ message: 'No resources to delete.' }) };
  }

  // S3 전체 사용량 가져오기
  const getTotalS3Usage = async () => {
    let totalSize = 0;
    let continuationToken = null;

    do {
      const response = await s3.send(
        new ListObjectsV2Command({
          Bucket: bucketName,
          ContinuationToken: continuationToken,
        })
      );

      totalSize += response.Contents?.reduce((sum, obj) => sum + obj.Size, 0) || 0;
      continuationToken = response.NextContinuationToken;
    } while (continuationToken);

    return totalSize; // 바이트 단위 반환
  };

  const totalS3UsageAfterDeletion = formatSize(await getTotalS3Usage());

  // 삭제된 리소스 정보 내림차순 정렬 (크기 기준)
  deletedClients.sort((a, b) => b.size - a.size);

  // 삭제 정보 문자열 생성
  const deletionDetails = deletedClients
    .map((client) => `  - ${client.prefix}: ${formatNumberWithCommas(client.count)}건 / ${formatSize(client.size)}`)
    .join('\n');

  // Slack 알림 메시지 생성
  const message = {
    channel: '#rtc-notice',
    text: `===============================\n       ‼️ AWS S3 리소스 삭제 알림 ‼️\n------------------------------------------------\n1. S3 총 사용량: ${totalS3UsageAfterDeletion}\n2. 삭제한 리소스 크기: ${formatSize(
      totalDeletedSize
    )} (~ ${cutoffDateString})\n3. 삭제 정보:\n${deletionDetails}\n\n===============================`,
  };

  await sendSlackNotification(message);

  return { statusCode: 200, body: JSON.stringify({ message: 'Resource cleanup completed' }) };
};

/**
 * Slack 알림 전송 함수
 */
const sendSlackNotification = (message) => {
  ...// 생략
};