[TroubleShooting] 롤백이 되지 않는 S3 Bucket

👀 현재 상황 및 배경 설명

• 애플리케이션을 구현하는 과정에서 이미지를 저장해야 하는 상황이 생겼다.
• AWS S3 Bucket을 사용하여 이미지는 S3에 저장하고, 해당 이미지의 URL은 서버의 DB에 저장하는 방식으로 구현했다.
• 이 방식은 스토리지와 데이터베이스의 역할을 분리함으로써, 이미지는 클라우드 스토리지에 안전하게 보관하고, 관련 메타데이터는 DB에 저장하여 서버의 부담을 줄이고 이미지 저장 및 제공 속도를 높일 수 있는 장점이 있다.

 

▶ 구현 코드

🔽 S3에 이미지를 업로드 및 삭제하는 서비스 클래스인 S3ImageService

/**
 * S3에 이미지를 업로드 및 삭제하는 서비스 클래스입니다.
 */
@Service
@RequiredArgsConstructor
public class S3ImageService {

    @Value("${cloud.aws.s3.bucket}")
    private String bucketName;

    public final AmazonS3 amazonS3;

    /**
     * S3에 파일 업로드
     */
    public String uploadImage(MultipartFile file) {
        String fileName = UUID.randomUUID() + "_" + file.getOriginalFilename();

        try {
            ObjectMetadata metadata = new ObjectMetadata();
            metadata.setContentLength(file.getSize());
            metadata.setContentType(file.getContentType());

            amazonS3.putObject(bucketName, fileName, file.getInputStream(), metadata);

            return amazonS3.getUrl(bucketName, fileName).toString();
        } catch (IOException e) {
            throw new S3Exception(S3ErrorCode.FILE_UPLOAD_ERROR);
        }
    }
    
    /**
     * S3에서 이미지 삭제
     */
    public void deleteImage(String imageUrl) {
        String fileName = imageUrl.substring(imageUrl.lastIndexOf("/") + 1);
        amazonS3.deleteObject(bucketName, fileName);
    }
}

🔽 사진을 업데이트하는 Service 클래스 메서드

/**
 * 가게 사진을 업데이트합니다.
 */
@Transactional
protected void updateMarketImages(Market market, List<MultipartFile> updatedImages) {
    // 기존 사진 조회
    List<MarketImage> marketImageList = marketImageRepository.findAllByMarketId(market.getId());

    // S3에서 기존 사진 삭제
    for (MarketImage marketImage : marketImageList) {
        s3ImageService.deleteImage(marketImage.getImageUrl());
    }

    // DB에서 기존 사진 URL 삭제
    marketImageRepository.deleteAll(marketImageList);

    for (MultipartFile imageFile : updatedImages) {
    	// S3에 새로운 사진 업로드
        String imageUrl = s3ImageService.uploadImage(imageFile);

        MarketImage updateImage = MarketImage.builder()
                .market(market)
                .imageUrl(imageUrl)
                .build();
		
        // DB에 새로운 사진 URL 저장
        marketImageRepository.save(updateImage);
    }
}

 

 

🚨 문제 상황

• S3 Bucket에 이미지를 업로드(amazonS3.putObject)하거나 삭제(amazonS3.deleteObject)하는 작업은 트랜잭션이 적용되지 않는다.
• 사진을 업데이트하는 메서드에서 오류가 발생하여 트랜잭션이 롤백될 경우, DB에서 URL을 추가하거나 삭제하는 작업은 롤백되지만, S3 버킷에 대한 작업은 롤백되지 않는다. 이는 S3 버킷에 고아 객체가 남아 데이터 정합성에 문제가 발생할 수 있다는 의미다.

고아 객체: 데이터베이스와 같은 관리 시스템에서 참조되지 않거나 연관된 엔티티가 삭제된 이후에도 남아 있는 불필요한 데이터를 의미한다. 예를 들어, S3에 저장된 이미지가 데이터베이스에 더 이상 참조되지 않을 경우 해당 이미지는 고아 객체가 된다.
데이터 정합성: 시스템에서 데이터가 일관되고 정확하게 유지되는 상태를 의미한다. 데이터 정합성 문제가 발생하면 서로 다른 시스템 간의 데이터 불일치가 생길 수 있다. 이는 데이터의 신뢰성을 떨어뜨리는 문제를 초래한다. 예를 들어, 데이터베이스에는 삭제되었다고 표시되어 있지만 S3에는 여전히 이미지가 남아 있는 경우가 이에 해당한다.

 

 

✏️ 원인 분석

S3 Bucket 관련 작업에 트랜잭션이 적용되지 않는 이유는 S3가 외부의 독립된 스토리지 서비스로 동작하기 때문이다. 트랜잭션은 일반적으로 데이터베이스와 같은 트랜잭션을 지원하는 시스템에서만 동작한다.

1. S3는 데이터베이스가 아니다.
   • S3는 단순한 파일 저장소로, 데이터베이스처럼 트랜잭션 관리 기능이 포함되어 있지 않다. 즉, S3는 데이터를 저장하거나 삭제할 때 즉시 변경 사항을 반영하며, 이를 되돌리는 롤백 기능이 없다.
2. HTTP 기반의 요청
   • S3와의 상호작용은 HTTP 요청을 통해 이루어지며, 각 요청이 독립적으로 실행된다. HTTP 요청의 stateless 특성상 각 작업은 완료된 후 되돌릴 수 없으며, 데이터베이스 트랜잭션과 같은 일관된 상태를 보장할 수 없다.

따라서 S3와 같은 외부 스토리지 서비스는 트랜잭션이 적용되지 않으며, S3에서의 작업은 성공 여부와 관계없이 즉시 반영되고 롤백되지 않는다.

 

 

🔨 해결 방법

▶ 1. 실패: try-catch를 활용한 예외 처리

🔽 구현 코드

/**
 * 가게 사진을 업데이트합니다.
 */
@Transactional
protected void updateMarketImages(Market market, List<MultipartFile> updatedImages) {
    // 기존 사진 조회
    List<MarketImage> marketImageList = marketImageRepository.findAllByMarketId(market.getId());

    // S3에서 기존 사진 삭제
    try {
        for (MarketImage marketImage : marketImageList) {
            s3ImageService.deleteImage(marketImage.getImageUrl());
        }
    } catch (Exception e) {
        throw new RuntimeException("기존 이미지를 S3에서 삭제하는 중 오류가 발생했습니다.");
    }

    // DB에서 기존 사진 URL 삭제
    try {
        marketImageRepository.deleteAll(marketImageList);
    } catch (Exception e) {
        throw new RuntimeException("기존 이미지를 DB에서 삭제하는 중 오류가 발생했습니다.");
    }

    // 새로운 사진 업로드 및 저장
    for (MultipartFile imageFile : updatedImages) {
        try {
            // S3에 새로운 사진 업로드
            String imageUrl = s3ImageService.uploadImage(imageFile);

            MarketImage updateImage = MarketImage.builder()
                    .market(market)
                    .imageUrl(imageUrl)
                    .build();

            // DB에 새로운 사진 URL 저장
            marketImageRepository.save(updateImage);
        } catch (Exception e) {
            throw new RuntimeException("새로운 이미지를 업로드하는 중 오류가 발생했습니다.");
        }
    }
}

🔽 문제점

• try-catch로 S3 작업에서 발생하는 예외를 처리하고 있지만, S3에 반영된 변경 사항은 롤백되지 않아 해결책이 되지 않는다.

 

▶ 2. 실패: 로직 분리 및 순서 변경

🔽 문제점

• DB 삭제 후 S3 삭제, DB 업로드 후 S3 업로드와 같이 로직을 분리하고 순서를 변경하면 데이터 정합성을 어느 정도 유지하는 데 도움이 되지만, 트랜잭션 도중에 서버가 다운되거나 예기치 않은 오류가 발생할 경우 여전히 완벽한 해결책이 되지 않는다.

 

▶ 3. 실패: 예외 처리를 통해 수동으로 파일 삭제

• 사진 업로드 실패 시 업로드에 실패한 사진을 수동으로 삭제한다.
• 사진 삭제 실패 시 삭제에 실패한 사진을 수동으로 다시 업로드한다.

🔽 구현 코드

/**
 * 가게 사진을 업데이트합니다.
 */
@Transactional
protected void updateMarketImages(Market market, List<MultipartFile> updatedImages) {
    // 기존 사진 조회
    List<MarketImage> marketImageList = marketImageRepository.findAllByMarketId(market.getId());

    // S3에서 기존 사진 삭제 및 보상 로직 처리
    for (MarketImage marketImage : marketImageList) {
        try {
            // S3에서 기존 사진 삭제
            s3ImageService.deleteImage(marketImage.getImageUrl());
        } catch (Exception e) {
            // 삭제 실패 시 복구 보상 로직
            System.err.println("S3에서 기존 파일 삭제 중 오류 발생: " + e.getMessage());
            try {
                // S3에 다시 업로드 시도 (실패한 파일 복구)
                s3ImageService.uploadImageFromUrl(marketImage.getImageUrl());
            } catch (Exception restoreException) {
                System.err.println("S3에 기존 파일 복구 중 오류 발생: " + restoreException.getMessage());
                throw new RuntimeException("기존 이미지를 복구하는 중 오류가 발생했습니다.", restoreException);
            }
            throw new RuntimeException("기존 이미지를 삭제하는 중 오류가 발생했습니다.", e);
        }
    }

    // DB에서 기존 사진 URL 삭제
    marketImageRepository.deleteAll(marketImageList);

    // 새로운 사진 업로드 및 저장
    for (MultipartFile imageFile : updatedImages) {
        String imageUrl = null;

        try {
            // S3에 새로운 사진 업로드
            imageUrl = s3ImageService.uploadImage(imageFile);

            MarketImage updateImage = MarketImage.builder()
                    .market(market)
                    .imageUrl(imageUrl)
                    .build();

            // DB에 새로운 사진 URL 저장
            marketImageRepository.save(updateImage);
        } catch (Exception e) {
            // 업로드 실패 시, 업로드된 파일 삭제
            if (imageUrl != null) {
                try {
                    s3ImageService.deleteImage(imageUrl);
                } catch (Exception deleteException) {
                    System.err.println("S3에 업로드된 파일 삭제 중 오류 발생: " + deleteException.getMessage());
                }
            }
            throw new RuntimeException("새로운 이미지를 업로드하는 중 오류가 발생했습니다.", e);
        }
    }
}

🔽 문제점

1. 한눈에 봐도 로직이 복잡해져 가독성이 매우 떨어진다.
2. 수동으로 업로드하거나 삭제하는 과정에서 또다시 오류가 발생할 가능성이 있다.
3. 삭제에서는 성공했으나 업로드에서 실패하게 된다면 또다시 데이터 정합성 문제가 발생하게 된다.
   • 이를 해결하기 위해 로직을 분리하려 했으나, 삭제는 기존 사진 조회 리스트를 사용하고, 업로드는 요청받은 Multipart 리스트를 사용하여 처리하기 때문에 로직이 매우 복잡해진다.

 

▶ 4. 보류: Spring Scheduler를 사용하여 S3 Bucket을 주기적으로 정리하는 보상 트랜잭션

• 스케줄러를 통해 매일 자정에 S3 Bucket의 고아 객체를 삭제한다.

🔽 구현 코드

/**
 * 주기적으로 S3에서 고아 객체 삭제 (매일 자정 실행)
 */
@Scheduled(cron = "0 0 0 * * ?")
public void cleanUpOrphanImages() {
    // 1. S3 버킷의 모든 파일 목록 가져오기
    ObjectListing objectList = amazonS3.listObjects(bucketName);
    List<S3ObjectSummary> s3Objects = objectList.getObjectSummaries();

    // 2. 데이터베이스에 저장된 모든 이미지 URL 가져오기
    Set<String> dbImageUrls = marketImageRepository.findAll().stream()
            .map(MarketImage::getImageUrl)
            .collect(Collectors.toSet());

    // 3. S3에 존재하지만 데이터베이스에 없는 파일(고아 객체) 삭제
    for (S3ObjectSummary s3Object : s3Objects) {
        String imageUrl = amazonS3.getUrl(bucketName, s3Object.getKey()).toString();
        if (!dbImageUrls.contains(imageUrl)) {
            amazonS3.deleteObject(bucketName, s3Object.getKey());
        }
    }
}

🔽 문제점

1. S3에서 객체를 삭제하는 과정과 동시에 데이터베이스의 상태가 변경되거나 시스템에 다른 변화가 생길 수 있다. 자정에 스케줄러가 S3의 고아 객체를 삭제하는 동안 새로운 사진이 업로드되거나 기존 사진이 삭제되는 경우를 의미한다.
2. s3Objects와 dbImageUrls를 모두 메모리에 로드하기 때문에 파일의 수나 데이터베이스의 이미지 URL 수가 많을 경우 메모리 부족 문제가 발생할 수 있다. 특히 대규모 파일 관리 환경에서는 이러한 방식으로 모든 데이터를 한꺼번에 메모리에 올리는 것은 비효율적이다.

 

▶ 5. 해결1: S3 Bucket 업로드, S3 Bucket 삭제, DB 업로드 및 삭제 로직 3개로 분리

• 클라이언트 앱에서 사진을 업로드 및 삭제하는 창을 따로 만들어, S3 버킷에 사진을 업로드하고 URL을 반환한다. X 버튼을 누르면 S3 버킷에서 해당 사진을 삭제한다. 이후 사진 업데이트 버튼을 누르면 DB에 저장되도록 한다. 총 로직을 3개로 분리한다. 

🔽 구현 코드

/**
 * S3에서 가게 사진을 삭제합니다.
 */
public void deleteMarketImage(String imageUrl) {
    s3ImageService.deleteImage(imageUrl);
}

/**
 * S3에 가게 사진을 업로드합니다.
 */
public MarketImageUrlResponse uploadMarketImage(MultipartFile uploadImage) {
    return MarketImageUrlResponse.builder()
            .imageUrl(s3ImageService.uploadImage(uploadImage))
            .build();
}

/**
 * 가게 사진을 업데이트합니다.
 */
@Transactional
protected void updateMarketImages(Market market, List<String> imageUrls) {
    // 기존 사진 조회
    List<MarketImage> marketImageList = marketImageRepository.findAllByMarketId(market.getId());

    // DB에서 기존 사진 URL 모두 삭제
    marketImageRepository.deleteAll(marketImageList);

    // DB에 새로운 사진 URL 모두 저장
    for (String imageUrl : imageUrls) {
        MarketImage updateImage = MarketImage.builder()
                .market(market)
                .imageUrl(imageUrl)
                .build();

        marketImageRepository.save(updateImage);
    }
}

🔽 문제점

1.  로직을 분리하여 각 작업의 책임을 덜고 오류 발생 범위를 줄였지만, 사용자가 사진 업데이트를 누르지 않으면 S3 버킷에 고아 객체가 생성되어 여전히 데이터 정합성 문제가 발생하게 된다.
   • 이 문제를 6번에서 이어서 해결했다.
2. 사진 업로드와 삭제가 클라이언트에 의해 수동으로 수행되도록 나누어졌기 때문에, 사용자가 서버와의 모든 작업을 올바르게 완료해야 데이터 정합성이 유지된다. 따라서 클라이언트와 서버 간의 의존성이 생긴다.

 

▶ 6. 해결2: Lifecycle 규칙을 사용하여 객체의 수명 주기를 관리

• 5번 방법에서 발생한 문제인, 사용자가 사진 업데이트 버튼을 누르지 않으면 S3 버킷에 고아 객체가 남는 상황을 해결하기 위해 S3 Lifecycle 규칙을 도입한다.
• 사용자가 사진을 업로드할 때 temp 폴더에 임시 저장하고, 사진 업데이트 버튼을 누르면 main 폴더로 이미지를 이동시키는 방식이다.

🔽 S3 Bucket 설정

• S3 Bucket에서 수명 주기 규칙 생성을 클릭한다.

• 임시로 파일을 저장할 폴더 이름을 접두사로 설정한다.

• 객체의 만료 일자를 설정한다.

• 설정 완료 이후 화면이다.

🔽 구현 코드

1. tmp 폴더에 이미지 임시 저장

사용자가 이미지를 업로드할 때, 아직 최종적으로 업데이트하지 않았으므로 이미지를 최종 저장소가 아닌 S3의 temp 폴더에 임시로 저장한다.

/**
 * S3 temp 폴더에 파일 업로드
 */
public String uploadImageToTemp(MultipartFile file) {
    String fileName = "temp/" + UUID.randomUUID() + "_" + file.getOriginalFilename();

    try {
        ObjectMetadata metadata = new ObjectMetadata();
        metadata.setContentLength(file.getSize());
        metadata.setContentType(file.getContentType());

        amazonS3.putObject(bucketName, fileName, file.getInputStream(), metadata);

        return amazonS3.getUrl(bucketName, fileName).toString();
    } catch (IOException e) {
        throw new S3Exception(S3ErrorCode.FILE_UPLOAD_ERROR);
    }
}

2. 사진 업데이트 버튼 클릭 시 이미지 이동

사용자가 사진 업데이트 버튼을 클릭하면, temp 폴더에 저장된 이미지를 main 폴더로 이동시킨다.

 /**
 * S3 temp 폴더에서 main 폴더로 파일 이동
 */
public void moveImagesToMain(List<String> imageUrls) {
    for (String imageUrl : imageUrls) {
        String decodedFileName = getDecodedFileName(imageUrl);

        String tempFileName = "temp/" + decodedFileName;
        String mainFileName = "main/" + decodedFileName;

        if (!doesDecodedImageExist(tempFileName)) {
            throw new S3Exception(S3ErrorCode.IMAGE_NOT_FOUND_ERROR);
        }

        // 파일 이동
        amazonS3.copyObject(bucketName, tempFileName, bucketName, mainFileName);

        // 원본 temp 파일 삭제
        amazonS3.deleteObject(bucketName, tempFileName);
    }
}

/**
 * 가게 정보를 업데이트합니다.
 */
@Transactional
public void updateMarket(Long marketId, MarketUpdateRequest marketUpdateRequest) {
    // 가게 조회
    Market market = marketRepository.findById(marketId)
            .orElseThrow(() -> new MemberException(MarketErrorCode.NOT_FOUND_MARKET_ID));

    // 한 줄 소개 업데이트
    market.updateSummary(marketUpdateRequest.getSummary());

    // 영업 시간 업데이트
    market.updateBusinessHours(marketUpdateRequest.getOpenAt(), marketUpdateRequest.getCloseAt());

    // 픽업 시간 업데이트
    market.updatePickUpHours(marketUpdateRequest.getPickupStartAt(), marketUpdateRequest.getPickupEndAt());

    // 가게 사진 업데이트
    updateMarketImages(market, marketUpdateRequest.getImageUrls());
    s3ImageService.moveImagesToMain(marketUpdateRequest.getImageUrls()); // S3 Bucket: temp -> main
}

3. S3에서 파일 삭제 메서드 수정

temp 폴더와 main 폴더가 나뉘었기 때문에, S3에서 파일을 삭제하는 로직도 이에 맞게 변경해야 한다. temp 폴더에 있는 파일은 S3 Lifecycle 규칙에 의해 자동으로 삭제되므로, main 폴더에 있을 경우에만 삭제하도록 수정한다.

/**
 * S3에서 파일 삭제
 * main 폴더에 있을 경우에만 삭제합니다.
 */
public void deleteImage(String imageUrl) {
    String decodedFileName = getDecodedFileName(imageUrl);
    String mainFileName = "main/" + decodedFileName;

    if (doesDecodedImageExist(mainFileName)) {
        amazonS3.deleteObject(bucketName, mainFileName);
    }
}

 

 

🔍 결과 관찰

5번과 6번 방법을 결합하여 문제를 성공적으로 해결했다.

• 사진을 업로드하는 API를 실행하면 이미지가 일시적으로 temp 폴더에 저장된다. 

• 이후, 사용자가 사진 업데이트 버튼을 누르면 이미지가 main 폴더로 이동된다.

• temp 폴더와 main 폴더가 각각 명확하게 분리되어 정상적으로 작동한다.

로직을 분리함으로써 각 작업의 책임을 명확히 할 수 있었고, S3 Lifecycle 규칙을 통해 고아 객체 문제를 해결했다. 이로써 데이터 정합성을 효과적으로 유지할 수 있었다.

 

 

💡 고찰

이번 해결책은 S3 버킷에 남는 고아 객체 문제를 해결하는 데 효과적이었지만, S3의 PutObject, deleteObject, copyObject 작업을 반복하면서 발생하는 트래픽 비용을 고려할 필요가 있다. S3는 요청에 비례해 비용이 발생하므로, 빈번한 이미지 업로드 및 삭제 작업이 이루어질 경우 예상치 못한 비용 증가가 발생할 수 있기 때문이다.

1. 서버 저장소를 활용한 비용 절감: 현재는 이미지를 즉시 temp 폴더에 저장하고 있으나, 이를 서버의 로컬 저장소나 캐시에 임시로 저장한 후, 필요할 때 S3로 업로드하는 방식으로 변경할 수 있다. 이 방법을 통해 S3와 데이터 전송 횟수를 줄이고, 4번 방식에서 설명한 스케줄러를 활용해 주기적으로 이미지를 S3로 업로드하는 방식으로 전환하면 효율성을 높일 수 있다.
2. AWS Lambda 활용: AWS Lambda를 사용하여 이벤트 기반으로 이미지를 관리하는 방식도 고려해 볼 수 있다. Lambda는 특정 이벤트(파일 업로드, 파일 미사용 기간 경과 등)가 발생할 때 자동으로 실행되므로, S3 버킷에 저장된 파일들을 주기적으로 관리할 수 있다. 이를 통해 불필요한 고아 객체를 자동으로 정리하고, 필요할 때에만 S3 작업을 수행하는 효율적인 방법을 도입할 수 있다.

 

추가적인 고찰로, 현재 사진을 업데이트할 S3 버킷의 기존 사진과 데이터베이스에 저장된 URL을 모두 삭제한 후, 새로운 사진을 S3 버킷에 업로드한 후 DB에 URL을 저장하는 덮어쓰기 방식을 사용하고 있다. 이 방식은 불필요하게 많은 쿼리가 발생하므로, 개선이 필요하다고 생각한다.

이와 관련된 사항을 개선했으며, 자세한 개선 내용은 여기를 참고하면 좋을 것 같다.

 

 

📍 참고 자료

• S3를 이용한 사용자의 고아 이미지 처리
• AWS S3 이미지 저장 및 삭제와 DB로직 트랜잭션 분리