[AWS Rekognition] 프로필 이미지 수동 심사 99% 자동화 경험

sequenceDiagram
    participant User as 유저
    participant API as GameServer
    participant S3 as AWS S3
    participant DB as Database
    participant Admin as 운영툴
 
    User->>API: 프로필 이미지 업로드
    API->>S3: 이미지 저장
    API->>DB: ProfileImageExamineStatus = HOLD
    Note over User: 이미지 미노출
 
    Admin->>DB: HOLD 상태 이미지 조회
    Admin->>Admin: 수동 심사
    Admin->>DB: APPROVE / DISAPPROVE
    Note over User: 승인 후 이미지 노출

{
  "ModerationLabels": [
    {
      "Name": "Explicit Nudity",
      "Confidence": 98.5,
      "ParentName": "",
      "TaxonomyLevel": 1
    },
    {
      "Name": "Graphic Male Nudity",
      "Confidence": 95.2,
      "ParentName": "Explicit Nudity",
      "TaxonomyLevel": 2
    }
  ],
  "ModerationModelVersion": "7.0"
}

sequenceDiagram
    participant User as 유저
    participant API as GameServer
    participant Rek as Rekognition
    participant S3 as AWS S3
    participant DB as Database
 
    User->>API: 프로필 이미지 업로드
    API->>Rek: 이미지 분석 요청
    Rek-->>API: 결과 (안전/유해)
 
    alt 안전한 이미지 (99%)
        API->>S3: 이미지 저장
        API->>DB: ProfileImageExamineStatus = APPROVE
        API-->>User: 성공 (즉시 노출!)
    else 유해 의심 (1%)
        API->>S3: 이미지 저장
        API->>DB: ProfileImageExamineStatus = HOLD
        API-->>User: 심사 대기 중
    end

public record ImageModerationResult(
    bool IsSafe,
    List<string> DetectedLabels,
    double MaxConfidence
);
 
[Singleton]
public class RekognitionModerationService(
    AmazonRekognitionClient client,
    ILogger<RekognitionModerationService> logger)
    : IRekognitionModerationService
{
    // 75% 이상 confidence면 유해로 판단
    private const float ConfidenceThreshold = 75f;
    
    // API 호출 시 최소 50% 이상만 반환받음
    private const float MinConfidence = 50f;
 
    public async Task<ImageModerationResult> ModerateImageAsync(byte[] imageBytes)
    {
        try
        {
            var request = new DetectModerationLabelsRequest
            {
                Image = new Image
                {
                    Bytes = new MemoryStream(imageBytes)
                },
                MinConfidence = MinConfidence
            };
 
            var response = await client.DetectModerationLabelsAsync(request);
 
            // 75% 이상 confidence인 유해 레이블만 필터링
            var dangerousLabels = response.ModerationLabels
                .Where(l => l.Confidence >= ConfidenceThreshold)
                .ToList();
 
            var isSafe = !dangerousLabels.Any();
 
            if (!isSafe)
            {
                logger.LogWarning(
                    "유해 컨텐츠 감지: {Labels}, MaxConfidence: {MaxConfidence}%",
                    string.Join(", ", dangerousLabels.Select(l => l.Name)),
                    dangerousLabels.Max(l => l.Confidence));
            }
 
            return new ImageModerationResult(
                IsSafe: isSafe,
                DetectedLabels: dangerousLabels.Select(l => $"{l.Name} ({l.Confidence:F1}%)").ToList(),
                MaxConfidence: dangerousLabels.Any() ? dangerousLabels.Max(l => l.Confidence) : 0
            );
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Rekognition 이미지 분석 중 오류 발생");
            
            // Rekognition 오류 시 안전하게 HOLD 처리
            return new ImageModerationResult(
                IsSafe: false,
                DetectedLabels: new List<string> { $"Rekognition Error: {ex.Message}" },
                MaxConfidence: 0
            );
        }
    }
}

public class UserProfileUpload(
    IRepository<RdbUser> userRepository,
    IAmazonS3Handler amazonS3Handler,
    IRekognitionModerationService rekognitionModerationService,
    ILogger<UserProfileUpload> logger)
    : IUserProfileUpload
{
    public async Task<ResultCodes> UploadProfileImage(...)
    {
        // ... 이미지 처리 로직 ...
        
        using (var memoryStream = new MemoryStream())
        {
            await image.WriteAsync(memoryStream);
            
            // Rekognition 이미지 검증
            var imageBytes = memoryStream.ToArray();
            var moderationResult = await rekognitionModerationService.ModerateImageAsync(imageBytes);
            
            if (moderationResult.IsSafe)
            {
                // 자동 승인
                userProfileImages.ProfileImageExamineStatus = ProfileImageExamineStatus.APPROVE;
                userProfileImages.IsApproved = true;
                userProfileImages.Manager = "Auto-Rekognition";
                logger.LogInformation(
                    "프로필 이미지 자동 승인: UserId={UserId}, Position={Position}",
                    user.Id, position);
            }
            else
            {
                // 수동 심사 필요
                userProfileImages.ProfileImageExamineStatus = ProfileImageExamineStatus.HOLD;
                userProfileImages.IsApproved = false;
                userProfileImages.DisApproveOrRemoveReason = 
                    $"Rekognition 감지: {string.Join(", ", moderationResult.DetectedLabels)}";
            }
            
            // S3 업로드
            memoryStream.Position = 0;
            await amazonS3Handler.UploadFileToS3Async(BucketType.Public, memoryStream, fileName);
        }
        
        await userRepository.SaveChangesAsync();
        return ResultCodes.Success;
    }
}

// AWS Rekognition 이미지 검증 서비스
serviceCollection.AddSingleton<AmazonRekognitionClient>();
serviceCollection.AddSingleton<IRekognitionModerationService, RekognitionModerationService>();

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "rekognition:DetectModerationLabels"
            ],
            "Resource": "*"
        }
    ]
}