kjw81024 님의 블로그

WebSocket- NGINX 연결 오류

kjw81024 — Thu, 13 Aug 2026 11:03:18 +0900

영상 송출 및 person detection 을 Cloudflared 에서 WebSocket 으로 바꾸며 생겼던 오류 정리

문제 1 : ConnectionAbortedError [WinError 10053]

ConnectionAbortedError (연결 중단 오류) 는 네트워크 통신 중 상대방이나 로컬 소프트웨어 (firewall, vaccine) 이 활성 연결을 강제로 끊을 때 발생 -> 이미 맺어진 연결을 일부러 중단 시킴 -> 윈도우 소켓 스택이 abort 처리함

요청이 들어오면 NGINX 가 직접 처리할건지 backend 로 보내줄건지 결정

-> 이 요청을 받아서 뒤로 넘겨주는게 PROXY

근데 nginx.conf 에 192.158.x.x:4327/ws/xx 가 들어왔을 때 어떻게 하면 되는지 적혀있지 않아서

NGINX 가 백엔드로 넘기지 않고 본인이 처리하려고 함

-> 그래서 기본 동작 (정적 파일 서빙) 으로 처리하려다가 Websocket 을 어떻게 보낼지 몰라서 바로 연결을 끊음

-> abort 오류 발생

해결

(1) NGINX 에 이미 있는 conf 설정에 192.158.x.x:4327/ws/camera/ingest 를 backend proxy 하는 location 규칙을 추가하면 해결 됨

(해당 경로를 백엔드로 넘겨주라는 말을 추가해주는거니까!)

그걸 넣으면 똑같은 요청도 오류가 나지 않음

server {
    listen 4327;
    server_name 192.168.50.219;

    location /ws/ {
        proxy_pass http://localhost:8000;   # 백엔드(내부 8000)로 넘김
        proxy_http_version 1.1;
        # 추가 proxy 설정
    }
}

(2) 두번째 해결방법은 도메인 temp.url.co.kr 로 들어오는 요청은 이미 세팅되어서 돌아가고 있는 상황이기 때문에

규칙을 새로 파지 않고 , IP 를 192.168.x.x:4327 로 직접 연결하지 않고

proxy 되는 endpoint 로 전환 하기!!!

배포 서버 url = temp.url.co.kr/ws/camera/ingest 로 연결하니까 연결 이후에 바로 연결 끊김/ 실패가 뜨는게 사라짐

# 이 명령어에서 ws url 부분을 
python3 camera_daemon.py --source --backend --ws-url--ws-token

# 기존
--ws-url ws://192.168.x.x:4327/ws/camera/ingest

# 수정 
--ws-url wss://temp.url.co.kr/ws/camera/ingest

이번엔 (1) 대신 (2) 를 선택햇는데

왜냐하면... IP:4327 로 들어오는 요청은 오류 메시지에서 보이다시피 ws:// 로 시작함

근데 도메인은 HTTPS 니까 Websocket 도 wss://

암호화 된 WebSocket 으로 붙는게 훨씬 좋기 때문에 IP 를 하드코딩하여 nginx 에 추가하지 않고 실행 방법을 수정했다

잘 돌아감!

문제 2: 잘 고치고 나니까 새로운 오류가 떴다 ... WebSocketBadStatusException

[ws][WARN] 연결 끊김/실패: WebSocketBadStatusException:
Handshake status 400 None ... b'Can "Upgrade" only to "WebSocket".'

이번에는 해겨책이 에러메시지에 포함되어서 나왔다

Can "Upgrade" only to "WebSocket" 웹소켓은 Upgrade 로 바꿔달라는 의미

client 는 upgrade websocket 헤더를 붙여서 handshake 요청을 보내는데

이 때 NGINX 가 Upgrade 헤더를 백엔드로 안 넘겨주면 그냥 HTTP 요청으로 받기 때문에 오류가 난다

(NGINX 가 backend 로 어떻게 넘겨주는지는... 얘가 proxy 서버라 거기까진 관리자 모드로 확인이 불가능하긴 하다)

일단 이런 오류가 발생했을 때 NGINX /ws/ location 에 Upgrade 전달 설정을 추가해주기

location /ws/ {
    proxy_pass http://localhost:8000;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
}

Upgrade header 는 client 가 만들지만, NGINX 가 그걸 backend 로 전달해줘야 handshake 가 완성

문제 3

오류가 전혀 안 뜨는 상황에서 카메라 화면이 미리보기 화면으로만 드고 CCTV 처럼 송출이 안 된다 ....

Tomcat WebSocket 메시지 버퍼 기본값이 8KB 인데 JPEG 가 n00KB 라 크기 제한을 넘어버려서 프레임이 거부되는 현상이었다 ... 연결은 유지되지만 프레임이 안 넘어가는 문제

해결: 백엔드 WebSocket Config 에서 ServletServerContainerFactoryBean 의 버퍼 크기를 1MB 로 올리기

text 랑 binary 둘 다

private static final int WS_MAX_MESSAGE_BYTES = 1024 * 1024; // 1MB
container.setMaxTextMessageBufferSize(WS_MAX_MESSAGE_BYTES);
container.setMaxBinaryMessageBufferSize(WS_MAX_MESSAGE_BYTES);

다 해결하고 나니까.....

잘 뜸!

그새 좀 늙은듯한 나............ ㅎ

WebSocket 개념 정리

kjw81024 — Tue, 11 Aug 2026 15:29:29 +0900

국비지원 부캠 수업을 들을 때 Websocket 을 다루는 역할을 맡지 않아서 이번에 인턴하면서 Websocket 개념이랑 ...

몰라서 생긴 여러 트러블슈팅을 정리하고 넘어가기

이번에 프로젝트에서 사용한 이유는

crowd count, 영상 CCTV 처럼 송출 이 필요한데 그 때마다 client (dashboard) 에 즉시 알려줘야 하기 땜누에 HTTP polling 보다 효율적인 방식인 Websocket 사용이었다

특징

비교 대상: HTTP

HTTP	응답 이후 연결이 끊김 (매번 새로 요청, 검증) keyword: 비연결, 무상태
WebSocket	한 번 연결하면 계속 유지 server -> client 방향으로 먼저 데이터 보낼 수 있음 (양방향)

ws:// 랑 wss:// 는 Http 랑 동일하게 암호화 여부 (s 가 붙은게 security)

만약 사용하는 서버가 https://tempurl.co.kr 로 서빙되면 반드시 wss:// 를 사용하기

아니면 브라우저가 Mixed Content 에러를 띄운다고 함 (Https page 에서 암호화 안 된 연결을 시도하는거니까!)

연결 과정을 Handshake 라고 부르는 듯 함 귀엽다.!! 악수라니

1. client 가 일반 HTTP 요청을 보낼 때 header 에 Upgrade: websocket 이 포함됨

프론트 코드에서 아래 한 줄을 실행하면

const ws = new WebSocket("wss://temp.url.co.kr/ws/crowd");

브라우저가

GET /ws/crowd HTTP/1.1
Host: tmep.url.co.kr
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: xxxxx
Sec-WebSocket-Version: 13

요런 헤더가 붙은 HTTP 요청을 만들어서 보냄

이 설정이 NGINX 에서 해주는 아래 설정

location /ws/ {
    proxy_pass http://localhost:8000;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
}

Upgrade 요청을 붙여주기

2. 서버가 101 Switching Protocols 응답하면 그때부터 HTTP 연결이 WebSocket 연결로 upgrade 됨

3. 이후로 계속 열린 채널로 메시지 주고 받기
(매번 요청을 새로 쓸 필요 없어짐)

추가

기억해둘만한 WebSocket 객체의 기본 이벤트

ws.onopen = () => console.log("연결됨");
ws.onmessage = (event) => console.log("데이터 옴:", event.data);
ws.onerror = (error) => console.log("에러:", error);
ws.onclose = () => console.log("연결 끊김");

특히 onmessage 에서 event.data 가 문자열로 오기 때문에 JSON.parse(data) 해줘야함!!!

추가로 onclose 되면 재시도를 해줘야하기 때문에 특정 시간 이후에 재시도 하는 로직을 추가해주는게 좋다

ws.onclose = () => {
  setTimeout(() => connectWebSocket(), 3000); // 3초 뒤 재시도
};

++ 백엔드 서버 하나랑만 연결 가능함 - 한 번 연결된 백엔드 인스턴스랑 계속 붙어있어야한다

WebSocket 프로토콜에는 ping/pong 이 있는데 java script 브라우저 에는 native ping 을 보내는 api 가 X

-> 근데 NGINX 의 proxy_read_timeout 은 backend 로부터 아무런 데이터가 안오는걸 기준으로 count 를 세기 때문에

가짜메시지... 평범한 메시지를 주기적으로 보내는 방식 사용

const ws = new WebSocket("wss://temp.url.co.kr/ws/crowd");

setInterval(() => {
  if (ws.readyState === WebSocket.OPEN) {
    ws.send(JSON.stringify({ type: "ping" }));
  }
}, 30000); // 30초마다 살아있다고 알림

client (front) 에서 이렇게 보내주면

@Override
protected void handleTextMessage(WebSocketSession session, TextMessage message) {
    if (message.getPayload().contains("\"type\":\"ping\"")) {
        session.sendMessage(new TextMessage("{\"type\":\"pong\"}"));
        return;
    }
    // 나머지 로직...
}

Spring Boot 쪽 WebSocket Handler 가 이렇게 받아서... 연결이 안 끊기게 해줌

NGINX 개념 정리

kjw81024 — Tue, 11 Aug 2026 11:32:02 +0900

NGINX: 웹서버이자 리버스 프록시 서버 ..... 라는데 뭐라는지 모르겠다.... ㅜㅜ

클라이언트 요청을 받아서 뒤의 실제 application server 로 전달

역할

1. 외부 요청을 내부 백엔드로 전달

2. react 빌드 결과물 같은 정적 파일을 직접 응답 (백엔드까지 가지 않음)

3. LB (로드밸런싱) : backend instance 가 여러개일때 분산시킴

proxy-pass : 이 위치로 들어온 요청을 내가 지정한 다른 주소로 그대로 넘겨줘!! 라는 의미

location /api/ {
    proxy_pass http://localhost:8000;
}

이렇게 적혀있으면 /api/ 로 시작하는 요청이 들어오면 localhost:8000 으로 전달해주라는 의미

(1) client가 배포_URL/api/xxx 로 요청을 보내면

-> (2) nginx 가 받아서 localhost:8000/api/xxx 로 다시 요청을 보냄 (서버 내부 상황)

-> (3) 백엔드가 응답하면

-> (4) nginx 가 다시 client 한테 돌려줌

이 때 client 는 1, 3만 알고 f12 개발자 도구를 봐도 (2), (3) 은 알 수 없음

react build 같은 정적 파일을 직접 응답

빌드 전에는 이런식의 .tsx, .jsx 같은 형태의 파일들로 작성됨

-> 얘는 브라우저, nginx 둘 다 못 읽기 때문에 컴파일이 필요

npm run build

같은 프론트엔드 실행 코드를 쓰면 Vite 가 모든 코드를 순수 JS 로 변환 -> 파일을 묶거나 압축해서

dist/
  index.html
  assets/index-a1b2c3.js   # 순수 JavaScript
  assets/index-a1b2c3.css  # 순수 CSS

요런 파일로 뱉어냄 (이 시점에ㅓㅅ react 라는건 파일상으로 존재 X - 복잡한 부분들은 빌드할때 다 처리됨 )

NGINX 는 dist/ 폴더를 보고

/요청이 왔으니까 index.html 파일 내용을 복사해서 응답 보내기

/assets/contents.js 요청이 오니까 그 파일 내용 복사해서 응답 보내기... 등등을 함

location / {
    root /path/to/front/dist;
    try_files $uri /index.html;
}

화면을 그린다는건 브라우저 안에서 일어나는 일

브라우저가 NGINX 가 던져줘서 다운로드 한 JS 코드를 실행 -> 화면에 컴포넌트가 그려지고 ... 이벤트가 붙고... 라우팅 됨

그러니까 렌더링이라는 실제 작업은 사용자 브라우저의 컴퓨터에서 일어남

결론! NGINX 가 정적파일을 직접 응답한다는 말은 파일을 나눠주는 분배자 느낌이라고 보면 됨

로드밸런싱은 말 그대로... 요청이 들어오면 나눠져있는 여러 백엔드 인스턴스에게 값을 분배해주는거

설정 구조

server {
    listen 80;
    server_name temp.serverurl.co.kr;

    location / {
        root /path/to/front/dist;   # 정적 파일
        try_files $uri /index.html; # SPA 라우팅 대응
    }

    location /api/ {
        proxy_pass http://localhost:8000; # 백엔드로 전달
    }
}

location: URL 경로별로 다르게 처리하겠다는 규칙

proxy_pass: 이 경로는 다른 서버로 넘김

try-files: 파일 없으면 이거 시도하기 -> 404 방지

nginx.conf 는 관심사 분리 기준으로 두기~~

nginx 가 프론트 서빙용이라면 front repo 에 둬도 되고 (nginx.conf 가 프론트 docker image 안에 포함되는 상황)

여러 서비스를 총괄하는 진입점이면 별도 infra repo 에 두는게 좋음

추가

설정 파일을 수정하고 nginx 를 그냥 재시작하면 문법 오류 있을 때 서비스가 통째로 다운될 수 있음

sudo nginx -t              # 문법 검사만, 실제 반영 안 함
sudo nginx -s reload       # 무중단으로 설정만 다시 읽음 (재시작 X)

이 순서로 확인해주는 습관이 국룰이다

오류가생겼는데 backend log 가 텅 비었을 때 : nginx 선에서 막혔을 가능성을 고려해서 nginx error log 를 확인해주자!

/var/log/nginx/access.log   # 어떤 요청이 들어왔는지
/var/log/nginx/error.log    # nginx 레벨에서 뭔가 실패했을 때 (백엔드 연결 실패 등)

pip3 install 트러블슈팅

kjw81024 — Tue, 11 Aug 2026 10:33:59 +0900

python : python interpreter 를 실행시키는 명령어

python3 은 말 그대로 python3 버전 인터프리터...

왜 1이랑 2는 없는거지 했는데 옛날에는 python2, python3 이 같이 설치되어 있었기 때문에 버전 구분이 필요해서 3만 따로 생긴듯

pip, pip3 은 package 설치 도구

pip3 을 안 붙이면 PATH 에 잡힌 기본 pip 를 가리킴 (2일수도..있음)

문제

# cv2 를 사용하는 python 파일 실행했는데 cv2가 없다고 함 

PS C:\Users\user\Documents\ai-cms\docs\tools> python3 test_person_count.py
Traceback (most recent call last):
  File "C:\Users\user\Documents\ai-cms\docs\tools\test_person_count.py", line 7, in <module>
    import cv2
ModuleNotFoundError: No module named 'cv2'

# cv2 를 설치하려고 하니까 이미 존재 (Requirement already satisfied) 

PS C:\Users\user\Documents\ai-cms\docs\tools> pip3 install opencv-contrib-python
Requirement already satisfied: opencv-contrib-python in c:\users\user\appdata\local\programs\python\python312\lib\site-packages (5.0.0.93)
Requirement already satisfied: numpy>=2 in c:\users\user\appdata\local\programs\python\python312\lib\site-packages (from opencv-contrib-python) (2.5.1)
[notice] A new release of pip is available: 25.0.1 -> 26.2.1
[notice] To update, run: python.exe -m pip install --upgrade pip

나는 이런 문제가 발생했다 ....

필요한 패키지가 없어서 오류가 뜸 -> pip3 으로 install 받으려고 했는데 이미 있다고 함... < 예???

원인

python3 이랑 pip3 이 서로 다른 pyrhon 설치본을 가리키고 있어서 뜨는 오류

where.exe python3
where.exe pip3

python3, pip3 이 각각 어떤 실행파일, 인터프리터를 쓰는지 확인하는 명령어로 확인해보니

둘이 다른 경로를 가리키고 있음 => 다른 설치본

해결 과정

일단 진짜 설치본보다 PATH 우선순위가 높아서 이상한곳으로 연결되는 경우가 흔하다고 해서

설정 - 앱 - 고급 앱 설ㄹ정 - 앱 실행 별칭 에서 꺼줬다

그리고 powershell 에서 python list 를 확인

python 3.14.7 이 설치되어 있었다...! uninstall 해주기 -> 3.12 만 남김

py --list
pythonmanager uninstall 3.14

앞으로 실행할때 py -3.12 로 명시하는 습관 들여두면 이후에 다른 python 버전을 다운받을때도 편하다고 한다

아니면 아예 python 이 참조하는 site-packages 에 설치되어 꼬이지 않도록 명시해주는 방법 사용하기 (아마 얘가 제일 편한듯)

python -m pip install xxx

pip install xxx 는 path 에 잡힌 pip 실행 파일을 그대로 실행 -> 어떤 pyhton 에 연결된 pip 인지 헷갈림

python3 -m pip install xxx -> 지금 사용중인 python3 인터프리터에 정확하게 연결

해결 2

개별 venv (가상 환경 - virtual environment) 사용

# 가상환경 생성
python3 -m venv venv

# 가상환경 활성화
source venv/bin/activate

# 가상환경 활성화 (windows)
venv\Scripts\activate

# 활성화된 상태에서는 그냥 pip, python 써도 안전함
pip install xxx

이러면 pip, python 이 다른데를 안 봄

cloudflared 사용

kjw81024 — Fri, 7 Aug 2026 16:54:11 +0900

사람 수 카운트는 POST api 로 5초에 한 번씩 숫자만 보내주면 되는 형식

대표님 (ㄷㄷ) 요구사항으로 추가되는 기능이 CCTV 처럼 카메라가 비추는 화면을 확인할 수 있으면 좋을 것 같다고 하심

나는 그냥 사진 post 하던거랑 비슷하게 프레임 하나하나 post 하면 되는건가? 했는데 숫자 하나 보내는거랑은 다르다고 해서 ai 한테 무슨 차이인지 물어봤다

1) 프레임마다 POST 를 따로 날리면 요청마다 헤더 + 왕복시간 + 초당 10~15 프레임 뽑으려면 부담이 커짐

2) count POST 요청은 5초에 한번이라 가능하지만... 얘는 초당 몇 장씩 백엔드 -> 프론트 로 넘어가는거니까 트래픽 과도

-> 터널 URL 로 MJPEG 스트림을 순서대로 받는 개념은 똑같지만, 요청을 매번 새로 여는 것이 아니라 연결 하나를 계속 열어둔 채로 프레임을 이어붙여 보낸느 방식이 필요해짐 (요청-응답 오버헤드 TCP, TLS handshake 등이 X)

추가로 영상 스트림 주소 (camera_url) 이 노트북 로컬 IP 로 적혀있으면 같은 wifi 에 있는 사람만 배포서버 front 에 띄워지는 영상을 볼 수 있는 문제가 있기 때문에

로컬 스트림도 외부에서 접근 가능한 주소 필요 !!!!

결론: cloudflared 를 씁시다...

먼저 cloudflared 는 터널링 도구

내 로컬 서버 localhost 를 외부 접근 가능 공개 URL 로 노출시켜주는 역할

(1) cloudflared 가 내 컴퓨터에서 cloudflare edge server 로 outbound 연결을 먼저 맺고

(2) 연결을 하면 공개 URL 이 생김

(3) 그 URL 로 들어오는 요청을 내 localhost 포트로 그대로 relay

-> 내가 따로 inbound port 열 필요 X,

ngrok 이랑 비슷한 느낌

포트포워딩, 공유기 설정 없이 바로 사용할 수 있음 (공개 IP 없어도 , CGNAT 이어도 가능)

[카메라] → [메인 스레드] ─ YOLO 검출 → count 백엔드로 POST
└ 프레임 JPEG 인코딩 → 공유 버퍼
[서브 스레드(HTTP 서버)] ─ GET /video_feed → 공유 버퍼를 MJPEG로 스트리밍

설치방법...

최근에 맥이랑 윈도우 왔다갔다 쓰려니까 정신 나갈 것 같다........

둘 다 적어놓는걸로

# mac
brew install cloudflared

# windows
winget install --id Cloudflare.cloudflared

실행은

cloudflared tunnel --url http://localhost:8090

이렇게 하면 된다

이런 화면이 쭉쭉 내려가는데 (시간이 약간 소요됨)

첫번째 네모에 있는 quick tunnel 메시지 아래 https:// xxxx.trycloudflare.com 주소가 공개 URL 이다

이제 저 공개 URL 을 복사해서

python3 camera_daemon.py \
    --source 0 \
    --public-url https://ind-agent-poison-founded.trycloudflare.com/video_feed \ 
    --backend https://xxx/api/crowd/live

이런식으로 명령을 보내주면 영상이 송출되는것을 확인할 수 있음

(참고로 이 때 생기는 공개 url 은 cloudflared 를 실행시키는 터미널이 꺼지면 같이 꺼지니까 매번 실행시켜서 새로운 값을 넣어줘야함)

사용한 코드는 대충 아래 부분을 필수적으로 넣어줬다

_latest_jpeg = None
_lock = threading.Lock()

# --- MJPEG 서버 (stdlib만, flask 불필요) ---
class MJPEGHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header("Content-Type", "multipart/x-mixed-replace; boundary=frame")
        self.end_headers()
        while True:
            with _lock:
                jpg = _latest_jpeg
            if jpg is None:
                time.sleep(0.05); continue
            self.wfile.write(b"--frame\r\n")
            self.wfile.write(b"Content-Type: image/jpeg\r\n\r\n")
            self.wfile.write(jpg + b"\r\n")

# 카메라 루프를 안 막게 데몬 스레드로 서버 실행
server = ThreadingHTTPServer(("0.0.0.0", 8090), MJPEGHandler)
threading.Thread(target=server.serve_forever, daemon=True).start()

# --- 카메라 루프 (카메라 소유자) ---
while True:
    ret, frame = cap.read()
    results = model(frame, classes=[0])           # YOLO 사람 검출
    count = len(results[0].boxes)                 # → 백엔드로 POST

    ok, buf = cv2.imencode(".jpg", results[0].plot())  # 박스 그린 프레임
    if ok:
        with _lock:
            _latest_jpeg = buf.tobytes()          # 공유 버퍼 갱신

... 사실 AI 한테 짜달라고 하면 잘 짜준다

짠 코드를 적당히 읽어보고 어색한 부분 물어보면서 고치면 됨...!!!!

좀 밤티같긴 하지만 잘 나옴, 인식도 잘 되고 프레임도 나쁘지않게 들어온다

원래 목표였던 제 3의 client 도 잘 보이는지 확인

핸드폰 캡처

배터리 23퍼센트.ㅎ

데이터 키고도 잘 보인다 화면 !!

돌리다보면 cloudflared 를 켜둔 터미널창에 아래와 같은 오류가 뜨는데 (가끔????)

시각	에러	의미	심각도
07:15	connection refused	8090에 서버 없음	❌ (근데 이제 해결됨)
07:26	stream canceled, code 0	브라우저가 스트림 연결 정상 종료	⚠️ 대체로 무해

요런거라고 하고

나는 자동으로 해결됐다 아마 초반에 렉걸려서 8090 서버 못 찾아서 생긴 문제인듯?!

터미널에서 한글이 깨짐

kjw81024 — Thu, 6 Aug 2026 10:52:14 +0900

맥북에 있던 내용을 데스크탑으로 싹 옮기면서

JDK 랑 도커랑 ... IDE 랑 등등 다운을 받고 ./gradlew 실행을 시켜봄

쒕뱶?꾨즺.....ㅋ

콘솔이 UTF-8 로그를 못 읽어서 화면에서 깨져보이는거라구 함

chcp 65001

이걸 terminal 에 치고 run 하면 되는데 터미널 시작 할 때 마다 쳐야함 ...

개발단계라 여러번 터미널을 닫고 켜서 귀찮기 때문에 영구 설정을 해보기로 했다

notepad $PROFILE

파워쉘 프로필을 열어 설정해주면 되는데

나는 저 명령어를 치니까 메모장이 뜨더니 지정된 경로를 찾을 수 없다는 오류가 발생

프로필이 가리키는 파일/폴더 가 존재하지 않아서 뜨는 것 ...

빈 메모장에 쳐도 되는데 그럼 저장할 폴더가 애매해지기 때문에 폴더부터 만들어줬다

if (!(Test-Path $PROFILE)) { New-Item -ItemType File -Path $PROFILE -Force }

프로필 경로가 없다면 강제로 새 파일을 만들어서 저장하겠다는 의미

그 다음 notepad 명령어를 치면

요런 파일 이름으로 뜬다

적용해주고싶었던건 UTF-8 을 읽는거니까 ..

[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
$OutputEncoding = [System.Text.Encoding]::UTF8

위 내용을 넣어주고 저장

그러고 바로 실행시키려고 하면

이런 오류가 뜸....

이 시스템에서 스크립트를 실행 할 수 없으므로 PowerShell_profile,ps1 파일을 로드할 수 없다 .......

프로필 파일은 만들어졌지만 PowerShell 실행 정책 때문에 프로필 스크립트 로드가 막힘

기본적으로 파워쉘이 스크립트 실행을 막기 때문 (보안...)

현재 사용자만 스크립트 허용해주기

Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned

무슨 의미인지 검색해보니까

RemoteSigned = 내가 로컬에서 만든 스크립트(프로필 같은 거)는 실행 허용, 인터넷에서 받은 건 서명 있어야 실행 → 안전하면서 프로필은 잘 돌아감
CurrentUser = 시스템 전체 안 건드리고 내 계정만 → 관리자 권한 불필요

뭐... 이런거라고 한다 ...... 잘 모름 ㅎ,,,

친 다음 터미널을 새로 열어주고 실행시키면 된다!

빨간 글씨도 안 뜨고 안 깨진 상태로 잘 출력되는 모습

PostgreSQL (Docker) 접속 (로컬)

kjw81024 — Tue, 4 Aug 2026 12:04:21 +0900

로컬 개발 DB 를 접속하려고 하는데

지금 인턴하면서 스는 cursor 에는 내장 SQL 실행기가 따로 없다고 해서 터미널에서 docker exec 으로 여는거 메모

1. 컨테이너 이름 확인하기

docker ps

맨 뒤에 있는 NAMES 를 기억하면 된다

지금 접속하려고 하는건 postgres 니까 aicms-dev-postgres 를 기억하기 !

IMAGE 이름이랑 착각하지 않게 조심....

2. psql 접속

docker exec -it <NAMES> psql -U <USER> -d <DB명>

-it 는 psql 프롬프트로 들어간다는 의미

-U 뒤에는 DB 유저 (사수님께서 보내주셨다 ㅎ)

-d 뒤에는 DB 이름 (이것두..)

그냥 접속 정보는 docker-compose.yml 또는 application.yml 파일에 가면 알 수 있다고 하심

명령어를 잘 입력했다면

터미널 입력 창이

<DB명>=#

로 바뀌었다

3. 쿼리문 작성

터미널 창에서 찾고싶은 정보같은걸 SELECT 문을 사용하여 바로 찾아주면 됨!

추가.

만약에 접속까진 안 하고 바로 실행해보고싶으면

docker exec -it <NAMES> psql -U <USER> -d <DB명> -c "SELECT count(*) FROM contents;"

-c 가 쿼리를 한 번 실행하고 바로 빠져나온다는 뜻이라고 함!

근데 그냥 접속하는게 편할 것 같긴 하다

트러블슈팅

긴 쿼리를 클로드한테 부탁해서 붙여넣었는데 오류가 났다

사용한적도 없는 이상한 모양의 A 가 입력되었다고 함

이유: 채팅/ 문서에서 명령어를 복사하면 하이픈 ( - ) 이 대시로 바뀌는 경우가 있어서 생기는 문제라고 한다 ....

그래서 짧은 쿼리 안 쓰고 그냥 접속해서 했음 ㅎㅎ...

사실 손으로 다 치면 생기지 않는 문제라 간단히 하고 패스

UnsatisfiedLinkError 트러블슈팅

kjw81024 — Mon, 3 Aug 2026 18:00:48 +0900

인턴 하면서 노트북 필요하다고 그래서 친구한테 맥북을 빌려왔다......

처음 써보는 맥북이라 더 헤매는 중인듯

와서 프로젝트 파악을 하면서 테스트를 돌려보고 있었늗네

./gradlew test로 실행하니까 다른 테스트 40개는 성공하는데 AiMediaTest의 두 개 테스트만 실패

java.lang.UnsatisfiedLinkError
java.lang.NoClassDefFoundError

OpenCV를 사용하는 테스트에서만 오류가 발생한다는걸 알았다.

이 프로젝트는 AI 로 영상을 제작해서 화면에 띄우는 프로젝트인데

OpenCV 랑 FFmpeg를 사용

os 에 맞는 native library (.dll, .so, .dylib)을 함께 사용하는 프로젝트

-> 현재 실행중인 운영체제 (난 arm64) 랑 CPU 아키텍처에 맞는 네이티브 라이브러리가 반드시 로드되어야 함

맥이 어떤 CPU 아키텍처인지 확인하는 쉬운 방법

uname -m

해봤더니 arm64 가 떴고, 참고로 Apple Silicon(M1, M2, M3)은 모두 arm64를 사용한다고 한다

일단 마저 gradle properties 를 확인해보니까 platfrom 이 linux-x86_64전용

나를 위한 네이티브 바이너리는 없었다......

즉 프로젝트는 linux-x86_64 용 OpenCV이고 내가 실행시키는 환경은 macOS arm64 라서 JVM 이 라이브러리 로딩에 실패해서 UnsatisfiedLinkError 가 뜬다

위에 잇는 NoClassDefFoundError 발생 이유

OpenCV 관련 클래스가 로딩되는 과정에서 내부적으로 네이티브 라이브러리를 먼저 불러오는데

네이티브 라이브러리 로드 실패
↓
클래스 초기화 실패
↓
NoClassDefFoundError

순서로 돌아가서 초기화 실패 때문에 오류가 뜬 것...

해결

공용 설정 파일(back/gradle.properties)은 Docker와 CI 서버에서도 사용하기 때문에 수정하면 안 되고

내 로컬에서만 Gradle 전역 설정을 넣어줬다

# .gradle/gradle.properties 파일

javacppPlatform=macosx-arm64

그리고 쓸데없이 돌아가는 Gradle demon 은 죽임

./gradlew --stop

Gradle 데몬이 백그라운드에 계속 떠 있으면서 이전 javacppPlatform 값을 캐싱하고 있어서 옛날에 저장되어있던 linux-x86-64 값을 계속 가지고 있게 되기 때문....

얘때문에 고쳐졌는데도 고쳐졌는지 몰랏다

그다음 테스트 할 때는 cursor 말고 별도 터미널에서 실행시킴으로써 해결할 수 잇엇다

실시간 카메라 - 백엔드 서버 연결

kjw81024 — Mon, 3 Aug 2026 17:57:31 +0900

목업으로 처리하고 있던 유동인구 정보를 실제 카메라에 잡히는 인원으로 추정할 수 있도록 하는 과정

인구를 감지하는 방법중 제시한건 2개

1 그냥 그 때 그 때 화면에 나오는 사람 수를 기준으로 추정하는 방법과

2 특정 사람을 인식해서 몇 명 정도인지 대략 측정하는 방법 (중복으로 카운트 되지 않도록 함)

2번은 최대 가능한 인원이 3개정도고, 가격이 너무 비싼 문제 등 여러가지 하자가 많았기 때문에 1을 선택했다.

1에서도 4개로 나눌 수 있었고 간단하게 정리했다

	연결 방법
웹캠 구매	라즈베리파이 사용 -> 직접 웹캠을 연결
맥북 등 노트북 카메라 사용	그냥 터미널에서 돌리면 됨
아이폰 연결	와이파이 스트림 사용 (맥북이나 라즈베리파이 아무거나 상관 x)
안드로이드 연결	라즈베리파이 (USB 웹캠 모드로 하고 파이랑 연결)

그중 아이폰 연결은 와이파이 스트림 (동일 와이파이를 사용하는 경우에 한함) 으로 연결하는 방식이었고

앱을 깔아서 진행했다. 사용한 앱은 SIMPLE IP CAM

들어가면 FPS 나 해상도 ? 등을 조정할 수 있었고

http://x.x.x.x:8080/stream.mjpg

조정 이후 Start server 누르면 이런 큐알 화면으로 이동

굳이 큐알을 사용할 필요는 없고 저 밑에잇는 URL 로 사용하면 됨

지금 나는 보이다시피 데이터로 연결되어있어서 0.0.0.0 으로 뜨지만 와이파이 연결하면 그 ip 번호로 뜨고

비디오 화면 코드에 해당 url 값을 넣어주면 된다.

# webcam, android, macbook
cap = cv2.VideoCapture(0)
# iphone
cap = cv2.VedioCapture("http://x.x.x.x:8080/stream.mjpg")

코드는 처음에

"""
사람 수 검출 테스트 스크립트 (터미널 5초 주기 최대치 출력 버전)
- 화면 창: 실시간 박스 표시 (기존과 동일)
- 터미널: 5초마다 그 구간 동안 감지된 인원수의 최대값을 출력
- 종료: 영상 창 활성화 상태에서 'q' 키
"""
import cv2
import time
import requests

# 로컬 테스트용
# BACKEND_URL = "http://localhost:8000/api/crowd/live"

# 배포용 
BACKEND_URL = "http://x.x.x.x:4327/api/crowd/live"

# 경로는 백엔드 확정 후 교체
last_sent = 0


hog = cv2.HOGDescriptor()
hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())

# 1. 아이폰 카메라 (Simple IP Camera) 사용하여 연결
# cap = cv2.VideoCapture("http://x.x.x.x:8080/stream.mjpg")

# 2. 노트북 카메라, 웹캠, 안드로이드 USB-C 카메라 사용하여 연결
# 추가: 웹캠이랑 안드로이드 USB-C 사용하는 경우 라즈베리파이 필요 
cap = cv2.VideoCapture(0)

if not cap.isOpened():
    print("카메라를 열 수 없습니다.")
    print("- 맥북이면: 시스템 설정 > 개인정보 보호 및 보안 > 카메라에서 터미널 권한 확인")
    print("- 다른 프로그램이 카메라를 이미 쓰고 있는지도 확인해보세요 (Zoom, 카메라 앱 등)")
    exit()

print("카메라 열림. 영상 창에서 'q' 키를 누르면 종료됩니다.")
print("터미널에는 5초마다 그 구간의 최대 인원수가 출력됩니다.\n")

window_start = time.time()
window_max = 0

while True:
    ret, frame = cap.read()
    if not ret:
        # 아이폰으로 테스트 시 break 대신 countinue 로 바꿔주기 
        print("프레임을 읽지 못했습니다. 카메라 연결을 확인하세요.")
        break

    small = cv2.resize(frame, (640, 480))

    boxes, weights = hog.detectMultiScale(
        small, winStride=(8, 8), padding=(8, 8), scale=1.05
    )

    for (x, y, w, h) in boxes:
        cv2.rectangle(small, (x, y), (x + w, y + h), (0, 255, 0), 2)

    count = len(boxes)
    window_max = max(window_max, count)

    cv2.putText(
        small, f"People: {count}", (10, 30),
        cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2
    )

    cv2.imshow("Person Detection Test", small)

    now = time.time()
    if now - window_start >= 5:
        print(f"[{time.strftime('%H:%M:%S')}] 최근 5초간 최대 인원수: {window_max}")
        try:
            requests.post(BACKEND_URL, json={"count": window_max}, timeout=1)
        except requests.RequestException:
            pass  # 백엔드 없거나 꺼져 있어도 검출은 계속
        window_start = now
        window_max = 0

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

이렇게 짰음

이미지가 들어오는 경로를 cap 으로 받아주고 (카메라를 킴)

cap 이 잘 열려있다면 프레임 마다 사람이 몇 명 있는지 세어서 박스로 표시

hog 가 사람 검출기로 사용된다

hog = cv2.HOGDescriptor()
hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())

해당 화면을 resizing 해준다 크기를 줄이면 계산이 빨라지기 때문에 매 프레임마다 사람을 인식해야하는 경우 유용함!

boxes, weights 를 찾고 사람을 인식하면 사각형 목록으로 받고

참고로 winStride, scale 이 얼마나 ... 자세히 어떤 크기까지 인식할지를 정하는 세부 설정으로 사용된다.

boxes 를 for문으로 돌면서 초록색 네모를 그리고

나는 매 프레임마다 서버로 보내지 않고 5초 내에 인식된 최대 사람수를 보내기 때문에 해당 값을 count 와 window_max 를 사용하여 저장하고 보낸다

now = time.time()
if now - window_start >= 5:

5초를 세기 위해 now 값을 저장해주고 현재 시각 - 타이머 시작시간 이 5초 이상이면 보내고 아니면 pass ...

    print(f"[{time.strftime('%H:%M:%S')}] 최근 5초간 최대 인원수: {window_max}")
    try:
        requests.post(BACKEND_URL, json={"count": window_max}, timeout=1)
    except requests.RequestException:
        pass

5초가 지나면 로그를 찍고

post 를 사용해서 앞서 저장한 backend 서버로 몇 명이 인식되었는지 보낸다.

이 과정에서 생긴 오류는 RequestException 으로 예외처리 해줌

requests 는 기본으로 제공되는 라이브러리가 아니기 때문에 pip3 install requests 로 다운받아주기!

반복문 종료 이후 (q 또는 ctrl C) release 해줌

근데 솔직히..>!!!! 성능이 너무 쓰레기였다

혼자 개발하고 있는.. 인턴이다보니 사람들을 부를수 없어서 핸드폰으로 여러 사람을 캡처해서 보여줘도 인원이 안 늘거나

가방 같은것도 사람으로 인식해서 갑자기 2가 되는 경우가 생겼다

성능개선 타임. . .

옛날에 대학교 때 yolo 로 자전거 인식 프로그램 만들었던 기억이 나서 yolo 를 도입하기로 했다

"""
사람 수 검출 테스트 스크립트 (YOLO 버전)
화면 창: 실시간 박스 표시
터미널: 5초마다 그 구간 최대 인원수 출력
종료: 영상 창에서 'q'
"""
import cv2
import time
import requests
from ultralytics import YOLO

# 로컬 테스트용
# BACKEND_URL = "http://localhost:8000/api/crowd/live"
# 배포 서버용
BACKEND_URL = "http://xxxx.xxxxx.co.rk/api/crowd/live"

모델 로드 (최초 실행 시 가중치 자동 다운로드, yolo11n.pt는 ~5MB)
model = YOLO("yolo11n.pt")   # 정확도 더 필요하면 yolo11s.pt / yolo11m.pt
CONF = 0.4                   # 신뢰도 임계값 (낮추면 더 많이 잡지만 오검출↑)
DEVICE = "cpu"               # 애플 실리콘이면 "mps"로 바꿔 GPU 가속 시도 가능

# 아이폰 카메라 (Simple IP Camera) 사용하여 연결
# cap = cv2.VideoCapture("http://x.x.x.x:8080/stream.mjpg")
# 노트북 카메라, 웹캠, 안드로이드 USB-C 카메라 사용하여 연결
# 추가: 웹캠이랑 안드로이드 USB-C 사용하는 경우 라즈베리파이 필요
cap = cv2.VideoCapture(0)
if not cap.isOpened():
    print("카메라를 열 수 없습니다.")
    exit()

print("카메라 열림. 'q'로 종료.\n")

window_start = time.time()
window_max = 0

while True:
    ret, frame = cap.read()
    if not ret:
        print("프레임을 읽지 못했습니다.")
        break

    small = cv2.resize(frame, (640, 480))

    # classes=[0] → COCO 'person' 클래스만 검출
    results = model(small, classes=[0], conf=CONF, device=DEVICE, verbose=False)
    boxes = results[0].boxes

    count = len(boxes)
    for box in boxes:
        x1, y1, x2, y2 = map(int, box.xyxy[0])
        score = float(box.conf[0])
        cv2.rectangle(small, (x1, y1), (x2, y2), (0, 255, 0), 2)
        cv2.putText(small, f"{score:.2f}", (x1, y1 - 6),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)

    window_max = max(window_max, count)

    cv2.putText(small, f"People: {count}", (10, 30),
                cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
    cv2.imshow("Person Detection Test", small)

    now = time.time()
    if now - window_start >= 5:
        print(f"[{time.strftime('%H:%M:%S')}] 최근 5초간 최대 인원수: {window_max}")
try:
            requests.post(BACKEND_URL, json={"count": window_max}, timeout=1)
        except requests.RequestException:
            pass
        window_start = now
        window_max = 0

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

yolo 를 사용하기 위해 ultralytics 를 pip3 install 해주고 import 해줌

model = YOLO("yolo11n.pt")   # 학습된 모델 파일 불러오기
CONF = 0.4                   # 신뢰도 임계값
DEVICE = "cpu"               # 계산을 CPU로 할지 GPU로 할지

hog 를 사용하던 검출기 대신 model 을 yolo11 로 불러왔다

results = model(small, classes=[0], conf=CONF, device=DEVICE, verbose=False)
boxes = results[0].boxes

yolo 는 진짜 여러 클래스들을 구분할 수 잇는데 여기선 [0] 을 사용해서 사람만 검출할 수 잇도록 지정해주고

conf 값 (몇퍼센트 이상으로 사람이라고 판단되면 count 할지)

device 는 뭘 쓸지 등등을 매개변수로 넘겨서 처리

이후는 박스를 그리고 사람을 세어 추가한다.

처음 다운로드랑 세팅에는 시간이 약간 걸렸는데 다 받고 나니까 성능이 진짜!!! 최고 . .. .

뒷모습만 겨우인식하던 hog 랑 다르게 사람 수를 거의 정확하게 세는 모습을 확인할 수 있었다

	HOG (기존)	YOLO (신규)
import	cv2, time, requests	+ ultralytics
검출기 생성	HOGDescriptor 2줄	YOLO("yolo11n.pt") + CONF/DEVICE
검출 실행	detectMultiScale(...)	model(small, classes=[0], ...)
좌표 형식	(x, y, w, h)	(x1, y1, x2, y2)

post 를 사용해서 보내준 값들은 백엔드 코드에서

@PostMapping("/live") 
public Map<String, Object> live (@RequestBody LiveRequest body) {
	return crowdService.sampleAndStore(body.peopleCount(), body.level());
}

로 받고 서비스 코드에서 확인한다.

시뮬레이션을 위해 만들어둔 수동 사람 조정 요청이 1순위

2순위가 캠으로 들어오는 정보

3순위가 목업 센서 (그냥 만들어지는 가짜 정보들)

body 값으로 들어온 사람 수, level (혼잡도 레벨: 한산, 보통, 붐빔,, 등)을 사용해서 캐시와 DB 에 각각 저장

변화 정도에 따라 알림을 주거나 오토파일럿을 실행하는 동기처리를 수행

Race Condition 검증 Test 정리

kjw81024 — Fri, 5 Jun 2026 00:09:01 +0900

주요 비즈니스 로직에 분산 락을 적용하면서...

튜터님께서 이렇게 고치는 이유가 뭐냐고 여쭤보셨다

TX 시작 -> Lock 획득 -> 비즈니스로직 -> Lock 해제 -> TX commit 이 이루어지면

Lock 해제와 TX commit 사이에 빈 공간이 생기기 때문에 해제된 락을 다른 스레드가 잡아서 읽어버리면 TX commit 전이기 때문에 바뀌기 전의 정보를 읽는다.... 라고 대답했는데

그걸 직접 확인을 해봤냐고 여쭤보셔서... 아니라구 함

그냥 널리 알려져있는 문제라 내가 꼭 확인을 해야하나? 라는 생각도 들었다

그래도 테스트 하기 ....

테스트 1

확인 목적: 실제로 락이 트랜잭션 안쪽이면 문제가 생기는가?

안티패턴 시나리오

[ANTI-PATTERN]
A: @Transactional 시작 → 락 획득 → expire() → 락 해제 → sleep(후속 로직) → commit
B:                                    ↑ 이 시점에 깨어남
                                                → findById → PENDING 읽음 (A 아직 commit 전)
                                                → cancel() → commit (v=1)
A:                                                                           → commit 시도
                                                                                   → WHERE version=0 → 0 rows
                                                                                   → OptimisticLockException

운영 패턴 시나리오

[FIXED]
A: 락 획득 → (tx 시작 → expire() → commit) → 락 해제
B:                                                                          ↑ 이 시점에야 락 획득 가능
                                                                            → findById → EXPIRED 읽음
                                                                            → cancel 거부 (상태 가드)

CountDownLatch 로 A 가 락 해제한 직후, commit 전 시점을 B 의 시작시점으로 잡음

시작시점까지 Sleep 으로 잡으니까 계속 애매하게 되다가 안 되다가 함....

LockTransactoinRaceConditionTest.java

@SpringBootTest
@ActiveProfiles("test")
class LockTransactionRaceConditionTest {

	private static final String LOCK_INSIDE_TX_KEY_PREFIX = "lock:inside-tx:";
    private static final String CORRECT_LOCK_KEY_PREFIX = "lock:reservation:";

    
    @BeforeEach
    void setup() {
		// reservation 생성, reservation Id 가져옴
    }


    @AfterEach
    void cleanup() {
    	// lock key 만들어진거 delete, reservationRepository 도 비워줌
    }

    @Test
    @DisplayName("[ANTI-PATTERN] 락이 트랜잭션 안쪽 — B는 stale PENDING으로 cancel commit, A의 expire는 @Version에 막혀 손실됨")
    void race_condition_when_lock_inside_transaction() throws Exception {
        CountDownLatch aReleasedLock = new CountDownLatch(1);
        AtomicReference<Throwable> aError = new AtomicReference<>();
        AtomicReference<Throwable> bError = new AtomicReference<>();
        AtomicBoolean bCommitted = new AtomicBoolean(false);

        // A: expire (락 해제 후 sleep -> 나중에 commit 시도)
        Thread tA = new Thread(() -> {
            try {
                lockInsideTxExpireService.expireWithLockInside(reservationId, aReleasedLock);
            } catch (Throwable t) {
                aError.set(t);
            }
        });

        // B: A 가 락 해제하자마자 -> stale PENDING 읽고 cancel commit
        Thread tB = new Thread(() -> {
            try {
                aReleasedLock.await();
                cancelService.cancel(reservationId);
                bCommitted.set(true); // B 입장에선 정상 종료
            } catch (Throwable t) {
                bError.set(t);
            }
        });

        tA.start();
        tB.start();
        tA.join();
        tB.join();

        // (1) B 는 PENDING 을 읽고 cancel 까지 commit 했다 — 락 직렬화 실패의 직접 증거
        assertThat(bError.get()).isNull();
        assertThat(bCommitted.get()).isTrue();

        // (2) A 의 commit 은 @Version 이 막아서 OptimisticLockException
        //	== race 가 @Version 까지 도달했다 == 분산 락만으론 못 막은 케이스
        assertThat(aError.get()).isInstanceOf(ObjectOptimisticLockingFailureException.class);

        // (3) 최종 DB 는 B 의 cancel 이 살아남고, A 의 expire 는 흔적 없음
        Reservation saved = reservationRepository.findById(reservationId).orElseThrow();
        assertThat(saved.getStatus()).isEqualTo(ReservationStatus.CANCELED);
        assertThat(saved.getCanceledBy()).isNotNull();
        assertThat(saved.getCanceledAt()).isNotNull();
        assertThat(saved.getCancelReason()).isNotNull();
        assertThat(saved.getExpiredAt()).isNull();
    }

    @Test
    @DisplayName("[FIXED] 락이 트랜잭션 바깥 — B는 EXPIRED를 읽고 취소 자체가 거부된다")
    void no_race_when_lock_outside_transaction() throws Exception {
        CountDownLatch aAcquiredLock = new CountDownLatch(1);
        AtomicReference<Throwable> bError = new AtomicReference<>();
        AtomicReference<Throwable> error = new AtomicReference<>();

        // A: 락 획득 -> expireOne (commit) -> 락 해제
        Thread tA = new Thread(() -> {
            try {
                reservationLockService.executeWithReservationLock(reservationId, () -> {
                    aAcquiredLock.countDown();
                    reservationExpireService.expireOne(reservationId);
                    return null;
                });
            } catch (Throwable t) {
                error.set(t);
            }
        });

        // B: A 락 해제 후 락 획득 -> 이미 EXPIRED -> cancel 거부
        Thread tB = new Thread(() -> {
            try {
                aAcquiredLock.await();
                acquireLockAndCancel(reservationId);
            } catch (Throwable t) {
                bError.set(t); // 이건 기대하는 예외
            }
        });

        tA.start();
        tB.start();
        tA.join();
        tB.join();

        assertThat(error.get()).isNull(); // A는 정상
        assertThat(bError.get())
                .isInstanceOf(IllegalStateException.class)
                .hasMessageContaining("락 획득 타임아웃");

        Reservation saved = reservationRepository.findById(reservationId).orElseThrow();
        assertThat(saved.getStatus()).isEqualTo(ReservationStatus.EXPIRED);

        // 데이터가 오염되지 않았다
        assertThat(saved.getCanceledBy()).isNull();
        assertThat(saved.getCanceledAt()).isNull();
        assertThat(saved.getCancelReason()).isNull();
    }

    private void acquireLockAndCancel(Long id) throws InterruptedException {
        long deadline = System.currentTimeMillis() + 3_000;
        while (System.currentTimeMillis() < deadline) {
            try {
                reservationLockService.executeWithReservationLock(id,
                        () -> cancelService.cancel(id));
                return;
            } catch (ReservationException e) {
                // 락 획득 실패 (A가 아직 안 풀었음) → 재시도
                Thread.sleep(10);
            }
            // ReservationException 이 아닌 예외 (INVALID_STATUS 등) 는 위로 전파
        }
        throw new IllegalStateException("락 획득 타임아웃");
    }

    // ─────────────────────────────────────────────────────────────────
    // 안티패턴 테스트 전용 빈
    // ─────────────────────────────────────────────────────────────────
    
    // 많은 생략 

    static class LockInsideTxExpireService {
        @Transactional
        public void expireWithLockInside(Long id, CountDownLatch lockReleasedSignal) {
			//@Transactional 메서드 내부에서 락을 잡고/해제
    	}

    static class LockOutsideReader {
		// 락 바깥에서 호출 - 자체 read-only 트랜잭션을 시작해서 commit 된 값 읽기 
    }

    static class CancelService {
        @Transactional
        public Void cancel(Long id) {
        	// 예약 취소 로직
        }
    }
}

결과

B 는 PENDING 을 읽고 cancel commit 까지 성공
A 의 expire 는 @Version 에 의해 ObjectOptimisticLockingFailureException 으로 손실
즉 환불 처리, Proposal 복구 같은 후속 작업이 싹 다 누락될 수 있음

테스트 2

확인 목적: 락이 트랜잭션 안쪽이면 커넥션 자원도 낭비되는가?

케이스 A

@Transactional 진입 → (DB 접근 X) → tryLock 실패 → rollback
→ 커넥션 획득 안 됨 → 낭비 0

케이스 B

@Transactional 진입 → findById → tryLock 실패 → rollback
→ 커넥션 점유 + 무의미한 rollback 비용 발생

TransactionConnectionWasteTest.java

@SpringBootTest
@ActiveProfiles("test")
@TestPropertySource(properties = {
        // lazy connection acquisition 을 진짜로 동작시키기 위한 조합
        "spring.datasource.hikari.auto-commit=false",
        "spring.jpa.properties.hibernate.connection.provider_disables_autocommit=true"
})
class TransactionConnectionWasteTest {


    @BeforeEach
    void setup() {
		// reservation 과 reservation id 초기화 
    }

    @AfterEach
    void cleanup() {
		// repository 비움 
	}

    @Test
    @DisplayName("[A] @Transactional 진입만으론 커넥션 미획득 — DB 접근 전 락 실패 = 낭비 0")
    void connection_not_acquired_when_lock_fails_before_db_access() {
        // given
        HikariPoolMXBean pool = hikariDataSource.getHikariPoolMXBean();
        int baseline = pool.getActiveConnections();
        AtomicInteger activeAtFailure = new AtomicInteger(-1);

        // when - DB 접근 없이 락 실패 시뮬레이트
        assertThatThrownBy(() -> probe.failLockWithoutDbAccess(activeAtFailure))
                .isInstanceOf(SimulatedLockFailure.class);

        // then
        // (1) 락 실패 직전, 트랜잭션은 진입했지만 커넥션은 아직 안 잡혀 있었음
        assertThat(activeAtFailure.get())
                .as("DB 접근 전이면 @Transactional 진입만으론 커넥션 획득 X")
                .isEqualTo(baseline);
        // (2) 사후에도 baseline 유지
        assertThat(pool.getActiveConnections()).isEqualTo(baseline);
    }

    @Test
    @DisplayName("[B] DB 조회 후 락 실패 — 커넥션 점유 + 무의미한 rollback (낭비 발생)")
    void connection_acquired_and_wasted_when_lock_fails_after_db_access() {
        // given
        HikariPoolMXBean pool = hikariDataSource.getHikariPoolMXBean();
        int baseline = pool.getActiveConnections();
        AtomicInteger activeAtFailure = new AtomicInteger(-1);

        // when - findById 후 락 실패 시뮬레이트
        assertThatThrownBy(() -> probe.failLockAfterDbAccess(activeAtFailure, reservationId))
                .isInstanceOf(SimulatedLockFailure.class);

        // then
        // (1) 락 실패 시점에 커넥션이 이미 점유 중 -> rollback 비용까지 그대로 낭비됨
        assertThat(activeAtFailure.get())
                .as("DB 접근 후엔 커넥션 점유. 락 실패해도 rollback 까지 못 풀어줌")
                .isEqualTo(baseline + 1);
        // (2) rollback 종료 시점엔 풀로 반환됨
        assertThat(pool.getActiveConnections()).isEqualTo(baseline);
    }

    // ────────────────────────────────────────────────────────────
    // 테스트 전용 빈 + 시뮬레이션 예외
    // ────────────────────────────────────────────────────────────

    static class SimulatedLockFailure extends RuntimeException {
        // 실제 Redis 락 실패 대신 던지는 예외
    }

    @TestConfiguration
    static class Config {
        @Bean
        ConnectionWasteProbeService connectionWasteProbeService(
                ReservationRepository repo, HikariDataSource ds) {
            return new ConnectionWasteProbeService(repo, ds);
        }
    }
    
    static class ConnectionWasteProbeService {

        @Transactional
        public void failLockWithoutDbAccess(AtomicInteger activeRecorder) {
            // Case A: 트랜잭션 진입 -> DB 접근 X -> 락 실패
        }

        @Transactional
        public void failLockAfterDbAccess(AtomicInteger activeRecorder, Long id) {
			// Case B: 트랜잭션 진입 -> findById -> 락 실패
        }
    }
}

실제 Redis 호출 대신 SimulatedLockFailure 로 lock 실패를 시뮬레이션, HikariPoolMXBean.getActiveConnections() 로 커넥션 수 측정

트러블슈팅: https://kjw81024.tistory.com/102

케이스	락 실패 지점	커넥션 상태
A : DB 접근 전	try Lock 실패	미점유 - 낭비 0
B : DB 접근 후	try Lock 실패	점유중 (roll back 까지 낭비)

테스트 3

확인 목적: 분산 락이 뚫렸을 때 @Version 이 단독으로 정합성을 보호하는가?

시나리오 — 락 없이 두 트랜잭션이 동시에 같은 reservation 을 confirm

A: tx 시작 → read (v=0) → [barrier, 둘 다 read 완료 동기화] → confirm → commit (v=1)
B: tx 시작 → read (v=0) → [barrier] → A commit 대기 → confirm → commit 시도
→ UPDATE ... WHERE version=0 → 0 rows → StaleObjectStateException
→ Spring 이 ObjectOptimisticLockingFailureException 으로 래핑

CyclicBarrier 로 두 스레드가 같은 v=0 을 읽은 시점을 동기화, CountDownLatch 로 A commit 이후에만 B 가 write 하도록 순서 고정

OptimisticLockFallbackTest.java

@SpringBootTest
@ActiveProfiles("test")
class OptimisticLockFallbackTest {

    @BeforeEach
    void setup() {
		// rservation, reservationId 초기화 
    }

    @AfterEach
    void cleanup() {
		// repository 클린
	}

    @Test
    @DisplayName("[FALLBACK] 동시에 confirm 시도 — @Version 이 늦은 쪽을 OptimisticLock 으로 막는다")
    void optimistic_lock_blocks_second_writer() throws Exception {
        // given
        CyclicBarrier bothRead = new CyclicBarrier(2); // 두 스레드가 read 까지 완료한 시점에 동기화
        CountDownLatch aCommitted = new CountDownLatch(1); // A 의 commit 후 B 가 깨어남
        AtomicReference<Throwable> aError = new AtomicReference<>();
        AtomicReference<Throwable> bError = new AtomicReference<>();

        // when
        Thread tA = new Thread(() -> {
            try {
                probe.readBarrierConfirm(reservationId, bothRead);
            } catch (Throwable t) {
                aError.set(t);
            } finally {
                aCommitted.countDown(); // A 의 @Transactional 종료(commit/rollback) 이후에 시그널
            }
        });

        Thread tB = new Thread(() -> {
            try {
                probe.readBarrierWaitConfirm(reservationId, bothRead, aCommitted);
            } catch (Throwable t) {
                bError.set(t);
            }
        });

        tA.start();
        tB.start();
        tA.join();
        tB.join();

        // then
        // (1) A 는 성공
        assertThat(aError.get())
                .as("먼저 commit 한 A 는 정상 종료")
                .isNull();

        // (2) B 는 OptimisticLockException 으로 막힘
        assertThat(bError.get())
                .as("늦게 commit 시도한 B 는 version 불일치로 막힘")
                .isInstanceOf(ObjectOptimisticLockingFailureException.class);

        // (3) 최종 상태는 A 가 쓴 것 그대로, version 도 정확히 +1
        Reservation finalState = reservationRepository.findById(reservationId).orElseThrow();
        assertThat(finalState.getStatus()).isEqualTo(ReservationStatus.CONFIRMED);
        assertThat(finalState.getVersion()).isEqualTo(1L);
    }

    // ─────────────────────────────────────────────────────────────────
    // 테스트 전용 빈
    // ─────────────────────────────────────────────────────────────────

    @TestConfiguration
    static class Config {
        @Bean
        OptimisticLockProbe optimisticLockProbe(ReservationRepository repo) {
            return new OptimisticLockProbe(repo);
        }
    }

    static class OptimisticLockProbe {

        @Transactional
        public void readBarrierConfirm(Long id, CyclicBarrier bothRead) throws Exception {
        	// read → 둘 다 read 한 시점 동기화 → confirm → (메서드 종료 시 commit)
        }

        @Transactional
        public void readBarrierWaitConfirm(Long id, CyclicBarrier bothRead,
                                          CountDownLatch aCommitted) throws Exception {
              // B: read → 동기화 → A 의 commit 이 끝날 때까지 대기 → confirm → (메서드 종료 시 commit 실패)
        }
    }
}

결과

A: 정상 commit, status = CONFIRMED, version = 1
B: ObjectOptimisticLockingFailureException 으로 차단
최종 DB: A 의 write 만 반영, version = 1 정확히 일치

결론

해결 - 락을 트랜잭션 바깥으로
운영 코드에서 경계를 뒤집는 두 가지 방법

(a) Service 분리

ReservationLockService.executeWithReservationLock(id, () -> {
    reservationExpireService.expireOne(id);  // @Transactional → 이 안에서 commit 까지
});
// executeWithReservationLock 의 finally 에서 락 해제
// 즉 락 해제 시점 = commit 이후

(b) AOP — @DistributedLock + @Order(HIGHEST_PRECEDENCE)

@DistributedLock(key = "'reservation:' + #reservationId")
@Transactional
public void someMethod(Long reservationId) { ... }

@Order(HIGHEST_PRECEDENCE) 덕분에 락 Advice 가 트랜잭션 Advice 보다 바깥에서 감싼다. 두 방법의 효과는 같음

추가 - 락이 뚫려도 @Version 이 마지막 방어선
분산 락은 강력하지만 절대적이지 않다. TTL 만료, 락 키 누수, 신규 코드의 락 우회 등으로 두 트랜잭션이 동시에 진입할 수 있다.

그래서 Reservation 엔티티에 @Version 을 추가했다.

@Version
private Long version;

Hibernate 는 UPDATE 시 WHERE id=? AND version=? 를 붙인다. 먼저 commit 한 쪽이 version 을 올리면, 나중 쪽의 UPDATE 는 0 rows 가 되어 ObjectOptimisticLockingFailureException 으로 막힌다.

정리 - 2중 방어선

방어선	수단	역할
1차	분산 락 (락이 트랜잭션 바깥)	대부분의 경합을 직렬화. race 자체를 차단
2차	@Version 낙관락	락이 어떻게든 뚫렸을 때 정합성 보호

락을 트랜잭션 안에 두면 1차 방어선이 제 역할을 못 하고, 결국 2차 방어선까지 race 가 도달한다. 2차 방어선은 "막아주기는 하지만 A 의 작업이 손실된다" 는 부작용이 있다. 1차에서 제대로 막혀야 2차가 보조 역할만 하게 된다.

정리

진행한 테스트는 다음과 같다

테스트 1 : LockTransactionRaceCondition (정합성 관점 - 후속 비즈니스 로직 복구 누락 위험)

테스트 2 : OptimisticLockFallback (정합성 관점 - 2차 방어선)

테스트 3 : TransactionConnectionWaste (자원 관점 - 커넥션 낭비 + Hikari autoCommit 함정)

테스트	질문	결론
1 [anti]	락이 안쪽이면 실제로 race 가 생기는가?	stale read → @Version 까지 닿음 → expire 손실
1 [fixed]	락을 바깥으로 빼면 race 가 차단되는가?	B 가 락을 잡는 순간 이미 commit 완료 → race 없음
2	락이 뚫려도 @Version 이 혼자 막을 수 있는가?	늦은 commit 을 OptimisticLockException 으로 차단
3 [A]	DB 접근 전 락 실패는 커넥션을 낭비하는가?	낭비 없음
3 [B]	DB 접근 후 락 실패는 커넥션을 낭비하는가?	점유 + rollback 비용 낭비

정합성 관점과 자원관점 전체에서 봤을 때 락은 반드시 트랜잭션 바깥에 있어야 함

구현방법 1: ReservationLockService 분리, 2: @DistributedLock + @Order

그래도 뚫리는 극단적인 케이스는 @Version 이 마지막 방어선으로 막아준다

회고

코드를 먼저 고쳐놓고 문제를 증명하는 순서가 됐는데 (튜터님이 말해서 그제서야 테스트해봄...) ..,, 오히려 덕분에 왜 이 구조가 맞는지에 대해서 더 정확하게 설명할 수 있게 됨