Lambda에서는 겪지 않은 이미지 메모리 문제가 Spring에서 드러난 이유

디코딩 전에 해상도를 확인하고, N칸마다 한 픽셀만 읽는 서브샘플링으로 디코딩하고, 동시 디코딩 수를 제한했습니다. 운영과 같은 메모리 조건에서 7장이 실패하던 40MP 이미지 10장 동시 업로드가 모두 성공했습니다.

배경과 과제

배경

예전 프로젝트에서는 이미지 리사이즈를 AWS Lambda에서 했습니다. Lambda의 기본 설정은 인프라팀이 해 주었고 저는 그 위에서 도는 Node의 이미지 처리 코드만 작업했습니다. 원본이 S3에 올라오면 업로드 이벤트를 받은 Lambda가 sharp(Node 이미지 라이브러리)로 줄이고 압축해 리사이즈용 버킷에 새로 저장했습니다. 주로 0~30MB, 고화질도 20~30MB 정도의 이미지가 올라왔습니다.

sharp 옵션은 기본값에 크기만 지정한 정도였습니다. 그때 운영에서 이미지 처리 실패가 문제로 올라온 적은 없었습니다.

팔도곳간은 상품 이미지와 리뷰 사진을 POST /api/v1/media/{purpose}로 받아 긴 변 1600px 이하의 JPG로 바꿔 S3에 올립니다. 고치기 전에는 Content-Type(image/jpeg, image/png)과 파일 크기(10MB 이하)만 확인하고 ImageIO.read로 전체 디코딩한 뒤 Thumbnailator로 줄여 JPG(품질 0.75)로 압축했습니다.

운영 환경은 EC2 t2.large(메모리 8GiB) 한 대에 MySQL과 앱을 함께 띄웁니다. 앱 컨테이너는 mem_limit: 2560m, -XX:MaxRAMPercentage=75라서 힙은 약 1.9GB입니다. 개발 당시에는 모놀리스 구조라 미디어 업로드와 주문·결제·상품 조회가 이 힙을 같이 썼습니다.

핵심 과제

10MB 제한은 압축된 파일 크기 기준인데, 디코딩에 드는 메모리는 파일 크기와 상관없이 해상도로 정해집니다. 운영과 같은 메모리 조건의 컨테이너에서 40MP 이미지 10장을 동시에 올리니 7장이 메모리 부족(OOM)으로 실패했습니다.

설계 시 고려한 점

  • PNG는 같은 색으로 칠한 이미지를 약 1000:1까지 압축합니다. 16000×16000 16비트 RGBA PNG는 파일이 1.9MB지만 디코딩하면 약 1,953MB가 됩니다. 이런 압축 폭탄도 기존 검사(Content-Type, 10MB)를 모두 통과합니다.
  • 악의적인 파일만 문제인 것도 아닙니다. 40MP 해상도의 정상 사진도 16비트면 한 장에 약 300MB를 씁니다. 판매자 몇 명이 상품 이미지를 동시에 올리면 힙을 넘길 수 있습니다.
  • Lambda와 Spring 사이에는 두 가지 차이가 있었습니다. 라이브러리 쪽에서는 ImageIO.read가 원본 픽셀을 전부 메모리에 올리지만, sharp는 JPEG·WebP를 디코딩하면서 작게 읽고(shrink-on-load) 순차 읽기로 위에서부터 차례로 처리합니다. 구조 쪽에서는 Lambda는 요청마다 따로 메모리를 갖지만 모놀리스는 힙 하나를 모든 요청이 같이 씁니다. 라이브러리 차이는 Node 실험으로 쟀고, 구조 차이는 측정하지 않았습니다.

운영 제약

  • 이미지 변환은 S3 업로드 이벤트로 Lambda를 돌리거나 이미지 전용 서버를 두는 것이 정석입니다. 하지만 주어진 AWS 환경에서 쓸 수 있는 서비스가 제한적이라 Lambda도, 서버 추가도 어려웠습니다.
  • EC2 한 대에서 MySQL과 앱을 함께 돌려야 했습니다. 그래서 목표를 분리 없이, 이미지 처리가 서버 전체를 멈추지 못하게 만드는 것으로 잡았습니다.
  • t2는 CPU 크레딧을 모아 쓰는 버스트 인스턴스입니다. 디코딩·압축처럼 CPU를 오래 쓰는 작업이 쌓이면 크레딧이 바닥나 서버 전체가 느려지므로, 메모리와 함께 CPU도 아껴야 했습니다.

이미지 업로드 처리 흐름

고친 뒤에는 디코딩 전에 세 번 걸러냅니다

고치기 전에는 용량만 통과하면 곧바로 전체 디코딩으로 넘어갔습니다. 고친 뒤에는 무거운 디코딩에 닿기 전에 횟수, 동시 실행 수, 해상도로 걸러냅니다. 헤더 해상도 확인은 세마포어 안에서 합니다.

고친 뒤에는 디코딩 전에 세 번 걸러냅니다고치기 전에는 용량 검사 뒤 바로 전체 디코딩하고, 고친 뒤에는 횟수 제한, 용량 검사, 세마포어를 거쳐 세마포어 안에서 헤더 해상도를 확인하고 서브샘플링으로 디코딩한 뒤 축소해 S3에 저장하는 흐름고치기 전고친 뒤세마포어 안429413503 · 10초413용량 검사10MB 이하ImageIO.read전체 디코딩축소·JPG1600px · S3횟수 제한10분에 50회용량 검사10MB 이하세마포어서버당 1건헤더 해상도8000px · 40MP서브샘플링N칸마다 1픽셀축소·JPG1600px 이하디코딩 전 거절
고친 뒤에는 디코딩 전에 세 번 걸러냅니다고치기 전에는 용량 검사 뒤 바로 전체 디코딩하고, 고친 뒤에는 횟수 제한, 용량 검사, 세마포어를 거쳐 세마포어 안에서 헤더 해상도를 확인하고 서브샘플링으로 디코딩한 뒤 축소해 S3에 저장하는 흐름고치기 전고친 뒤세마포어 안429413503 ·10초413용량 검사10MB 이하ImageIO.read전체 디코딩축소·JPG1600px · S3횟수 제한10분에 50회용량 검사10MB 이하세마포어서버당 1건헤더 해상도8000px · 40MP서브샘플링N칸마다 1픽셀축소·JPG1600px 이하디코딩전 거절

새로 추가한 단계고친 뒤 없앤 단계(점선 테두리)

고치기 전·후 측정 결과

성공 건수
40MP 이미지 10장 동시 업로드에서 3건 → 10건 성공. 고치기 전 7건은 500(OOM)으로 실패했고 고친 뒤 마지막 요청은 5.0초에 끝났습니다.
컨테이너 최대 메모리
같은 시나리오에서 2,247MB → 1,123MB.
Full GC
같은 시나리오에서 16회 → 0회.
다른 API 최대 응답
1,052ms → 31ms. 업로드하는 동안 상품 목록 GET을 50ms마다 호출해 쟀고 고치기 전에도 실패한 호출은 없었습니다.
압축 폭탄
bomb8.png 2건 동시: 1건 500, 컨테이너 2,247MB → 2건 모두 413, 컨테이너 899MB. bomb16.png 1장(다른 요청 없음): 500(0.3초) → 413(0.05초).
서브샘플링 단독
이미지 처리 코드만 떼어 max40mp.png 1장으로 잰 값입니다. 처리 시간 2.4초 → 0.6초, 힙 증가 585MB → 74MB.
대가
한 번에 1건씩 처리하니 12MP 사진 10장을 다 끝내는 시간이 2.7초에서 2.9초로 늘었습니다. 503은 어느 시나리오에서도 나지 않았지만 운영 EC2는 측정한 PC보다 느려서 40MP처럼 큰 이미지를 여러 장 올리면 10초 대기를 넘겨 503이 날 수 있습니다.
측정 환경
M3 Pro와 Docker(CPU 2개, mem_limit 2560m), PutObject에 200만 돌려주는 가짜 S3로 쟀습니다. 운영 EC2와 같지 않아 시간은 운영보다 짧게 나오고, 요청도 같은 PC에서 보내 클라이언트→서버 전송 시간과 S3 업로드 시간이 빠져 있습니다. 메모리 한도와 힙 설정은 운영과 같게 맞춰 같은 메모리 한도에서 위험과 개선 효과를 재현했습니다. 운영 환경의 실패율과 지연은 따로 검증해야 합니다. 모든 시나리오는 단회 측정입니다. 컨테이너 메모리에는 JVM 자체가 쓰는 약 700~1,000MB가 포함됩니다.

핵심 구현과 판단

1. 운영과 같은 메모리 조건으로 재현

운영에서 겪은 장애가 아니어서 재현부터 했습니다. 앱 컨테이너를 운영과 같은 mem_limit: 2560m, -XX:MaxRAMPercentage=75(힙 약 1.9GB)로 두고 CPU는 2개로 제한했습니다. 고치기 전은 #210 직전 커밋(e9faaee), 고친 뒤는 현재 코드(70d3134)로 빌드했습니다. #210 이후 미디어 로직은 모듈 분리(#293) 외에 바뀌지 않았습니다. DB는 MySQL 컨테이너를, S3는 PutObject에 200만 돌려주는 가짜 서버를 썼습니다.

시나리오마다 앱 컨테이너를 새로 띄우고 업로드를 동시에 보내는 동안 상품 목록 GET을 50ms마다 호출해 다른 API가 영향을 받는지 봤습니다. 메모리는 컨테이너 cgroup의 최대 사용량으로, GC는 GC 로그로 쟀습니다. 시나리오마다 한 번씩만 잰 단회 측정입니다.

  • 입력 이미지는 픽셀이 모두 0인 PNG를 행 단위로 압축해 직접 만들었습니다. bomb16.png(16000×16000 16bit RGBA, 1.9MB, 디코딩 시 계산상 약 1,953MB), bomb8.png(20000×20000 8bit RGB, 1.1MB, 약 1,144MB), max40mp.png(7900×5000 16bit RGBA, 0.3MB, 약 301MB), normal24mp.png(6000×4000 8bit RGB, 0.07MB, 약 69MB)입니다. 사진처럼 압축되는 12MP·24MP JPEG(1.5MB, 2.2MB)도 따로 만들었습니다.
  • bomb16.png 1장: 0.3초 만에 500으로 끝났고 힙은 늘지 않았습니다. 요청한 배열이 힙 전체보다 커서 JVM이 할당을 바로 거절했고, PNG 리더가 이 OOM을 IIOException으로 감싸 던졌습니다. 이 파일은 서버를 멈추지 못합니다.
  • bomb8.png 1장: 3.9초 동안 힙이 1,823MB까지 올라갔고 컨테이너 메모리는 한도의 88%(2,251MB)까지 찼습니다. 힙 안에 들어가는 크기가 위험합니다. 2건을 동시에 넣으면 1건이 500으로 실패했습니다.
  • max40mp.png 10건 동시: 7건이 500(OOM)으로 실패하고 3건만 성공했습니다(약 7초). Full GC가 16번 돌았고 힙은 최대 1,896MB까지 찼습니다. 다른 API는 한 번도 실패하지 않았지만 응답 시간이 p99 496ms, 최대 1,052ms까지 늘었습니다.
  • "다른 API까지 멈춘다"는 재현되지 않았습니다. 재현된 것은 업로드 자체의 대량 실패, Full GC 반복, 다른 API의 응답 지연입니다.

2. 왜 sharp에서는 괜찮았나

같은 입력을 Node(sharp)에도 넣어 봤습니다. 비교를 위해 같은 API를 Node로 옮긴 실험 코드이고 운영 코드가 아닙니다. multer로 받아 sharp로 바로 리사이즈하는 흔한 첫 구현을 같은 컨테이너 조건(2,560MB, CPU 2개)에서 쟀습니다.

sharp는 헤더로 해상도를 확인해 거절하기(268MP), 디코딩하면서 작게 읽기(shrink-on-load, JPEG·WebP만), 위에서부터 차례로 읽으며 처리하기(순차 읽기)를 기본으로 켜 둡니다. 작게 읽기와 순차 읽기는 서로 다른 기능입니다. 기존 ImageIO.read 호출에는 이 방어가 하나도 없었고 앞의 두 가지는 ImageReader로 직접 구현했습니다.

구조도 다릅니다. Lambda는 실행 환경 하나가 한 번에 요청 하나만 처리해서 이미지 10장이 동시에 오면 실행 환경 10개가 각자 메모리를 갖고 돕니다. 모놀리스는 힙 하나를 업로드 10건과 주문·결제 API가 같이 씁니다. 그래서 Spring에는 sharp에도 없는 동시 실행 제한이 하나 더 필요했습니다. 이 부분은 AWS의 동작 방식에서 나온 설명이고 측정하지 않았습니다. 측정한 Node는 Lambda가 아니라 일반 서버입니다.

  • bomb16.png 1장: Spring 첫 구현은 500(OOM), Node(sharp)는 성공(1.4초, 컨테이너 289MB)했습니다. 268MP 한도 아래라 거절되지 않고 끝까지 처리됐는데, 원본 전체를 올렸다면 약 1,953MB가 필요합니다. sharp는 거절해서가 아니라 원본을 한 번에 올리지 않아서 버텼습니다.
  • bomb8.png 1장: Spring은 성공했지만 컨테이너 2,251MB를 썼고 sharp는 400MP라 픽셀 한도에 걸려 디코딩 전에 500으로 거절했습니다.
  • max40mp.png 10건 동시: Spring은 7건 실패, sharp는 10건 성공(컨테이너 814MB)했습니다.
  • 12MP JPEG 10건 동시: 둘 다 성공했고 컨테이너 메모리는 Spring 1,452MB, sharp 275MB였습니다.

3. 디코딩 전에 헤더로 해상도 확인

ImageIO.read 대신 ImageReader를 직접 씁니다. getWidth(0), getHeight(0)은 헤더만 읽고 픽셀은 풀지 않습니다. 한 변 8000px 또는 총 4천만 픽셀(40MP)을 넘으면 413으로 거절합니다. 스마트폰 기본 사진이 보통 12MP(4032×3024)라 일반 사용자는 걸리지 않습니다. 이 확인은 5번의 세마포어 안에서 합니다.

  • 픽셀 수는 int로 곱하면 오버플로가 나서 long으로 계산합니다. 지금은 한 변 8000px 검사가 먼저 걸러 주지만 그 검사가 없다면 50000×50000의 곱이 int 범위를 넘어 음수가 되고 총 픽셀 검사를 통과합니다.
  • ImageIO는 Content-Type이 아니라 파일 바이트를 보고 리더를 고릅니다. Content-Type은 클라이언트가 얼마든지 바꿀 수 있어서 허용 형식(JPEG, PNG)의 리더만 씁니다.

4. 서브샘플링으로 필요한 크기만큼만 디코딩

어차피 1600px 이하로 줄일 이미지라 원본 픽셀을 전부 올릴 필요가 없습니다. setSourceSubsampling으로 N칸마다 하나씩만 읽어서 원본 크기의 배열이 아예 생기지 않게 했습니다.

  • Thumbnailator에 파일을 그대로 넘겨도 내부에서 ImageIO로 전체 디코딩합니다. 그래서 디코딩을 직접 하고 그 사이에 해상도 검사와 서브샘플링을 끼워 넣었습니다.
  • 목표를 1600이 아니라 3200(저장 크기의 2배)으로 둔 것은 화질 때문입니다. 서브샘플링은 픽셀을 건너뛰어 계단 현상이 생기므로, 마지막 축소는 보간하는 Thumbnailator에 맡깁니다.
  • 7900×5000 이미지는 3칸마다 읽어 2634×1667이 되고 픽셀 데이터는 계산상 약 301MB에서 약 34MB로 줄어듭니다.

5. 서버별 동시 디코딩 수 제한

해상도 한도 안의 이미지도 몰리면 위험합니다. 헤더 확인과 디코딩부터 JPG 압축까지를 공정 모드 Semaphore로 감싸 서버당 한 번에 1건만 처리합니다. 10초를 기다려도 차례가 오지 않으면 503을 돌려줍니다.

한 가지로는 막을 수 없었습니다. 해상도 제한은 압축 폭탄을 막지만 동시 요청은 못 막고 동시 실행 제한만 두면 bomb8.png 한 장이 힙을 거의 다 씁니다.

  • 압축까지 감싼 이유: 디코딩한 원본은 압축이 끝날 때까지 메모리에 남아 있습니다.
  • 기다리는 이유: 판매자는 상품 이미지를 여러 장 한꺼번에 올립니다. 곧바로 거절하지 않고 최대 10초까지 차례를 기다립니다.
  • 서버별로 제한하는 이유: 메모리는 서버마다 따로 있는 자원입니다. Redis 같은 분산 락 없이 JVM 안의 세마포어로 충분하고 서버가 늘어도 그대로 맞습니다.

6. sharp로 돌아가 보면

Lambda에서 sharp를 기본값으로 쓴 것도 안전하지는 않았습니다. 메모리 문제가 드러나지 않았을 뿐입니다. 당시에는 처리 실패를 따로 추적하지 않아서 드러나지 않은 실패가 있었는지는 알 수 없습니다.

  • 268MP 한도는 서비스 기준보다 훨씬 높습니다. bomb16.png(256MP)는 한도 아래라 끝까지 처리됐고 처리에 1.4초가 걸렸습니다. 순차 읽기는 메모리를 아껴 줄 뿐 압축을 푸는 시간은 줄이지 못합니다. Lambda는 실행 시간만큼 요금을 내므로 이 시간은 곧 비용입니다.
  • bomb16.png 처리에 컨테이너 메모리 289MB가 들었습니다. 메모리를 작게 잡은 Lambda라면 sharp로도 실패할 수 있습니다. 당시 Lambda의 메모리 값은 확인할 수 없어서 이 가능성은 검증하지 못했습니다.
  • sharp의 기본 한도는 헤더만 읽는 metadata()에도 걸려서 268MP를 넘는 이미지가 해상도 초과(413)가 아니라 읽기 실패(400)로 나왔습니다. 헤더를 읽을 때는 기본 한도를 끄고 직접 비교해야 합니다.
  • 실험 코드에 Spring과 같은 방어(해상도 40MP, 동시 1건)를 넣자 bomb16.png와 bomb8.png는 413으로 거절됐고 max40mp.png 10장은 컨테이너 266MB로 처리됐습니다. sharp를 다시 쓴다면 limitInputPixels를 서비스 기준으로 낮춥니다.

주요 예외 처리

무거운 디코딩에 닿기 전에 걸러냅니다. 클라이언트가 고칠 문제는 4xx, 서버 사정은 5xx로 나눴습니다.

해상도가 한 변 8000px 또는 총 40MP를 넘는 이미지 (압축 폭탄 포함)

처리
세마포어 차례를 받은 뒤 헤더에서 가로·세로만 읽고, 디코딩하지 않고 413으로 거절합니다.
결과
다른 요청이 없을 때 bomb16.png는 0.05초 만에 413으로 끝나고 bomb8.png 2건 동시도 컨테이너 899MB에서 거절됩니다. 서버가 바쁘면 차례를 기다리다 10초가 지나 413이 아니라 503을 받을 수 있습니다.

해상도 한도 안의 큰 이미지가 동시에 몰리는 경우

처리
세마포어로 서버당 1건만 디코딩하고 나머지는 최대 10초까지 차례를 기다립니다. 10초 안에 차례가 오지 않으면 503을 돌려줍니다.
결과
max40mp.png 10건 동시가 모두 성공했고 Full GC는 0회였습니다. 측정한 시나리오에서는 503이 나지 않았습니다.

깨진 파일이나 허용하지 않은 형식의 파일

처리
파일 바이트로 고른 리더 중 허용 형식(JPEG, PNG)의 리더만 쓰고 깨진 파일은 400으로 응답합니다.
결과
클라이언트가 고칠 문제를 서버 오류(500)로 돌려주지 않습니다.
추가 예외 처리 1개

한 회원이 업로드를 반복하는 경우

처리
회원별로 10분에 50회까지 받고 넘으면 요청 맨 앞에서 429로 거절합니다.
결과
남용은 막지만 메모리 보호에는 도움이 안 됩니다. 횟수는 저장된 미디어로 세므로 디코딩에 실패한 요청은 들어가지 않습니다.

감수한 것과 남은 과제

동시 디코딩을 1건으로 둔 것은 처리량을 포기하고 안정성을 택한 결정입니다. 기다리는 동안 톰캣 스레드도 최대 10초 묶입니다. 판매자가 상품 하나에 이미지를 최대 10장 올리는 수준이라 감수했고 트래픽이 늘면 허용 수를 늘리거나 비동기 처리를 검토합니다.

헤더 해상도 확인도 세마포어 안에 있어서 서버가 바쁘면 압축 폭탄도 차례를 기다리다 503을 받을 수 있습니다. 헤더만 읽는 일은 가벼우므로, 세마포어 밖으로 빼서 기다리지 않고 바로 거절하는 것이 다음 과제입니다.

업로드 횟수 세기와 저장이 원자적이지 않아, 동시 요청 두 건이 같은 횟수를 읽고 둘 다 통과해 한도를 몇 건 넘길 수 있습니다. 목적이 남용 방지라 정확한 카운터 대신 이 오차를 받아들였습니다.

ImageDecodeLimiter 주석은 서브샘플링해도 한 건에 최대 약 160MB를 쓴다고 적었습니다. 허용 범위에서 크게 디코딩되는 6400×6250 16비트 RGBA(40MP)를 골라 쟀더니 최대 힙 증가가 159MB로 주석과 맞았고, 서브샘플링을 끄면 536MB였습니다. 이미지 하나로 잰 값이라 모든 허용 이미지의 상한을 보장하지는 않습니다.

남은 과제는 영상입니다. 영상은 디코딩 없이 원본 그대로 S3에 올려 메모리 문제는 아니지만, 서버가 중계만 하면서 톰캣 스레드와 대역을 붙잡습니다. presigned POST로 서버를 거치지 않고 S3에 직접 올리는 방향을 정리해 두었습니다.

제약이 풀리면 이미지도 presigned URL로 S3에 올리고 업로드 이벤트로 Lambda가 리사이즈하는 구조로 옮깁니다. 그러면 공유 힙을 보호하던 세마포어는 필요 없어지고, 서브샘플링과 해상도 제한은 Lambda 메모리에 맞춰 다시 검증합니다.

도구가 기본으로 해 주던 일을 알아야 다른 도구로 옮길 때 빠뜨리지 않습니다. Lambda에서 이 문제를 겪지 않은 것도 제가 막아서가 아니었습니다. 실험으로는 sharp의 기본값이 메모리를 아껴 준 것을 확인했고, Lambda의 구조가 준 영향은 측정하지 않았습니다.

ASK ME기준 ·이 글 · Lambda에서는 겪지 않은 이미지 메모리 문제가 Spring에서 드러난 이유

프로젝트, 담당 범위, 기술적 판단을 물어보세요.

추천 질문

포트폴리오에 작성된 내용으로만 답합니다