윤재의 개발 블로그

TIL #133 : 맥에서 한글 입력 시 자모분리 및 입력지연 해결법 (구름 입력기 + 카라비너)

yunjae62 — Sun, 22 Feb 2026 18:47:35 +0900

맥 사용 6년 차

드디어 한글 자소분리/자모분리 및 입력 지연 문제를 해결했다!!!!!!!!!!!!!!!

아래의 단계대로 하면 된다.

한 10분 정도 걸리는데, 로그아웃/로그인 과정이 필요해서 약간 귀찮긴 하다.

1. 구름 입력기 설치

2. 로그아웃 후 다시 로그인

3. Karabiner-Elements 설치

4. 룰 등록

그럼 꼬우~

우선 구름 입력기에 접속해서 pkg를 내려받아 설치를 해준다.

소개 사이트 : https://gureum.io/

설치 사이트 : https://github.com/gureum/gureum/releases

비개발자라면 안 익숙할 수 있어서 스크린샷까지 첨부해 둔다.

티스토리의 개구려 이미지 에디터에는 도형 추가 기능이 없어서 피치로 화살표를 대체한다.....

최하단의 Assets -> Gureum-1.13.2.pkg 를 내려받으면 된다. (1.13.2는 버전이라서 더 최신 버전을 내려받으면 되겠다)

그리고 꼭 재시작이나 로그아웃/로그인을 해주어야 한다!!!!

안 하면 설정에서 입력 소스에 구름 입력기가 표기되지 않는다.

재시작을 하고 설치를 한 후에는 설정에서 입력 소스 변경을 한글 기본 입력기에서 구름 입력기로 변경을 해주어야 한다.

키보드 -> 텍스트 입력 -> 입력 소스 편집 버튼 클릭하면 되겠다.

원래라면 ABC(영어)와 두벌식(한글)이 있었겠지만, 우선 두벌식을 클릭 후 하단의 - 버튼을 눌러 제거를 해준다.

그다음 + 버튼을 눌러서 두벌식(옆의 구름 아이콘이 있어야 함)을 선택 후 추가 버튼을 누르면 된다.

그러면 이제 Caps Lock을 누르면 한/영 전환이 안 될 거다 ㅋㅋ

왜냐면... 캡스락은 기본적으로 입력기가 2개 이상 있을 때만 전환이 되기 때문이다.

그리고 더 충격적인 건, 맥에서 한영 전환 같은 입력 소스 전환 단축키는 캡스락이 아니라 컨트롤+스페이스 였다...

맥 6년 쓰면서 처음 알았다....

처음에는 한글 자모분리만 안 되는 것에도 감사하며 열심히 컨+스를 썼지만... 이게 앵간히 불편해야지 ㅡㅡ

자꾸 습관적으로 캡스락 누르는데 한글 전환은 안 되고 대문자 영어로 써지니 안 되겠다 이거 해결 본다고 찾아봤다가 카라비너를 발견했다.

공식 사이트 : https://karabiner-elements.pqrs.org/

Karabiner-Elements(이하 카라비너)는 맥에서 키보드 단축키를 자유롭게 재설정해주는 프로그램이다.

이걸 이용하면 캡스락으로 한/영 전환을 하면서도, 길게 누르면 영 대문자까지 사용 가능하도록 할 수 있다.

우선 위의 링크에 들어가서 설치를 해준다.

일단 설치하면 허용해 달라고 물을 텐데 들어가서 설정해 주면 된다.

이미 설치해 버려서 까먹었지만.. 기억을 되살려보자면

- 개인정보 보호 및 보안 -> 입력 모니터링

- 맥 실행 시 자동 실행

정도였던 것 같다.

이제 진짜 마지막이다.

네이버 블로그 : https://blog.naver.com/hankboy/221200885234

위의 링크로 들어가서 덧 17에 써져 있는 다운로드 링크의 파일을 내려받는다.

종종 구글 드라이브에 접속 못 하는 사람들이 있어서 코드만 남겨두는데, 같은 블로거로서 위의 링크 1 클릭 한 번씩 하고 오면 좋겠다.

아래를 복사해서 파일명은 아무렇게 저장하면 되겠다.

{
   "title":"Caps Lock 을 한/영 전환으로 사용 (rev.1.0)",
   "rules":[
      {
         "description":"Caps Lock to KO/EN Toggle on macOS",
         "manipulators":[
            {
               "type":"basic",
               "conditions":[
                  {
                     "type":"frontmost_application_unless",
                     "bundle_identifiers":[
                        "com.parallels.desktop",
                        "com.parallels.vm",
                        "com.parallels.desktop.console",
                        "com.parallels.winapp.",
                        "com.vmware.fusion",
                        "com.vmware.horizon",
                        "com.vmware.view"
                     ]
                  }
               ],
               "parameters":{
                  "basic.to_if_alone_timeout_milliseconds":200,
                  "basic.to_if_held_down_threshold_milliseconds":200
               },
               "from":{
                  "key_code":"caps_lock",
                  "modifiers":{
                     "optional":[
                        "any"
                     ]
                  }
               },
               "to_if_alone":[
                  {
                     "key_code":"spacebar",
                     "modifiers":[
                        "left_control",
                        "left_option"
                     ]
                  }
               ],
               "to_if_held_down":[
                  {
                     "key_code":"caps_lock"
                  }
               ]
            }
         ]
      },
      {
         "description":"Caps Lock to KO/EN Toggle on Parallels",
         "manipulators":[
            {
               "type":"basic",
               "conditions":[
                  {
                     "type":"frontmost_application_if",
                     "bundle_identifiers":[
                        "com.parallels.desktop",
                        "com.parallels.vm",
                        "com.parallels.desktop.console",
                        "com.parallels.winapp."
                     ]
                  }
               ],
               "parameters":{
                  "basic.to_if_alone_timeout_milliseconds":200,
                  "basic.to_if_held_down_threshold_milliseconds":200
               },
               "from":{
                  "key_code":"caps_lock",
                  "modifiers":{
                     "optional":[
                        "any"
                     ]
                  }
               },
               "to_if_alone":[
                  {
                     "key_code":"right_option"
                  }
               ],
               "to_if_held_down":[
                  {
                     "key_code":"caps_lock"
                  }
               ]
            }
         ]
      },
      {
         "description":"Caps Lock to KO/EN Toggle on VMware",
         "manipulators":[
            {
               "type":"basic",
               "conditions":[
                  {
                     "type":"frontmost_application_if",
                     "bundle_identifiers":[
                        "com.vmware.fusion",
                        "com.vmware.horizon",
                        "com.vmware.view"
                     ]
                  }
               ],
               "parameters":{
                  "basic.to_if_alone_timeout_milliseconds":200,
                  "basic.to_if_held_down_threshold_milliseconds":200
               },
               "from":{
                  "key_code":"caps_lock",
                  "modifiers":{
                     "optional":[
                        "any"
                     ]
                  }
               },
               "to_if_alone":[
                  {
                     "key_code":"right_option"
                  }
               ],
               "to_if_held_down":[
                  {
                     "key_code":"caps_lock"
                  }
               ]
            }
         ]
      }
   ]
}

내려받으면 해당 파일을 ~/.config/karabiner/assets/complex_modifications 폴더 안에 넣는다.

비개발자라면 여기서 조금 헤맬 수도 있어서 차근차근 설명을 붙여보자면... 우선 파인더에서 본인맥 홈폴더에 들어간다. 나 같은 경우는 yunjae62인데, 각 사용자마다 다르다.

여기서 command + shift + . 을 눌러준다. 숨김 파일을 볼 수 있는 단축키다.

그러면 .config 라고 하는 폴더가 보일 건데, 이후로 위의 경로까지 쭉쭉 들어가서 파일을 넣어주면 된다.

그런 다음 다시 카라비너로 돌아가서, 왼쪽의 Complex Modifications -> 상단의 Add predefined rule 버튼을 클릭한다.

나 같은 경우는 이미 추가해서 아래 3개가 있으니 오해 금지.

그다음 뜨는 창에서 파일을 정상적으로 넣었다면 이게 보일 건데, 오른쪽 아래의 Enable All 버튼을 클릭하면 된다.

그러면 끝!!!!!!!!!!

하기 전에, 찐막 한 가지!

상단바에 있는 구름 입력기를 클릭하면 환경설정란이 있는데 클릭.

1번째는 이미 체크가 되어 있을 텐데 2번째 모아치기도 체크해 주면 좋다!!

느 ㄴ 같은 경우나 ㅣㅇㅇ 같은 경우에 자동으로 는, 잉 으로 완성해 준다 ㅋㅋㅋㅋ 진짜 편함!!!!!!!!!!

정말 너무 편해서... 바로 블로그부터 켰다...

포스팅해야 하는데... 노션에다가 적어놓은 포스팅거리가 한가득인데... 퇴근하면 귀찮아서 글을 안 쓴다 ㅠㅠ

노력해 보겠습니다...

2025년 회고

yunjae62 — Sun, 18 Jan 2026 14:59:26 +0900

벌써 2026년이다.
원래 회고를 잘 안 하기는 하는데 그래도 25년은 의미 깊은 날들이 많았어서 한번 정리를 해보려고 한다.

일단 잘한 점 3가지를 꼽아보았다.

1. 머리 변경
2. 취업!
3. 일기 꾸준히 쓰기

우선 머리를 가르마펌으로 바꾸었는데, 인생에서 제일 잘 한 결정 중 하나가 될 것 같다 ㅎㅎ
내가 원래 머리를 덮고 투블럭으로만 했었는데... 머리를 바꾸는 계기가 된 사건이 하나 있었다.

1월에 편의점에서 맥주를 사는데 사장님께서 나보고 신분증을 요구하면서.. 중학생인 줄 알았다고 하시는 거다.
항상.... 듣는 말이어서 그냥 넘어갈 수도 있었지만, 그때 문득 나이 27살 먹고 중학생 소리를 듣는 게 맞나..?라는 생각이 들면서 주변에 나이 들어 보이는 법을 물어보고 다녔고, 머리를 까자는 결론을 내렸다.

처음에는 펌까지는 부담스러워서.. 어떻게든 도구들로 해보려 했는데 이눔의 자기주장 강한 쌩직모 머리는 들을 생각을 안 했다. 그때 부트캠프에서 막 친해지기 시작한 ㅁㅊ이가 울집 근처 회사에서 면접보고 울집까지 와서 스타일링을 해주었다... ㅋㅋㅋㅋㅋㅋㅋㅋ 슥슥 몇 번 하더니 완성되었다.. 대박

그 날의 일기 발췌 ㅋㅋ

참고로 ㅁㅊ이는 그 회사에 합격하여 인턴을 하고 현재는 정직원으로 전환되어 재직중이고
나는 머리를 깠음에도 여전히 중학생이냐는 소리를 듣고 다닌다. ㅠㅠ

그 날의 일기 발췌

다음은 취업.
큰 곳에 취업을 하지는 않았지만, 회사가 기대했던 것보다 더 좋았다.
우선 사람들이 너무 다 좋다. 다들 친절하니 열심히라서 일이 재밌다.

참고로 제이지는 창업한 대표님이다..

하지만 무엇보다 좋은 것은 내가 돈을 번다는 사실.
내가 소득세를 내다니 ㅋㅋㅋ
내가 사회에 기여하고 보수를 받는다는 사실이 너무 기뻤다.

반년 간 열심히 굴렀더니 기술이사님께 인정을 받아서 올해부터는 회사 핵심 업무를 담당하게 되었다.
최소 트래픽 200 TPS, 피크 때는 2000도 찍는 울 회사 캐시카우....
이제 장애내면 초단위 매출손실 감당해야 된다 ㅠㅠㅠ

마지막으로 일기 덕분에 이 회고가 존재했을 정도로 아주 가치가 크다.
사실 일기는 내 인생 전체에서 수많은 시도가 있었다. 다만 쓰다가 얼마 안 가 포기한 게 대부분이었다..

우선 공책이라는 물리적인 매체에 적다 보니 내 생각을 손이 못 따라가는 게 컸고, 또 나는 일기를 지금까지 조선왕조실록마냥 몇 시에 뭐 했다. 몇 시에 뭐 했다. 식의 사실중심 일기를 써와서 한 번 일기를 적는데 너무 오래 걸렸다.

그래서 포기하고 있다가... 2년 전 한 지인의 추천으로 노션에 일기를 써보라고 권유받았는데, 사실 중심 말고 감정 중심의 일기를 써보라고 했다.
그땐 일단 했었는데, 생각보다 효과가 굉장했고? 습관이 되어서 이제는 틈틈이 쓰게 되었다 ㅋㅋㅋㅋㅋㅋ

사실 아직도 내 감정을 구체적으로 서술하는 게 힘들기는 하지만, 그래도 의식적으로 훈련을 하니 많이 늘었다. 또 요즘은 적은 일기를 지피티 돌려서 내가 미쳐 놓치고 있던 감정들을 알려달라 하면서 나를 더 이해하려 한다.. ㅋㅋㅋ

이렇게 하다 보니 뭔가 더 F에 가까워지고 있다. 정확히는 이성과 감성을 모두 적절하게 활용할 수 있게 되었다.
일기를 쓰면서 내가 겪은 하나의 사건에 대해서 어떤 생각들을 했고, 그로 인해 어떤 감정들을 느꼈는지를 정리하다 보니
나와 비슷한 경험을 했던 타인도 이런 생각을 하고 감정을 느꼈겠지? 하면서 공감이 되어 배려하고 이해할 수 있게 되었다.

요즘은 매일 쓰지는 않고, 하루가 인상 깊을 때마다 적고 있고, 키워드로 그날 느낀 감정을 키워드로 해시태그 달아두고 있다 ㅋㅋ
하지만 올해 매일매일이 너무 스펙타클해서 하루도 빠짐없이 매일 쓰고 있다....

또 일기를 쓰면서 나에 대해서 더 잘 알게 되는 것 같다.
그저 흘러가는 생각으로 휘발될 수 있었던 것이 활자로 남아서 두고두고 읽히니 과거의 나와 연결되는 느낌.

일기 쓸 때 이미지를 최대한 많이 첨부하면 추억회상 때 감정이 더 배가 된다.

또 나는 유명한 기록쟁이다...
나는 특히 시간을 소중하게 여겨서.. 수능이 끝난 후부터 지금까지 구글 캘린더에 내 일정을 전부 기록해오고 있다.
젊을 때는 자는 시간까지 기록했었는데, 요즘은 그것까지는 무의미한 데이터라 판단해서 특별히 알아두어야 할 일정만 기록하고 있다.

이렇게 일기 + 사진 + 캘린더로 내 과거를 남겨놓으니 과거를 돌아볼 때 내가 몇 월 며칠에 무엇을 하고 있었는지 바로 알 수 있어서 좋은 점이 많은 것 같다. 습관이 잡혀서 기록하는게 귀찮지도 않고.

지인 형과 함께 사업을 도운 적이 있다. 이후 외주를 물고 오면서 수익분배 관련해서 처음 내 가치에 대해서 생각해 보았다.

원래라면 나는 기획/설계/프론트/백엔드/인프라까지 전부 다 할 줄 아니 이 정도는 받아야 하지 않나?라고 추상적으로 생각했지만, 대표형은 내가 어떤 작업들을 하고, 각 작업에는 시간이 얼마나 걸리며, 내 시급은 어느 정도인 것 같으니 이 정도의 수익을 분배받아야겠다고 이야기를 해주었다.

이 말을 듣고 큰 충격을 받았다. 내 말에는 근거가 없구나. 나는 내 가치를 몰랐구나.

그 뒤로 내 연봉의 시급을 계산해보고, 내가 하는 일의 작업 시간을 측정해보며 내가 얼마 만큼의 리턴을 받아야 하는지를 의식적으로 생각해보는 훈련을 하고 있다. 회사에서도 내가 하는 업무가 어떤 임팩트가 있는지를 고려하면서...

https://www.youtube.com/watch?v=nkc8tVCxZKM&t=757s

링크 타면 시간 링크를 걸어두었는데, 한 1분 길이 정도 봐주면 좋겠다
내게 꽤 큰 울림이 있던 말이었다.

원소윤님이 말하는 다정함에는 발산하는 다정함과 수렴하는 다정함이 있다고 한다.
일반적으로 앞에서 챙겨주는 발산하는 다정함도 있지만, 수렴하는 다정함도 있는 것 같다.
곁에서 지켜주고 함구하며 기다리는 그런 다정함.
듣고 머리가 띵 했다. 이런 류의 개념을 지금껏 떠올리지 못하고 있었어서.

나는 수렴하는 다정함을 추구!하는 사람인 것 같다.
지인의 비밀을 함구하고, 호불호를 기억해 챙겨주는 그런 사람이 되려고 의식적으로 노력해왔다.
타인이 그렇게 안 느꼈다면 음.. 어쩔 수 없지만...

종종 만나면 삶의 낙이 무엇인지 물어보는 ㅇㄹ이라는 친구가 있다.
덕분에 내 삶의 낙이 무엇을까? 계속 생각해보는 계기가 되었다.

그러다 한 7월쯤 어렴풋이 깨달은게 있다. 일상 속에서 여유가지고 행동하기.

출근길에 사람들은 지금 오는 지하철 타려고 뛰어갈 때 나는 ‘먼저 가세요~ 전 나중에 가렵니다~’ 생각하면서 옆으로 비켜주면서 천천히 걷기.

퇴근길에 사람들은 몇 초 안 남은 횡단보도 건너려고 뛰어갈 때 나는 옆길로 비켜 걸으며 하늘에 둥둥 떠다니는 구름 보거나 비행기 구경하기.

비가 오는 날에 어떻게든 안 맞으려고 우산으로 꽁꽁 싸매기 보다, 좀 맞더라도 우산을 조금 들어 올려서 내리는 비 구경하면서 우중충한 하늘 바라보기.

꽤나 소소한 것들인데 이런 작은 것에서 은은히 재미를 느끼는 것 같다.

월드 IT쇼에 ㅂㅈ이형이랑 다녀왔다가 화재로 대피를 했다. 생애 첫 화재사고 경험담...
오전에 돌아다니고 있는데 갑자기 통로 반대편의 아주머니께서 불이야~하며 장난스런 말투로 지나가길래, 나는 사람들이 많아서 길 뚫으려고 장난치는 줄 알았는데, 갑자기 안내 방송으로 화재가 났다고 해서 대피했다. ㅋㅋ

나가서 점심 먹고 카페에 있다보니 재입장이 가능하다고 해서 다시 들어갔다. 3층 전시장에 가니 연기 냄새가 그윽했지만.. 일단 다녔다 ㅋ

삼성 부스가 제일 재미있었다. 갤럭시 AI가 문장으로 이모지를 만들어주었는데 코딩하는 다람쥐를 만들어 디스플레이에 슬쩍 공개해두고 도망쳤다 ㅋ

[제주도 여행] 1일 차

yunjae62 — Sun, 27 Jul 2025 18:39:51 +0900

드디어 쓰는 1일 차...

시작은 이러했다.

아직 연락하는 군대 동기가 있는데 취업도 했겠다, 한번 만나야겠다 싶어서 연락하니 제주도란다.

참고로 연락할 때마다 장소가 서울, 부산, 진천, 인천이었고... 제주도까지는 생각을 못해서 많이 당황했다.

제주공항 근처 게스트하우스에서 일하면서 한 달 살기를 하고 있다고 했다.

이 친구도 볼 겸, 혼자 제주도 여행을 1박 2일로 다녀오기로 했다.

원래 2박 3일로 잡았고 복귀날 다음날이 출근날이었다가 하루는 쉬려고 줄였는데 정말 잘한 결정이었다. 그 하루동안 하루 종일 누워있었다 ㅋㅋ

6/30 (월)

주말동안 본가에 내려가서 가족들이랑 시간을 보내고, 근처에 있는 여수공항으로 아침 9시 반 비행기를 탔다.

평일 아침, 그것도 여수공항이라 사람이 거의 없었다.

탑승 수속을 하는데 사람이 아무도 없어서 들어가니 저 멀리서 직원분이 이리 오시면 됩니다!! 했다. 1분 컷 후 입장..

제주공항

여수에서 출발해서인지 50분? 정도 하늘 구름 구경하니 도착했다.

도착하고 나서 공항까지 가는 버스를 타는데, 내가 제일 마지막으로 탑승해서 내릴 때 제일 먼저 내렸다 ㅋ

짐도 배낭 하나만 챙겨서 1등으로 제주 땅을 밟았다.

바로 만나서 같이 밥먹고 카페에서 수다 떨었다.

어떻게 버거이름이 피즈버거 ㅋㅋ

제주도는 버거도 다르구만 하면서 들어왔다.

아니 제주도까지 와서 버거??? 라고 생각할 수도 있는데

나랑 친구는 둘 다 먹는 것에 큰 관심이 없어서... 아무 곳이나 갔다

맛은 그냥 버거!

그렇게 점심을 해결하고 카페에서 그동안 못 나눈 수다를 떨다가 이제 나는 남서쪽으로 이동하기 위해 버스를 탔다.

여기는 하늘여행글라이더체험장.

제주올패스에서 할인해주는 곳이라 탔는데, 하늘을 자유롭게 나는 게 아니라 고정된 코스를 왕복하고 오는 거라 그냥 그랬다..

손님이 나 혼자라 사장님이 사진이랑 영상 찍어주셨다 ㅋㅋ

다음은 근처에 있는 제주항공우주박물관에 갔다. 영어로 JAM 이라고 줄여 부르는 모양

원래 항공우주쪽에 관심이 있기도 하고, 박물관도 종종 가는 편이라 들렀다.

여기는 관내에 있는 그림카페라는 곳이랑 묶어서 제주올패스 할인을 받았다.

엘리베이터의 컨셉부터 재밌었던 곳

그림카페에서 항공우주박물관 입장권까지 발급해주고 있어서 먼저 들러서 아이스티 공짜로 마시면서 앉아있었다.

정말 말 그대로 그림 카페였던 것.. 신기했다

근데 그냥 신기하기만 해서 좀 앉아 있다가 박물관 관람하러 내려갔다.

박물관은 1층은 항공, 2층은 우주를 주제로 전시되어 있다.

항공 쪽은 그렇게 큰 관심이 없어서 빠르게 훑으려 했는데 재밌는 체험들이 많았다.

이렇게 옆의 조종기로 전투기 조종 체험도 해볼 수 있었다

저 건너편은 초등학생 애기였는데 주변에 사람이 없어서 나도 슬쩍하고 왔다 ㅋㅋㅋㅋㅋ

실제 서울을 둘러볼 수 있었다.

전투기가 건물과 부딪히면 어떻게 되지? 싶어서 해봤는데 폭발하더라.

2층으로 올라왔다.

전시장에 내 생일을 입력하면 360도 대형 스크린에서 내 별자리가 표시됐다.

우주에 보내는 메시지를 만들어 볼 수 있는 체험이 있었는데

누가 바보 라고 만들어뒀다 ㅋㅋㅋ 귀엽

다음은 오설록 티 뮤지엄에 왔다.

겉보기에는 작아보였는데 내부는 엄청 넓고 사람도 바글바글했다.

제주 관광객 다 여기 있나 봐;;

안에는 오설록 굿즈들, 상품들과 카페가 있었다.

오설록 티는 주변에 많이 주기도 하고 또 나도 받기도 해서 집에 많아서... 제주올패스로 말차아이스크림 무료로 먹을 수 있어서 그것만 창가 1인석에서 먹고 주변 구경하고 왔다.

맛은 있었다.

숙소는 산방산 근처의 사계여행이라는 게스트하우스를 잡았다.

수수료까지 해서 2.7만 원?이었던 것 같다.

주변에 편의점과 식당가가 있으면서 값싼 곳을 골랐다.

근처에 6인실 게하가 여기보다 만 원 싼 곳이 있긴 했는데 왠지 같은 방에 사람 있을 것 같고 여기가 시설이 더 깔끔하길래 골랐다.

근데!!! 이 날 게스트하우스 전체를 혼자 썼다 ㅎㅎ

사장님께는 매출이 없어서 안 좋을 것 같아 내색은 안 했지만 나는 너무 좋았다 ㅋㅋ

숙소에서 1시간 정도 쉬면서 폰 충전도 하고 나서 저녁을 먹으러 나갔다.

제주도는 7시에 대부분 식당을 닫기 때문에 후다닥 먹어야 한다.

사계소희네국수 라는 곳에서 고기국수를 먹었다.

나 외에도 다른 관광객 중년부부가 사장님과 이야기를 나누고 계셨는데 전국 음식 이야기를 하고 계셨다.

그중 전라도가 상다리가 부러질 정도로 나온다고, 순천이 맛집이 많다고 해서 기분이 좋아졌다 ㅎㅎ 물론 아는 척 안 하고 먹고 바로 나왔다.

밥을 먹고 산책 겸 산방산 보문사를 다녀오기로 했다.

사진은 갔다 오기 전후 사진인데, 제주 날씨가 엄청 휙휙 바뀌었다. 다녀오니 구름이 산방산 머리를 쓰다듬고 있었다.

그냥 경치가 좋아서 찍어본 사진들

산방산을 갔다가 그 밑의 용머리해안까지 다녀오기로 했다.

원래 입장료를 받고 더 깊숙이 다녀올 수 있는데 마감돼서 근처 해안만 봤다.

그리고 숙소로 돌아갔다.

ㅋㅋ 이거 캡처한 후에 편의점 다녀왔는데 그것까지 하면 딱 2만 보 채웠을 것 같다.

하루 11킬로...

ㅋㅋㅋ 제주도까지 와서도 코테는 못 참지......

이렇게 1일 차가 끝났다.

[제주도 여행] 0일 차

yunjae62 — Wed, 2 Jul 2025 16:19:44 +0900

취업했다.

그래서 첫 출근 전까지 하루 빼고 매일 약속 잡고 놀러 다녔다..... ㅋㅋ

그러다가 1박 2일로 제주도나 다녀올까 싶어서 혼자 월화 다녀왔다. 뭔가 일본은 너무 멀고 비싸고, 국내는 여행 기분이 안 나서 그 사이 어딘가로 제주도로 결정했다 ㅋㅋㅋ 마침 친구가 제주 한 달 살기를 하고 있어서 겸사겸사 밥 한 번 먹기로 했다.

남서쪽인 안덕/대정쪽 위주 + 제주시 공항 주변을 놀다가 왔다.

총 경비는 27만 원 들었다.

항공권	84,100
숙박비 (1박)	26,970
관광패스 (제주올패스 24시간권)	11,900
관광	85,500
식비	40,400
교통	16,950
총액	265,820

항공권은 본가 내려가서 가족들과 친척들, 고향친구들을 보고 제주로 넘어간 거라 여수공항->제주공항, 제주공항->김포공항으로 다녀왔다. 스카이스캐너에서 젤 싼걸루 샀다. 아침 9시 반 비행기 타고 다음날에 밤 9시 비행기로 복귀했다.

숙소는 4인실 게스트하우스로 다녀왔는데 숙소 전체에 손님이 나밖에 없었다 ㅎㅎㅎㅎ 내가 쓰는 토스뱅크카드가 아고다에서 10% 할인을 해줘서 이걸로 할인받아 결제했다.

제주올패스는 제주도의 관광패스인데, 주요 관광지, 카페, 식당, 체험장에서 할인이나 증정을 해준다. 나는 24시간권을 구매해서 5곳을 다녀왔는데 총 8만 원을 할인받았다..!!! 제주올패스 웹사이트에서는 15,800원인데, 카카오톡 채널에서는 30% 할인해서 11,900원으로 구매할 수 있다. 참고하길!! 대신 관광지 간 1시간 텀을 두고 다음 관광지를 이용할 수 있다.

뚜벅이로 버스+택시 타고 다녔는데, 제주도는 택시가 비싸서 딱 2번만 탔다. 택시비로는 11,000원, 버스비로 5,750원 쓴 듯! 제주도는 제주버스정보시스템 사이트에서 각 버스번호 별로 시간표가 정해져 있으니 계획을 세울 때 참고하면 좋다. 안 그러면 배차간격이 30분, 1시간 이런 버스 놓쳐서 기다리기만 할 수도 있다.

1일 차

제주공항 -> 친구랑 식사/카페 -> 행글라이더 체험 -> 그림카페/항공우주박물관 -> 오셜록 -> 숙소 -> 산방산/보문사 -> 용머리해안

2일 차

송악산 -> 카트체험 -> 돌고래투어 -> 승마체험 -> 넥슨컴퓨터박물관 -> 동문시장 -> 용두암 -> 제주공항

진짜 야무지게 다녔다

친구가 너 행군하냐고 ㅋㅋㅋㅋㅋ

이틀 동안 4만보 걸었자나

TIL #132 : Arrays.fill의 얕은 복사로 인한 참조 공유 이슈

yunjae62 — Sat, 14 Jun 2025 14:35:50 +0900

요번 거는 간단한거.. 근데 뭐가 문제인지 모르고 좀 헤맸다.

원래 알고리즘 풀 때 리스트랑 배열을 같이 쓰는 것을 안 좋아하는데, 오늘은 무슨 바람이 불었는지 이렇게 풀고 싶었다.

public class Main {

    public static void main(String[] args) {
        List<Integer>[] graph = new ArrayList[3];
        Arrays.fill(graph, new ArrayList<>());
        
        for (int i = 0; i < 3; i++) {
            graph[i].add(i);
        }

        System.out.println(Arrays.toString(graph));
    }
}

이런 식으로 List<Integer>[] 로 이차원 배?열을 만들었다.

그리고 Arrays.fill로 각 배열 요소에 ArrayList를 넣어주었다.

그리고 (원래는 입력 받아 넣겠지만 패스하고) 반복문으로 각 인덱스에 해당 인덱스를 리스트에 넣도록 해주었다.

[[0], [1], [2]]

예상 출력 결과는 위일 줄 알았다.

[[0, 1, 2], [0, 1, 2], [0, 1, 2]]

하지만 결과는 이랬다.

지금은 이렇게 for 문으로 순서대로 숫자를 넣으니 바로 리스트가 같은 인스턴스로 들어갔구나 유추가 쉬웠지만, 내가 문제 풀 때는 입력이 다양했어서 알아채기가 힘들었다.

public class Arrays {
    public static void fill(Object[] a, Object val) {
        for (int i = 0, len = a.length; i < len; i++)
            a[i] = val;
    }
}

문제는 Arrays.fill 부분이었다. 각 요소별 넣어줄 줄 알았는데... 이 멍청이 ㅠㅠ

그래서 배열이나 컬렉션 같이 주소를 넣어주는 거는 조심히 써야겠다.

public class Main {

    public static void main(String[] args) {
        List<List<Integer>> graph = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            graph.add(new ArrayList<>());
        }
    }
}

지금까지 해왔던 대로 앞으로는 그냥 이렇게 List<LIst<>> 쓰면 되겠다.

간단한 건데 어이없어서 글로 써본다...

TIL #131 : Spring Kafka에서 @KafkaListener 기본 컨테이너 팩토리 설정 오류 해결

yunjae62 — Mon, 9 Jun 2025 14:09:41 +0900

문제

Spring Kafka를 이용해서 아웃박스 패턴을 간단히 만들어보고 있었다. 도커로 카프카를 띄우고, 프로듀서가 메시지를 잘 전송하는 것을 확인했는데 컨슈머가 브로커와 연결을 못하고 있었다.

상황

도커 컴포즈로 카프카 실행하기

services:
  kafka:
    image: bitnami/kafka:3.7.1
    container_name: kafka
    ports:
      - "19092:19092"
    environment:
      - KAFKA_KRAFT_CLUSTER_ID=A616ADF4-FA94-440F-BE52-CC89ED7EC507
      - KAFKA_CFG_NODE_ID=0
      - KAFKA_CFG_PROCESS_ROLES=controller,broker
      - KAFKA_CFG_LISTENERS=INTERNAL://:9092,EXTERNAL://:19092,CONTROLLER://:9093
      - KAFKA_CFG_ADVERTISED_LISTENERS=INTERNAL://kafka:9092,EXTERNAL://localhost:19092
      - KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP=INTERNAL:PLAINTEXT,EXTERNAL:PLAINTEXT,CONTROLLER:PLAINTEXT
      - KAFKA_CFG_CONTROLLER_LISTENER_NAMES=CONTROLLER
      - KAFKA_CFG_INTER_BROKER_LISTENER_NAME=INTERNAL
      - KAFKA_CFG_CONTROLLER_QUORUM_VOTERS=0@localhost:9093
      - ALLOW_PLAINTEXT_LISTENER=yes
    volumes:
      - kafka_data:/bitnami/kafka

  kafka-ui:
    image: provectuslabs/kafka-ui:latest
    ports:
      - "8081:8080"
    depends_on:
      - kafka
    environment:
      - DYNAMIC_CONFIG_ENABLED=true
      - KAFKA_CLUSTERS_0_NAME=local
      - KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS=kafka:9092
      - KAFKA_CLUSTERS_0_PROPERTIES_SECURITY_PROTOCOL=PLAINTEXT

volumes:
  kafka_data:

도커 컴포즈는 위와 같다. 사실 설정을 잘 한건지 아직도 모르겠다. 계속 공부하는데 어려워..ㅠ

일단 간략하게 설명하자면, KAFKA_CFG_ADVERTISED_LISTENERS는 advertised.listeners 설정으로, 클라이언트에게 브로커의 접속 주소를 알려주는 설정이다. 그리고 EXTERNAL://localhost:19092는 내부 브로커 간이 아닌, 외부 클라이언트는 여기로 접속하라는 의미이다.

따라서 클라이언트는 이를 통해 localhost:19092로 요청을 보내게 된다. 즉, 같은 로컬이면 상관 없겠지만, 다른 네트워크라면 못 찾게 되니 실제 서버를 띄울 때는 도메인을 입력해야 한다.

또 나는 도커를 사용했고, 컨테이너의 포트를 19092:19092로 외부-내부를 연결해뒀으니, 로컬 컴퓨터에서 19092로 요청을 보내면 이 카프카 컨테이너로 요청이 가고, 컨테이너는 이를 내부의 19092 포트로 포워딩한다.

그리고 KAFKA_CFG_LISTENERS=EXTERNAL://:19092 설정은 카프카 브로커가 실제로 수신할 주소이다. 이때 :19092는 0.0.0.0:19092를 줄인 것으로, 모든 IP에 대해서 포트만 19092 이기만 하면 받겠다는 뜻.

스프링 카프카로 컨슈머 설정하기

import java.util.HashMap;
import java.util.Map;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.listener.ContainerProperties.AckMode;
import org.springframework.kafka.listener.DeadLetterPublishingRecoverer;
import org.springframework.kafka.listener.DefaultErrorHandler;
import org.springframework.kafka.support.ExponentialBackOffWithMaxRetries;
import org.springframework.kafka.support.serializer.JsonSerializer;

@Configuration
@EnableKafka
public class KafkaConsumerConfig {

    @Bean
    public ConsumerFactory<String, Object> consumerFactory() {
        Map<String, Object> props = new HashMap<>();

        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:19092"); // 브로커 접속 주소

        props.put(ConsumerConfig.GROUP_ID_CONFIG, "payment-group"); // 컨슈머 그룹

        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class); // 키는 문자열
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class); // 값은 문자열

        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false); // 수동 커밋

        return new DefaultKafkaConsumerFactory<>(props);
    }

    // 여기 !!!
    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, Object> paymentRefundListenerContainerFactory(
        KafkaTemplate<Object, Object> kafkaDlqTemplate) {

        ConcurrentKafkaListenerContainerFactory<String, Object> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());

        // 수동 커밋 설정
        factory.getContainerProperties().setAckMode(AckMode.MANUAL);

        // 에러 핸들러 + 재시도 5회 + DLQ 설정
        DeadLetterPublishingRecoverer recoverer = new DeadLetterPublishingRecoverer(
            kafkaDlqTemplate,
            (record, ex) -> new TopicPartition(record.topic() + ".DLT", record.partition())
        );

        // 지수 백오프 설정: 초기 1초, 최대 5번 (4회 재시도 + 마지막 1회)
        ExponentialBackOffWithMaxRetries backOff = new ExponentialBackOffWithMaxRetries(4); // 4회 재시도
        backOff.setInitialInterval(1000L); // 1초
        backOff.setMultiplier(2.0); // x2씩 증가 → 1s, 2s, 4s, 8s
        backOff.setMaxInterval(10000L); // 최대 10초

        factory.setCommonErrorHandler(new DefaultErrorHandler(recoverer, backOff));

        return factory;
    }

    @Bean
    public KafkaTemplate<Object, Object> kafkaDlqTemplate() {
        Map<String, Object> props = new HashMap<>();

        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:19092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class);

        return new KafkaTemplate<>(new DefaultKafkaProducerFactory<>(props));
    }
}

코드를 전부 다 볼 필요는 없다.

2번째 빈에 여기 !!! 라고 적어둔 곳의 paymentRefundListenerContainerFactory라는 메서드명만 보면 된다.

스프링은 빈 등록 시 메서드명을 기준으로 빈이름이 등록된다. 그리고 빈 조회 시 타입을 우선으로 찾고, 같은 타입의 빈이 여러 개면 빈 이름으로 찾는다.

문제는, 스프링 카프카가 제공하는 @KafkaListener 어노테이션은 따로 속성으로 containerFactory 속성에 팩토리명을 지정하지 않으면 기본값으로 "kafkaListenerContainerFactory"를 조회한다.

INFO [ntainer#0-0-C-1] org.apache.kafka.clients.NetworkClient   : [Consumer clientId=consumer-payment-group-1, groupId=payment-group] Node -1 disconnected.
WARN [ntainer#0-0-C-1] org.apache.kafka.clients.NetworkClient   : [Consumer clientId=consumer-payment-group-1, groupId=payment-group] Connection to node -1 (localhost/127.0.0.1:9092) could not be established. Node may not be available.
WARN [ntainer#0-0-C-1] org.apache.kafka.clients.NetworkClient   : [Consumer clientId=consumer-payment-group-1, groupId=payment-group] Bootstrap broker localhost:9092 (id: -1 rack: null) disconnected

이런 로그가 뜬다.

스프링 카프카의 자동 설정

나는 localhost:9092를 설정해준 적이 없다. 하지만 여기로 요청하는 이유는 스프링 카프카가 kafkaListenerContainerFactory가 없으면 스프링이 자체적으로 만들어주기 때문이다.

package org.springframework.boot.autoconfigure.kafka;

// ...

@AutoConfiguration
@ConditionalOnClass(KafkaTemplate.class)
@EnableConfigurationProperties(KafkaProperties.class)
@Import({ KafkaAnnotationDrivenConfiguration.class, KafkaStreamsAnnotationDrivenConfiguration.class })
@ImportRuntimeHints(KafkaAutoConfiguration.KafkaRuntimeHints.class)
public class KafkaAutoConfiguration {

	private final KafkaProperties properties;

	KafkaAutoConfiguration(KafkaProperties properties) {
		this.properties = properties;
	}

	// ...

	@Bean
	@ConditionalOnMissingBean(KafkaTemplate.class)
	public KafkaTemplate<?, ?> kafkaTemplate(ProducerFactory<Object, Object> kafkaProducerFactory,
			ProducerListener<Object, Object> kafkaProducerListener,
			ObjectProvider<RecordMessageConverter> messageConverter) {
		PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
		KafkaTemplate<Object, Object> kafkaTemplate = new KafkaTemplate<>(kafkaProducerFactory);
		messageConverter.ifUnique(kafkaTemplate::setMessageConverter);
		map.from(kafkaProducerListener).to(kafkaTemplate::setProducerListener);
		map.from(this.properties.getTemplate().getDefaultTopic()).to(kafkaTemplate::setDefaultTopic);
		map.from(this.properties.getTemplate().getTransactionIdPrefix()).to(kafkaTemplate::setTransactionIdPrefix);
		map.from(this.properties.getTemplate().isObservationEnabled()).to(kafkaTemplate::setObservationEnabled);
		return kafkaTemplate;
	}

	@Bean
	@ConditionalOnMissingBean(ProducerListener.class)
	public LoggingProducerListener<Object, Object> kafkaProducerListener() {
		return new LoggingProducerListener<>();
	}

	// 여기 !!!
	@Bean
	@ConditionalOnMissingBean(ConsumerFactory.class)
	DefaultKafkaConsumerFactory<?, ?> kafkaConsumerFactory(KafkaConnectionDetails connectionDetails,
			ObjectProvider<DefaultKafkaConsumerFactoryCustomizer> customizers) {
		Map<String, Object> properties = this.properties.buildConsumerProperties();
		applyKafkaConnectionDetailsForConsumer(properties, connectionDetails);
		DefaultKafkaConsumerFactory<Object, Object> factory = new DefaultKafkaConsumerFactory<>(properties);
		customizers.orderedStream().forEach((customizer) -> customizer.customize(factory));
		return factory;
	}

KafkaAutoConfiguration 클래스는 별도의 ConsumerFactory가 없으면 KafkaConsumerFactory 빈으로 등록해준다.

@ConfigurationProperties("spring.kafka")
public class KafkaProperties {

	/**
	 * List of host:port pairs to use for establishing the initial connections to the
	 * Kafka cluster. Applies to all components unless overridden.
	 */
	private List<String> bootstrapServers = new ArrayList<>(Collections.singletonList("localhost:9092"));

	// ...
}

이때 기본 설정은 KafkaProperties를 기반으로 하는데, spring.kafka.*를 기반으로 하고, 부트스트랩 서버의 기본값은 localhost:9092이다. 이래서 요청을 여기로 보냈던 것.

@Bean
@ConditionalOnMissingBean(name = "kafkaListenerContainerFactory")
ConcurrentKafkaListenerContainerFactory<?, ?> kafkaListenerContainerFactory(
        ConcurrentKafkaListenerContainerFactoryConfigurer configurer,
        ObjectProvider<ConsumerFactory<Object, Object>> kafkaConsumerFactory,
        ObjectProvider<ContainerCustomizer<Object, Object, ConcurrentMessageListenerContainer<Object, Object>>> kafkaContainerCustomizer) {
    ConcurrentKafkaListenerContainerFactory<Object, Object> factory = new ConcurrentKafkaListenerContainerFactory<>();
    configurer.configure(factory, kafkaConsumerFactory
        .getIfAvailable(() -> new DefaultKafkaConsumerFactory<>(this.properties.buildConsumerProperties())));
    kafkaContainerCustomizer.ifAvailable(factory::setContainerCustomizer);
    return factory;
}

그리고 KafkaAutoConfiguration은 KafkaAnnotationDrivenConfiguration를 임포트 하고 있는데, 이 클래스 내에서는 kafkaContainerFactory를 기반으로 kafkaListenerContainerFactory를 빈 등록하는 코드가 있다.

@Target({ ElementType.TYPE, ElementType.METHOD, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@MessageMapping
@Documented
@Repeatable(KafkaListeners.class)
public @interface KafkaListener {

	/**
	 * The bean name of the {@link org.springframework.kafka.config.KafkaListenerContainerFactory}
	 * to use to create the message listener container responsible to serve this endpoint.
	 * <p>
	 * If not specified, the default container factory is used, if any. If a SpEL
	 * expression is provided ({@code #{...}}), the expression can either evaluate to a
	 * container factory instance or a bean name.
	 * @return the container factory bean name.
	 */
	String containerFactory() default "";
    
    // ...
}

마지막으로 @KafkaListener는 containerFactory를 따로 지정하지 않으면 기본값으로 kafkaListenerContainerFactory를 사용한다.

해결

방법 1

아까 위의 빈 메서드명을 paymentRefundListenerContainerFactory에서 kafkaListenerContainerFactory로 변경해 주면 @KafkaListener가 해당 컨테이너 팩토리를 찾기 때문에 정상 동작한다.

방법 2

@KafkaListener(
    // ...
    containerFactory = "paymentRefundListenerContainerFactory"
)

이렇게 카프카 리스너에 컨테이너 팩토리를 명시적으로 빈 이름으로 작성해주면 된다.

TIL #130 : 컨트롤러 테스트에서 커스텀 UserDetails 인증 객체 사용하기

yunjae62 — Thu, 10 Apr 2025 19:05:54 +0900

요약

@WithMockUser는 기본적인 인증만 제공한다. 하지만 우리는 도메인에 맞는 커스텀 UserDetails를 사용하는 상황이고, 이럴 경우 @WithMockUser만으로는 인증 객체의 테스트가 어렵다. 이 글에서는 그런 상황에서 커스텀 인증 어노테이션을 만들어 중복 없이 테스트하는 방법을 정리한다.

문제

@RestController
@RequestMapping("/users")
@RequiredArgsConstructor
public class UserController {

    private final UserService userService;

    @GetMapping
    public UserRes getUser(@AuthenticationPrincipal UserDetails userDetails) {
        return userService.getUser(userDetails.getUsername());
    }
}

getUser 메서드처럼 @AuthenticationPrincipal UserDetails userDetails를 받는 컨트롤러 메서드가 있다.

만약 컨트롤러 메서드에서 UserDetails 인터페이스만 받는다면, @WithMockUser만으로도 충분하다.
하지만 UserDetailsImpl처럼 커스텀 인증 객체를 사용하고, 이 객체 안의 추가 필드나 로직을 테스트하고 싶다면 @WithMockUser로는 부족하다.

해결

나는 따로 @WithMockUser와 비슷한 역할을 하는 커스텀 어노테이션을 만들어주었다.

사전 코드 설명

우선 User, UserDetailsImpl 코드이다.

@Getter
@Entity
@Table(name = "tb_user")
@EntityListeners(AuditingEntityListener.class)
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String password;
    private String role;

    @CreatedDate
    private LocalDateTime createdAt;

    public User(String name, String password) {
        this.name = name;
        this.password = password;
        this.role = "ROLE_USER";
    }
}

public record UserDetailsImpl(User user) implements UserDetails {

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return List.of(user::getRole);
    }

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public String getUsername() {
        return user.getName();
    }
    
    // 이후 생략 
}

정말 간단하게 작성했다. 사실 이 정도면 @WithMockUser 써도 된다 ㅋ

테스트 코드를 보여주기 전에, 컨트롤러 슬라이스 테스트를 위한 밑작업을 해두었다.

public interface UserTest {

    String TEST_USER_NAME = "name01";
    String TEST_USER_PASSWORD = "1234";
    String TEST_USER_ROLE = "ROLE_USER";
    LocalDateTime TEST_USER_CREATED_AT = LocalDateTime.now();

    User TEST_USER = new User(TEST_USER_NAME, TEST_USER_PASSWORD);
}

나는 테스트용 인터페이스를 따로 만들어두는 편이다.

이렇게 만들어두고, 테스트 객체에서는 인터페이스를 구현하여 사용한다. 클래스가 아닌 인터페이스인 이유는, 여러 도메인을 implements 받을 수 있어서이다. 인터페이스의 본연의 역할과는 다르게 사용하긴 하지만.. 아직까지 더 나은 방식을 못 찾아서 일단 쓰는 중,,

import org.junit.jupiter.api.BeforeEach;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

public abstract class BaseControllerTest {

    @Autowired
    protected WebApplicationContext context;

    protected MockMvc mockMvc;

    @BeforeEach
    void setUpMockMvc() {
        this.mockMvc = MockMvcBuilders.webAppContextSetup(context).build();
    }
}

그리고 컨트롤러 테스트용으로 공통 추상 클래스를 만들어서 웹 컨텍스트와 MockMvc를 상속하여 재사용하도록 했다.

사전 작업 끝!

컨트롤러 테스트 코드 - 변경 전

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.BDDMockito.given;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

// ... 

@WebMvcTest(controllers = {UserController.class})
class UserControllerTest extends BaseControllerTest implements UserTest {

    @Autowired
    private ObjectMapper objectMapper;
    @MockitoBean
    private UserService userService;

    @BeforeEach
    void setUp() {
        UserDetails userDetails = new UserDetailsImpl(TEST_USER);
        SecurityContext securityContext = SecurityContextHolder.createEmptyContext();
        Authentication auth = new UsernamePasswordAuthenticationToken(userDetails, userDetails.getPassword(), userDetails.getAuthorities());
        securityContext.setAuthentication(auth);
    }

    @Test
    @DisplayName("유저 조회 테스트")
    void get_authenticated_user_test() throws Exception {
        // given
        UserDetails userDetails = (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        UserRes res = new UserRes(userDetails.getUsername(), TEST_USER_ROLE);
        given(userService.getUser(anyString())).willReturn(res);

        // when
        ResultActions perform = mockMvc.perform(get("/users")
            .contentType(MediaType.APPLICATION_JSON)
        );

        // then
        perform.andExpectAll(status().isOk(),
            jsonPath("$.name").value(res.name()),
            jsonPath("$.role").value(res.role())
        );
    }
}

이 코드는 컨트롤러 슬라이스 테스트다.

@WebMvcTest는 컨트롤러 슬라이스 테스트를 할 수 있도록 도와주는 어노테이션이다. 전체 빈을 로딩하지 않고, 컨트롤러 관련 빈만 불러오기 때문에 테스트 속도가 빠르다. 그리고 컨트롤러도 테스트 대상인 UserController 만을 대상으로 지정했다.

@BeforeEach
void setUp() {
    UserDetails userDetails = new UserDetailsImpl(TEST_USER);
    SecurityContext securityContext = SecurityContextHolder.createEmptyContext();
    Authentication auth = new UsernamePasswordAuthenticationToken(userDetails, userDetails.getPassword(), userDetails.getAuthorities());
    securityContext.setAuthentication(auth);
}

이 부분을 보면

UserDetails 생성
SecurityContext 생성
UserDetails 기반으로 Authentication 객체 생성
SecurityContext 내 인증 처리

로 인증 처리를 해주고 있다.

하지만 지금은 이 컨트롤러 하나지만, 나중에 컨트롤러가 늘어날 때마다 중복 코드가 만들어지게 된다. 그래서 이러한 중복을 없애기 위한 방법이 있다. 바로 @WithMockUser를 쓰는 것.

@WebMvcTest(controllers = {UserController.class})
@WithMockUser(username = "hi") // 여기 !!!
class UserControllerTest extends BaseControllerTest implements UserTest {

    @Autowired
    private ObjectMapper objectMapper;
    @MockitoBean
    private UserService userService;
    
    // setUp 제거 !!!

    @Test
    @DisplayName("유저 조회 테스트")
    void get_authenticated_user_test() throws Exception {
        // given
        UserDetails userDetails = (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        UserRes res = new UserRes(userDetails.getUsername(), TEST_USER_ROLE);
        given(userService.getUser(anyString())).willReturn(res);

        // when
        ResultActions perform = mockMvc.perform(get("/users")
            .contentType(MediaType.APPLICATION_JSON)
        );

        // then
        perform.andExpectAll(status().isOk(),
            jsonPath("$.name").value(res.name()),
            jsonPath("$.role").value(res.role())
        );
    }
}

실제로 이렇게 해도 테스트는 통과한다.

@Test
@DisplayName("유저 조회 테스트")
void get_authenticated_user_test() throws Exception {
    UserDetailsImpl userDetails = (UserDetailsImpl) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    Assertions.assertThat(userDetails.user().getCreatedAt()).isNull();
}

하지만 이렇게 커스텀 UserDetails의 필드를 조회해야할 때는 사용이 불가능하다. 또 컨트롤러에서 커스텀 UserDetails를 받을 때도.

그래서 커스텀 어노테이션을 만들었다.

커스텀 어노테이션 작성

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import org.springframework.security.test.context.support.WithSecurityContext;

@Retention(RetentionPolicy.RUNTIME)
@WithSecurityContext(factory = WithMockCustomUserSecurityContextFactory.class)
public @interface WithMockCustomUser {

    String name() default UserTest.TEST_USER_NAME;

    String password() default UserTest.TEST_USER_PASSWORD;

    String role() default UserTest.TEST_USER_ROLE;
}

우선 어노테이션을 만든다. 나는 @WithMockCustomUser이라고 만들었다.

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.test.context.support.WithSecurityContextFactory;

public class WithMockCustomUserSecurityContextFactory implements WithSecurityContextFactory<WithMockCustomUser>, UserTest {

    @Override
    public SecurityContext createSecurityContext(WithMockCustomUser customUser) {
        User user = new User(customUser.name(), customUser.password());
        UserDetails userDetails = new UserDetailsImpl(user);
        Authentication auth = new UsernamePasswordAuthenticationToken(userDetails, userDetails.getPassword(), userDetails.getAuthorities());

        SecurityContext context = SecurityContextHolder.createEmptyContext();
        context.setAuthentication(auth);

        return context;
    }
}

그리고 SecurityContextFactory를 커스텀으로 만들어주면 된다. 내부 로직은 위와 비슷하게, customUser로부터 User를 만들어서 인증 처리한다.

package org.springframework.security.test.context.support;

import java.lang.annotation.Annotation;
import org.springframework.security.core.context.SecurityContext;

public interface WithSecurityContextFactory<A extends Annotation> {
    SecurityContext createSecurityContext(A annotation);
}

WithSecurityContextFactory<A>에서 A 제네릭은 앞서 만든 WithMockCustomUser 어노테이션을 넣어주면 된다. 어노테이션 밖에 못 들어간다.

컨트롤러 테스트 코드 - 변경 후

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.BDDMockito.given;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

// ... 

@WebMvcTest(controllers = {UserController.class})
@WithMockCustomUser(name = "hi") // 여기 1 !!! 
class UserControllerTest extends BaseControllerTest implements UserTest {

    @Autowired
    private ObjectMapper objectMapper;
    @MockitoBean
    private UserService userService;

    @Test
    @DisplayName("유저 조회 테스트")
    void get_authenticated_user_test() throws Exception {
        // given
        // 여기 2 !!!
        UserDetails userDetails = (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        UserRes res = new UserRes(userDetails.getUsername(), TEST_USER_ROLE, TEST_USER_CREATED_AT);
        given(userService.getUser(anyString())).willReturn(res);

        // when
        ResultActions perform = mockMvc.perform(get("/users").contentType(MediaType.APPLICATION_JSON));

        // then
        perform.andExpectAll(status().isOk(),
            jsonPath("$.name").value(res.name()),
            jsonPath("$.role").value(res.role()),
            jsonPath("$.createdAt").value(res.createdAt().toString())
        );
    }
}

그 다음 아까 봤었던 컨트롤러에 적용해 보았다.

컨트롤러 클래스에 @WithMockCustomUser(name = "hi") 어노테이션이 붙었다. 이를 통해 커스텀 UserDetails에 접근할 수 있다.

TIL #129 : 구글 번역 → next-intl 전환으로 렌더링 속도 70% 개선 (2.34s → 0.71s)

yunjae62 — Tue, 8 Apr 2025 15:28:23 +0900

요약

기존 구글 번역 기반의 느리고 문단이 깨지는 방식을 next-intl 도입으로 렌더링 평균 2.34초 → 0.71초로 70% 개선한 적용하였다.

문제

인턴으로 입사한 직후, 대표님으로부터 받은 첫 업무는 서비스 내 영문 페이지의 성능 개선이었다. 기존에는 별도의 영문 페이지가 존재하지 않았고, 사용자가 전환 버튼을 누르면 국문 페이지에 구글 번역 스크립트를 삽입하여 클라이언트에서 전체 번역을 수행하는 방식이었다.

이 방식은 국문 페이지가 먼저 렌더링된 뒤, 번역 스크립트가 로드되고 번역 요청이 수행된 후에야 화면이 바뀌는 구조라, 사용자 입장에서는 약 2초간 한글 화면을 계속 보게 되어 이질감을 느낄 수 있었다. 또한 번역 도중 줄바꿈이 깨지거나, 마우스 호버 시 구글 번역 UI가 노출되는 등의 문제가 있었다.

성능 개선을 위한 기준 수립을 위해, localhost 환경에서 가장 단순한 페이지(이미지 1개, DB 요청 없음)를 선정하여 테스트를 진행했다. HTTPS 환경에서는 SSL/TLS 핸드셰이크에 의한 초기 지연이 발생하므로, 변경 전후를 모두 로컬에서 테스트했다.

이후 캐시 비우기 및 강력 새로고침을 10회 반복하였고, MutationObserver를 활용해 텍스트가 마지막으로 변경된 시점을 1초 디바운스로 측정하여 평균 렌더링 시간을 구했다.

'use client'

import { useEffect } from 'react'

const GAP = 1000 // 디바운스 기준 시간 (ms)

export default function TranslateObserver() {
  useEffect(() => {
    const target = document.getElementById('observe-target') // 감지할 최상위 DOM 요소
    if (!target) return

    let finalTimer: NodeJS.Timeout | null = null
	
    // 텍스트 변화 감지 → 변화 이후 GAP 동안 추가 변화가 없으면 최종 반영 시점으로 판단
    const observer = new MutationObserver(() => {
      if (finalTimer) clearTimeout(finalTimer)

      finalTimer = setTimeout(() => {
        const timestamp = performance.now() - GAP // GAP만큼 보정한 최종 반영 시각
        console.log(`최종 텍스트 반영 시점: ${timestamp.toFixed(2)}ms`)
        observer.disconnect()
      }, GAP)
    })
	
    // target 이하 모든 자식 노드의 텍스트/구조 변경 감지
    observer.observe(target, {
      subtree: true,
      characterData: true,
      childList: true,
    })

    console.log('번역 감지 시작')

    return () => {
      if (finalTimer) clearTimeout(finalTimer)
      observer.disconnect()
    }
  }, [])

  return null
}

// layout.tsx

// ...

export default async function RootLayout({ children, params }: RootLayoutProps) {

  return (
    <html lang={locale}>
      <body>
        <Header />
        <main id={'observe-target'}>{children}</main>
        <TranslateObserver /> // 타깃(observe-target)보다 아래에.
        <Footer />
      </body>
    </html>
  )
}

next.js 자체의 렌더링이 아니라 외부 번역 API로 DOM 값이 변경되고, 번역 시간도 길어서 디바운스 시간을 길게 주었다.

1840.00ms
1996.70ms
2127.30ms
2245.60ms
2882.30ms
2197.20ms
2531.90ms
2456.70ms
2568.90ms
2576.30ms

평균 : 2342.29ms (2.34초)

해결

next-intl 국제화 라이브러리를 도입하고 Accept-Language 기반 콘텐츠 협상으로 첫 접속 시 자동으로 해당 언어로 라우팅 되도록 했다.

국제화(i18n)/지역화(l10n)

국제화 (i18n, internationalization) : 소프트웨어를 다양한 언어와 지역에 맞게 쉽게 현지화할 수 있도록 구조화하는 과정이다. i18n인 이유는 i와 n 사이에 18글자가 있기 때문. 쿠버네티스가 k8s라고 적는 이유와 동일하다.

지역화 (l10n, localization) : 국제화된 소프트웨어에 실제 언어, 날짜 형식, 통화, 문화적 요소 등을 적용하여 특정 지역 또는 언어권에 맞게 조정하는 과정이다.

콘텐츠 협상

콘텐츠 협상(Content Negotiation) : HTTP에서 같은 URI에 대해 가장 적합한 자원의 표현을 제공하는 메커니즘이다. 여기서 표현이란 송수신 가능한 자원의 형태로, 서버가 클라이언트에게 리소스를 전달할 때 하나의 자원을 다양한 형식(표현)으로 제공할 수 있다.

예를 들어, 클라이언트가 /items/1 이라는 자원을 요청할 때, Accept : application/json 을 요청 헤더로 함께 보내면 서버는 json 형식으로 응답할 수 있고, application/xml로 요청하면 xml로 응답할 수 있다.

콘텐츠 협상 관련 HTTP 헤더로는 아래와 같다.

Accept : 선호하는 미디어 타입 (application/json, application/ xml, text/html 등)
Accept-Language : 선호 언어 (ko, en, ko-KR, 등)
Accept-Charset: 선호하는 문자 인코딩(charset) (utf-8, iso-8859-1, 등)
Accept-Encoding: 선호하는 콘텐츠 인코딩(압축 방식) (gzip, deflate, br 등)

q(Quality Value) : 콘텐츠 협상을 할 때는 선호도로 우선순위를 반영할 수 있다. 0~1 사이값으로 값이 클수록 우선순위가 높다. 생략 시 1이다. 각 값에 ; 를 붙인 후 q=<값>을 붙인다.

예시 : Accept-Language: ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7

ko-KR: 한국어 (대한민국), 가장 선호 (q 생략 시 기본값 1.0)
ko;q=0.9: 한국어 (국가 상관 없음)
en-US;q=0.8: 영어 (미국)
en;q=0.7: 영어 (국가 상관 없음)

<언어> 또는 <언어>-<국가> 로 locale을 지정할 수 있다.

라이브러리 채택

우선 Next.js 특화된 국제화 라이브러리를 물색했다. next-intl, next-i18next 로 일단 좁혀졌다.

라이브러리 선택 기준은 다음과 같았다.

러닝 커브가 낮을 것 (Next.js도 아직 익숙하지 않음)
참고할 수 있는 자료가 많을 것
지역화(l10n)까진 필요 없이 단순한 국제화 기능만 필요
App Router 기반 프로젝트와 잘 호환될 것

결론적으로 next-intl을 택했다. 찾아보니 next-18next는 공식 깃허브 리드미에서도 앱 라우터는 i18next, react-i18next를 사용하라고 안내했다. 근데 Next.js에 i18next 얹혀서 넥스트에 맞게 또 설정해주는 것을 찾아보기에는 next-intl의 공식문서가 너무 잘 되어 있었다.

앱 라우터인지 페이지 라우터인지, i18n 라우팅하는지 아닌지에 따라 문서가 잘 나누어져 있고, 알려준대로 코드 복붙만 딱딱 해도 바로 작동했다. 또 번들 사이즈도 1.1kB에 주간 다운로드수도 약 55만에 꾸준히 성장하고 있어서 바로 채택했다. next-18next는 16.4kB, 42만 다운로드 수였다.

next-intl 예제

// /src/app/[locale]/page.tsx

import { useTranslations } from "next-intl";
import Button from "@/components/Button";
import Vertical from "@/components/Vertical";

export default function Home() {
  const t = useTranslations("Home");

  return (
    <div style={{ textAlign: "center" }}>
      <div>{t("hello")}</div>
      <Button />
      <Vertical />
    </div>
  );
}

// messages/ko.json

{
  "Home": {
    "hello": "안녕 세상아",
    "vertical": "<br></br>세로"
  }
}

// messages/en.json

{
  "Home": {
    "hello": "Hello World",
    "vertical": "<br></br>vertical"
  }
}

사용법도 간단했다. t 함수 불러와서 따로 각 언어별 json에 저장된 키를 가져오면 된다.

"use client";

import { useLocale } from "next-intl";
import { usePathname, useRouter } from "@/i18n/navigation";

export default function Button() {
  const locale = useLocale();
  const pathname = usePathname();
  const router = useRouter();

  const handleClick = () => {
    const afterLocale = locale === "ko" ? "en" : "ko";
    router.push(pathname, { locale: afterLocale });
  };

  return (
    <button
      onClick={handleClick}
      className="rounded-md bg-blue-500 px-4 py-2 text-white hover:bg-blue-600"
    >
      {locale === "ko" ? "영어로 보기" : "View in Korean"}
    </button>
  );
}

언어 전환 라우팅도 복잡한 설정 없이 그냥 옵션에 locale 넣어주면 알아서 해준다.

import { useTranslations } from "next-intl";

export default function Vertical() {
  const t = useTranslations("Home");

  return (
    <div>
      {t.rich("vertical", {
        br: () => <br />,
      })}
    </div>
  );
}

요구사항 중, 언어 별로 문단을 분리하거나 합치는 등 별도로 관리할 수 있으면 좋겠다고 하셨었는데, rich 라는 함수를 쓰면 각 언어 json 중 필요한 부분에 원하는 태그를 넣어두면 해당 태그를 변환시킬 수도 있었다. 이를 이용해서 영문 부분에 <br></br>을 넣어두어서 문단 분리를 할 수 있었다.

import { NextRequest } from "next/server";

const locales = ["en", "ko"];
const defaultLocale = "ko";

function parseAcceptLanguage(header: string | null): string[] {
  if (!header) return [];

  return header
    .split(",")
    .map((entry) => {
      const [lang, qValue] = entry.trim().split(";q=");
      return {
        lang: lang.trim(),
        q: qValue ? parseFloat(qValue) : 1.0,
      };
    })
    .sort((a, b) => b.q - a.q)
    .map((item) => item.lang);
}

// 가장 먼저 일치하는 언어 반환
function getLocale(request: NextRequest): string {
  const acceptLanguage = request.headers.get("Accept-Language");
  const acceptedLanguages = parseAcceptLanguage(acceptLanguage);

  for (const lang of acceptedLanguages) {
    const baseLang = lang.split("-")[0];
    if (locales.includes(baseLang)) {
      return baseLang;
    }
  }

  return defaultLocale;
}

export const routing = {
  locales,
  defaultLocale,
  getLocale,
};

또 따로 locale을 지정하지 않을 때는 Accept-Language 요청 헤더를 통해 언어 콘텐츠 협상으로 언어를 정하도록 했다.

적용 후

next-intl 적용 후에는 국제화를 적용하여 번역된 HTML을 내려주므로, 텍스트가 변경되지 않아서 최초 렌더링 시점을 기준으로 잡았다.

'use client'

import { useEffect } from 'react'

export default function TranslateObserver() {
  useEffect(() => {
    const timestamp = performance.now()
    console.log(`최초 렌더링 시점: ${timestamp.toFixed(2)}ms`)
  }, [])

  return null
}

역시나 마찬가지로 캐시 비우기 및 강력 새로고침으로 10회 진행했다.

716.50ms
678.10ms
654.30ms
681.90ms
700.50ms
746.60ms
680.20ms
676.00ms
787.30ms
747.40ms

평균 : 706.88ms (0.707초)

결론

평균 2.34초가 걸리던 화면 렌더링 시간을 next-intl 도입을 통해 평균 0.706초로 69.83% 단축할 수 있었고, 불필요한 스크립트 로딩도 제거되었고, UI 깨짐도 완전히 사라졌다.

TIL #128 : PNG 이미지를 WebP 확장자로 변환하여 95% 용량 절감

yunjae62 — Mon, 7 Apr 2025 16:21:21 +0900

요약

PNG 형식의 퍼블릭 이미지를 WebP 확장자로 변경하여 용량 95% 절감 (평균 2.46MB → 128KB, 총 29.53MB → 1.54MB)

문제 1 : public 이미지의 용량 비대

기존의 public 디렉터리에 있던 이미지들은 모두 PNG 확장자였고 기본적으로 MB 단위라서 불러오는데 체감 시간이 오래 걸렸다. 특히 가장 큰 이미지의 경우 11MB나 됐는데, 504 Gateway Timeout 에러가 발생했다. 이미지 로딩 이 너무 오래 걸려서 타임아웃이 난거다.

물론 Next.js의 Image 컴포넌트가 브라우저 호환여부에 따라 webp로 변환해주기는 하나, 원본의 용량 자체가 커서 다소 불러오는데 시간이 걸렸다.

해결 1 : WebP 변환하여 용량 절감

WebP 란?

WebP는 구글이 2010년에 개발한 이미지 포맷으로, 손실 및 비손실 압축, 움짤, 알파를 모두 지원하여 JPG 대비 25~34%, PNG 대비 26% 정도 줄어듦(구글 발표 기준)

기존의 12장의 PNG 이미지를 모두 WebP 확장자로 변경하여 평균 2.46MB에서 128KB로, 총 29.53MB에서 1.54MB로 95% 용량 절감하였다.

문제 2 : 원본 이미지보다 응답 이미지의 용량이 더 커짐

개발자 도구의 네트워크 탭을 확인해 보니 응답 이미지의 용량이 public 내의 원본 이미지 용량보다 더 컸다.

해결 2 : quality 속성을 100에서 75로 축소

코드 상에서는 next/image의 Image 컴포넌트를 사용하고 있었다. 이 컴포넌트는 요청된 사이즈에 맞게 리사이징 후 WebP로 재인코딩한다. 이 과정에서 원본보다 용량이 커질 수 있는데, quality 속성을 100으로 하면 압축을 거의 하지 않아서 결과적으로 원본보다 용량이 더 커지게 된다. 이를 기본값인 75로 지정해 주었다.

<Image 
    src={images.image1} 
    alt="image1" 
    fill 
    className="object-cover" 
    quality={75} // 여기 !! (또는 생략)
/>

문제 3 : 이미지 경고 로그

mage with src "/_next/static/media/image1.png" has legacy prop "layout". Did you forget to run the codemod?
Read more: https://nextjs.org/docs/messages/next-image-upgrade-to-13
Image with src "/_next/static/media/image1.png" has legacy prop "objectFit". Did you forget to run the codemod?
Read more: https://nextjs.org/docs/messages/next-image-upgrade-to-13

해당 링크를 참고하라고 한다.

해결 3 : 문서 대로 수정

<Image 
	src={images.image1} 
	alt="image1" 
	layout="fill" // 여기 1
	objectFit="cover" // 여기 2
	quality={75} 
/>

기존의 코드는 위와 같다.

<Image 
	src={images.image1} 
	alt="image1" 
	fill // 여기 1
	className="object-cover" // 여기 2
	quality={75} 
/>

변경한 코드는 위와 같다.

추가 개선 사항

이미지를 WebP 확장자로 변경하려고 하니, 일일이 페이지를 찾아가서 코드를 수정해야하는 문제가 있어서, 이미지 매핑 레이어를 추가해서 관리하였다.

import image1 from '@images/image1.webp'
import image2 from '@images/image2.webp'
import image3 from '@images/image3.webp'
// ...

export const images = {
  image1,
  image2,
  image3,
  // ...
}

결론

png → webp 확장자 변경으로 이미지 총합 29.53MB 에서 1.54MB로 95% 절감
12개의 이미지를 이미지 매핑 레이어로 중앙집중화 하여 유지보수성 증대
레거시 속성의 개선으로 경고 메시지 제거

TIL #127 : Axios Interceptor 도입으로 인증 공통화 및 141줄 절감

yunjae62 — Mon, 7 Apr 2025 14:21:34 +0900

요약

기존의 매 페이지마다 인증 처리를 하던 방식에서 Axios interceptor로 요청 전후를 공통 관심사로 묶어서 총 7페이지에서 순 141줄을 절감했다.

상황

인증이 필요한 페이지에서 등록/수정/삭제 요청을 보낼 때마다 매 페이지에서 인증 처리를 구현하고 있었다.

해결

Axios interceptor 도입하여 반복되는 인증 로직을 공통 관심사로 묶어 유지보수성과 일관성을 확보했다.

Axios 란?

Axios는 브라우저와 Node.js를 위한 Promise 기반 HTTP 클라이언트이다. 그러니까 브라우저든 Node.js든 동일하게 사용할 수 있는 웹 요청 라이브러리다.

Axios Instance 란?

Axios instance는 공통된 설정(예: baseURL, 헤더 등)을 사전에 정의해 재사용할 수 있도록 하는 Axios의 기능이다.

Axios interceptor 란?

Axios interceptor는 요청 또는 응답이 처리되기 전/후에 가로채어 공통 로직(예: 토큰 자동 추가, 에러 처리 등)을 수행할 수 있도록 도와주는 기능이다.

Axios Interceptor 적용

적용 전의 코드는 아래와 같다. 매 인증 요청을 보내는 페이지마다 해당 로직이 있었다.

try {
  const token = getAccessToken()

  if (!token) {
    router.push('/login')
    return
  }

  const response = await fetch('/api/items', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${token}`,
    },
    body: data,
  })

  if (response.ok) {
    router.push('/items')
  } else {
    const errorResponse = await response.json()

    if (response.status === 401) {
      alert('인증이 만료되었습니다. 다시 로그인해주세요.')
      removeAccessToken()
      router.push('/login')
    }
  }
} catch (error) {
  // ...
}

예제로 만들었다. 단순화해서 Access token만 썼다.

그리고 이를 공통화하기 위해 Axios Interceptor를 만들었다.

import axios from 'axios'

export const authInstance = () => {
  const instance = axios.create()

  instance.interceptors.request.use(
    (config) => {
      const token = getAccessToken()
      if (!token) {
        throw new CustomError('인증 토큰이 없습니다.', 401)
      }
      config.headers.Authorization = `Bearer ${token}`
      return config
    },
    (error) => Promise.reject(error),
  )

  instance.interceptors.response.use(
    (response) => response,
    (error) => {
      if (error?.response?.status === 401) {
        alert('인증이 만료되었습니다. 다시 로그인해주세요.')
        removeAccessToken()
        return Promise.reject(new CustomError('토큰 만료', 401))
      }
      return Promise.reject(error)
    },
  )

  return instance
}

인스턴스를 만들고, 요청 전에 토큰을 가져와 헤더에 넣어주었고, 응답에 401 에러가 나면 인증 만료 처리를 해주었다.

그리고 이를 처음 코드에 적용하면,

try {
  await authInstance().post('/api/items', data)
  router.push('/items')
} catch (error: CustomError) {
  if (error.status === 401) {
    alert('인증이 만료되었습니다. 다시 로그인해주세요.')
    router.push('/login')
}

이렇게 된다.

결론

7개 페이지에서 중복된 인증 처리 로직을 제거하여, 순 141줄을 절감하고 유지보수성을 높였다.

TIL #126 : SWR 도입으로 7개 페이지에서 93줄 코드 절감

yunjae62 — Mon, 7 Apr 2025 13:03:37 +0900

요약

SWR이라는 데이터 패치 라이브러리를 도입하여 외부에서 데이터를 불러올 때 로딩, 에러, 데이터를 단순하게 관리하고, 7페이지에서 총 순 93줄을 줄였다.

상황

인턴으로 간 회사에서 코드를 보니 매 페이지마다 외부 요청 페이지에서 요청, 로딩, 에러를 일일이 useState, fetch로 구현하고 있었다.

해결

SWR 라이브러리를 도입하였다.

SWR란?

SWR은 데이터 패치 리액트 훅이다.

Stale-While-Revalidate이라는 HTTP 캐시 무효 전략을 기반으로 만들어진 라이브러리로, Stale-While-Revalidate은 우선 캐시된 데이터를 반환하면서 데이터를 요청하고, 응답받으면 이를 최신화하는 전략이다.

import useSWR from 'swr'

const fetcher = (url: string) => fetch(url).then((res) => res.json());

function Profile() {
  const { data, error, isLoading } = useSWR('/api/user', fetcher)

  if (error) return <div>failed to load</div>
  if (isLoading) return <div>loading...</div>
  return <div>hello {data.name}!</div>
}

공식 문서에 나온 간단한 예제이다.

useSWR을 통해 원하는 url과 패처를 지정해 주면, 그에 대한 응답, 에러, 로딩처리를 해준다.

SWR 채택 이유

데이터 패치 라이브러리로 크게 SWR과 TanStack Query(구 React Query)가 있다.

우선 도입 전 상황은 이렇다.

프론트 스택에 대해 잘 모르고 시간도 없어서 러닝 커브가 크지 않아야 한다.
같은 이유로, 풍부한 레퍼런스가 있어야 한다.
대부분 단일 앤드 포인트의 단순 조회 로직만 있어서 풍부한 기능이 필요 없다. (조회, 로딩, 에러 처리만 필요)
Mutation이 거의 없고 Pagination이 필요 없다.
데이터가 실시간으로 변하지 않고, 변경 주기가 매우 길다.

SWR이 위의 상황에 가장 적합했다.

TanStack Query에 비해 더 적은 보일러플레이트
단순 기능
적은 용량 (5.2kB vs 15.5kB)
TanStack Query보단 낮지만 절대적으로 높은 주간 다운로드 수 (330만 vs 650만)

SWR 적용

기존에는 각 페이지마다 요청, 에러처리, 로딩처리가 개별로 구현되어 있었다.

'use client'

// ...

export default function Home() {
  const [items, setItems] = useState<Item[]>()
  const [isLoading, setIsLoading] = useState(false)
  const [error, setError] = useState<string | null>(null)

  useEffect(() => {
    itemsHandler()
  }, [])

  const itemsHandler = async () => {
    setIsLoading(true)
    setError(null)

    try {
      const response = await fetch(`/api/items`)
      if (!response.ok) {
        throw new Error('서버에서 데이터를 가져오는 데 실패했습니다.')
      }
      const data = await response.json()
      setItems(data.data)
    } catch (error) {
      setError('데이터를 불러오는 중 오류가 발생했습니다.')
    } finally {
      setIsLoading(false)
    }
  }

  if(isLoading) {
    return <p>로딩 중...</p>
  }

  if(error) {
    return <p>{error}</p>
  }

  return (
    <>
      <div>
        {items?.map((item) => (<ItemCard ... />))}
      </div>
    </>
  )
}

당연히 회사 코드 아니고 예제로 만들었다.

외부에서 데이터를 가져오는 페이지마다 항상 useState 3개와 데이터 패치 함수를 만들어주어야 했다.

이를 SWR을 적용하면 아래와 같다.

'use client'

// ...

interface ItemResponse {
  data: Item[]
  message: string
}

export default function Home() {
  const { data, error, isLoading } = useSWR<ItemResponse>(`/api/items`)

  if(isLoading) {
    return <p>로딩 중...</p>
  }

  if(error) {
    return <p>{error}</p>
  }
  
  const items = data?.data || []

  return (
    <>
      <div>
        {items.map((item) => (<ItemCard ... />))}
      </div>
    </>
  )
}

아까 예제를 보면 fetcher가 있었는데 여기는 없다. 이는 프로바이더에서 공통으로 쓰도록 했기 때문이다.

// SWRProvider.tsx

'use client'

import { SWRConfig } from 'swr'
import { ReactNode } from 'react'

const fetcher = (url: string) => fetch(url).then((res) => res.json())

export default function SWRProvider({ children }: { children: ReactNode }) {
  return (
    <SWRConfig
      value={{
        fetcher,
        revalidateOnFocus: false, // 탭 포커스 시 다시 요청 금지
        revalidateOnReconnect: false, // 온라인 복귀 시 다시 요청 금지
        refreshInterval: 0, // 주기적 요청 금지
      }}
    >
      {children}
    </SWRConfig>
  )
}

// layout.tsx

export default async function RootLayout({ children, params }: RootLayoutProps) {
  return (
    <html lang={locale}>
      <body>
        <SWRProvider>
            <Header />
            <main>{children}</main>
            <Footer />
        </SWRProvider>
      </body>
    </html>
  )
}

SWRProvider를 만들어서, 공통으로 쓰일 패처와 설정들을 해주었다.

만약 지정한 패처 말고 다른 패처를 쓰고 싶다면 useSWR에서 커스텀을 넣어주면 된다.

그 외에, SWR은 기본 설정이 탭 포커스가 될 때, 온라인 전환 시, 또 주기적으로 재요청을 보내서 요청이 과도하게 보내게 된다. 그래서 이 설정을 꺼주어서 요청 빈도를 줄였다.

이렇게 총 7페이지에 걸쳐서 순 93줄을 줄일 수 있었다. (늘어난 줄 수 - 줄어든 줄 수)

TIL #125 : 멀티스테이지 & .dockerignore로 Next.js Docker 이미지 용량 절반 줄이기

yunjae62 — Wed, 2 Apr 2025 16:20:54 +0900

요약

1.99GB였던 Next.js Docker 이미지를 멀티스테이지 빌드와 .dockerignore 도입으로 1.01GB까지 줄여 약 49% 경량화

문제

Next.js로 도커 이미지로 빌드하여 ECR에 푸쉬하여 사용하고 있었다. 하지만 기존에는 도커 이미지가 약 2GB로 크기가 커서, 빌드 시간이 오래 걸리고 ECR 업로드/다운로드 속도도 느렸다. 또 ECR에 저장할 때는 1GB당 월 0.1달러씩 부과하며, 트래픽에도 요금을 받고 있었기 때문에 용량을 더 줄이고자 했다.

해결 1 : 멀티 스테이지 도입

// 기존 Dockerfile

FROM node:version-alpine
ENV TZ=Asia/Seoul
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm install
COPY . .
RUN npm run build
EXPOSE 3000
CMD ["npm", "start"]

기존의 도커파일이다. 싱글 스테이지로 빌드하고 있어서 빌드 도구, 테스트 파일, 소스코드, .git 등도 실행 이미지에 남게 되어 용량도 커지고 보안적인 문제가 발생한다. 그래서 이를 멀티 스테이지로 빌드 부분과 실행 부분을 분리하였다.

# 1. 빌드 단계
FROM node:version AS builder

# 작업 디렉토리 설정
WORKDIR /app

# 종속성 설치
COPY package.json package-lock.json ./
RUN npm install

# 전체 소스 복사 후 빌드
COPY . .
RUN npm run build

# 2. 실행 단계 (경량화된 실행 환경)
FROM node:version-alpine AS runner

# 타임존 설정
ENV TZ=Asia/Seoul

# 작업 디렉토리
WORKDIR /app

# 실행에 필요한 파일만 복사
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./
COPY --from=builder /app/public ./public
COPY --from=builder /app/.next ./.next

# 포트 설정
EXPOSE 3000

# 실행 명령
CMD ["npm", "start"]

먼저 builder로 빌드를 진행하고, 빌드 후 필요한 파일만 runner로 옮겨와서 alpine으로 이미지를 구웠다. 빌드 후 builder는 폐기된다. 이를 통해 1.99GB -> 1.21GB로 용량이 감소했다.

해결 2 : .dockerignore 도입

.dockerignore 파일은 COPY . . 시 Docker가 읽는 컨텍스트에서 제외할 파일과 디렉터리를 지정하여, 불필요한 항목이 이미지에 포함되지 않도록 도와준다.

// .dockerignore 

# node_modules는 컨테이너에서 설치됨
node_modules

# Next.js 빌드 결과물은 build 단계에서 새로 생성됨
.next
out

# Git, 환경 설정, 빌드 도구 등 불필요한 파일
.git
.gitignore
*.log
.vscode
.idea
*.tsbuildinfo
.DS_Store

# 테스트 및 문서
coverage
__tests__
docs

1.21GB → 1.01GB로 용량이 줄었다. 하지만 builder는 폐기되는데 COPY가 없는 runner에서는 왜 용량이 줄었는지 찾아보았다.

용량이 줄어든 이유

처음에는 builder 측에서 npm install을 하면 /app/node_modules가 생기는데, COPY --from=builder /app/node_modules ./node_modules 로 node_modules가 중복으로 생겨서, 이로 인해 용량이 늘어난 줄 알았다.

하지만 중복의 디렉토리명을 추가하면 에러가 나지 않을까? 해서 찾아보니 도커는 명령어 별로 레이어를 구성하는데, 이후 명령으로 덮어써서 에러는 안 나고, node_modules가 레이어 별로 존재하기 때문에 용량이 늘어난 거인줄 알았다. 이는 로컬의 node_modules의 용량은 460MB였는데 레이어는 압축이 되기 때문에 납득이 될.... 뻔했다.

문제는 레이어가 늘어난 부분은 builder여서, runner 측 이미지에는 영향을 주지 않는데도 용량이 늘어났다는 거였다. 그래서 dive라는 도커 이미지 분석 툴을 이용해서 .dockerignore 적용 전후의 이미지를 분석해보았다.

.dockerignore 적용 전이다. /app 디렉터리에는 node_modules 하나만 있다.

.dockerignore 적용 후이다. 역시 /app 디렉토리에는 node_modules 하나만 있다.

하지만 다른 점이 하나 있다.

COPY node_modules 부분이 적용 전보다 약 148MB 더 커졌고,

COPY .next 부분이 적용 전보다 약 53MB 더 커졌다.

그래서 가설을 하나 세워봤다. 로컬의 node_modules와 .next를 가져왔고, 이게 용량이 더 크며, 이후 npm install 및 npm run build 시에는 이미 node_modules와 .next가 있으니 중복되는 것들은 덮어쓰기가 된 것. 이 포스팅 이전에 깃을 넘나들면서 의존성이 뒤섞여 설치하느라 충분히 용량이 커질만했다.

이 가설을 토대로 node_modules와 .next를 제거 후 도커 이미지를 빌드하니..... 1.01GB로 줄었다 ㅋㅋ

결론

1.99GB → 1.01GB로 이미지 49% 절감
- 배포 속도 향상 (업로드/다운로드 속도 향상, 컨테이너 실행 속도 향상)
- 저장 비용 절감 (ECR 저장 비용, 트래픽 비용 절감)
또한 ECR은 Docker 이미지를 레이어 단위로 gzip 압축하여 저장하므로, 실제 저장 용량은 약 293MB까지 감소 (1.01GB → 293.33MB)

[백준 자바 2096] 내려가기 (골드5)

yunjae62 — Tue, 26 Nov 2024 13:36:43 +0900

https://www.acmicpc.net/problem/2096

설명

N은 1 이상 10만 이하로, 한 줄에는 3칸이 있고 각 칸에는 최대 9까지 올 수 있으므로, 최악의 경우의 합을 더해도 9 * 10만 = 90만으로 int의 최댓값보다 작다.

또한 메모리가 4MB인데, 4byte(int) * 3칸 * 10만 줄 = 1.2MB로, 입력받는 배열에 최댓값, 최솟값 + 기타 연산하면서 생기는 객체들까지 고려하면 메모리 초과가 날 것 같았다.

그래서 입력 배열은 따로 만들지 않고 최댓값 배열과 최솟값 배열만 만들되, 각각 2 * 3 배열을 만들어서 값을 재사용하기로 했다.

우선 N과 최댓값 배열 maxArr, 최솟값 배열 minArr을 선언해준다. 그리고 각 배열을 2*3으로 초기화해준다.

i / j	1	2
0	0	0
1	0	0

(블로그 스킨이 표를 이상하게 표현해서.. 양해 부탁드려요)

각 배열은 초기값이 이렇게 되어 있을 거다.

이제부터 0행은 기존값을, 1행은 기존값으로부터 최댓값을 계산한 후, 다 계산하면 이를 다시 0행으로 옮겨줄 거다.

우선 최댓값을 구하는 부분부터.

먼저 3칸의 입력을 받아서 x0, x1, x2에 넣어주었다. (최솟값 배열 계산할 때도 쓰여야 해서)

다음은 1행에 대해서 0행 중 최댓값을 가져온 뒤, 입력값을 각각 열에 맞게 더해준다.

i / j	0	1	2
0	0	0	0
1	1	2	3

첫 번째 예제인 N=3, 그 다음 첫 줄인 1 2 3을 받을 때, 33번째 줄까지 처리하면 위와 같게 된다. (0행이 시작이라 0으로 초기화되어 있으므로 입력값만 받게 된다.)

i / j	0	1	2
0	1	2	3
1	1	2	3

그다음 1행의 계산이 끝나면 이를 다시 0행으로 옮겨준다.

i / j	0	1	2
0	1	2	3
1	2 + 4 = 6	3 + 5 = 9	3 + 6 = 9

그리고 그 다음 입력인 4 5 6이 입력될 때 33번째 줄까지 처리되면 위와 같고,

i / j	0	1	2
0	6	9	9
1	2 + 4 = 6	3 + 5 = 9	3 + 6 = 9

이를 다시 0행으로 옮기면 위와 같다.

i / j	0	1	2
0	6	9	9
1	9 + 4 = 13	9 + 9 = 18	9 + 0 = 9

마지막으로 입력이 4 9 0이 입력된 후 33번째 줄까지 처리하면 위와 같고,

i / j	0	1	2
0	13	18	9
1	13	18	9

이를 0행으로 옮기면 최종적으로 위와 같다.

계산이 다 끝나면 마지막의 0행으로 옮기는 로직에 의해 0행의 값들 중 최댓값을 구하면 된다.

최솟값도 최댓값 계산한 방식으로 똑같이 하면 돼서 넣진 않았다.

끝!

전체 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    static int N;
    static int[][] maxArr;
    static int[][] minArr;

    static int stoi(String s) {
        return Integer.parseInt(s);
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = stoi(st.nextToken());

        maxArr = new int[2][3];
        minArr = new int[2][3];

        for (int i = 1; i <= N; i++) {
            st = new StringTokenizer(br.readLine());

            int x0 = stoi(st.nextToken());
            int x1 = stoi(st.nextToken());
            int x2 = stoi(st.nextToken());

            maxArr[1][0] = Math.max(maxArr[0][0], maxArr[0][1]) + x0;
            maxArr[1][1] = Math.max(maxArr[0][0], Math.max(maxArr[0][1], maxArr[0][2])) + x1;
            maxArr[1][2] = Math.max(maxArr[0][1], maxArr[0][2]) + x2;

            maxArr[0][0] = maxArr[1][0];
            maxArr[0][1] = maxArr[1][1];
            maxArr[0][2] = maxArr[1][2];

            minArr[1][0] = Math.min(minArr[0][0], minArr[0][1]) + x0;
            minArr[1][1] = Math.min(minArr[0][0], Math.min(minArr[0][1], minArr[0][2])) + x1;
            minArr[1][2] = Math.min(minArr[0][1], minArr[0][2]) + x2;

            minArr[0][0] = minArr[1][0];
            minArr[0][1] = minArr[1][1];
            minArr[0][2] = minArr[1][2];
        }

        int max = Math.max(maxArr[0][0], Math.max(maxArr[0][1], maxArr[0][2]));
        int min = Math.min(minArr[0][0], Math.min(minArr[0][1], minArr[0][2]));

        System.out.println(max + " " + min);
    }
}

[백준 자바 11048] 이동하기 (실버2)

yunjae62 — Mon, 25 Nov 2024 17:01:53 +0900

https://www.acmicpc.net/problem/11048

설명

전형적인 DP 문제이다. 문제에서는 (r+1, c), (r, c+1), (r+1, c+1)로 이동할 수 있다는 부분 때문에 현재 위치를 기준으로 다음 위치의 값을 어떻게 넣어줄지 생각하게 되는데, DP는 역으로 현재 위치의 값이 과거의 어느 위치로부터 영향받았는지로 생각하면 조금 더 수월하게 풀린다. 물론 그래도 DP는 너무 어렵다.,...

문제의 답이 N, M에 도착할 때 가장 많은 사탕을 가지고 있어야 하는 경우이고, 이동은 오른쪽, 아래, 오른쪽 아래 대각선 3방향으로 밖에 이동하지 못한다는 조건으로 생각해 보자.

두 번째 조건을 반대로 생각해보면, 현재 위치에 있으려면 그전에는 왼쪽, 위, 왼쪽 위 대각선 중 하나에 있어야 한다.

여기서 첫 번째 조건을 생각해보면, 최대한 많은 사탕을 가지고 있으려면 왼쪽, 위, 대각선 중 가장 많은 사탕을 가지고 있는 경우에 현재 위치의 사탕값을 더하면 된다.

현재 위치 사탕 최댓값 = 현재 위치 사탕 개수 + Max(왼쪽 사탕 개수, 위쪽 사탕 개수, 왼쪽 위 사탕 개수)

이를 수식으로 표현하면 위와 같다.

또 꽤 많은 DP 문제를 풀 때, N개의 요소가 있다면 배열을 N+1 크기로 만들어서 0번째 인덱스를 0으로 초기화해두면 코드가 더욱 간결해진다.

전체 코드

import java.io.*;
import java.util.*;

public class Main {

    static int stoi(String s) {
        return Integer.parseInt(s);
    }

    static int N, M;
    static int[][] dp;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = stoi(st.nextToken());
        M = stoi(st.nextToken());

        dp = new int[N + 1][M + 1]; // (1)

        // (2)
        for (int i = 1; i <= N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 1; j <= M; j++) {
                dp[i][j] = Math.max(dp[i][j - 1], Math.max(dp[i - 1][j], dp[i - 1][j - 1])) + stoi(st.nextToken());
            }
        }

        System.out.println(dp[N][M]);
    }
}

타 풀이에서는 2차원 배열을 2개 선언해서 하나는 입력용, 하나는 DP용으로 푸는 경우가 많았는데, 문제 특성상 왼쪽 위부터 오른쪽 아래까지 오른쪽으로 돌면서 차례차례 계산해 나가기 때문에 2차원 배열 하나만 써도 풀린다.

(1) 부분

위의 팁 부분에서 말한 것처럼, N, M 각각에 +1씩 해주어서 i = 0, j = 0 인 부분을 0으로 기본값 초기화를 해두었다.

(2) 부분

우선 i, j가 1부터 시작한다.

그리고 첫 행(가로줄)을 StringTokenizer로 입력받고, 각 열(세로줄)마다 정수로 변환한 뒤, [i][j - 1], [i - 1][j], [i - 1][j - 1] 이렇게 왼쪽, 위쪽, 왼쪽 위 대각선의 값 중 최댓값을 가져와서, 이를 입력값(현재 위치의 사탕 개수)과 더하여 2차원 배열에 넣어준다.

i - 1 이나 j - 1을 해도 문제가 없는 이유는 i, j 가 1부터 시작해서이고, 각 0번째 인덱스는 0으로 초기화되기 때문에 계산에 문제가 생기지 않는다.

TIL #124 : Spring Data Redis에서 Lua Script 사용하기

yunjae62 — Mon, 18 Nov 2024 21:46:47 +0900

상황

레디스는 각각의 명령어들은 원자적으로 실행이 되지만, 비즈니스로직을 작성하다 보면 여러 명령어들을 한 번에 처리해야 하는 경우가 생긴다.

이를 위해, 레디스를 루아스크립트를 이용해서 여러 명령어를 원자적으로 처리할 수 있도록 지원하고 있다.

레디스에서 LuaScript 사용하기

127.0.0.1:6379> eval "return 'Hello world!'" 0
"Hello world!"

레디스로 스크립트를 실행하는 명령어는 EVAL 이며, 그 다임 인수로 “…”를 감싸서 루아스크립트를 작성하면 된다.

또한 그 다음 인수로는 이후 입력될 KEY 개수이고, 키 개수만큼 입력한 다음의 인수로는 인수를 입력받는다.

EVAL <루아스크립트> <이후 입력될 KEY 개수> [<키1> <키2>, ..., <인수1> <인수2>, ...]

정리하면 위와 같이 입력할 수 있다.

또한 위의 예제에서 볼 수 있듯, 문자열은 ‘…’로 감싸면 된다.

키나 인수를 이용하는 방법은 KEYS[i], ARGV[i] 키워드를 이용하면 된다.

이때 주의할 점은, i는 0이 아닌 1부터 시작된다는 점과, 무조건 대문자로 적어야 한다는 점이다.

127.0.0.1:6379> eval "return 'hello, ' .. ARGV[1]" 0 'world'
"hello, world"

위의 명령어를 풀어서 설명해보자면, ‘hello, ‘ 와 ARGV[1] 문자열을 결합하여 리턴하며 (루아 스크립트에서.. 는 문자열을 결합하는 명령어다), 키는 0개이며, 인수로는 ‘world’가 입력된다.

이때 ARGV[1]는 1번째 인수인 world가 넣어지며, 따라서 “hello, world” 가 리턴된다.

127.0.0.1:6379> set a b
OK

127.0.0.1:6379> get a
"b"

127.0.0.1:6379> eval "return 'hello, ' .. redis.call('get', KEYS[1]) .. ARGV[1]" 1 a 'aby'
"hello, baby"

그리고 redis.call(’명령어’, ARGV…)를 통해 레디스에 명령을 내릴 수 있는데, 이를 응용해 보면

우선 set a b 명령을 통해 키 a에 값 b를 넣고, 레디스에 get a를 루아스크립트로 해보도록 하자.

루아스크립트 이후의 인수로 1 a ‘aby’로 해뒀는데, 이는 키의 개수가 1개이며, 키는 a, 인수는 ‘aby’라는 의미다.

그러면 redis.call(’get’, KEYS [1]) 는 첫 번째 키인 a가 들어가서 redis.call(’get’, a)가 되어, get a 명령을 수행한다.

또 ARGV[1]은 ‘aby’로 대체되므로, 리턴되는 문자열은 ‘hello, ‘ + ‘b’ + ‘aby’가 되어 ‘hello, baby’가 출력된다.

Spring Data Redis에서 LuaScript 사용하기

-- resources/script.lua
redis.call('set', KEYS[1], 'b')
return 'hello, ' .. redis.call('get', KEYS[1]) .. ARGV[1]

우선 스프링 프로젝트의 resources 디렉터리에 script.lua를 만들어주었다.

외부에서 입력받은 키에 'b'를 넣고, 리턴으로 'hello, ' + 'b' + ARGV[1] 가 되는, 위의 CLI 예제랑 비슷한 예제로 구성해 보았다.

요로코롬

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.data.redis.serializer.RedisSerializer;

@Configuration
public class RedisConfig {

    @Value("${spring.data.redis.host}")
    private String host;

    @Value("${spring.data.redis.port}")
    private int port;

    @Value("${spring.data.redis.password}")
    private String password;

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();

        config.setHostName(host);
        config.setPort(port);
        config.setPassword(password);

        return new LettuceConnectionFactory(config);
    }

    @Bean
    public StringRedisTemplate stringRedisTemplate() {
        return new StringRedisTemplate(redisConnectionFactory());
    }

    @Bean
    public RedisScript<String> script() { // 여기 !!!
        Resource script = new ClassPathResource("/script.lua"); 
        return RedisScript.of(script, String.class);
    }
}

그다음, 레디스 설정 부분이다. 윗 부분은 다들 아실테니, 맨 밑의 빈을 보면 된다. 위에서 만들어둔 script.lua를 가져오는데, 이때 RedisScript<T>의 T는 스크립트의 리턴 타입이다.

import java.util.List;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;

@SpringBootTest
public class RedisScriptTest {

    @Autowired
    private RedisScript<String> script;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    public void test() {
        // given
        String key1 = "a";
        String argv1 = "aby";
        
        // when
        String returnValue = stringRedisTemplate.execute(script, List.of(key1), argv1);

        // then
        Assertions.assertThat(returnValue).isEqualTo("hello, baby");
    }
}

그 다음 테스트를 구성해 보았다.

스크립트를 빈으로 등록해 두어서 주입을 받을 수 있고, 키를 a로 두고 인수를 aby로 두어 위의 CLI 예제랑 똑같이 넣어보았다.

그러면 "hello, baby"가 되어야 한다.

결과는 성공!!

참고 링크

레디스 공식 문서

TIL #123 : 배치 작업에는 꼭 정렬 하기

yunjae62 — Sun, 17 Nov 2024 23:23:42 +0900

문제

  @Bean(JOB_NAME + "_reader")
  public ItemReader<Product> itemReader() {
      return new JpaPagingItemReaderBuilder<Product>()
          .name(JOB_NAME + "_reader")
          .pageSize(CHUNK_SIZE)
          .entityManagerFactory(entityManagerFactory)
          .queryString("SELECT p FROM Product p")
          .build();
  }

이렇게 JpaPagingItemReader로 엔티티를 읽어오도록 하고, 각 Product 엔티티별로 price를 +1000 하는 작업을 하기로 했다.

9개를 가지고 작업을 했었는데, 어느 건 그대로인데 어느 건 2번 작업이 되어 있다.

해결

  @Bean(JOB_NAME + "_reader")
  public ItemReader<Product> itemReader() {
      return new JpaPagingItemReaderBuilder<Product>()
          .name(JOB_NAME + "_reader")
          .pageSize(CHUNK_SIZE)
          .entityManagerFactory(entityManagerFactory)
          .queryString("SELECT p FROM Product p ORDER BY p.id") // 여기 !!!
          .build();
  }

id를 기준으로 정렬했다.

모두 +1000 된 것을 볼 수 있다.

근데 왜 쿼리가 2번 나가는지 모르겠다. 로그가 2번 찍히는 건가 싶기도 했는데 처리 시간이 0ms인 것과 1ms인 것이 있다.

왜 이러지... 일단 p6spy로 로그를 찍고 있다.

TIL #122 : 읽기전용/쓰기전용DB를 @Transactional의 readOnly로 구분하기

yunjae62 — Sat, 16 Nov 2024 12:04:16 +0900

상황

DB를 2개를 쓰고, 하나를 primary db로 읽기+쓰기 작업을, 나머지 하나는 replica db로 읽기 작업만 하는 DB로 구성이 되었을 때, 매번 기능을 만들 때마다 읽기/쓰기를 구분해서 데이터소스를 가져오기보다, 어노테이션의 readOnly 속성으로 알아서 데이터소스를 구분하도록 하고 싶었다.

spring:
  datasource:
    hikari:
      main:
        driver-class-name: org.postgresql.Driver
        jdbc-url: jdbc:postgresql://localhost:54326/sample
        username: sample
        password: 1234
      sub:
        driver-class-name: org.postgresql.Driver
        jdbc-url: jdbc:postgresql://localhost:54327/sample
        username: sample
        password: 1234
  jpa:
    hibernate:
      ddl-auto: update
    properties:
      hibernate:
        show_sql: true # sql 로깅
        format_sql: true # SQL 문 정렬하여 출력
        highlight_sql: true # SQL 문 색 부여
        use_sql_comments: true # 콘솔에 표시되는 쿼리문 위에 어떤 실행을 하려는지 HINT 표시

application.yml 설정은 위와 같다. spring.datasource.hikari의 main, sub로 나뉜 부분에서, jdbc-url의 포트 부분만 보면 된다.

primary는 54326, replica는 54327 포트라는 것만 기억해두면 된다.

해결

public enum DataSourceType {
    READ_WRITE,
    READ_ONLY
}

우선 데이터소스 타입을 읽기쓰기가 모두 가능한 READ_WRITE, 읽기만 가능한 READ_ONLY 2개를 가지는 열거형 타입을 만들었다.

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.transaction.support.TransactionSynchronizationManager;

public class TransactionRoutingDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return TransactionSynchronizationManager.isCurrentTransactionReadOnly()
            ? DataSourceType.READ_ONLY
            : DataSourceType.READ_WRITE;
    }
}

그다음, AbstractRoutingDataSource를 상속받는 커스텀 데이터소스를 만들고, determieCurrentLookupKey를 오버라이딩 해서, 현재 트랜잭션의 readOnly 여부에 따라 위의 열거형 타입을 다르게 해 주었다.

import com.zaxxer.hikari.HikariDataSource;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy;

@Configuration
public class DataSourceConfig {

    /**
     * 메인 DB 데이터소스 (읽기 + 쓰기)
     */
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.hikari.main")
    public DataSource mainDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    /**
     * 서브 DB 데이터소스 (읽기 전용)
     */
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.hikari.sub")
    public DataSource subDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    /**
     * 라우팅 데이터소스 - readOnly 속성에 따라 라우팅
     */
    @Bean
    @DependsOn({"mainDataSource", "subDataSource"})
    public DataSource routingDataSource(
        @Qualifier("mainDataSource") DataSource mainDataSource,
        @Qualifier("subDataSource") DataSource subDataSource
    ) {
        TransactionRoutingDataSource routingDataSource = new TransactionRoutingDataSource();

        Map<Object, Object> dataSourceMap = Map.of(
            DataSourceType.READ_WRITE, mainDataSource,
            DataSourceType.READ_ONLY, subDataSource
        );

        routingDataSource.setTargetDataSources(dataSourceMap);
        routingDataSource.setDefaultTargetDataSource(mainDataSource);

        return routingDataSource;
    }

    /**
     * 데이터소스 프록시 - 트랜잭션 진입 후 readOnly 속성에 따라 데이터소스 결정
     */
    @Bean
    @Primary
    @DependsOn({"routingDataSource"})
    public DataSource dataSource(@Qualifier("routingDataSource") DataSource routingDataSource) {
        return new LazyConnectionDataSourceProxy(routingDataSource);
    }
}

코드가 긴데, 우선 맨 위의 2개의 데이터소스는 application.yml 파일의 속성값을 가져와서 HikariDataSource를 만들어주는 코드다.

다음의 routingDataSource는 readOnly 유무에 따른 데이터소스를 라우팅하는 데이터소스다.

마지막은 스프링은 트랜잭션 진입 시 모든 데이터소스에 커넥션을 가져오고 이후에 데이터소스를 결정한다. 이러면 메인과 서브 모두 커넥션을 가져온다. (이에 대한 내용은 내 다른 글에서 확인할 수 있다.)

그래서 이를 실제 DB요청할 때 커넥션을 점유하도록 하고, 그 전에 데이터소스를 결정하도록 LazyConnectionDataSourceProxy로 감싸주었다.

import ex.multisource.domain.Product;
import ex.multisource.dto.ProductCreateReq;
import ex.multisource.repository.ProductRepository;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Slf4j(topic = "product-service")
@Service
@RequiredArgsConstructor
public class ProductService {

    private final DataSource dataSource;
    private final ProductRepository productRepository;

    @Transactional(readOnly = true)
    public Product getProduct(Long id) {
        logDataSourceInfo();
        return productRepository.findById(id)
            .orElseThrow(() -> new IllegalArgumentException("Product not found"));
    }

    @Transactional
    public Product saveProduct(ProductCreateReq request) {
        logDataSourceInfo();
        Product product = Product.create(request.name(), request.price());
        return productRepository.save(product);
    }

    private void logDataSourceInfo() {
        try (Connection connection = dataSource.getConnection()) {
            log.info("Connected to database: {}", connection.getMetaData().getURL());
        } catch (SQLException e) {
            log.error("Failed to log DataSource information", e);
        }
    }
}

이제 테스트로 @Transactional 에 reradOnly에 따라 다른 DB로 요청되는지 확인해 보자.

커넥션의 요청 url로 확인할 거고, 위의 yml 파일에서 설정한 대로 54326이면 primary db, 54327이면 replica db이다.

INFO 23092 --- [multi-source-service] [nio-8080-exec-1] product-service : Connected to database: jdbc:postgresql://localhost:54326/sample
[Hibernate] 
    /* insert for
        ex.multisource.domain.Product */insert 
    into
        products (name, price) 
    values
        (?, ?) 
    returning id
INFO 23092 --- [multi-source-service] [nio-8080-exec-3] product-service : Connected to database: jdbc:postgresql://localhost:54327/sample
[Hibernate] 
    select
        p1_0.id,
        p1_0.name,
        p1_0.price 
    from
        products p1_0 
    where
        p1_0.id=?

첫 번째로 insert 요청(product 생성)은 jdbc:postgresql://localhost:54326/sample로 54326 포트로 primary db로 요청이 갔다.

두 번째로 select 요청(product 조회)은 jdbc:postgresql://localhost:54327/sample로 54327 포트로 replica db로 요청이 갔다.

잘 작동하는 것을 볼 수 있다!!

TIL #121 : 스프링 배치 5버전에서 멀티 dataSource 중 하나 지정하기

yunjae62 — Sat, 16 Nov 2024 10:32:59 +0900

문제

멀티 데이터소스 환경에서, 스프링 배치 5 버전에서는 특별한 설정을 하지 않으면 @Primary 데이터소스를 가져온다. 하지만 나는 Primary가 아닌 다른 데이터소스를 가져오려고 설정을 했더니 Job이 실행이 되지 않고, 또 application.yml 파일에 적어둔 배치 설정도 적용이 되지 않던 문제가 있었다.

상황

# application.yml
spring:
    batch:
        jdbc:
          platform: postgresql # DBMS, 안 적으면 자동으로 탐색 
          # 실행할 스키마, 배치 라이브러리 내부에 각 DBMS 별로 sql이 작성돼있다.
          schema: classpath:org/springframework/batch/core/schema-postgresql.sql 
          initialize-schema: always # 항상 스키마를 초기화할 건지

원래 이렇게 application.yml을 작성해두고,

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.job.builder.JobBuilder;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.step.builder.StepBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;

@Slf4j(topic = "simple-job")
@Configuration
@RequiredArgsConstructor
public class SimpleJob {

    private static final String JOB_NAME = "simple_job";

    private final JobRepository jobRepository;
    private final PlatformTransactionManager transactionManager;

    @Bean(JOB_NAME)
    public Job simpleJob() {
        return new JobBuilder(JOB_NAME, jobRepository)
            .start(simpleStep())
            .incrementer(new RunIdIncrementer())
            .build();
    }

    @Bean(JOB_NAME + "_step")
    public Step simpleStep() {
        return new StepBuilder(JOB_NAME + "_step", jobRepository)
            .tasklet((contribution, chunkContext) -> {
                log.info("Hello, world!");
                return null;
            }, transactionManager)
            .build();
    }
}

헬로 월드 로그를 출력하는 간단한 잡을 만들어두고 실행하면,

[main] simple-job : Hello, world!

이렇게 잘 출력이 된다.

import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;

@Configuration
@EnableScheduling
@EnableBatchProcessing(dataSourceRef = "subDataSourceProxy")
public class BatchConfig {

}

하지만 스프링 배치 5 버전에서 데이터소스를 변경하려면 @EnableBatchProcessing 어노테이션의 dataSourceRef 속성에 원하는 데이터소스 빈이름을 작성해주어야 한다.

하지만 이렇게 작성하고 실행을 하면 application.yml에 작성해 둔 설정이 적용이 안 되고, 잡도 실행이 되지 않는다.

이유는 스프링 배치 5 버전으로 올라오면서 기존의 설정 방법과 달라지고, @EnableBatchProcessing 어노테이션이 필수가 아닌 선택이 되었는데, 이 어노테이션을 사용하면 자동 설정들이 되지 않기 때문.

그래서 직접 설정을 해주고 또 잡도 실행시켜주어야 한다.

해결

// 커스텀으로 만든 DataSourceConfig
@Bean
public DataSourceInitializer batchDataSourceInitializer(@Qualifier("subDataSourceProxy") DataSource dataSource) {
    JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

    if (isBatchTablesPresent(jdbcTemplate)) {
        return null;
    }

    ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
    populator.addScript(resourceLoader.getResource("classpath:org/springframework/batch/core/schema-postgresql.sql"));

    DataSourceInitializer initializer = new DataSourceInitializer();
    initializer.setDataSource(dataSource);
    initializer.setDatabasePopulator(populator);

    return initializer;
}

private boolean isBatchTablesPresent(JdbcTemplate jdbcTemplate) {
    try {
        jdbcTemplate.execute("SELECT 1 FROM BATCH_JOB_INSTANCE LIMIT 1");
        return true;
    } catch (Exception e) {
        return false;
    }
}

우선, DataSourceInitializer를 통해 원하는 데이터소스에 배치 메타데이터 테이블이 존재하지 않는다면 새로 테이블을 생성하도록 코드를 작성해 두었다.

import java.util.Map;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobParameter;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.JobParametersInvalidException;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.core.repository.JobExecutionAlreadyRunningException;
import org.springframework.batch.core.repository.JobInstanceAlreadyCompleteException;
import org.springframework.batch.core.repository.JobRestartException;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@RequiredArgsConstructor
public class Launcher {

    private final Job simpleJob;
    private final JobLauncher jobLauncher;

    @Scheduled(cron = "0/10 * * * * *", zone = "Asia/Seoul")
    public void run() {
        JobParameters jobParameters = new JobParameters(
            Map.of("requestTime", new JobParameter<>(System.currentTimeMillis(), Long.class))
        );

        try {
            jobLauncher.run(simpleJob, jobParameters);
        } catch (JobExecutionAlreadyRunningException
                 | JobInstanceAlreadyCompleteException
                 | JobParametersInvalidException
                 | JobRestartException e) {
            throw new RuntimeException(e);
        }
    }
}

위의 BatchConfig에서 @EnableScheduling을 해주었기 때문에 스케줄링을 할 수 있어서, @Scheduled로 하긴 했는데, 그냥 JobLauncher로만으로도 실행시킬 수 있다.

[scheduling-1] settle-job : Hello, world!

10초마다 잘 뜬다!

TIL #120 : 멀티 데이터소스 환경에서 이중 커넥션 점유 막기

yunjae62 — Fri, 15 Nov 2024 20:40:35 +0900

문제

스프링은 트랜잭션에 진입한 후에 커넥션을 점유하고, 이후에 데이터소스를 결정한다.

우리는 두 개의 데이터소스를 채택해서, 이중으로 커넥션을 점유하는 문제가 있었다.

상황

spring:
  application:
    name: multi-source-service
  datasource:
    hikari:
      postgres:
        driver-class-name: org.postgresql.Driver
        jdbc-url: jdbc:postgresql://localhost:54326/sample
        username: sample
        password: 1234
      postgres-two:
        driver-class-name: org.postgresql.Driver
        jdbc-url: jdbc:postgresql://localhost:54327/sample
        username: sample
        password: 1234

management:
  endpoints:
    web:
      exposure:
        include: '*'
  endpoint:
    health:
      show-details: always
    prometheus:
      enabled: true

우선 application.yml 은 위와 같고,

import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

@Configuration
public class DataSourceConfig {

    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.hikari.postgres")
    public DataSource mainDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.hikari.postgres-two")
    public DataSource subDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }
}

기존 코드는 위와 같다.

import ex.multisource.domain.Product;
import ex.multisource.dto.ProductCreateReq;
import ex.multisource.repository.ProductRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Slf4j(topic = "product-service")
@Service
@RequiredArgsConstructor
public class ProductService {

    private final ProductRepository productRepository;

    @Transactional
    public Product saveProduct(ProductCreateReq request) throws InterruptedException {
        Product product = Product.create(request.name(), request.price());
        Thread.sleep(1000L * 180);
        return productRepository.save(product);
    }
}

그리고 테스트용으로, @Transactional 어노테이션을 붙여서 요청이 들어오면 트랜잭션 내에서 180초 동안 멈춰있도록 했다.

그 뒤 요청을 보내고 actuator로 현재 활성 커넥션 수를 확인해 본 결과, 메인 데이터소스와 서브 데이터소스 2개를 점유하고 있었다.

해결

실제로 DB에 요청을 보낼 때 커넥션을 획득하는 LazyConnectionDataSourceProxy로 데이터소스를 감싸주었다.

import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy;

@Configuration
public class DataSourceConfig {

    @Bean
    @Primary
    public DataSource mainDataSourceProxy(DataSource mainDataSource) {
        return new LazyConnectionDataSourceProxy(mainDataSource);
    }

    @Bean
    public DataSource subDataSourceProxy(@Qualifier("subDataSource") DataSource subDataSource) {
        return new LazyConnectionDataSourceProxy(subDataSource);
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.hikari.postgres")
    public DataSource mainDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.hikari.postgres-two")
    public DataSource subDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }
}

변경 코드는 위와 같다. 기존 데이터소스들은 그대로 두고, 각각 프록시로 감싼 데이터소스를 하나 더 만들었다.

java.lang.IllegalArgumentException: dataSource or dataSourceClassName or jdbcUrl is required.
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'entityManagerFactory' defined in class path resource
Caused by: java.lang.IllegalArgumentException: dataSource or dataSourceClassName or jdbcUrl is required.

따로 dataSource를 두지 않고, mainDataSource를 바로 해두고 싶었는데, 위의 에러가 계속 났다. 프록시로 데이터소스를 감싸느라, JPA에서 엔티티매니저를 만드는데 문제가 생기는 것 같은데 정확히는 알아보아야 한다.

LazyConnectionDataSourceProxy로 데이터소스를 감싸면 실제 DB에 요청할 때 커넥션을 획득하기 때문에, 활성 커넥션이 0개인 것을 확인할 수 있다!!!!

노션으로 작성한 이력서 이쁘게 PDF로 뽑아내기

yunjae62 — Thu, 14 Nov 2024 15:16:54 +0900

배경

노션으로 작성한 이력서를 PDF로 내보내기 하면 페이지로 나눠질 때 페이지 사이 간격이 우주만큼 커지게 된다. 또 상하좌우 여백도 조절하지 못해서 아쉬웠는데, 더 이쁘게 뽑아내는 방법을 공유하려고 한다.

1. 좌우 너비 늘리기

오른쪽 위의 ... 버튼을 누르고, 전체 너비를 켜주고, 내보내기를 누른다.

2. HTML 내보내기

내보내기 형식을 HTML로 하고 내보내기 버튼을 클릭한다.

3. 브라우저에서 인쇄 열기

오른쪽 위 ... 버튼을 누르고 인쇄 버튼을 누른다.

4. 페이지 커스텀 조절

PDF로 저장 -> A4 -> 여백 맞춤 -> 배율 맞춤 (65 설정)

왼쪽 페이지의 상하좌우로 있는 mm 단위로 여백을 입맛에 맞추면 되는데, 나는 상하 10mm, 좌우 20mm로 정했다.

끝!!

TIL #119 : Jacoco 테스트 커버리지 항목에 롬복이 생성한 코드 무시하기

yunjae62 — Wed, 13 Nov 2024 16:13:00 +0900

문제

Jacoco로 테스트 커버리지를 검사하다 보면, lombok이 만들어준 getter, setter, 생성자 등등까지 테스트 항목에 포함되게 된다.

getter, setter까지 테스트를 하는 것은 테스트를 작성하는 의미가 없다고 판단해서 이를 무시할 수 있는지 알아보았다.

해결

// lombok.config
# jacoco 테스트 커버리지 시, lombok이 생성한 코드는 제외
lombok.addLombokGeneratedAnnotation = true

프로젝트 루트 디렉토리에 lombok.config 파일을 만들어서 위와 같이 작성해 주었다.

TIL #118 : 롬복 @RequiredArgsConstructor 사용 시 @Qualifier 사용 불가 해결하기

yunjae62 — Wed, 13 Nov 2024 16:04:01 +0900

문제

멀티 데이터소스를 채택하면서, 메인 데이터소스는 @Primary를 붙였고, 배치 데이터소스는 @Qualifier를 사용해서 가져오려고 했었다. 하지만 lombok의 @RequiredArgsConstructor 사용 시 @Qualifier 사용이 불가능했던 문제가 있다.

@Slf4j
@Service
@RequiredArgsConstructor
public class TestService {

    private final DataSource dataSource;
    
    @Qualifier("batchDataSource")
    private final DataSource batchDataSource;

    // ...
}

TestService는 2개의 DataSource를 주입받고 있다.

@Service
public class TestService {
    @Generated
    private static final Logger log = LoggerFactory.getLogger(TestService.class);
    private final DataSource dataSource;
    @Qualifier("batchDataSource")
    private final DataSource batchDataSource;

    @Generated
    // 여기 아래 !!!
    public TestService(final DataSource dataSource, final DataSource batchDataSource) {
        this.dataSource = dataSource;
        this.batchDataSource = batchDataSource;
    }
}

롬복이 만들어준 빌드된 코드를 보면 위와 같다.

필드를 보면 @Qualifier가 잘 적혀있는 것 같이 보이지만, 생성자에서는 @Qualifier가 없어서 주입을 못 받는다.

해결

// lombok.config
# 롬복 애노테이션 프로세서가 생성자 생성 시 사용할 필드에 선언된 @Qualifier를 복사
lombok.copyableAnnotations += org.springframework.beans.factory.annotation.Qualifier

프로젝트 루트 디렉터리에 lombok.config 파일을 만들어서 위와 같이 작성해 주면 된다.

@Service
public class TestService {
    @Generated
    private static final Logger log = LoggerFactory.getLogger(TestService.class);
    private final DataSource dataSource;
    @Qualifier("batchDataSource")
    private final DataSource batchDataSource;

    @Generated
    // 여기 아래 !!!
    public TestService(final DataSource dataSource, @Qualifier("batchDataSource") final DataSource batchDataSource) {
        this.dataSource = dataSource;
        this.batchDataSource = batchDataSource;
    }
    
    // ...
}

이제 생성자의 인수에 @Qualifier가 잘 붙어있는 것을 볼 수 있다.

TIL #117 : 인텔리제이 프로젝트 구조의 하위 디렉토리 전부 펼치기 단축키

yunjae62 — Wed, 13 Nov 2024 15:24:21 +0900

스프링을 쓰다 보면, src클릭 main 클릭 java 클릭 com 클릭 ooo클릭 ooo 클릭해야만 드디어 스프링 애플리케이션을 볼 수 있다. 근데 이제 시작이다. 그 하위의 디렉터리를 또 하나하나 클릭하다 보면 화딱지가 난다...

그러다 클릭 한 번으로 하위 디렉토리를 모두 열 수 있는 방법을 알게 되었다.

우선 설정을 연다. (맥은 cmd + ,)
왼쪽 메뉴에서 키맵(keymap)을 클릭 후
트리 노드 전체 펼치기(Fully Expand Tree Node) 검색
트리 노드 전체 펼치기 우클릭 후 마우스 단축키 추가 클릭
편한 단축키 등록 (나는 cmd + 휠클릭으로 했다)

정말 너무 편하다....

TIL #116 : 스프링/도커컴포즈에 Graceful shutdown 적용하기

yunjae62 — Wed, 13 Nov 2024 15:15:10 +0900

문제

CI/CD를 구성하면서, CD 마지막 과정은 EC2 서버의 기존 도커 컴포즈를 down 하고 다시 up 하는 과정이 있다. 그리고 재시작하면서 스프링 컨테이너를 강제 종료하는데, 이때 진행 중인 로직도 그대로 강제 종료되는 문제가 있었다.

예를 들어, 주문 처리 중 재고는 감소시켰는데 강제 종료가 되어서 재고가 롤백되지 않는 문제가 있을 수 있다. (MSA 환경이다)

또한 Eureka server에 설정된 Eviction timer가 종료되기 전까지 유레카에 남게되는 문제도 있다.

해결

Graceful shutdown을 적용했다.

스프링 부트

spring:
  application:
    name: payment-service
  config:
    import: classpath:application-database.yml # database 속성 가져오기용
  profiles:
    default: dev
  lifecycle:
    timeout-per-shutdown-phase: 10s # 여기 1 !!!!

server:
  shutdown: graceful  # 애플리케이션 종료 시 정상 종료 (Graceful Shutdown) # 여기 2 !!!

spring.lifecycle.timeout-per-shutdown-phase를 10초로 주어서 종료 전까지 받은 요청을 처리하도록 했다.

server.shutdown을 graceful로 설정해주었다.

도커 컴포즈

services:
    payment-server:
        # // ... 
      stop_grace_period: 15s # 여기 1 !!!
      stop_signal: SIGTERM # 여기 2 !!!
      depends_on:
        - eureka-server

stop_signal을 SIGTERM을 주었다.

stop_grace_period를 15초를 주어서, 스프링의 10초보다 5초 넉넉히 주어서 스프링이 종료 후 도커 컨테이너가 종료되도록 했다.

TIL #115 : 자바에서 offset 있는 DateTime 파싱하기

yunjae62 — Wed, 13 Nov 2024 15:03:42 +0900

문제

토스페이먼츠 API를 이용하던 중, 응답으로 주던 날짜 형식 "2024-10-02T21:16:13+09:00" 이 LocalDateTime으로 파싱이 되지 않았다.

해결

OffsetDateTime을 이용해서 파싱 할 수 있었다.

1. LocalDateTime 파싱 에러 발생

@Test
@DisplayName("LocalDateTime 파싱 - 에러남")
public void testLocalDateTimeParseException() {
    // given
    String rawTime = "2024-10-02T21:16:13+09:00";

    // when & then
    assertThatThrownBy(() -> LocalDateTime.parse(rawTime))
        .isInstanceOf(java.time.format.DateTimeParseException.class);
}

LocalDateTime으로 파싱 시, DateTimeParseException이 발생한다.

2. OffsetDateTime 파싱

@Test
@DisplayName("OffsetDateTime 파싱")
public void testOffsetDateTimeParsing() {
    // given
    String rawTime = "2024-10-02T21:16:13+09:00";

    // when
    OffsetDateTime offsetDateTime = OffsetDateTime.parse(rawTime);

    // then
    assertThat(offsetDateTime.getOffset()).isEqualTo(ZoneOffset.of("+09:00"));
}

@Test
@DisplayName("OffsetDateTime 파싱 후 LocalDateTime 변환")
public void testOffsetDateTimeToLocalDateTime() {
    // given
    String rawTime = "2024-10-02T21:16:13+09:00";
    OffsetDateTime offsetDateTime = OffsetDateTime.parse(rawTime);

    // when
    LocalDateTime localDateTime = offsetDateTime.toLocalDateTime();

    // then
    assertThat(localDateTime.getHour()).isEqualTo(21);
}

OffsetDateTime으로 변환하면 예외가 발생하지 않는다.

그리고 Offset을 가져오면 "+09:00"가 된다.

이를 "Asia/Seoul"로 변환하고 싶었는데, 아쉽게도 +9 시간대를 쓰는 시간대가 여러 개가 있을 수 있어서 변환이 되지 않았다.

3. offset 조정

@Test
@DisplayName("OffsetDateTime 조정 - 2시간 차이의 시간대로 변경")
public void testOffsetDateTimeAdjustment() {
    // given
    String rawTime = "2024-10-02T21:16:13+09:00";

    // when
    OffsetDateTime offsetDateTime = OffsetDateTime.parse(rawTime);
    OffsetDateTime adjusted = offsetDateTime.withOffsetSameInstant(ZoneOffset.of("+07:00"));

    // then
    assertThat(adjusted.getHour()).isEqualTo(19);
}

Offset을 +7로 조정이 잘 되는지 테스트해보았다.

원래라면 21시였던 것이, 19시로 변경이 잘 된 것을 확인할 수 있다.

전체 테스트 코드

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

import java.time.LocalDateTime;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

public class ZonedDateTimeTest {

    @Test
    @DisplayName("LocalDateTime 파싱 - 에러남")
    public void testLocalDateTimeParseException() {
        // given
        String rawTime = "2024-10-02T21:16:13+09:00";

        // when & then
        assertThatThrownBy(() -> LocalDateTime.parse(rawTime))
            .isInstanceOf(java.time.format.DateTimeParseException.class);
    }

    @Test
    @DisplayName("OffsetDateTime 파싱")
    public void testOffsetDateTimeParsing() {
        // given
        String rawTime = "2024-10-02T21:16:13+09:00";

        // when
        OffsetDateTime offsetDateTime = OffsetDateTime.parse(rawTime);

        // then
        assertThat(offsetDateTime.getOffset()).isEqualTo(ZoneOffset.of("+09:00"));
    }

    @Test
    @DisplayName("OffsetDateTime 파싱 후 LocalDateTime 변환")
    public void testOffsetDateTimeToLocalDateTime() {
        // given
        String rawTime = "2024-10-02T21:16:13+09:00";
        OffsetDateTime offsetDateTime = OffsetDateTime.parse(rawTime);

        // when
        LocalDateTime localDateTime = offsetDateTime.toLocalDateTime();

        // then
        assertThat(localDateTime.getHour()).isEqualTo(21);
    }

    @Test
    @DisplayName("OffsetDateTime 조정 - 2시간 차이의 시간대로 변경")
    public void testOffsetDateTimeAdjustment() {
        // given
        String rawTime = "2024-10-02T21:16:13+09:00";

        // when
        OffsetDateTime offsetDateTime = OffsetDateTime.parse(rawTime);
        OffsetDateTime adjusted = offsetDateTime.withOffsetSameInstant(ZoneOffset.of("+07:00"));

        // then
        assertThat(adjusted.getHour()).isEqualTo(19);
    }
}

TIL #114 : Spring Security 없이 PasswordEncoder 이용하기

yunjae62 — Wed, 13 Nov 2024 13:17:04 +0900

문제

간편결제를 구현하기 위해 6자리 숫자 비밀번호를 도입했다. 근데 평문으로 저장할 순 없으니 암호화를 해야 하는데, 스프링 시큐리티까지는 필요 없이 비밀번호 암호화만 하면 되었다.

해결

dependencies {
		
    // ...

    // spring security crypto
    implementation 'org.springframework.security:spring-security-crypto' // 여기 !!!
    
    // ...
}

spring-security-crypto 라이브러리를 의존한다.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class PasswordEncoderConfig {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

시큐리티 없이 PasswordEncoder를 이용할 수 있다!

import java.util.regex.Pattern;
import lombok.RequiredArgsConstructor;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import radiata.common.exception.BusinessException;
import radiata.common.message.ExceptionMessage;

@Service
@RequiredArgsConstructor
public class PayUserValidator {

    private static final Pattern PASSWORD_PATTERN = Pattern.compile("^[0-9]{6}$");
    private final PasswordEncoder passwordEncoder;

    public void validatePassword(String payUserPassword, String inputPassword) {
        if (!PASSWORD_PATTERN.matcher(inputPassword).matches()) {
            throw new BusinessException(ExceptionMessage.INVALID_PASSWORD);
        }

        if (!passwordEncoder.matches(inputPassword, payUserPassword)) {
            throw new BusinessException(ExceptionMessage.INVALID_PASSWORD);
        }
    }
}

검증할 땐 우선 숫자 6자리인지 검증 후, 그 비밀번호가 DB에 저장된 비밀번호와 맞는지 확인하도록 했다.

TIL #113 : Assertj로 LocalDateTime.now() 단위 테스트 코드 작성하기

yunjae62 — Wed, 13 Nov 2024 13:03:41 +0900

문제

결제 엔티티에서 결제 승인 메서드를 실행하면 결제 승인 시간에 자동으로 현재 시간으로 넣어준다.

자동으로 넣어준 LocalDateTIme을 어떻게 테스트할지 궁금했는데, 특정 시간과 가까운지 테스트하는 코드가 있었다.

상황

/**
 * 결제 승인
 */
public void approve() {
    this.status = PaymentStatus.APPROVED;
    this.approvedAt = LocalDateTime.now(); // 여기 !!!
}

결제 승인 메서드 실행 시 approvedAt에 현재 시간을 넣어준다.

해결

전체 테스트 코드

import static org.assertj.core.api.Assertions.assertThat;

// ... 

@Test
@DisplayName("결제 성공")
void payment_approve() {
    // given 
    TemporalUnitWithinOffset acceptableTimeOffset = new TemporalUnitWithinOffset(1, ChronoUnit.SECONDS);

    // when
    payment.approve();

    // then
    assertThat(payment.getStatus()).isEqualTo(PaymentStatus.APPROVED);
    assertThat(payment.getApprovedAt()).isCloseTo(LocalDateTime.now(), acceptableTimeOffset);
}

각 코드 설명

TemporalUnitWithinOffset acceptableTimeOffset = new TemporalUnitWithinOffset(1, ChronoUnit.SECONDS);

TemporalUnitWithinOffset를 통해 Second 단위로 1인 범위(즉 1초 이내인지)의 객체를 생성한다.

assertThat(payment.getApprovedAt()).isCloseTo(LocalDateTime.now(), acceptableTimeOffset);

그리고 isCloseTo를 통해 현재 시간과 오프셋 이내로 차이가 나는지 확인한다.

유닛테스트라서,, 테스트가 아무리 느려도 1초가 걸리지는 않을 거라고 생각이 들어서.. 이렇게 해봤다. 컴퓨터 환경에 따라 조절하면 될 것 같다.

TIL #112 : 자바 애플리케이션을 도커 이미지로 만들 때 용량 줄이기

yunjae62 — Wed, 13 Nov 2024 12:22:23 +0900

요약

eclipse-temurin:17-jre-alpine으로 이미지 굽자.

상황

어느날 문득, 서버에서 배포할 때 이미 빌드되어 jar 파일만 실행한다면, JDK가 아닌 JRE만 있어도 되는 거 아닌가? 하는 생각이 들었다.

요즘 배포할 때는 도커 이미지로 구워서 띄워버려서, JRE를 사용하면 용량을 더 줄일 수 있을 것 같아서 한번 알아봤다.

openjdk를 우선으로 찾아보았는데 내 서치 실력이 부족한 건지 17-jre만 있는 것은 찾을 수가 없어서, temurin으로 테스트해보았다.

예상대로 17-JDK (419.47 MB) > 17-JDK-alpine (335.97 MB) > 17-JRE (262.53 MB) > 17-JRE-alpine (185.34 MB) 순으로 용량이 줄어들었다.

JDK에서 JRE로 바꾸기만 해도 용량이 반토막이 나고, alpine으로 바꾸면 거기에 또 약 80 MB가 줄어든다!!!

여기서 alpine 이란? 보안과 경량화를 목표로 설계된 alpine linux를 기반으로 하여 이미지 크기가 작아 저장 공간을 절약하고 업로드/다운로드 시간이 줄어드는 장점이 있다.

jar 이미지 굽기

FROM eclipse-temurin:17-jre-alpine
# FROM --platform=linux/amd64 eclipse-temurin:17-jre-alpine # ARM 사용 시 

RUN mkdir /app

ARG JAR_FILE=build/libs/*.jar
COPY ${JAR_FILE} /app/app.jar

ENTRYPOINT ["java", "-jar", "/app/app.jar"]

이제 위 이미지와 도커파일을 토대로 JAR 파일을 만들어보면,

17-jre-alpine

17-jre

17-jdk-alpine

17-jdk

빌드된 jar 파일이 66.15 MB 이었는데, 딱 jar 파일만큼 용량이 늘어났다.

하지만 완벽한 것 같은 jre-alpine도 한 가지 단점이 있다.

ARM을 지원하지 않는다는 것... 그래서 --platform=linux/amd64 를 넣었던 것.

17-jre는 멀티 플랫폼을 지원한다.

참고 링크

티스토리 블로그

TIL #111 : ID를 가진 JPA 엔티티 생성 시 SELECT 문이 나가는 문제

yunjae62 — Mon, 11 Nov 2024 15:18:14 +0900

문제

우리는 JPA 엔티티를 Ksuid라고 하는 고유 식별자를 사용하기로 했다. UUID 같은거다.

생성시간 기반의 20byte 고유 식별자로, 시간순으로 정렬이 가능해서 인덱싱의 이점을 누리면서도 랜덤값도 포함되어 중복 가능성이 거의 없으며, 길이도 짧다.

따라서 엔티티를 저장할 때 id를 넣어서 생성하도록 했다.

@Transactional
public <S extends T> S save(S entity) {
    Assert.notNull(entity, "Entity must not be null");
    if (this.entityInformation.isNew(entity)) {
        this.entityManager.persist(entity);
        return entity;
    } else {
        return this.entityManager.merge(entity);
    }
}

하지만 JpaRepository의 save 메서드는 isNew 메서드를 통해 현재 엔티티가 새로 생성되었는지 여부를 확인하는데,

@Transient
public boolean isNew() {
    return this.getId() == null;
}

그 조건은 id가 null 인 경우다.

우리는 id를 넣어준 후 save 하기 때문에 항상 isNew가 false 가 되어 persist가 아닌 merge를 실행하게 된다.

select c1_0.id,ci1_0.coupon_id,ci1_0.id,ci1_0.status,ci1_0.user_id,c1_0.max_quantity,c1_0.name,c1_0.now_quantity,c1_0.version from coupons c1_0 left join coupon_issues ci1_0 on c1_0.id=ci1_0.coupon_id where c1_0.id=?
insert into coupons (max_quantity,name,now_quantity,version,id) values (?,?,?,?,?)

그러면 생성 전에, id가 있는지 여부를 확인하기 위해 select 문이 나가고, id가 없으면 Insert 문이 나가게 된다.

해결

import jakarta.persistence.MappedSuperclass;
import jakarta.persistence.PostPersist;
import lombok.Getter;
import org.springframework.data.domain.Persistable;

@Getter
@MappedSuperclass
public abstract class BaseEntity implements Persistable<String> {

    private transient boolean isNew = true; // 새로운 엔티티 여부를 추적할 필드

    @Override
    public boolean isNew() {
        return this.isNew;
    }

    // persist 후에 기존 엔티티로 인식되도록 설정
    @PostPersist
    public void postPersist() {
        this.isNew = false;
    }
}

모든 엔티티에 대해서 Ksuid를 사용하기 때문에, 이를 BaseEntity에 넣어서 각각의 엔티티가 중복 구현하지 않도록 했다.

우선 Persistable<T> 인터페이스를 구현했는데, 여기서 T는 키의 타입을 넣어주면 된다.

isNew 라는 변수를 통해 현재 엔티티가 새로 생성되었는지 아닌지를 판단하도록 했고, private를 통해 자식 엔티티가 접근하지 못하도록 하고, transient를 통해 DB에 실제로 저장이 되지 않도록 했다. 그리고 기본값으로 true를 두었다.

다음으로 @PostPersist 어노테이션을 통해, 새로 생성 시 isNew는 false가 되도록 했고, isNew 메서드를 override 해서 변수를 리턴하도록 했다.

import jakarta.persistence.CascadeType;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import java.util.Set;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;

@Getter
@Entity
@Table(name = "coupons")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Coupon extends BaseEntity { // 여기!!!

    @Id
    private String id;

    private String name;
    private Integer nowQuantity;
    private Integer maxQuantity;

    @OneToMany(mappedBy = "coupon", cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REMOVE}, orphanRemoval = true)
    private Set<CouponIssue> couponIssues;

    public static Coupon create(String id, String name, Integer nowQuantity, Integer maxQuantity) {
        Coupon coupon = new Coupon();

        coupon.id = id;
        coupon.name = name;
        coupon.nowQuantity = nowQuantity;
        coupon.maxQuantity = maxQuantity;

        return coupon;
    }
}

그리고 실제 엔티티에서는 BaseEntity를 상속받아서 사용하도록 했다.

이러면 엔티티에서는 생성인지 영속인지 모르고 사용할 수 있다!!

insert into coupons (max_quantity,name,now_quantity,version,id) values (?,?,?,?,?)

insert 문만 나가는 것을 볼 수 있다!!

24/10/04(금) 110번째 TIL : 컴포넌트 스캔 패키지 구조 문제

yunjae62 — Mon, 7 Oct 2024 13:08:08 +0900

문제

멀티 모듈 구조에서 JpaRepository 빈을 읽어오지 못하는 문제가 있었다.

상황

우리는 멀티 모듈을 채택했고, 스프링 앱, 도메인 코어, 데이터베이스 모듈로 3개를 분리했다. 스프링 앱에서 실행 시, 데이터베이스 모듈의 JpaConfig 설정을 읽어오지 못해서 도메인 코어의 repository에 JpaRepository를 빈이 없다고 주입을 못해주고 있었다.

간단하게 현제 문제인 것들만 정리하자면

모듈

payment-core : 결제 도메인의 핵심 부분 (서비스, 도메인, 리포지토리 포함)
- 모듈 위치 : service:payment:core
- 패키지 시작점 : radiata.service.payment.core
payment-api : 결제 도메인의 외부 요청 부분 (스프링 애플리케이션, 컨트롤러, 앤드포인트 포함)
- 모듈 위치 : service:payment:api
- 패키지 시작점 : radiata.service.payment.api
database : 데이터베이스 관련 부분 (설정 yml 및 Config 객체 포함)
- 모듈 위치 : database
- 패키지 시작점 : radiata.database

객체

database 모듈에는 JpaConfig가 있고,

payment-core 모듈 에는 Repository, JpaRepository가 있고 (둘을 분리해둠),

payment-api 모듈 에서는 PaymentApplication의 스프링 앱이 있다.

인텔리제이 측에서는 Repository가 빈이 있다고 표시되지만, 실제 실행 시 찾을 수 없다고 떴다.

해결

package radiata.service.payment.core;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Configuration;

@EnableAutoConfiguration
@Configuration
public class ComponentScanConfiguration {

}

payment-core의 최상의 패키지에 위 객체를 두면 해결이 된다.

...가 아니라 하나 더 해야 된다.

package radiata.service.payment.api;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(scanBasePackages = { "radiata.service.payment" })
public class PaymentApplication {

    public static void main(String[] args) {
        SpringApplication.run(PaymentApplication.class, args);
    }
}

payment-api 모듈의 스프링 애플리케이션에 스캔 패키지를 지정해주어야 한다.

@SpringBootApplication(scanBasePackages = { "radiata.service.payment" })
@SpringBootApplication(scanBasePackages = { "radiata.database" })

둘 중 하나를 해주면 실행이 된다. 하지만 database 모듈은 언제든지 실행이될 수 있으니 위의 코드를 쓰기로 했다.

참고로 api 모듈은 radiata.service.payment.api에 SpringApplication이 있는 최상위 패키지이고,

core 모듈은 radiata.service.payment.core가 최상위 패키지라서,

둘의 상위인 radiata.service.payment로 지정을 해주었다.

이후로 스프링이 빈을 스캔하는 방식을 더 공부해서 정리해볼 예정이다.

24/09/30(월) 109번째 TIL : 카프카 직렬화 및 역직렬화

yunjae62 — Tue, 1 Oct 2024 10:04:38 +0900

문제 : 카프카 직렬화/역직렬화 처리 중 만난 에러들

하도 많이 만나서 일단 생각나는 것만 적고..

에러 1 : 객체로 요청 및 응답받고 싶으면 Value의 시리얼라이저를 Json으로 하기.

물론 문자열로도 가능하긴 한데, 요청/응답마다 ObjectMapper로 직렬화/역직렬화하기보다, 카프카에서도 JsonSerializer를 제공해 주는데 굳이 문자열로 쓸 필요는 없을 것 같다. 또 컴파일 때 요청 보낼 객체의 타입검사를 해주기도 하고.

import ex.application.order.message.DeliveryMessage;
import java.util.Map;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.kafka.support.serializer.JsonSerializer;

@Configuration
public class KafkaProducerConfig {

    @Bean
    public ProducerFactory<String, DeliveryMessage> producerFactory() { // 여기 제네릭 부분 !!!
        Map<String, Object> configProperties = Map.of(
            ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092",
            ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class,
            ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class, // 여기 !!!
        );

        return new DefaultKafkaProducerFactory<>(configProperties);
    }

    @Bean
    public KafkaTemplate<String, DeliveryMessage> kafkaTemplate() { // 여기 제네릭 부분 !!!
        return new KafkaTemplate<>(producerFactory());
    }
}

에러 2 : 컨슈머 측은 역직렬화로 설정해주어야 한다.

사실 당연한 건데.. 컨슈머 측에서 시리얼라이저로 했었다.

import ex.application.product.message.DeliveryMessage;
import java.util.Map;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.support.serializer.JsonDeserializer;

@Configuration
@EnableKafka
public class KafkaConsumerConfig {

    @Bean
    public ConsumerFactory<String, DeliveryMessage> consumerFactory() {
        Map<String, Object> configProperties = Map.of(
            ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092",
            ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class, // 여기 !!!
            ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class, // 여기 !!!
        );

        return new DefaultKafkaConsumerFactory<>(configProperties);
    }

    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, DeliveryMessage> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, DeliveryMessage> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        return factory;
    }
}

ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG 속성의 값을 JsonDeserializer.class 로 해줬다.

ConsumerConfig 인 것도 몰랐고,, 복붙하느라,, Deserializer 인 줄도 몰랐다...

에러 3 : 프로듀서, 컨슈머 측에서 서로 다른 패키지 및 타입 정보를 맞춰줘야 한다.

맞다.. 난 이것도 모르는 감자다..

우선 위 코드로 보내면 컨슈머 측에서 에러난다.

// key 
0059d5e2-dcfc-4cc7-853c-0207890c772f

// value
{
	"orderId": "0059d5e2-dcfc-4cc7-853c-0207890c772f",
	"paymentId": null,
	"userId": "yun01",
	"productId": 1,
	"productQuantity": 10,
	"payAmount": 100,
	"errorType": null
}

// headers // 여기 !!!
{
	"__TypeId__": "ex.application.order.message.DeliveryMessage"
}

일단 프로듀서 측에서는 DeliveryMessage 객체의 위치를 헤더에 담아서 보낸다.

하지만 컨슈머 측의 DeliveryMessage 객체의 위치는 ex.application.product.message.DeliveryMessage이다.

따라서 컨슈머는 ex.application.order.message.DeliveryMessage 에서 DeliveryMessage객체를 찾다가 없어서 에러를 뱉는다.

@Bean
public ProducerFactory<String, DeliveryMessage> producerFactory() {
    Map<String, Object> configProperties = Map.of(
        ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092",
        ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class,
        ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class,
        JsonSerializer.ADD_TYPE_INFO_HEADERS, false // 여기!!!
    );

    return new DefaultKafkaProducerFactory<>(configProperties);
}

일단 나는 프로젝트마다 패키지명을 다르게 해 줄 생각이어서 프로듀서 측에서 타입 정보를 보내지 않도록 했다.

@Bean
public ConsumerFactory<String, DeliveryMessage> consumerFactory() {
    Map<String, Object> configProperties = Map.of(
        ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092",
        ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class,
        ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class,
        JsonDeserializer.USE_TYPE_INFO_HEADERS, false, // 여기 !!!
        JsonDeserializer.VALUE_DEFAULT_TYPE, "ex.application.product.message.DeliveryMessage" // 여기 !!!
    );

    return new DefaultKafkaConsumerFactory<>(configProperties);
}

그다음 컨슈머 측에서는 어차피 필요 없는 타입 정보를 사용하지 않도록 하고, 컨슈머 프로젝트의 DeliveryMessage 객체의 위치를 지정해 주었다.

해결..!

최종 에러 없는 코드

프로듀서 측 코드

import ex.application.order.message.DeliveryMessage;
import java.util.Map;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.kafka.support.serializer.JsonSerializer;

@Configuration
public class KafkaProducerConfig {

    @Bean
    public ProducerFactory<String, DeliveryMessage> producerFactory() {
        Map<String, Object> configProperties = Map.of(
            ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092",
            ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class,
            ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class,
            JsonSerializer.ADD_TYPE_INFO_HEADERS, false
        );

        return new DefaultKafkaProducerFactory<>(configProperties);
    }

    @Bean
    public KafkaTemplate<String, DeliveryMessage> kafkaTemplate() {
        return new KafkaTemplate<>(producerFactory());
    }
}

컨슈머 측 코드

import ex.application.product.message.DeliveryMessage;
import java.util.Map;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.support.serializer.JsonDeserializer;

@Configuration
@EnableKafka
public class KafkaConsumerConfig {

    @Bean
    public ConsumerFactory<String, DeliveryMessage> consumerFactory() {
        Map<String, Object> configProperties = Map.of(
            ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092",
            ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class,
            ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class,
            JsonDeserializer.USE_TYPE_INFO_HEADERS, false, 
            JsonDeserializer.VALUE_DEFAULT_TYPE, "ex.application.product.message.DeliveryMessage" 
        );

        return new DefaultKafkaConsumerFactory<>(configProperties);
    }

    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, DeliveryMessage> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, DeliveryMessage> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        return factory;
    }
}

24/08/28(수) 108번째 TIL : EmbeddedId 식별자 값객체

yunjae62 — Mon, 9 Sep 2024 22:22:34 +0900

값객체를 엔티티의 식별자에도 사용하기 시작했다.

@Getter
@Embeddable
@EqualsAndHashCode
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class HubId implements Serializable { // JPA 식별자 타입은 Serializable 구현해야 함

    @Column(name = "id")
    private UUID id;

    public static HubId of(UUID id) {
        HubId hubId = new HubId();
        hubId.id = id;
        return hubId;
    }

    public static HubId ofRandom() {
        HubId hubId = new HubId();
        hubId.id = UUID.randomUUID();
        return hubId;
    }
}

요구사항이 식별자는 UUID여서 랜덤의 UUID를 가지는 생성자를 정적 팩토리 메소드로 만들었다.

@Getter
@Entity
@Table(name = "p_hub")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Hub extends BaseEntity {

    @EmbeddedId
    private final HubId id = HubId.ofRandom();

    @Embedded
    private Address address;

    @Embedded
    private Coordinate coordinate;

    @OneToMany(mappedBy = "hub")
    private List<Inventory> inventoryList = new ArrayList<>();

    @Builder
    private Hub(Address address, Coordinate coordinate) {
        this.address = address;
        this.coordinate = coordinate;
    }
}

그리고 이렇게 @EmbeddedId 어노테이션으로 값객체를 식별자로 사용한다는 것을 표시했다.

JPA에서 식별자 타입은 Serializable 타입이어야 해서 이를 구현해주면 된다.

값객체를 식별자로 사용하면 아래와 같은 이점이 있다.

식별자라는 의미를, 그것도 Hub 엔티티의 식별자라는 의미를 부각시킬 수 있다.
하나의 UUID 필드가 아닌, "객체" 이므로 기능을 추가할 수 있다.
- 위와 같이, UUID를 HubId로 변환한다든지, 랜덤한 UUID로 HubId를 만드는 기능을 추가했다

24/08/27(화) 107번째 TIL : Embeddable 값객체

yunjae62 — Mon, 9 Sep 2024 22:11:53 +0900

이번 프로젝트에서 DDD 개념을 일부 도입해 보면서 값객체를 시도해 볼 수 있는 부분에 적용을 해보았다.

인터넷에 유명한 Money나 Address는 당연히 구현해봤고, 아래는 그 외에 잘 구현했다고 생각되는 것을 적어봤다.

@Getter
@Embeddable
@EqualsAndHashCode
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Rating {

    private static final int MIN_SCORE = 1;
    private static final int MAX_SCORE = 5;

    private Integer score;

    public Rating(int score) {
        if (!isScoreInRange(score)) {
            throw new GlobalException(ResultCase.INVALID_INPUT);
        }

        this.score = score;
    }

    private boolean isScoreInRange(int score) {
        return MIN_SCORE <= score && score <= MAX_SCORE;
    }
}

final이나 Record 타입으로 하고 싶었는데, JPA는 기본 생성자를 필요로 해서 할 수 없었다.

프로젝트 요구사항 중, 리뷰에 평점을 1~5점 남길 수 있다는 요구사항이 있었다.

단순히 int 타입으로 score를 표현할 수도 있겠지만, 단순히 int 필드보고 얘가 평점이라고 가스라이팅 하기보다, 보다 명확하게 평점임을 표시하고 싶었다.

그래서 Rating 이라는 객체를 만들었고, 일단 생성하면 더 이상 값을 변경하지 못하게 하여 불변을 보장했다.

그리고 생성 시 정책이었던 1~5 사이 값인지를 검증하는 로직을 넣어서 일단 생성만 하면 이후 추가 검증을 할 필요 없이 안심하며 값을 사용할 수 있도록 했다.

그리고 상태와 행위를 한 곳에서 관리하여 응집도를 높일 수도 있다!!

24/08/26(월) 106번째 TIL : mapStruct와 @Getter 사용 시 boolean 필드 매핑

yunjae62 — Sun, 1 Sep 2024 12:31:07 +0900

문제

Review 엔티티에 기본형 boolean 타입의 isReported 필드가 있었는데, 이를 DTO로 변환하는 mapStruct 매퍼를 사용 중, 컴파일 시 아래와 같은 경고가 떴다.

// ReviewMapper.class

// ...
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;

import static org.mapstruct.MappingConstants.ComponentModel.SPRING;

@Mapper(componentModel = SPRING)
public interface ReviewMapper {

    ReviewResponseDto toReviewResponseDto(Review review);
}

// ReviewResponseDto.class

public record ReviewResponseDto(
        // ...
        boolean isReported
) {
}

ReviewMapper.java:17: warning: Unmapped target property: "isReported".
    ReviewResponseDto toReviewResponseDto(Review review);

상황

// ReviewMapper 인터페이스의 구현체 

@Component
public class ReviewMapperImpl implements ReviewMapper {

    @Override
    public ReviewResponseDto toReviewResponseDto(Review review) {
        if ( review == null ) {
            return null;
        }
        
        // ...

        boolean isReported = false; // 여기 !!!

        ReviewResponseDto reviewResponseDto = new ReviewResponseDto( // ... , isReported );

        return reviewResponseDto;
    }
    
    // ...
}

컴파일된 매퍼를 보니 isReported가 false로 초기화 되어있고 따로 review에서 값을 가져오지는 않았다.

해결

// ReviewMapper.class

// ...
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;

import static org.mapstruct.MappingConstants.ComponentModel.SPRING;

@Mapper(componentModel = SPRING)
public interface ReviewMapper {

    @Mapping(target = "isReported", source = "reported") // 여기 !!!
    ReviewResponseDto toReviewResponseDto(Review review);
}

위와 같이, is- 접두사를 제거한 reported 로 해두면 적용이 된다.

설명

@Entity
@Table(name = "p_review")
public class Review extends BaseEntity {

    // ...
    
    @Column(name = "is_reported")
    private boolean isReported;
    
    // ...

    @Generated // 롬복이 만들어준 코드는 @Generated 어노테이션이 붙음 
    public boolean isReported() {
        return this.isReported;
    }
    
    // ...
}

@Getter 롬복 어노테이션을 사용할 때, 기본형 boolean 타입의 경우 is- 프리픽스를 그대로 유지한 isReported() getter가 만들어진다.

// ReviewMapper 인터페이스의 구현체 

@Component
public class ReviewMapperImpl implements ReviewMapper {

    @Override
    public ReviewResponseDto toReviewResponseDto(Review review) {
        if ( review == null ) {
            return null;
        }
        
        // ...

        boolean isReported = review.isReported(); // 여기 !!!

        ReviewResponseDto reviewResponseDto = new ReviewResponseDto( // ... , isReported );

        return reviewResponseDto;
    }
    
    // ...
}

그리고 source = "reported"로 작성을 해두면 mapStruct는 java beans 8.3.2 스펙에 따라 isReported() getter로 isReported 필드의 값을 가져오도록 코드를 만들어준다.

24/08/23(금) 105번째 TIL : Gradle로 WAR 파일 빌드하기

yunjae62 — Fri, 30 Aug 2024 19:42:02 +0900

상황

MSA 1차 과제의 답안이 공개되어 보던 중 기존의 강의와 해설 영상에서도 다루지 않았던 코드를 발견했다.

// ServletInitializer.class

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

public class ServletInitializer extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(YmlApplication.class);
    }
}

war 파일 빌드하는데 쓰이는 녀석이라는 것 같다.

War 빌드

// build.gradle

plugins {
    id 'java'
    id 'war' // 추가 !!
    id 'org.springframework.boot' version '3.3.2'
    id 'io.spring.dependency-management' version '1.1.6'
}

새로고침하면 bootWar, war 가 생긴 것을 볼 수 있다.

build 를 눌러보면

오후 5:18:54: 실행 중 'build'...

> Task :compileJava
> Task :processResources UP-TO-DATE
> Task :classes
> Task :resolveMainClassName
> Task :bootWar
> Task :war
> Task :assemble
> Task :compileTestJava UP-TO-DATE
> Task :processTestResources NO-SOURCE
> Task :testClasses UP-TO-DATE
OpenJDK 64-Bit Server VM warning: Sharing is only supported for boot loader classes because bootstrap classpath has been appended
> Task :test
> Task :check
> Task :build

BUILD SUCCESSFUL in 24s
7 actionable tasks: 5 executed, 2 up-to-date
오후 5:19:19: 실행이 완료되었습니다 'build'.

war 파일이 생성된 것을 볼 수 있다.

참고 링크

https://cordcat.tistory.com/103

24/08/22(목) 104번째 TIL : Redis maxmemory 소숫점 설정

yunjae62 — Fri, 30 Aug 2024 19:35:43 +0900

문제

ubuntu:~$ sudo docker logs redis

*** FATAL CONFIG FILE ERROR (Redis 7.4.0) ***
Reading the configuration file, at line 1133
>>> 'maxmemory 1.5gb'
argument must be a memory value

maxmemory 설정을 소숫점으로 하니 실행이 되지 않았다.

해결

// redis.conf

maxmemory 1500mb

// ...

MB 단위로 설정해주어 해결했다.

24/08/21(수) 103번째 TIL : EC2 EBS 재부팅 없이 용량 확장 도전기

yunjae62 — Fri, 30 Aug 2024 19:28:49 +0900

문제

EBS 용량을 늘려주었음에도 EC2에서는 적용 안 됨.

상황

도커 이미지들 이것저것 다 다운받다보니 EBS 8GB 설정해둔 게 99% 사용 중

ubuntu@ip:~$ df -h
Filesystem       Size  Used Avail Use% Mounted on
/dev/root        6.8G  6.7G   93M  99% /
tmpfs            208M     0  208M   0% /dev/shm
tmpfs             83M  1.4M   82M   2% /run
tmpfs            5.0M     0  5.0M   0% /run/lock
efivarfs         128K  3.3K  125K   3% /sys/firmware/efi/efivars
/dev/nvme0n1p16  891M  105M  724M  13% /boot
/dev/nvme0n1p15   98M  6.4M   92M   7% /boot/efi
tmpfs             42M   12K   42M   1% /run/user/1000

EBS 용량을 늘려주었다. 하지만 EC2에서 df -h 해보니 위와 동일했다..

해결

사실 재부팅하면 바로 해결되나, 재부팅 없이 적용하고 싶었음
아래는 재부팅 없이 적용 방법... 인데 실패했다.

ubuntu@ip:~$ lsblk
NAME         MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
loop0          7:0    0 21.9M  1 loop /snap/amazon-ssm-agent/7994
loop1          7:1    0 33.7M  1 loop /snap/snapd/21761
loop2          7:2    0 49.1M  1 loop /snap/core18/2826
nvme0n1      259:0    0   12G  0 disk
├─nvme0n1p1  259:1    0    7G  0 part /
├─nvme0n1p15 259:2    0   99M  0 part /boot/efi
└─nvme0n1p16 259:3    0  923M  0 part /boot

우선 lsblk 명령어를 통해 블록 장치 목록을 확인한다. 이때 마운트 되지 않은 블록까지 포함됨.

ubuntu@ip:~$ sudo growpart /dev/nvme0n1 1
CHANGED: partition=1 start=2099200 old: size=14677983 end=16777182 new: size=23066591 end=25165790
ubuntu@ip-172-31-43-127:~$ lsblk
NAME         MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
loop0          7:0    0 21.9M  1 loop /snap/amazon-ssm-agent/7994
loop1          7:1    0 33.7M  1 loop /snap/snapd/21761
loop2          7:2    0 49.1M  1 loop /snap/core18/2826
nvme0n1      259:0    0   12G  0 disk
├─nvme0n1p1  259:1    0   11G  0 part /
├─nvme0n1p15 259:2    0   99M  0 part /boot/efi
└─nvme0n1p16 259:3    0  923M  0 part /boot

그 다음 아래쪽 nvme0n1 (인스턴스 타입에 따라 다를 수 있음) 참고하여 sudo growpart /dev/nvme0n1 1 명령어를 쳐주면 파티션이 확장된다.

ubuntu@ip:~$ df -h
Filesystem       Size  Used Avail Use% Mounted on
/dev/root        6.8G  6.7G   93M  99% /
tmpfs            208M     0  208M   0% /dev/shm
tmpfs             83M  1.3M   82M   2% /run
tmpfs            5.0M     0  5.0M   0% /run/lock
efivarfs         128K  3.3K  125K   3% /sys/firmware/efi/efivars
/dev/nvme0n1p16  891M  105M  724M  13% /boot
/dev/nvme0n1p15   98M  6.4M   92M   7% /boot/efi
tmpfs             42M   12K   42M   1% /run/user/1000

하지만 파티션만 확장됐을 뿐, 파일 시스템은 확장되지 않아서 여전히 99%를 차지하고 있다.

ubuntu@ip:~$ sudo resize2fs /dev/nvme0n1
resize2fs 1.47.0 (5-Feb-2023)
resize2fs: Device or resource busy while trying to open /dev/nvme0n1
Couldn't find valid filesystem superblock.

이딴 에러가 뜨면 재부팅이 답이라고 한다..

ubuntu@ip:~$ df -h
Filesystem       Size  Used Avail Use% Mounted on
/dev/root         11G  6.6G  4.0G  63% /
tmpfs            208M     0  208M   0% /dev/shm
tmpfs             83M  1.1M   82M   2% /run
tmpfs            5.0M     0  5.0M   0% /run/lock
efivarfs         128K  3.3K  125K   3% /sys/firmware/efi/efivars
/dev/nvme0n1p16  891M  105M  724M  13% /boot
/dev/nvme0n1p15   98M  6.4M   92M   7% /boot/efi
tmpfs             42M   12K   42M   1% /run/user/1000

재부팅하니 해결.

참고 링크

24/08/20(화) 102번째 TIL : spring boot에서 active profile 선택하기

yunjae62 — Fri, 30 Aug 2024 19:22:18 +0900

// application.yml

spring:
  application:
    name: yml

server:
  port: 8088

fruit:
  list:
    - name: banana
      color: yellow
    - name: apple
      color: red

developer:
  name: yunjae

application.yml

// application-dev.yml

server:
  port: 8055

application-dev.yml

// DeveloperName.class 

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Data
@Component
@ConfigurationProperties("developer")
public class DeveloperName {
    private String name;
}

yml 파일에서 developer 키 속, name 키의 값을 가져와서 넣어준다.

// Test.class

@Slf4j
@Component
@RequiredArgsConstructor
public class Test {

    private final DeveloperName developerName;

    @Value("${server.port}")
    private String port;

    @Value("${spring.profiles.active}")
    private String activeProfile;

    @PostConstruct
    void setup() {
        log.info("dev name : {}", developerName);
        log.info("server port : {}", port);
        log.info("active profile {}", activeProfile);
    }
}

ex.yml.YmlApplication : No active profile set, falling back to 1 default profile: "default"

스프링은 특별히 profile을 지정해주지 않으면 default 로 프로필을 지정하며, application.yml 파일을 가져온다.

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'test': Injection of autowired dependencies failed
// ... 
Caused by: java.lang.IllegalArgumentException: Could not resolve placeholder 'spring.profiles.active' in value "${spring.profiles.active}"
// ...

yml 파일대로 실행하면, 위와 같은 에러를 내며 종료한다.

application.yml 파일에는 spring.profiles.active를 지정해주지 않았기 때문에 당연쓰

해결 방법은 인텔리제이 기준으로 실행/디버그 구성 창을 켜서

빌드 및 실행 탭의 오른쪽에 옵션 수정 → VM 옵션 추가 → -Dspring.profiles.active={prifile이름} 을 입력해주거나,
그 밑의 Active profiles 부분에 그냥 {profile이름} 만 넣어줘도 된다.
아니면 application.yml 파일에 spring.profiles.default=dev 로 하기

사진은 두 가지 방법 모두를 보여주려고 적은거라 둘 중 하나만 해도 된다.

변경 후 실행해보면

ex.yml.YmlApplication                    : The following 1 profile is active: "dev"
o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port 8055 (http)
ex.yml.Test                              : dev name : DeveloperName(name=yunjae)
ex.yml.Test                              : server port : 8055
ex.yml.Test                              : active profile dev

dev profile 로 지정된 것을 볼 수 있다.

24/08/19(월) 101번째 TIL : 어노테이션에는 상수만 가능

yunjae62 — Fri, 30 Aug 2024 19:12:28 +0900

문제

import org.springframework.http.HttpMethod;

public class CorsConstant {

    public static final String[] ALLOWED_ORIGINS = {
            "http://localhost:3000"
    };

    public static final String[] ALLOWED_METHODS = {
            HttpMethod.GET.name(),
            HttpMethod.POST.name(),
            HttpMethod.PUT.name(),
            HttpMethod.DELETE.name(),
            HttpMethod.OPTIONS.name()
    };
}

Attribute value must be constant

@CrossOrigin 어노테이션에 origins를 입력 중, 상수 클래스를 만들어 가져오면 관리하기 편리할까 싶어서 로직을 작성하다가 위와 같은 에러를 만났다.

해결

우선 자바의 어노테이션은 컴파일 시점에 처리가 된다. 따라서 어노테이션의 속성들은 컴파일 시점 상수를 사용해야만 한다.

위의 CorsConstant의 ALLOWED_ORIGINS는 static final을 붙이긴 했지만 우선은 배열이므로 참조위치만 안 바뀔 뿐이지, 내부 요소의 값은 바뀔 수 있다. 따라서 컴파일 시점의 상수가 아니라서 에러가 난 것.

해결은.. 직접 문자열 배열로 써주거나 그냥 WebSecurityConfig로 중앙 집중식으로 써두었다.

@RestController
public class SampleController {

    @CrossOrigin(
            origins = {
                    "http://localhost:3000"
            }
    )
    @GetMapping("/api/sample")
    public String getSample() {
        return "sample data";
    }
}

이렇게 쓰거나

@Configuration
public class WebConfig {

    public static final String[] ALLOWED_ORIGINS = {
            "http://localhost:3000"
    };

    public static final String[] ALLOWED_METHODS = {
            HttpMethod.GET.name(),
            HttpMethod.POST.name(),
            HttpMethod.PUT.name(),
            HttpMethod.DELETE.name(),
            HttpMethod.OPTIONS.name(),
            RequestMethod.GET.name()
    };

    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/**")
                        .allowedOrigins(ALLOWED_ORIGINS)
                        .allowedMethods(ALLOWED_METHODS)
                        .allowedHeaders("*")
                        .allowCredentials(true)
                        .maxAge(3600)
                        .exposedHeaders("Custom-Response-Header1", "Custom-Response-Header2");
            }
        };
    }
}

이렇게 써주었다.

ENUM으로도 테스트

public enum TestEnum {
    GET("GET");

    public final String value;
    public static final String testValue = "GET";

    TestEnum(String value) {
        this.value = value;
    }
}

ENUM으로도 테스트 해봤는데 어노테이션 속성으로는 static 속성들만 표시가 되었다. (TestEnum.GET도 내부적으로는 public static final TestEnum GET = new TestEnum("GET") 이니깐.)

정리

자바의 어노테이션은 컴파일 시에 처리가 되므로, 어노테이션의 속성들은 컴파일 시점 상수여야 한다.
배열의 경우, static final을 붙여도 내부 요소는 변경 가능하므로(mutable) 컴파일 시점 상수가 아니다.

참고 링크

24/08/16(금) 100번째 TIL : CORS 커스텀 응답 헤더 가져오기

yunjae62 — Mon, 19 Aug 2024 16:19:01 +0900

문제

과거 프로젝트에서 JWT을 이용한 인증 방식을 택해서, 액세스 토큰 및 리프레쉬 토큰을 커스텀 응답 헤더에 넣어서 보내주었다. 하지만 프론트에서 응답 헤더에서 받아올 수 없었다.

해결

기본적으로, 응답 헤더는 CORS-safelisted response header 만 노출된다. (simple response header 라고도 한다) CORS-safelisted response header란, 클라이언트의 스크립트에 노출되어도 안전하다고 여겨지는 헤더들이다. 기본적으로 아래와 같은 헤더들이 있다.

이 외의 헤더들은 Access-Control-Expose-Headers 로 허용을 해주어야 한다.

따라서 커스텀 응답 헤더를 프론트에서 받기 위해서는 스프링 기준으로 아래와 같이 작성해주면 된다.

주석으로 밑부분에 여기 라고 적은 부분!

Spring Security 미사용

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig {

    public static final String[] ALLOWED_ORIGINS = {
            "http://localhost:3000"
    };

    public static final String[] ALLOWED_METHODS = {
            HttpMethod.GET.name(),
            HttpMethod.POST.name(),
            HttpMethod.PUT.name(),
            HttpMethod.DELETE.name(),
            HttpMethod.OPTIONS.name()
    };

    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/**")
                        .allowedOrigins(ALLOWED_ORIGINS)
                        .allowedMethods(ALLOWED_METHODS)
                        .allowedHeaders("*")
                        .allowCredentials(true)
                        .maxAge(3600)
                        // 여기 !
                        .exposedHeaders("Custom-Response-Header1", "Custom-Response-Header2");
            }
        };
    }
}

Spring Security 사용

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {

        http.cors(getCorsConfigurerCustomizer());
        // ... 

        return http.build();
    }

    private Customizer<CorsConfigurer<HttpSecurity>> getCorsConfigurerCustomizer() {
        return corsConfigurer -> corsConfigurer.configurationSource(request -> {
            CorsConfiguration config = new CorsConfiguration();
            config.setAllowedOrigins(Collections.singletonList("*")); // 모든 오리진 허용
            config.setAllowedMethods(Collections.singletonList("*")); // 모든 메서드 허용
            config.setAllowedHeaders(Collections.singletonList("*")); // 모든 헤더 허용
            // 여기 !!
            config.setExposedHeaders(List.of("Custom-Response-Header1", "Custom-Response-Header2"); 
            return config;
        });
    }

그러면 응답에 다음과 같은 헤더가 포함되게 된다.

Access-Control-Expose-Headers: Custom-Response-Header1, Custom-Response-Header2

팁으로 와일드 카드로 에스터리스크(*)를 사용할 수 있는데, Authorization 헤더는 지정할 수 없어서 명시적으로 작성해주어야 한다.

Access-Control-Expose-Headers: *, Authorization

참고 링크

24/08/14(수) 99번째 TIL : Spring Security 없이 CORS 설정하기

yunjae62 — Mon, 19 Aug 2024 15:26:28 +0900

의존성 목록

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

의존성이 web, lombok 밖에 없다.

전역 설정

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig {

    public static final String[] ALLOWED_ORIGINS = {
            "http://localhost:3000",
            "http://yunjae.click",
            "https://yunjae.click"
    };

    public static final String[] ALLOWED_METHODS = {
            HttpMethod.GET.name(),
            HttpMethod.POST.name(),
            HttpMethod.PUT.name(),
            HttpMethod.DELETE.name(),
            HttpMethod.OPTIONS.name()
    };

    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/**")
                        .allowedOrigins(ALLOWED_ORIGINS)
                        .allowedMethods(ALLOWED_METHODS)
                        .allowedHeaders("*")
                        .allowCredentials(true)
                        .maxAge(3600)
                        .exposedHeaders("Custom-Response-Header");
            }
        };
    }
}

origin과 method 목록은 따로 빼서 변수로 만들어두었다.

headers나 exposedHeaders도 입맛에 맞게 따로 빼면 될 것 같다.

컨트롤러 레벨 설정

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SampleController {

    @CrossOrigin(
            origins = {"http://localhost:3000"},
            methods = {RequestMethod.GET, RequestMethod.POST},
            maxAge = 3600L
    )
    @GetMapping("/api/sample")
    public String getSample() {
        return "sample data";
    }
}

@CrossOrigin 어노테이션을 이용하면 이용할 수 있다.

특이한게 전역설정 땐 허용 메서드를 String 으로 받는데, @CrossOrigin 어노테이션의 methods는 RequestMethod 타입으로 받는다. 그래서 전역 설정 때도 Httpmethod.GET.name() 말고 통일을 위해 RequestMethod.GET.name() 으로 해도 될 것 같다.

24/08/13(화) 98번째 TIL : Spring boot에서 record로 application.yml 읽기

yunjae62 — Tue, 13 Aug 2024 14:29:32 +0900

문제

스프링 부트에서 Record 클래스로 application.yml 파일 값 가져오려다가 에러가 났다.

상황

// application.yml 

fruit:
  list:
    - name: banana
      color: yellow
    - name: apple
      color: red

yml 파일에 fruit.list 속에 과일 리스트가 있는 형태를 스프링에서 가져다 쓰려고 했다.

// Fruit.class

public record Fruit(
        String name,
        String color
) {
}

// FruitList.class

import org.springframework.boot.context.properties.ConfigurationProperties;
import java.util.List;

@ConfigurationProperties("fruit") // 여기 !! 
public record FruitList(
        List<Fruit> list
) {
}

외부에서 가져오는 프로퍼티인 만큼 레코드 타입으로 불변을 보장하려고 했는데 아래와 같은 에러가 났다.

해결

해결법은 스프링 부트 2.2 버전 이전과 이후로 나뉜다.

스프링 부트 2.2 이전 해결법

1. @Component 사용

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
@ConfigurationProperties("fruit")
public record FruitList(
        List<Fruit> list
) {
}

이 방법으로는 현재는 에러가 난다.

2. @EnableConfigurationProperties 사용

import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties({FruitList.class}) // 사용할 클래스를 지정해주어야 함 
public class ConfigurationPropertyConfig {
}

이렇게 하면 동작은 되지만 매 프로퍼티 클래스를 작성해주어야 하는 불편함이 있다.

스프링 부트 2.2 이후 해결법

3. @ConfigurationProperties 사용

import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationPropertiesScan // 여기 !! 
public class ConfigurationPropertyConfig {
}

그냥 @ConfigurationProperties 만 붙여주면 끝난다.

정리

마지막으로 전체 코드를 보여주면 아래와 같다.

// YmlApplication.class

@SpringBootApplication
public class YmlApplication {

    public static void main(String[] args) {
        SpringApplication.run(YmlApplication.class, args);
    }
}

// ConfigurationPropertyConfig.class

import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationPropertiesScan
public class ConfigurationPropertyConfig {
}

// Fruit.class

public record Fruit(
        String name,
        String color
) {
}

// Test.class

import jakarta.annotation.PostConstruct;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@RequiredArgsConstructor
public class Test {

    private final FruitList fruitList;

    @PostConstruct
    void setup() {
        for (Fruit fruit : fruitList.list()) {
            log.info("fruit name : {}, color : {}", fruit.name(), fruit.color());
        }
    }
}

// console

fruit name : banana, color : yellow
fruit name : apple, color : red

로그 결과는 위와 같다.

잘 나오는 것을 볼 수 있다.

참고 링크

24/08/12(월) 97번째 TIL : Spring cloud gateway에서 최종 라우팅 서비스 URI 가져오기

yunjae62 — Mon, 12 Aug 2024 14:31:25 +0900

문제

이번 과제에서 처리된 서비스의 서버 포트를 응답 헤더에 담으라는 요구사항이 있었다.

@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("/products")
public class ProductController {

    private final ProductService productService;

    @Value("${server.port}")
    private String port;

    /**
     * 상품 목록 조회 API
     */
    @GetMapping
    public ResponseEntity<List<GetProductsRes>> getProductList(GetProductsReq request, Pageable pageable) {

        List<GetProductsRes> productList = productService.getProductList(request, pageable);

        return ResponseEntity.ok()
                .header(GlobalConstant.CUSTOM_SERVER_PORT_HEADER, port)
                .body(productList);
    }

나는 무식하게 일일이 컨트롤러에 이렇게 다 담았었는데, 제출 이후 팀원들과 이야기하다가 이 중복을 어떻게 해결했는지를 논의했었다.

한 팀원분께서 게이트웨이에 넣으셨다는 말씀을 해주셔서 바로 커비 해버렸다.

해결

@Component
public class AddServerPortInHeaderFilter implements GlobalFilter, Ordered {

    private static final String SERVER_PORT_HEADERS_NAME = "Server-Port";

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

        return chain.filter(exchange)
                .then(Mono.fromRunnable(() -> addServerPortInHeader(exchange)));
    }

    private void addServerPortInHeader(ServerWebExchange exchange) {
        URI uri = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);

        if (uri != null) {
            ServerHttpResponse response = exchange.getResponse();
            HttpHeaders headers = response.getHeaders();

            String port = String.valueOf(uri.getPort());
            headers.add(SERVER_PORT_HEADERS_NAME, port);
        }
    }

    @Override
    public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE;
    }
}

URI uri = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);

스프링 클라우드 게이트웨이는 클라이언트의 요청이 게이트웨이에 도착한 후, 처리할 서비스로 요청을 보내는데, 이 과정에서 GATEWAY_REQUEST_URL_ATTR 속성으로 속성값을 가져오면 최종적으로 결정된 목적지 URI를 가져올 수 있다.

uri : http://<ip주소>:19093/products

로그로 가져와본 상품 조회 API URI이다.

ProductApplication인 19093 포트를 잘 가져오는 것을 볼 수 있다.

public final class ServerWebExchangeUtils {
    private static final Log log = LogFactory.getLog(ServerWebExchangeUtils.class);
    public static final String PRESERVE_HOST_HEADER_ATTRIBUTE = qualify("preserveHostHeader");
    public static final String URI_TEMPLATE_VARIABLES_ATTRIBUTE = qualify("uriTemplateVariables");
    public static final String CLIENT_RESPONSE_ATTR = qualify("gatewayClientResponse");
    public static final String CLIENT_RESPONSE_CONN_ATTR = qualify("gatewayClientResponseConnection");
    public static final String CLIENT_RESPONSE_HEADER_NAMES = qualify("gatewayClientResponseHeaderNames");
    public static final String GATEWAY_ROUTE_ATTR = qualify("gatewayRoute");
    public static final String GATEWAY_REACTOR_CONTEXT_ATTR = qualify("gatewayReactorContext");
    public static final String GATEWAY_REQUEST_URL_ATTR = qualify("gatewayRequestUrl");
    public static final String GATEWAY_ORIGINAL_REQUEST_URL_ATTR = qualify("gatewayOriginalRequestUrl");
    public static final String GATEWAY_HANDLER_MAPPER_ATTR = qualify("gatewayHandlerMapper");
    public static final String GATEWAY_SCHEME_PREFIX_ATTR = qualify("gatewaySchemePrefix");
    public static final String GATEWAY_PREDICATE_ROUTE_ATTR = qualify("gatewayPredicateRouteAttr");
    public static final String GATEWAY_PREDICATE_MATCHED_PATH_ATTR = qualify("gatewayPredicateMatchedPathAttr");
    public static final String GATEWAY_PREDICATE_MATCHED_PATH_ROUTE_ID_ATTR = qualify("gatewayPredicateMatchedPathRouteIdAttr");
    public static final String GATEWAY_PREDICATE_PATH_CONTAINER_ATTR = qualify("gatewayPredicatePathContainer");
    public static final String WEIGHT_ATTR = qualify("routeWeight");
    public static final String ORIGINAL_RESPONSE_CONTENT_TYPE_ATTR = "original_response_content_type";
    public static final String CIRCUITBREAKER_EXECUTION_EXCEPTION_ATTR = qualify("circuitBreakerExecutionException");
    public static final String GATEWAY_ALREADY_ROUTED_ATTR = qualify("gatewayAlreadyRouted");
    public static final String GATEWAY_ALREADY_PREFIXED_ATTR = qualify("gatewayAlreadyPrefixed");
    public static final String CACHED_SERVER_HTTP_REQUEST_DECORATOR_ATTR = "cachedServerHttpRequestDecorator";
    public static final String CACHED_REQUEST_BODY_ATTR = "cachedRequestBody";
    public static final String GATEWAY_LOADBALANCER_RESPONSE_ATTR = qualify("gatewayLoadBalancerResponse");
    public static final String GATEWAY_OBSERVATION_ATTR = qualify("gateway.observation");
    private static final byte[] EMPTY_BYTES = new byte[0];
    
    // ...
}

URI 말고도 다양한 속성값들을 가져올 수 있다.

그리고 팀원분은 AbstractGatewayFilterFactory 를 구현하셨는데, 이는 특정 라우트에만 적용되는 필터를 정의할 때 사용한다고 한다. 만약 전역적으로 적용되는 필터를 사용해야 한다면 GlobalFilter를 구현하면 된다.

24/08/09(금) 96번째 TIL : Spring Gateway 애플 실리콘 맥 에러

yunjae62 — Sat, 10 Aug 2024 14:47:18 +0900

문제

spring:
  main:
    web-application-type: reactive  # Spring 애플리케이션이 리액티브 웹 애플리케이션으로 설정됨
  application:
    name: gateway-service 
# ...

2024-08-10T14:06:47.934+09:00 ERROR 63786 --- [gateway-service] [ctor-http-nio-2] i.n.r.d.DnsServerAddressStreamProviders  : 
Unable to load io.netty.resolver.dns.macos.MacOSDnsServerAddressStreamProvider, fallback to system defaults. 
This may result in incorrect DNS resolutions on MacOS. 
Check whether you have a dependency on 'io.netty:netty-resolver-dns-native-macos'. 
Use DEBUG level to see the full stack: java.lang.UnsatisfiedLinkError: failed to load the required native library

Spring gateway 를 리액티브로 설정해서 쓰려고 하니 에러가 났다.

Netty는 네이티브 코드를 사용해서 DNS와 연동하는데, 애플 실리콘 (M1, M2, M3 등등의 ARM 기반 아키텍처) 에서는 호환되는 것이 없어서 필요한 라이브러리가 없어서 따로 라이브러리를 통해 제공해주어야 한다.

해결

    runtimeOnly 'io.netty:netty-resolver-dns-native-macos:4.1.112.Final'

MVN리포지토리에서 최신 버전을 찾아서 입력해주면 된다.

참고 링크

https://shanepark.tistory.com/495

24/08/08(목) 95번째 TIL : Spring Data Redis 및 Redis-cli 문자열 인코딩 방식

yunjae62 — Fri, 9 Aug 2024 11:53:05 +0900

문제

localhost:63790> subscribe home
1) "subscribe"
2) "home"
3) (integer) 1
1) "message"
2) "home"
3) "{\"messageId\":\"abcde\",\"sender\":\"1234\",\"message\":\"abcde\"}"
1) "message"
2) "home"
3) "{\"messageId\":\"abcde\",\"sender\":\"1234\",\"message\":\"\xed\x95\x98\xec\x9d\xb4\"}"
1) "message"
2) "home"
3) "{\"messageId\":\"abcde\",\"sender\":\"1234\",\"message\":\"\xea\xb0\x80\"}"

레디스로 pub/sub 테스트를 해보던 중에 한글이 깨지던 문제가 있었다.

해결

❯ redis-cli -h localhost -p 63790 --raw
localhost:63790> subscribe home
subscribe
home
1
message
home
{"messageId":"abcde","sender":"1234","message":"가"}

redis-cli로 접속 시 --raw를 붙여주면 해결된다.

레디스는 --raw를 통해 원시 출력을 강제할 수 있다. (출처 : 레디스 공식 문서)

❯ redis-cli -p 63790
127.0.0.1:63790> set my "hello\nworld"
127.0.0.1:63790> get my
"hello\nworld"
127.0.0.1:63790> set hangul "한글 입니다."
OK
127.0.0.1:63790> get hangul
"\xed\x95\x9c\xea\xb8\x80 \xec\x9e\x85\xeb\x8b\x88\xeb\x8b\xa4."

❯ redis-cli -p 63790 --raw
127.0.0.1:63790> get my
hello
world
127.0.0.1:63790> get hangul
한글 입니다.

실제로 --raw를 붙이면 잘 나오는 것을 볼 수 있다.

Spring Data Redis 가 한글을 인코딩하는 방식

아까 위에서 봤듯, 한글 "가" 는 "\xea\xb0\x80"로 표기가 됐는데, 레디스는 아스키 문자로 저장이 된다.

한글 "가"는 \x가 3번 나왔으니까, 3byte 로 저장이 된다는 소린데, 3byte로 한글이 저장되는 인코딩 방식은 UTF8이다.

그래서 인코딩 사이트로 UTF8 한글 "가"를 검색해보니,

https://dencode.com/

레디스에서 저장이 되던 eab080을 확인할 수 있다.

즉 자바에서 문자열을 UTF8로 변환하여 주지만, 레디스에서는 byte 단위로 읽어서 8비트씩 끊어서 저장하느라 저렇게 표기된 것.

하지만 자바는 UTF16을 사용한다.(정확히 말하면 ASCII 로 표기할 수 있으면 1byte, 하나라도 아니라면 2byte. 이에 대해서는 내 또 다른 글을 참고하면 좋다,,) 그러면 2byte여야 할 텐데 왜 3byte로 변환이 됐는지 찾아보니

    @Bean
    public RedisTemplate<?, ?> redisTemplate() {

        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory());

        redisTemplate.setKeySerializer(RedisSerializer.string()); // 키 직렬화 
        redisTemplate.setValueSerializer(RedisSerializer.json()); // 값 직렬화 

        return redisTemplate;
    }

레디스 설정에 사용한 직렬화 방식.

그리고 RedisSerializer.string() 내부를 들어가 보니

    static RedisSerializer<String> string() {
        return StringRedisSerializer.UTF_8;
    }

우선 키를 직렬화할 땐 UTF8로 직렬화를 한다.

다음으로 RedisSerializer.json()이 문자열을 어떤 인코딩 방식으로 직렬화하는지 살펴보자면

    static RedisSerializer<Object> json() {
        return new GenericJackson2JsonRedisSerializer();
    }

RedisSerializer.json()은 GenericJackson2JsonRedisSerializer 를 반환한다.

    public GenericJackson2JsonRedisSerializer() {
        this((String)null);
    }

    public GenericJackson2JsonRedisSerializer(@Nullable String typeHintPropertyName) {
        this(typeHintPropertyName, JacksonObjectReader.create(), JacksonObjectWriter.create());
    }

    public GenericJackson2JsonRedisSerializer(@Nullable String typeHintPropertyName, JacksonObjectReader reader, JacksonObjectWriter writer) {
        this(new ObjectMapper(), reader, writer, typeHintPropertyName);
        registerNullValueSerializer(this.mapper, typeHintPropertyName);
        this.mapper.setDefaultTyping(createDefaultTypeResolverBuilder(this.getObjectMapper(), typeHintPropertyName));
    }

    public GenericJackson2JsonRedisSerializer(ObjectMapper mapper) {
        this(mapper, JacksonObjectReader.create(), JacksonObjectWriter.create());
    }

    public GenericJackson2JsonRedisSerializer(ObjectMapper mapper, JacksonObjectReader reader, JacksonObjectWriter writer) {
        this(mapper, reader, writer, (String)null);
    }

    private GenericJackson2JsonRedisSerializer(ObjectMapper mapper, JacksonObjectReader reader, JacksonObjectWriter writer, @Nullable String typeHintPropertyName) {
        Assert.notNull(mapper, "ObjectMapper must not be null");
        Assert.notNull(reader, "Reader must not be null");
        Assert.notNull(writer, "Writer must not be null");
        this.mapper = mapper;
        this.reader = reader;
        this.writer = writer;
        this.defaultTypingEnabled = Lazy.of(() -> {
            return mapper.getSerializationConfig().getDefaultTyper((JavaType)null) != null;
        });
        this.typeResolver = newTypeResolver(mapper, typeHintPropertyName, this.defaultTypingEnabled);
    }

GenericJackson2JsonRedisSerializer 생성자를 맨 위에서부터 차례대로 보면 된다.

this를 타고 내려가면서 2번째 생성자를 보면 JacksonObjectWriter.create()라는 메서드를 통해 JSON을 직렬화하기 위한 객체를 만든다.

그리고 6번째 생성자에서, 만든 JacksonObjectWriter를 this.writer 에 넣어준다.

JacksonObjectWriter.create() 내부를 봐보면,

@FunctionalInterface
public interface JacksonObjectWriter {
    byte[] write(ObjectMapper mapper, Object source) throws IOException;

    static JacksonObjectWriter create() {
        return ObjectMapper::writeValueAsBytes;
    }
}

내부를 보니 ObjectMapper.writeValueAsBytes()라는 메서드를 실행시킨다. 안을 또 봐보면

    public byte[] writeValueAsBytes(Object value) throws JsonProcessingException {
        BufferRecycler br = this._jsonFactory._getBufferRecycler();

        byte[] var6;
        try {
            ByteArrayBuilder bb = new ByteArrayBuilder(br);
            Throwable var4 = null;

            try {
                // 여기 
                this._writeValueAndClose(this.createGenerator((OutputStream)bb, JsonEncoding.UTF8), value); 
                byte[] result = bb.toByteArray();
                bb.release();
                var6 = result;
            } catch (Throwable var26) {
                var4 = var26;
                throw var26;
            } finally {
                if (bb != null) {
                    if (var4 != null) {
                        try {
                            bb.close();
                        } catch (Throwable var25) {
                            var4.addSuppressed(var25);
                        }
                    } else {
                        bb.close();
                    }
                }

            }
        } catch (JsonProcessingException var28) {
            JsonProcessingException e = var28;
            throw e;
        } catch (IOException var29) {
            IOException e = var29;
            throw JsonMappingException.fromUnexpectedIOE(e);
        } finally {
            br.releaseToPool();
        }

        return var6;
    }

위 코드를 다 볼 필욘 없고 2번째 try문의 여기라고 써둔 바로 밑 줄을 보면 JsonEncoding.UTF8이라고 되어 있다.

우리의 목적은 자바 객체가 JSON으로 변환되면서 어떤 인코딩으로 변환되는지 확인하는 거였으니 더 깊게 안 들어가고 (들어가도 더 복잡하고 이해하기 힘들다,,) 여기까지 확인하는 걸로.

결론

Redis는 기본적으로 byte-encoded character로 표기한다. (not human readable)
Spring Data Redis는 UTF8로 인코딩한다.
사람이 읽을 수 있게 표기하려면 redis-cli에서 --raw 옵션을 추가하면 된다.

24/08/07(수) 94번째 TIL : EurekaServerConfig 빈 중복 해결하기

yunjae62 — Wed, 7 Aug 2024 13:12:17 +0900

문제

유레카 서버 설정을 위해 따로 EurekaServerConfig라고 하는 클래스를 만들어 실행했지만, 중복되는 빈객체로 실행이 되지 않았다.

상황

@EnableEurekaServer
@SpringBootApplication
public class EurekaApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class, args);
    }
}

강의 예제에는 애플리케이션 클래스 위에 붙여주었지만, 나는 애플리케이션에 덕지덕지 @Enable- 어노테이션을 붙이는 걸 좋아하지는 않아서 따로 ~Config 클래스를 만들어주기로 했다.

@SpringBootApplication
public class EurekaApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class, args);
    }
}

우선 애플리케이션 클래스에서는 Enable- 어노테이션을 지워주었고,

// ./config/EurekaServerConfig.java

import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableEurekaServer
public class EurekaServerConfig {
}

EurekaServerConfig.class를 만들어서 어노테이션을 붙여주었다.

2024-08-07T12:48:05.345+09:00 ERROR 89334 --- [server] [           main] o.s.b.d.LoggingFailureAnalysisReporter   : 

***************************
APPLICATION FAILED TO START
***************************

Description:

The bean 'eurekaServerConfig', defined in class path resource [org/springframework/cloud/netflix/eureka/server/EurekaServerAutoConfiguration$EurekaServerConfigBeanConfiguration.class], could not be registered. A bean with that name has already been defined in file [/Users/barami62/projects/adv-sparta/msa-exam-01/com.sparta.msa_exam.eureka/build/classes/java/main/com/sparta/msa_exam/eureka/config/EurekaServerConfig.class] and overriding is disabled.

Action:

Consider renaming one of the beans or enabling overriding by setting spring.main.allow-bean-definition-overriding=true

하지만 실행이 되지 않았다.

너무 길어서 줄넘김하려고 했는데 티스토리에서는 지원되지 않나 보다,,

요약하면 유레카 라이브러리의 빈 이름이랑 겹치니까 이름을 고치던지 설정을 오버라이딩 가능하도록 변경하라고 한다.

package org.springframework.cloud.netflix.eureka.server;

public class EurekaServerAutoConfiguration implements WebMvcConfigurer {

    // ...
    
    @Configuration(
        proxyBeanMethods = false
    )
    protected static class EurekaServerConfigBeanConfiguration {
        protected EurekaServerConfigBeanConfiguration() {
        }

        @Bean
        @ConditionalOnMissingBean
        public EurekaServerConfig eurekaServerConfig(EurekaClientConfig clientConfig) {
            EurekaServerConfigBean server = new EurekaServerConfigBean();
            if (clientConfig.shouldRegisterWithEureka()) {
                server.setRegistrySyncRetries(5);
            }

            return server;
        }
    }
}

어떤 애가 우리 클래스 못 쓰게 만든건지 궁금해서 찾아보니 유레카 서버 라이브러리 속에 있었다.

그냥 이 녀석 때문에 안 된다는 것만 확인하고 넘어갔다.

해결

방법 1. 클래스 이름 변경

// ./config/CustomEurekaServerConfig.java

import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableEurekaServer
public class CustomEurekaServerConfig {
}

CustomEurekaServerConfig.class 로 만들어 주었더니 정상적으로 실행이 되었다.

방법 2. 빈 오버라이딩 허용

// application.yml 

...

spring:
  main:
    allow-bean-definition-overriding: true

...

빈이 오버라이딩 되도록 허용을 해주었다.

예상과는 다르게 정상적으로 실행되었다…

하지만 라이브로리를 가져다 쓰는 입장에서 굳이 오버라이딩했다가 어떤 일을 당할지 모르기 때문에 1번 방법을 쓰기로 했다.

24/08/06(화) 93번째 TIL : 도커 볼륨으로 레디스 데이터 공유하기

yunjae62 — Tue, 6 Aug 2024 23:51:56 +0900

문제

도커로 레디스를 띄울 때, 기존 데이터나 설정을 유지하고 싶었다.

해결

도커로 레디스를 띄울 때, 볼륨을 통해 저장 공간을 공유하고, redis.conf 라는 레디스 설정 파일도 공유하여 레디스 컨테이너를 띄울 때 데이터를 유지하도록 해결했다.

과정

우선 EC2 Ubuntu24.04 버전에 도커를 띄운 상황에서 설명하겠다.

sudo docker volume create redis-data

우선 redis-data 라고 하는 볼륨을 만들어준다.

$ sudo docker volume inspect redis-data
[
    {
        "CreatedAt": "2024-08-05T20:43:25+09:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/redis-data/_data",
        "Name": "redis-data",
        "Options": null,
        "Scope": "local"
    }
]

docker volume inspect <볼륨명> 을 통해 생성 시간, 저장 위치를 비롯한 볼륨 정보를 볼 수 있다.

cd ~
mkdir redis-dir
cd ./redis-dir
sudo vi redis.conf

또한 ~/redis-dir 에 레디스 전용 디렉토리를 하나 만들고, 여기에 redis.conf 파일을 만들어 두기로 했다.

# redis.conf 
# i 를 눌러서 입력 모드로 전환 후, 아래처럼 입력. 

bind 0.0.0.0 # 외부 접근 가능 

port 6379 # 포트는 6379 

requirepass 1234 # 접속 시 인증 필요. auth 1234 하면 인증 처리 

maxmemory 1gb # 최대 논리 메모리는 1GB 

maxmemory-policy allkeys-lru # 논리 메모리 초과 시 LRU(가장 오래된 데이터 삭제) 선택 

appendonly yes # AOF 활성화 (모든 쓰기 로그 저장) -> 실행 시 RDB가 아닌 AOF 파일 읽어 복구 

# 다 입력 후, ESC를 눌러서 명령 모드로 돌아온 후 :wq 로 저장 후 나가기.

vi로 들어온 redis.conf 파일이다.

i를 눌러서 입력 모드로 전환 후, bind 0.0.0.0 부터 appendonly yes 까지 적고 ESC를 눌러 명령 모드로 돌아온 후, :wq를 입력하고 엔터를 눌러서 저장하고 빠져나온다.

레디스 띄우기

sudo docker run -d \ 
  -p 6379:6379 \ 
  -v ~/redis-dir/redis.conf:/etc/redis/redis.conf \ 
  -v redis-data:/data \ 
  --name redis-ex \ 
  redis:latest redis-server /etc/redis/redis.conf

그리고 도커로 레디스를 실행해준다.

-p는 포트포워딩,

첫 번째 -v는 -v <redis.conf 저장 위치>:<컨테이너에 저장할 위치>

두 번째 -v는 -v <볼륨이름>:<컨테이너에 저장할 위치>

마지막 줄은 redis:latest 이미지를 사용하는데, redis-server /etc/redis/redis.conf 로 redis.conf를 설정파일로 실행할 수 있다.

...

캡쳐한줄 알았는데 안 하고 지워버렸다.

우선 redis-data 볼륨에는 레디스의 /data 디렉토리와 연동되어 저장되는데, 이 디렉토리에는 레디스의 ~.rdv, ~.aof, manifest 파일이 있다. (정확히는 옵션 기본값인 appendonlydir 디렉토리 안에.)

이 rdb, aof 파일로 레디스가 재시작될 때 복원을 진행하여 새로운 레디스 컨테이너를 띄워도 기존의 데이터를 유지할 수 있다.

레디스 스택 띄우기

sudo docker run -d \ 
  -p 6379:6379 \ 
  -p 8001:8001 \ 
  --name redis \ 
  -v ~/redis-dir/redis-stack.conf:/redis-stack.conf \ 
  -v redis-data:/data \ 
  redis/redis-stack

레디스 스택을 사용하는 경우에는 /etc/redis/redis.conf와 달리 바로 /redis-stack.conf 를 하면 된다.

레디스 볼륨에 저장되는 데이터

ubuntu:/var/lib/docker/volumes/redis-data/_data$ ls
appendonlydir  dump.rdb

아까 위에서 redis-data 볼륨의 위치를 inspect 명령어로 확인한 것을 토대로 이동해봤다.

appendonlydir 디렉토리와 dump.rdb가 있다.

dump.rdb는 레디스가 동작 중 스냅샷 개념으로 현재 메모리 정보를 저장해두는 파일이다.

ubuntu:/var/lib/docker/volumes/redis-data/_data/appendonlydir$ ls
appendonly.aof.1.base.rdb  appendonly.aof.1.incr.aof  appendonly.aof.manifest

appendonlydir은 aof 백업 방식을 택할 때 디렉토리명 옵션 기본값으로, 이 안에 백업용 rdb, aof, manifest 파일이 저장된다.

ubuntu:/var/lib/docker/volumes/redis-data/_data/appendonlydir$ sudo cat appendonly.aof.manifest
file appendonly.aof.1.base.rdb seq 1 type b
file appendonly.aof.1.incr.aof seq 1 type i

appendonly.aof.manufest 파일에는 매번 백업 시마다 백업되는 .rdb, .aof 파일의 버전을 저장해둔다. 백업본 재작성마다 숫자가 올라간다.

ubuntu:/var/lib/docker/volumes/redis-data/_data/appendonlydir$ sudo cat appendonly.aof.1.incr.aof
*2
$6
SELECT
$1
0
*3
$3
set
$1
a
$1
b
*2
$6
SELECT
$1
0
*3
$3
set
$1
c
$1
d

.rdb는 바이너리파일이라 읽기도 어렵지만 .aof 파일은 repl로 저장이 되어 알아볼 수 있다.

만약 flushall 로 모든 데이터가 날아갔대도, 쓰기작업마다 순차적으로 기록되는 .aof 파일의 마지막에 있는 flushall 명령어를 지우고 레디스를 다시 실행하면 복구가 가능하다.

24/08/05(월) 92번째 TIL : 레디스 인증 설정

yunjae62 — Mon, 5 Aug 2024 17:25:35 +0900

주제

예전에 레디스 해킹을 당해놓고서 아직도 정신 못 차리고 비밀번호 설정을 귀찮아서 안 해두다가 이번에 제대로 알아두기로 했다.

우선 도커로 레디스 설치부터 암호 설정, 암호로 접속하는 방법까지 다뤄보기로.

레디스 도커 설치

sudo docker run -d \ 
  --name redis-ex \
  -p 63790:6379 \
  -e REDIS_ARGS="--requirepass 1234" \
  redis/redis-stack-server

위는 레디스 스택을 포함하는 redis-stack-server 이미지이고

sudo docker run -d \ 
  --name redis-ex \
  -p 63790:6379 \
  redis --requirepass 1234

위는 그냥 레디스일 때이다. 각각 비밀번호를 설정하는 방법이 다르다.

--requiredpass 1234는 1234 라고 암호를 지정해주겠다는 명령어이다.

포트도 기본 포트인 6379에 무작위로 요청보내서 비밀번호 안 걸려있는 경우에 기존 키를 싹다 flushall 해서 없앤 뒤 스크립트를 넣어두고 사용하는 식으로 해킹 당한 적이 있기 때문에 항상 0을 하나 더 붙여서 사용하는 편이다.

ACL 설정

sudo docker exec -it redis-ex redis-cli

이제 레디스를 사용하려고 이와 같이 명령어를 입력하면

127.0.0.1:6379> ping
(error) NOAUTH Authentication required.
127.0.0.1:6379> set a b
(error) NOAUTH Authentication required.

이렇게 인증이 필요하다고 에러가 난다.

127.0.0.1:6379> auth 1234
OK
127.0.0.1:6379> ping
PONG

auth <비밀번호> 를 입력하면 인증이 된다.

이후 레디스 6버전 부터는 ACL(Access Control List)로 유저라는 개념이 도입됐다.

이 유저를 통해 실행 가능 커맨드와 접근 가능 키를 제한할 수 있다.

ACL SETUSER yunjae on >1234 ~* allcommands

yunjae 라는 유저의 비밀번호를 1234로 설정하고 (>1234), 모든 키에 대해 접근 가능(~*), 모든 커맨드 허용(allcommands)

acl setuser reader on >abcd ~read-only:* +@all -@set &*

이는 reader 라는 유저의 비밀번호를 abcd로 하고, 키는 read-only: 로 시작하는 키만 접근 가능하며, +@all 은 모든 커맨드 사용 가능하고, -@set 은 set 커맨드는 사용 불가능 하다는 뜻이다. &*는 모든 pub/sub채널에 대해 접근 가능하다는 뜻이다.

유저 상태는 on/off로 제어할 수 있다. on은 접근 허용, off는 유저는 만들어두지만 접근은 막아두겠다는 뜻이다.

아까 위에서 auth 1234 로 인증했는데, 이것은 구버전과의 호환성을 위해 남겨둔 것으로, 이후로는 auth <user> <password>로 접속하며, 기존의 requirepass로 한 경우 default 가 유저가 된다.

auth default 1234
auth reader abcd

이렇게 redis-cli로 접속 후 위와 같이 입력하면 된다.

redis-cli -h yunjae.click -p 6379 -a 1234
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.

redis-cli -h yunjae.click -p 6379 --user reader --pass abcd
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.

추천하지는 않지만 redis-cli 에서 바로 인증이 가능하긴 하다.

권한 확인

아까 위에서 reader 라는 유저는 read-only: 로 시작하는 키만 접근이 가능하고, set 커맨드는 사용이 불가능 하다고 설정했다. 이를 확인해보면 아래와 같다.

localhost:6379> set a b
(error) NOPERM No permissions to access a key

localhost:6379> get a
(error) NOPERM No permissions to access a key

localhost:6379> get read-only:a
"b"

미리 set read-only:a b 를 해둔 상태이다. 정상적으로 동작하는 것을 볼 수 있다.

참고 링크

24/08/02(금) 91번째 TIL : EC2 Ubuntu 포트포워딩

yunjae62 — Fri, 2 Aug 2024 23:07:43 +0900

문제

강의 자료에 나온대로 포트포워딩을 진행했지만 실제로는 포트포워딩이 되지 않았다.

상황

강의 자료에 나온 명령어는 다음과 같다.

sudo iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 8080

하지만 보안그룹 인바운드 규칙을 확인해봐도, 서버 내에 프로세스가 정상적으로 실행되었음을 확인해봐도 80포트로 접속이 되지 않았다.

ubuntu@ip-172-31-41-183:~$  sudo iptables -t nat -L --line-numbers
Chain PREROUTING (policy ACCEPT)
num  target     prot opt source               destination
1    REDIRECT   tcp  --  anywhere             anywhere             tcp dpt:http redir ports 8080

Chain INPUT (policy ACCEPT)
num  target     prot opt source               destination

Chain OUTPUT (policy ACCEPT)
num  target     prot opt source               destination

Chain POSTROUTING (policy ACCEPT)
num  target     prot opt source               destination

위의 명령어로 포트포워딩이 정상적으로 설정됐는지 확인했지만 잘 되어 있었다.

해결

우선 위의 명령어에 대한 자세한 설명은 이 블로그를 참고하고, 간략하게 설명하면 다음과 같다.

iptables : ip 관리하는 테이블로, 방화벽을 설정하는 명령어
-t nat : NAT 테이블을 선택
-A PREROUTING : -A는 새로운 정책을 추가, -A PREROUTING는 라우팅 전에 결정되는 규칙을 추가
-i eh0 : eth0인 입력 네트워크 인터페이스와 매칭
-p tcp : TCP 프로토콜과 매칭
-dPort 80 : 목적지 포트가 80에 대해 매칭
-j REDIRECT : -j는 jump로, 매칭되는 패킷을 어떻게 처리할지 결정, REDIRECT는 리디렉션.
-to-port 8080 : 패킷을 8080으로 리디렉션

정리하면 eth0 네트워크 인터페이스로 들어오는 패킷 중, 목적지 포트가 80인 TCP 패킷을 8080 포트로 리디렉션 해주는 명령어이다.

다른 글을 찾아보니 입력 네트워크 인터페이스를 바꿔주니 해결되었고, 그래서 나는 우분투의 각 버전과 아키텍처 별로 NI를 조사해보았다.

아래는 각 버전 별 ifconfig 명령어의 결과다.

우분투 24.04 - ARM

ens5: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 9001
        inet 172.31.41.183  netmask 255.255.240.0  broadcast 172.31.47.255
        inet6 fe80::822:cff:fed1:371f  prefixlen 64  scopeid 0x20<link>
        ether 0a:22:0c:d1:37:1f  txqueuelen 1000  (Ethernet)
        RX packets 22538  bytes 29638477 (29.6 MB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 11742  bytes 917655 (917.6 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 170  bytes 18165 (18.1 KB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 170  bytes 18165 (18.1 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

우분투 24.04 - X86(64)

enX0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 9001
        inet 172.31.2.58  netmask 255.255.240.0  broadcast 172.31.15.255
        inet6 fe80::31:faff:fe19:a1b  prefixlen 64  scopeid 0x20<link>
        ether 02:31:fa:19:0a:1b  txqueuelen 1000  (Ethernet)
        RX packets 21329  bytes 29947584 (29.9 MB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 2277  bytes 260858 (260.8 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 166  bytes 17850 (17.8 KB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 166  bytes 17850 (17.8 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

우분투 22.04 - ARM

ens5: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 9001
        inet 172.31.37.9  netmask 255.255.240.0  broadcast 172.31.47.255
        inet6 fe80::84c:38ff:fe39:717  prefixlen 64  scopeid 0x20<link>
        ether 0a:4c:38:39:07:17  txqueuelen 1000  (Ethernet)
        RX packets 22354  bytes 32723724 (32.7 MB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 10664  bytes 802619 (802.6 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 174  bytes 18800 (18.8 KB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 174  bytes 18800 (18.8 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

우분투 22.04 - X86(64)

eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 9001
        inet 172.31.8.217  netmask 255.255.240.0  broadcast 172.31.15.255
        inet6 fe80::e:5dff:fe7d:c547  prefixlen 64  scopeid 0x20<link>
        ether 02:0e:5d:7d:c5:47  txqueuelen 1000  (Ethernet)
        RX packets 24261  bytes 34927370 (34.9 MB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 2865  bytes 297580 (297.5 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 166  bytes 18114 (18.1 KB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 166  bytes 18114 (18.1 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

버전 및 아키텍처 별 네트워크 인터페이스 정리

표로 정리하면 다음과 같다.

우분투 버전	우분투 24.04		우분투 22.04
아키텍처	ARM	X86	ARM	X86
네트워크 인터페이스	ens5	enX0	ens5	eth0

실제로 버전 및 아키텍처에 따라 달라진다!

즉, 위의 명령어에서 eth0 부분을 현재 서버의 스펙에 맞게 변경해주면 정상적으로 동작이 된다.

나와 같은 경우는 t4g.nano를 사용하여 ARM 아키텍처를 사용하고 있으므로 우분투 버전에 상관없이 eth0를 ens5로 변경해주면 정상적으로 포트포워딩이 적용된다.

NIC 명명법이 변경된 이유

우분투에서 Predictable Network Interface Names 라고 하는, 네트워크 인터페이스 이름을 관리하는 방식이 변경이 되었기 때문이다. (참고 : 블로그)

이러한 변화는 systemd 197 에서부터 시작됐고, 기존의 예측 불가능한 명명법에서 예측이 가능하도록 이름을 할당하도록 명명법이 바뀌었다.

<pf><type><bus_id> 로 구성되며(출처 : IBM), 이더넷(pf가en)으로 예시를 든다면 아래와 같다. (출처 : systemd, systemd를 기반으로 하는 위키)

eno: Names containing the index numbers provided by firmware/BIOS for on-board devices, example: eno1 (eno = Onboard).
ens: Names containing the PCI Express hotplug slot numbers provided by the firmware/BIOS, example: ens1 (ens = Slot).
enp: Names containing the physical/geographical location of the hardware's port, example: enp2s0 (enp = Position).
enx: Names containing the MAC address of the interface (example: enx78e7d1ea46da).
eth: Classic unpredictable kernel-native ethX naming (example: eth0).

결론

AWS의 우분투 24.04 LTS버전에서는 enx* 이므로 맥주소를 기반으로 하는 명명법을 따랐다고 볼 수 있다.

TMI

이거 테스트 한다고 우분투 24.04부터 22.04까지 ARM과 X86기반 아키텍처 모두 만들어서 해봤다 ㅎㅎ

우분투 20.04 - x86으로도 해보려고 했지만 (ARM은 아예 없다)

우분투 20.04 버전으로는 Microsoft SQL Server와 함께 있는 AMI 인데, 일단 t2의 nano, micro, small은 모두 안 됐다,,

20.04 버전은 LTS 종료가 1년도 안 남았으니 그냥 안 쓰는 걸로,,

24/08/01(목) 90번째 TIL : AWS Amazon VPC CIDR 범위

yunjae62 — Thu, 1 Aug 2024 12:37:00 +0900

Amazon VPC

AWS는 Amazon VPC라는 서비스로 가상의 네트워크를 구성할 수 있다.

VPC 내의 최대 개수 제한

VPC는 리전마다 독립적으로 구성되어 있으며, 하나의 리전당 5개의 VPC를 구성할 수 있다. (공식 문서 출처)

또한 VPC당 200개의 서브넷이 최대이며 CIDR 블록은 IPv4와 IPv6 각각 5개가 최대이다.

VPC를 만들 때는 IPv4 CIDR 블록을 지정해야 한다.

VPC CIDR 허용 범위

공식 문서에서는 프라이빗 IP 주소 범위에 속하도록 권장하고 있지만, 허용된 블록의 크기는 /16 서브넷마스크부터 /28 서브넷마스크 까지다. 즉, IP주소는 65,536개부터 16개까지 제한할 수 있다.

사설 IP 범위 (출처 : RFC 1918)	CIDR 블록 예시
10.0.0.0 ~ 10.255.255.255 (10.0.0.0/8)	10.0.0.0/16 (VPC는 /16 넷마스크부터로 제한됨)
172.16.0.0 ~ 172.31.255.255 (172.16.0.0/12)	172.31.0.0/16 (VPC는 /16 넷마스크부터로 제한됨)
192.168.0.0 ~ 192.168.255.255 (192.168.0.0/16)	192.168.0.0/20

RFC 1918 section-3 : 사설 IP 주소공간

CIDR 범위 지정 시 주의할 점

하지만 일부 AWS 서비스의 경우(AWS Cloud9, Amazon SageMaker 등) 172.1.0.0/16 범위를 사용하고 있으므로, 충돌을 방지하려면 이 범위는 사용하지 않는 것을 권장하고 있다.

또한 이 외에 제한되는 IPv4 및 IPv6 VPC CIDR 블록은 공식문서에 자세히 안내하고 있다.