DDD + Layered Architecture(계층형 구조) 형태의 패키지 구조 기능 단위(feature/domain)로 분리

1) 도메인(feature)별로 분리되어 유지보수가 쉬움 2) 계층 구조로 역할이 명확함 DDD 3) 규모가 커져도 확장 가능 4) MSA 전환도 쉬움 만약 나중에 각 기능을 MSA로 분리해야 하면, 각 도메인을 그대로 떼서 새로운 서비스로 추출할 수 있음.

Mysql 사용

공사/시공 관리 ERP 고객, 파트너, 공정, 자재, 견적 등 관계형 데이터 구조가 강함

• 선후관계가 존재 트랜잭션 중요(공정 등록 → 체크리스트 등록 → 작업일정 등록)

데이터 구조가 명확한 편 👉 따라서 관계형 DB(RDBMS)를 쓰는 게 필수

• AWS RDS(MySQL) 가장 안정적, 장애 자동 복구, 백업 자동, 운영 부담 거의 없음 실제 서비스 운영(회사/스타트업)에서 대부분 선택하는 방식
  • 월 비용 발생 (초기 최소 2~3만원부터)

참고 https://romcanrom.tistory.com/75#toc2

인테리어 감리·현장 관리·실측·공정 일정 관리 등 인테리어 프로젝트 운영 전반을 통합 관리하기 위한 맞춤형 ERP 솔루션 현장에 최적화된 태블릿/노트북 기반 입력 환경을 제공하여 실측 → 공정 관리 → 자재 → 견적 → A/S까지 단일 흐름으로 관리합니다.

공사 현장 소음, 쉴 새 없이 울리는 카톡, 종이 영수증 더미, 엑셀 파일이 켜진 노트북 견적, 발주, 정산...언제까지 엑셀과 카톡방 뒤지며 일하시겠습니까?

고객 상담부터 견적, 공정 관리, 자재 발주, A/S까지 이어지는 모든 업무를 하나의 플랫폼에서 처리할 수 있어, 현장에서의 판단 속도를 높이고 내부 업무의 효율을 극대화합니다.

Renoflow는 인테리어 현장의 모든 순간을 기록하고 연결하여 더 빠르고 정확한 의사결정, 현장 중심의 효율, 체계적인 프로젝트 운영을 가능하게 합니다.

🔑 복잡한 공정을 다루는 인테리어 업계에서 Renoflow는 “현장의 실무를 가장 잘 이해하는 ERP”를 목표로 지속적으로 기능을 확장해 나가고 있습니다.

Problem | Solution

인테리어 프로젝트는 복잡하고 관리 리스크가 크다

💥 Problem) 과도한 업무 집중: 1인이 모든 것을 처리하는 구조

소규모 인테리어 회사는 실장 혹은 디자이너 한 명이 상담·실측·공정관리·자재·견적·고객 대응까지 담당합니다 이로 인해 다음과 같은 문제가 고착화되어 있습니다

• 사람 의존형 프로세스로 인수인계 불가 → 인력 교체 시 업무 중단
• 한 사람의 ‘머릿속’에 저장된 정보가 시스템화되지 않음
• 문서·데이터 누락 및 중복 발생
• 개인의 방식에 의존한 업무 운영
• 표준화된 템플릿 부재로 정합성 유지 어려움

🔑 Solution) 업무 표준화 & 템플릿 기반 자동화

✔ 단일 흐름으로 관리되는 All-in-One 프로세스

• 실측 → 공정 체크 → 자재 → 견적까지 모두 표준 템플릿과 자동화 로직으로 정리
• 신규 인력이 투입돼도 동일 형태의 작업 가능
• 태블릿·노트북 기반의 현장 친화 인터페이스 제공, 사무실은 실시간 상태 확인 → 원스톱으로 모든 업무 수행
• 실측 기록, 자동 공정 체크리스트, 자재 관리 연동 견적 자동 생성, 고객 변경사항 기록, 일정 및 이슈 팀내 공유 → 문서 누락 없음 / 중복 없음 / 인수인계 간편

💥 Problem) 공정·일정 관리의 복잡성

• 자재 입고 기록이 엑셀·카톡·메모·사진으로 분산
• 어느 자재가 언제/어디로 입고되었는지 추적 불가
• 현장 도착 전에 자재 누락이 발생해 시공 지연
• 공정 간 의존성이 높아 순서가 어긋나면 시공 지연 및 비용 증가
• 현장·사무·발주팀 간 정보가 분리되어 의사결정이 느림
• 별도의 체크 체계 부재 → 누락 시 큰 비용 발생
• 상담·실측·공정·자재·A/S 등 단계별로 관리해야 할 데이터가 방대
• 고객 소통 기록의 누락이 분쟁으로 이어짐

🔑 Solution) 데이터 중앙관리

✔ 하나의 프로젝트가 하나의 데이터셋으로 구성

• 카톡·메모·엑셀 등 산발적 문서를 제거 흐름을 한눈에 확인하는 “통합 관리” 프로젝트 전체 과정이 단일 플랫폼에서 운영됨
• 누구라도 프로젝트 전체 상황을 즉시 파악 가능 → 정보가 단일화되고, 조직 전체의 협업 효율이 높아진다. 실장, 디자이너, 관리자, 발주 담당, A/S 담당 등 각자의 역할에 맞춰 필요한 데이터를 볼 수 있음 조직 내 정보 불균형 해소
• 현장 직배송 / 사무실 입고 / 픽업 / 협력업체 전달 등 자재 입고 경로별 상태를 시스템에서 즉시 확인 어떤 자재가 언제 도착했는지 자동 로그 기록
• 공정별로 필요한 자재 체크 시공 전 준비해야 할 자재 자동 검증 → 자재 누락으로 인한 공정 지연을 원천 차단
• 커뮤니케이션 비용 절감

💥 Problem) 견적 오류로 인한 직접적 손실

인테리어 견적은 인건비·자재 단가가 지속적으로 변동하기 때문에 항상 최신 정보를 기초로 견적을 산출해야 합니다.

그러나 업계에서는 여전히:

• 종이 지류, 엑셀, 수기로 견적 관리
• 어떤 부분이 수정되었는지 이력 추적 불가
• 이동 중(현장 → 사무실) 문서 확인 어렵고 최신 여부 파악 불가
• 잘못된 단가 입력 → 회사의 직접적 손실 발생 → 견적 실수는 곧바로 재료비·인건비 차액으로 이어져 기업에 손해를 준다.

🔑 Solution) 견적서 자동 생성 & 최신 단가 연동

✔ 견적서 자동 생성 & 최신 단가 연동 Renoflow는 실무에서 가장 큰 리스크인 견적 실수를 제거합니다.

• 인건비·자재 단가 변경 반영하여 견적서 자동 생성
• 품목별 수정 이력 자동 기록
• 어디서 단가가 바뀌었는지 추적 가능
• 현장에서 즉시 견적 생성 가능
• 지류 및 수기 관리로 발생하는 ‘가격 오류 리스크’ 제거 → 잘못된 단가 입력으로 발생하는 손실 방지

💥 Problem) 현장에서 모바일은 비효율

• 화면이 작아 실측, 체크리스트, 사진 업로드가 어려움
• 고객과 상담 중 입력 행동 자체가 집중도 저해

🔑 Solution) 현장에서 쓰기 좋은 화면 구성

Renoflow는 현장의 특성을 반영하여 ‘태블릿·노트북 기반의 이동성’과 ‘PC 수준의 데이터 처리 환경’을 제공하도록 설계되었습니다.

• 태블릿 최적화 UI
• 손가락 입력 중심 인터랙션
• 사진·치수 입력 자동 저장
• 상담 중 집중도 저해 최소화

💥 Problem) 고객과의 소통 기록 부족

• 변경 요청 및 의사결정 기록 부재 → 분쟁·오해·추가 비용 발생

💥 Solution) 고객 관리 서비스

• 고객 서비스 요청,제공 모두 기록 보유
• 데이터를 통한 고객 맞춤 서비스 제공 가능
• 고객 정보 관리

📌 핵심 기능과 기능이 필요한 이유

Renoflow의 핵심 기능은 프로젝트 관리와 견적서 자동 생성, 자재 관리 에 있습니다. 이 외의 고객관리, 거래처 관리가 있지만 이는 Renoflow를 사용하면 기본적으로 사용 가능합니다

1. 프로젝트 관리

• 공간별 공정 구성, 일정 계획, 작업 순서 관리
• 공사 전/직전/중/후/A/S 단계별 체크리스트
• 현장에서 발생하는 이슈를 즉시 기록하고 공유
• 부서 간 정보 불균형 해소 및 동일한 기준으로 프로젝트 운영

2. 견적서 자동 생성

• 현장에서 입력한 실측·자재 정보 기반으로 즉시 견적서 생성
• 공정별 단가·수량 자동 계산
• 반복되는 견적 작성 시간을 획기적으로 절감
• 상담 현장에서 고객 의사결정 속도 상승

3. 자재 관리

• 각 공정별 필요 자재 자동 연동
• 자재 소요량·발주 시점 관리
• 중복 발주 방지 및 비용 관리 정확성 향상

(기본 제공 기능) 고객 관리 · 거래처 관리

• 프로젝트와 연동된 고객/거래처 정보 자동 생성
• 별도 CRM 없이도 기본 관리 가능

1. 프로젝트 관리 (현장 관리)

: 현장 관리 카테고리는 공사 단위가 한 프로젝트 입니다.

• view 1) 현장 관리 대시보드 매 월 진행중인 날과 견적예정인 현장을 한눈에 파악 가능하도록 구현했고, 프로젝트 검색이 가능하도록하여 프로젝트 조회를 빠르게 할 수 있도록 구현했습니다 로그인한 담당자가 진행중인 현장을 관리할 수 있도록 하여 담당자 프로젝트 관리에 집중할 수 있도록 기획했습니다

• view 2) 새 프로젝트 등록 사업자에게 있어 데이터 수집은 마케팅을 위해 중요한 정보가 됩니다. 예를 들어 work-in 오프라인으로 온 고객의 경우 두 가지 케이스로 나뉘어볼 수 있습니다

  • 단순 견적을 알고싶은 고객의 경우: WORK-IN 고객으로 등록하여 상담을 진행하게 됩니다
  • 현장을 밝히고 실제 견적을 내는 고객의 경우: 고객 등록 후 상담을 진행하게 됩니다 순서에 있어서 고객의 상태 파악이 가능할것으로 예상됩니다 어떤 담당자가 상담한 고객인지 확인 또한 가능합니다.

• view 3) 프로젝트 별 관리 대시보드 (개요) 프로젝트 (공사 단위)의 디테일을 설정하고 관리하는 페이지 입니다.

• view 3-2) 프로젝트 별 관리: 공간별 체크리스트 현장 공간별 체크리스트를 관리하여 담당자가 신규로 프로젝트에 투입되어도 체크리스트를 보고 대응이 가능하도록 업무의 통일화와 일관성을 줄 수 있습니다

• view 3-3) 프로젝트 별 관리: 공간별 실측 관리 (등록 및 조회) 현장

• view 3-4) 프로젝트 별 관리: 공정표 프로젝트 공정과 시공자 시공자 시공 항목을 매칭합니다 공정표는 현장에서 관리하는것이 아닌, 상담 후 담당자가 지정하는 것이기 때문에 세부 설정이 가능합니다.

• view 3-5) 프로젝트 별 관리: 자재 관리 등록된 자재 조회

• view 3-6) 프로젝트별 관리 : 수익/지출 관리

2. 견적 관리

: 견적서 생성 및 관리

• view 1) 견적서 생성 견적서 생성: 현장 검색 후 견적 항목 추가

• view 2) 단가표 계산기

• view 3) 빠른 견적 (템플릿)

3. 일정 관리

• view 1) 일정관리 대시보드
• view 1-2) 월간 플래너: 각 일정 클릭 시 해당 현장 정보 조회
• view 1-3) 주간 플래너: 주간 일정 관리

Renoflow가 제공하는 가치

1. 업무 표준화 및 인력 대체 가능성 확보 현장의 문서·관리 방식이 실장 개인의 습관과 경험에 의존하는 문제를 해결합니다. Renoflow는 실측, 자재, 고객 소통, 일정, 공정 등의 모든 프로세스를 표준화된 데이터 구조로 전환하여 인수인계가 용이하여 대체 인력 투입 가능하게 됩니다 실장 부재 시 업무 공백 최소화라는 운영 안정성을 제공합니다.

2. 견적 자동 생성으로 오차·손실 최소화 인건비·자재 단가는 계속 변동됩니다. 종이나 엑셀로 관리할 경우 어느 부분을 변경했는지 추적할 수 없고 이동하거나 현장에서 수정하기 어렵고 과거 견적의 버전 관리가 불가능합니다. Renoflow는 실측·자재 데이터와 최신 단가 정보를 기반으로 정확한 견적서를 자동 생성하고 변경 이력을 자동 관리하여 견적 오류로 발생하는 손해를 근본적으로 차단합니다.

3. 현장 중심의 효율성 강화 작업자는 태블릿 하나로 실측·사진·메모·공정 체크까지 현장에서 즉시 입력할 수 있습니다. 현장에서 수집된 모든 데이터는 실시간으로 내부 직원과 공유되며, 누락되기 쉬운 요소를 자동 더블체크하여 불필요한 커뮤니케이션과 재확인 시간을 줄여줍니다.

4. 고객 소통 품질 향상 프로젝트의 모든 히스토리가 기록되므로 고객과의 상담 내용, 변경 요청, 일정 조율 등이 명확하게 관리되어 분쟁 예방과 신뢰 강화에 도움을 줍니다.

5. 일정 리스크 최소화 공정 간 의존 관계를 고려한 일정 관리로 작업 순서 오류·공정 간 충돌을 예방하여 시공 지연을 최소화합니다.

6. 부서 간 정보 불균형 해소 현장팀, 사무팀, 발주팀 모두 동일한 데이터를 공유함으로써 각 부서가 독립적으로 움직이던 방식에서 → 데이터 기반 협업 구조로 전환됩니다.

Renoflow 사용자 주요 기능

1) 👩‍🦰 현장 실측·고객 상담을 담당하는 실장

주요 Pain Point

• 상담 중 신규 문의가 이어지며 기존 업무 누락 발생
• 빠르게 변하는 자재 트렌드·가격 변동을 지속적으로 반영하기 어려움
• 견적서 수정 시 변경 이력 관리가 어려워 손실 위험 존재
• 현장 실측 후 자료 정리·전달 과정이 비효율적
• 공간별·공정별 체크리스트가 통일되어 있지 않아 인수인계 어려움

Renoflow 제공 기능

• 상담·고객 관리 자동화

  상담 기록, 고객 정보, 메모를 자동 정리해 누락 방지

• 자재 가격·트렌드 실시간 반영

  업데이트되는 자재 DB로 최신 정보 기반 견적 산출

• 1초 견적 생성 및 이력 관리

  수정 내역 자동 기록으로 손해 리스크 최소화

• 현장 실측 데이터 즉시 저장

  사진·치수·메모를 현장에서 바로 업로드

• 공간·공정별 표준 체크리스트 제공

  실수와 누락을 줄이고 팀 간 인수인계용 템플릿으로 활용

2) 👫 반셀프 인테리어를 고민하는 일반 사용자

주요 Pain Point

• 공정 순서를 정확히 모름
• 어떤 공사가 어느 시점에 진행되어야 하는지 판단 어려움
• 각 공정별로 무엇을 체크해야 하는지 불확실
• 스케줄 조율이 어려워 공사 지연·중복 발생 가능

Renoflow 제공 기능

• 공정 순서 자동 가이드

  전체 공사 흐름을 한눈에 이해할 수 있도록 구조화

• 공정 일정 자동 조율

  이전/다음 공정과의 의존성을 기반으로 일정 추천

• 공정 체크리스트 제공

  각 공정별 사전 준비사항·확인 포인트 제공

• 내 공사의 실시간 진행도 확인

  투명하고 명확한 공사 관리 경험 제공

3) 👨‍🔧 현장 공유가 필요한 인테리어 업자(시공팀, 하도급팀)

주요 Pain Point

• 사무실 담당자와 현장 담당자 간 소통 오류로 문제 발생
• 공정 변경·자재 부족·지연 등 핵심 정보 전달이 늦음
• 사진, 메모, 자재 위치 등의 정보 공유가 각각의 메신저·문서에 분산
• 동일한 정보를 여러 번 설명해야 하는 비효율

Renoflow 제공 기능

• 현장–사무실 간 실시간 정보 공유 플랫폼

  공정 진행, 자재 입고, 작업 상태 등을 한 번에 공유

• 공정 변경·자재 이슈 알림

  즉시 전달되어 오류와 재작업 최소화

• 사진·파일·메모 자동 정리

  현장에서 촬영 시 즉시 프로젝트에 업로드

• 하청팀까지 포함한 공정 일정 통합 관리

  전체 일정과 작업자의 투입 상황을 명확하게 공유

✅ 1. 회원 가입 / 탈퇴

• 이메일, 휴대폰 번호, 비밀번호 등 입력받아 등록
• 필수 정보 유효성 검사
• 탈퇴 요청 처리 (soft delete 또는 완전 삭제)

✅ 2. 로그인 / 로그아웃

• 로그인: ID/PW 또는 OAuth2, 인증 성공 시 토큰(JWT 등) 발급
• 로그아웃: 토큰 무효화 (Blacklist 저장 등)

✅ 3. 인증(Authentication)

• 비밀번호 확인
• 토큰 검증
• 토큰 갱신 (Refresh Token)

✅ 4. 인가(Authorization)

• 역할(Role), 권한(Permission) 관리 (예: USER, ADMIN)
• 서비스 접근 제어를 위한 권한 검증

✅ 5. 회원 정보 조회 / 수정

• 마이페이지: 이름, 이메일, 휴대폰번호 등
• 비밀번호 변경
• 이메일 / 휴대폰 인증

✅ 6. 소셜 로그인 (선택)

• Google, Kakao, Naver 등 OAuth2 기반 로그인
• 소셜 계정 연동 / 해제

✅ 7. 사용자 상태 관리

• 활성 / 비활성 / 탈퇴 / 정지 상태
• 서비스 이용 제한 관리

✅ 8. 보안 관련 기능

• 비밀번호 암호화 (예: bcrypt)
• 비밀번호 찾기 (임시 비밀번호, 이메일 링크 등)
• 2차 인증 (선택)

✅ 9. 사용자 Activity 로그 (선택)

• 로그인 이력
• 비정상 접근 기록
• 계정 변경 이력

✅ 10. 기타 연동 기능

• 다른 서비스(예: 결제, 알림, 고객센터 등)에서 회원 ID로 조회할 수 있도록 API 제공
• 내부 인증용 API (예: 회원 ID → 유효성 검증)

🛡️ 1. 인증(Authentication)

🔐 1-1. 비밀번호 관리

• 암호화 저장:
  • bcrypt 또는 argon2 사용
  • 절대 평문 저장 ❌
• 비밀번호 정책:
  • 최소 8자 이상, 대소문자+숫자+특수문자 조합
  • 반복 문자 제한, 과거 비밀번호 재사용 금지 등

🔑 1-2. 로그인 방식

• ID/PW 로그인
  • 로그인 시도 횟수 제한 (예: 5회 실패 시 잠금)
  • 지연 응답 방식으로 brute-force 방지
• OAuth2 지원 (Google, Kakao 등)
  • 소셜 토큰 검증 후 자체 유저 등록 or 로그인 처리

📱 1-3. 2FA (2차 인증, 선택)

• OTP (예: Google Authenticator)
• SMS 또는 Email 기반 1회용 코드 인증

🛡️ 2. 인가(Authorization)

👤 2-1. Role/Permission 기반 접근 제어

• 예: USER, ADMIN, SUSPENDED
• Spring Security에서 @PreAuthorize("hasRole('ADMIN')") 등으로 제한

📦 2-2. 서비스 간 인가 처리 (MSA 환경)

• 내부 서비스 간 통신 시 internal-token 혹은 mTLS 사용
• Gateway에서 인증하고 내부 요청은 X-USER-ID header로 전달

🛡️ 3. 세션 & 토큰 관리

🪪 3-1. JWT (Access / Refresh Token)

• Access Token:
  • 수명 짧게 (예: 15분~30분)
  • 요청 시 헤더에 Authorization: Bearer <token>
• Refresh Token:
  • 수명 길게 (예: 2주~1달)
  • DB 저장 + Redis 저장 (보안 고려)

💥 3-2. 토큰 탈취 방지

• HTTP-only, Secure cookie로 전달 (특히 Refresh Token)
• IP / User-Agent 조합 검사
• Logout 시 Refresh Token 강제 삭제

🛡️ 4. 공격 방어

🧠 4-1. CSRF 방지

• REST API일 경우 CSRF 필요 없음 (stateless)
• 만약 세션/폼기반이라면 CSRF 토큰 사용

🕵️ 4-2. XSS / SQL Injection 방지

• 입력값 검증 (서버측 Validation + Frontend도 가능하면 적용)
• ORM 사용 (JPA, MyBatis 등에서 PreparedStatement 사용)
• Content-Security-Policy 설정

🔄 4-3. Rate Limiting

• 로그인 / 인증 API에는 초당 호출 수 제한
• Redis + Spring Cloud Gateway Filter로 구현 가능

🛡️ 5. 로깅 & 감사(Audit)

• 로그인/로그아웃 시도 로그
• 비밀번호 변경, 탈퇴, 권한 변경 등 중요한 이벤트 로그 기록
• 별도 Audit Log Service 구성 가능
• 로그 내 개인정보 마스킹 필수 (예: 이메일 → j***@gmail.com)

🛡️ 6. 암호화 & 데이터 보호

• 비밀번호 외에도 중요한 개인정보(휴대폰, 이메일)는 AES 등으로 암호화 저장 가능
• 민감한 데이터 전송 시 SSL/TLS 적용
• S3나 외부 저장소에 파일 업로드 시에도 서버단 암호화 고려

🛡️ 7. 계정 보호 기능

• 로그인 시 타 기기에서 로그인 여부 표시
• 최근 접속 기록 조회
• 계정 정지 기능 (SUSPENDED, BLOCKED 등 상태값)

🛡️ 8. 기타 고려사항

• 탈퇴 후 데이터 관리: 법적 보관 vs 즉시 삭제
• 비밀번호 찾기/재설정: 메일/SMS 통한 링크 방식, 링크는 일정 시간 내 만료
• IP 기반 접근 제어 (특정 관리자 기능은 사내망 IP만 허용)

✅ 정리: 보안 기능 체크리스트 예시

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception { 
http
.authorizeHttpRequests(auth -> auth
.requestMatchers("/css/**", "/images/**", "/js/**", "/favicon.*", "/*/icon-*").permitAll() .requestMatchers("/").permitAll()
.anyRequest().authenticated())
.formLogin(form -> form.loginPage("/login").permitAll())
.userDetailsService(userDetailsService) // 커스텀 UserDetailService 설정; 

return http.build();
}

UserDetailsService 구현

@Service("userDetailsService")
@RequiredArgsConstructor
public class FormUserDetailsService implements UserDetailsService {

private final UserRepository userRepository;

@Override
public UserDetails loadUserByUsername(String username (사용자가 입력한 username)) throws UsernameNotFoundException {
  Account account = userRepository.findByUsername(username); 
  if (account == null) {
    if (userRepository.countByUsername(username) == 0) {
    throw new UsernameNotFoundException("No user found with username: " + username);
      }
  }
  List<GrantedAuthority> authorities = List.of(new SimpleGrantedAuthority(account.getRoles())); // 권한 설정 ModelMapper mapper = new ModelMapper();
  AccountDto accountDto = mapper.map(account, AccountDto.class);
  }
    return new AccountContext(accountDto, authorities); 
    // AccountContext 는 UserDetails 를 구현한 클래스로서 AccountDto 를 Wrapping 함
}

AuthenticationProvider

AuthenticationProvider안에 UserDetails가 포함되어있는 것으로 AuthenticationProvider를 구현하여 적용하면 UserDetails를 설정하지 않아도 된다

@Override
public boolean support(Class<?> authentication){
    return authentication.isAssignablefrom(UsernamePasswordAuthenticationToken.class);
}

커스텀 인증상세 구현하기

: 사용자가 클라이언트에서 서버로 인증요청을 할 때 아이디와 비빌번호를 입력해서 보내주는데 이때 인증객체 Authentication에서 인증 작업을 하고, Details 객체에는 사용자의 IP 주소와 세션 ID와 같은 정보를 가지고 있다. 이 Details에 저장되어있는 객체가 WebAuthenticationDetails 객체이다

WebAuthenticationDetails

• HTTP 요청과 관련된 인증 세부 정보를 포함하는 클래스로서 기본적으로 사용자의 IP 주소와 세션 ID와 같은 정보를 가지고 있다
• 특정 인증 메커니즘에서 요청의 추가적인 정보를 인증 객체에 추가할 때 사용할 수 있으며 Authentication 객체와 함께 사용된다

AuthenticationDetailsSource

• Authentication -> Details 저장하는 역할을 한다
• 인증 과정 중에 Authentication 객체에 세부 정보(WebAuthenticationDetails)를 제공하는 소스 역할을 한다.
• WebAuthenticationDetails 객체를 생성하는 데 사용되며 인증 필터에서 참조한다

인증상세 구현

1. view에서 로그인시 header로 secret key를 보내준다

• 스프링 시큐리티의 PasswordEncoder 인터페이스는 비밀번호를 안전하게 저장하기 위해 비밀번호의 단방향 변환을 수행하는 데 사용
• 일반적으로 PasswordEncoder는 사용자의 비밀번호를 암호화하여 저장하거나 인증 시 검증을 위해 입력한 비밀번호와 암호화 되어 저장된 비밀번호를 서로 비교 해야할때 사용된다

DelegatingPasswordEncoder

• DelegatingPasswordEncoder 는 {id} 형식의 접두사를 사용하여 비밀번호가 어떤 방식으로 인코딩되었는지 식별하는 클래스로 예를 들어 {bcrypt} 접두사는 비밀번호가 BCrypt 방식으로 인코딩되었음을 나타낸다.
• DelegatingPasswordEncoder 는 어플리케이션에서 사용하는 기본 인코딩 방식을 변경할 수 있도록 해 주며 새로운 인코딩 방식이 권장되거나 필요할 때 비밀번호 인코딩 전략을 유연하게 유지할 수 있다
• 내부적으로 여러 암호화 알고리즘을 가지고 있고 이를 맞게 위임해주는 역할을 한다. 설정을 따로 하지 않으면 {bcrypt}이 기본값으로 설정된다

빈 정의

@Bean
public PasswordEncoder passwordEncoder() {
    return PasswordEncoderFactories.createDelegatingPasswordEncoder(); 
    // 기본적으로 bcrypt 암호화 알고리즘의 BCryptPasswordEncoder 객체를 생성하고 사용하게 된다
}

• 알고리즘 지정 생성

@Bean
public PasswordEncoder passwordEncoder() {
    String encodingId = "pbkdf2";
    Map<String, PasswordEncoder> encoders = new HashMap<>();
    encoders.put(encodingId, Pbkdf2PasswordEncoder.defaultsForSpringSecurity_v5_8());
    DelegatingPasswordEncoder delegatingPasswordEncoder = new DelegatingPasswordEncoder(encodingId, encoders); 
    return delegatingPasswordEncoder;
}

• 알고리즘 유형

  String encodingId = "bcrypt";
  Map<String, PasswordEncoder> encoders = new HashMap<>();
  encoders.put(encodingId, new BCryptPasswordEncoder());
  encoders.put("ldap", new org.springframework.security.crypto.password.LdapShaPasswordEncoder()); encoders.put("MD4", new org.springframework.security.crypto.password.Md4PasswordEncoder()); encoders.put("MD5", new org.springframework.security.crypto.password.MessageDigestPasswordEncoder("MD5")); encoders.put("noop", org.springframework.security.crypto.password.NoOpPasswordEncoder.getInstance()); encoders.put("pbkdf2", Pbkdf2PasswordEncoder.defaultsForSpringSecurity_v5_5()); encoders.put("pbkdf2@SpringSecurity_v5_8", Pbkdf2PasswordEncoder.defaultsForSpringSecurity_v5_8()); encoders.put("scrypt", SCryptPasswordEncoder.defaultsForSpringSecurity_v4_1()); encoders.put("scrypt@SpringSecurity_v5_8", SCryptPasswordEncoder.defaultsForSpringSecurity_v5_8()); encoders.put("SHA-1", new org.springframework.security.crypto.password.MessageDigestPasswordEncoder("SHA-1")); encoders.put("SHA-256",
  new org.springframework.security.crypto.password.MessageDigestPasswordEncoder("SHA-256")); encoders.put("sha256", new org.springframework.security.crypto.password.StandardPasswordEncoder()); encoders.put("argon2", Argon2PasswordEncoder.defaultsForSpringSecurity_v5_2()); encoders.put("argon2@SpringSecurity_v5_8", Argon2PasswordEncoder.defaultsForSpringSecurity_v5_8());

사용

@PostMapping(value="/signup")
public String signup(AccountDto accountDto) {
  ModelMapper mapper = new ModelMapper();
  Account account = mapper.map(accountDto, Account.class);
  account.setPassword(passwordEncoder.encode(accountDto.getPassword()));
  userService.createUser(account); 
  return "redirect:/";
}

2024-12-19 01:52:23 Web application could not be started as there was no org.springframework.boot.web.servlet.server.ServletWebServerFactory bean defined in the context.
2024-12-19 01:52:23 
2024-12-19 01:52:23 Action:
2024-12-19 01:52:23 
2024-12-19 01:52:23 Check your application's dependencies for a supported servlet web server.
2024-12-19 01:52:23 Check the configured web application type.

• docker compose 로 이미지 build시 에러 발생

2024-12-23 22:41:49 Caused by: io.jsonwebtoken.security.WeakKeyException: The specified key byte array is 0 bits which is not secure enough for any JWT HMAC-SHA algorithm.  The JWT JWA Specification (RFC 7518, Section 3.2) states that keys used with HMAC-SHA algorithms MUST have a size >= 256 bits (the key size must be greater than or equal to the hash output size).  Consider using the Jwts.SIG.HS256.key() builder (or HS384.key() or HS512.key()) to create a key guaranteed to be secure enough for your preferred HMAC-SHA algorithm.  See https://tools.ietf.org/html/rfc7518#section-3.2 for more information.

• 해결

8초 동안 Thought about WeakKeyException 해결법 이 오류 메시지는 JWT 서명용 키가 잘못 설정되어 “길이 0bit(즉, 실제로 값이 없음)”으로 인식되었기 때문에 발생합니다. HMAC-SHA 알고리즘을 사용할 때는 RFC 7518, Section 3.2에 의해 최소 256비트 이상의 키를 사용해야 합니다. 즉, 적어도 32바이트(= 256비트) 이상의 길이를 갖는 키가 필요합니다.

매개변수에서 Jwts.SIG.HS256.key() 제거

• 문제

  org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'loggingProducer' defined in URL [jar:nested:/seo-better-pay.jar/!BOOT-INF/lib/logging-service-0.0.1-SNAPSHOT-plain.jar!/com/yun/loggingservice/kafka/LoggingProducer.class]: Failed to instantiate [com.yun.loggingservice.kafka.LoggingProducer]: Constructor threw exception
  2024-12-24 22:20:31     at org.springframework.beans.factory.support.ConstructorResolver.instantiate(ConstructorResolver.java:318) ~[spring-beans-6.1.4.jar!/:6.1.4]

• 해결 docker compose 환경 변수

package com.yun.preapisecure.configuration;

import com.yun.preapisecure.CustomAuthenticationFilter;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.authentication.logout.LogoutHandler;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

import java.io.IOException;

@EnableWebSecurity
@Configuration
public class SecurityCustomFilterConfig {

    private static final Logger LOGGER = LoggerFactory.getLogger(SecurityCustomFilterConfig.class);

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {

        AuthenticationManagerBuilder builder = http.getSharedObject(AuthenticationManagerBuilder.class);
        AuthenticationManager authenticationManager = builder.build();


        http
            .authorizeHttpRequests(auth -> auth
                    .requestMatchers("/logoutSuccess").authenticated()
                    .requestMatchers("/login").permitAll()
                    .anyRequest().authenticated())
            .formLogin(Customizer.withDefaults())
                //.securityContext(securityContext -> securityContext.requireExplicitSave(true))//자동으로 session에 저장한다.
            .authenticationManager(authenticationManager)
            .addFilterBefore(customAuthenticationFilter(http, authenticationManager), UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }

/*    @Bean
    @Order(1)
    public SecurityFilterChain securityFilterChain2(HttpSecurity http) throws Exception {

        AuthenticationManagerBuilder builder = http.getSharedObject(AuthenticationManagerBuilder.class);
        AuthenticationManager authenticationManager = builder.build();

        http
                .securityMatchers(matchers -> matchers.requestMatchers("/open-banking/oauth/"))
                .authorizeHttpRequests(authorize -> authorize.anyRequest().permitAll());
        return http.build();
    }*/

    public CustomAuthenticationFilter customAuthenticationFilter(HttpSecurity httpSecurity, AuthenticationManager manager) {
        CustomAuthenticationFilter customAuthenticationFilter = new CustomAuthenticationFilter(httpSecurity);
        customAuthenticationFilter.setAuthenticationManager(manager);
        return customAuthenticationFilter;
    }

    //spring security User 사용자 정의 1. yml 파일 설정 / 2. User 설정 단 1번과 2번이 충돌할 경우 2번이 우선순위
    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails user = User.withUsername("user")
                .password("{noop}1234")
                .roles("USER")
                .build();

        return new InMemoryUserDetailsManager(user);
    }


}

package com.yun.preapisecure.configuration;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.session.MapSession;
import org.springframework.session.MapSessionRepository;
import org.springframework.session.SessionRepository;
import org.springframework.session.config.annotation.web.http.EnableSpringHttpSession;
import org.springframework.session.web.http.CookieSerializer;
import org.springframework.session.web.http.DefaultCookieSerializer;

import java.util.concurrent.ConcurrentHashMap;

@Configuration
@EnableSpringHttpSession
public class HttpSessionConfig {

    @Bean
    public CookieSerializer cookieSerializer() {
        DefaultCookieSerializer serializer = new DefaultCookieSerializer();
        serializer.setUseHttpOnlyCookie(true);
        serializer.setUseSecureCookie(true);
        serializer.setSameSite("Lax");//none인 경우 https로 추가조치 해야한다.
        return serializer;
    }

    @Bean
    public SessionRepository<MapSession> sessionRepository() {
        return new MapSessionRepository(new ConcurrentHashMap<>());
    }
}

package com.yun.preapisecure.provider;

import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Component;

@Component
public class CustomAuthenticationProvider implements AuthenticationProvider {
    private final UserDetailsService userDetailsService;

    public CustomAuthenticationProvider(UserDetailsService userDetailsService) {
        this.userDetailsService = userDetailsService;
    }

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        String loginId = authentication.getName();
        String password = authentication.getCredentials().toString();

        //아이디 검증
        UserDetails user = userDetailsService.loadUserByUsername(loginId);
        if (user == null) {
            throw new UsernameNotFoundException("사용자가 존재하지 않는다.");
        }
        //비밀번호 검증

        return new UsernamePasswordAuthenticationToken(
                user.getUsername(), user.getPassword(), user.getAuthorities());
    }

    @Override
    public boolean supports(Class<?> authentication) {
        //일반적으로는 넘어온 authentication token와 인증 토큰이 맞아야 true 반환
        return authentication.isAssignableFrom(UsernamePasswordAuthenticationToken.class);
    }
}

package com.yun.preapisecure.provider;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.Collection;

public class CustomUserDetails implements UserDetails { //DB에서 가져온 데이터를 return

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return null;
    }

    @Override
    public String getPassword() {
        return null;
    }

    @Override
    public String getUsername() {
        return null;
    }

    @Override
    public boolean isAccountNonExpired() {
        return false;
    }

    @Override
    public boolean isAccountNonLocked() {
        return false;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return false;
    }

    @Override
    public boolean isEnabled() {
        return false;
    }
}

package com.yun.preapisecure;

import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter;
import org.springframework.security.web.context.DelegatingSecurityContextRepository;
import org.springframework.security.web.context.HttpSessionSecurityContextRepository;
import org.springframework.security.web.context.RequestAttributeSecurityContextRepository;
import org.springframework.security.web.context.SecurityContextRepository;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

import java.io.IOException;

public class CustomAuthenticationFilter extends AbstractAuthenticationProcessingFilter {

    protected final ObjectMapper objectMapper = new ObjectMapper();

    public CustomAuthenticationFilter(HttpSecurity httpSecurity) {
        super(new AntPathRequestMatcher("/api/login", "GET"));
        setSecurityContextRepository(getSecurityContextRepository(httpSecurity));
    }

    private SecurityContextRepository getSecurityContextRepository(HttpSecurity httpSecurity) {
        SecurityContextRepository securityContextRepository = httpSecurity.getSharedObject(SecurityContextRepository.class);
        if (securityContextRepository == null) {
            securityContextRepository = new DelegatingSecurityContextRepository(new HttpSessionSecurityContextRepository(), new RequestAttributeSecurityContextRepository());
        }
        return securityContextRepository;
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException, IOException, ServletException {
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, password);

        return this.getAuthenticationManager().authenticate(token);
    }
}

: 요청에 따른 보안 기능 설정을 하여 실행

• Spring Security 는 여러 SecurityFilterChain @Bean 을 등록해서 다중 보안 기능을 구성 할 수 있다

초기화 구성

• 다중보안 설정하는 경우 각각의 SecurityFilterChain이 생기고 proxy에 SecurityFilterChains 생성되는 것

Custom DSLs

• Spring Security 는 사용자 정의 DSL 을 구현할 수 있도록 지원한다
• DSL을구성하면필터,핸들러,메서드,속성등을한곳에정의하여처리할수있는편리함을제공한다

AbstractHttpConfigurer<AbstractHttpConfigurer, HttpSecurityBuilder>

• 사용자 DSL 을 구현하기 위해서 상속받는 추상 클래스로서 구현 클래스는 두 개의 메서드를 오버라이딩 한다
  • init(B builder) : HttpSecurity 의 구성요소를 설정 및 공유하는 작업 등..
  • configure(B builder) : 공통클래스를 구성 하거나 사용자 정의 필터를 생성하는 작업 등..

DSL 적용하기 위한 API

//apply diprecate
HttpSecurity.with(C configurer, Customizer< C > customizer)

• configurer는AbstractHttpConfigurer을상속하고DSL을구현한클래스가들어간다
• customizer는DSL구현클래스에서정의한여러API를커스트마이징한다
• 동일한클래스를여러번설정하더라도한번만적용된다 (with를 여러번 하더라도 한번만 적용)

이중화 설정

서버 이중화 상태에서 인증/인가 데이터를 하나의 애플리케이션에서 가지고 있다면 비정상 종료시 데이터가 날아간다. 데이터가 캐시 쿠키 서버에 저장되고 이를 바라보고 있다고 생각

세션을 공유할 수 있도록 설정하는 것

implementation 'org.springframework.session:spring-session-data-redis' 
implementation 'org.springframework.boot:spring-boot-starter-data-redis'

spring.data.redis.host=localhost 
spring.data.redis.port= 6379

@Configuration 
⭐️@EnableRedisHttpSession 
public class RedisConfig {

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

public RedisConnectionFactory redisConnectionFactory() { 
return new LettuceConnectionFactory(host, port);
}

}

1. Servlet API 통합

Servlet 3+ 통합

1) SecurityContextHolderAwareRequestFilter

• HTTP 요청이 처리될 때 HttpServletRequest 에 보안 관련 메소드를 추가적으로 제공하는 래퍼(SecurityContextHolderAwareRequestWrapper) 클래스를 적용한다 • 이를통해개발자는서블릿API의보안메소드를사용하여인증,로그인,로그아웃등의작업을수행할수있다
• request 객체 + 보안 관련 메소드 -> warpper
• HttpServlet3RequestFactory 생성

2) HttpServlet3RequestFactory

• Servlet 3 API 와의 통합을 제공하기 위한 Servlet3SecurityContextHolderAwareRequestWrapper 객체를 생성한다
• Servlet3SecurityContextHolderAwareRequestWrapper 클래스는 SecurityContextHolderAwareRequestFilter를 상속받은 자식 클래스(구현체)이다.

3) Servlet3SecurityContextHolderAwareRequestWrapper

• HttpServletRequest 의 래퍼 클래스로서 Servlet 3.0의 기능을 지원하면서 동시에 SecurityContextHolder 와의 통합을 제공한다(인증 관련 기능 제공)
• 이 래퍼를 사용함으로써 SecurityContext 에 쉽게 접근할 수 있고 Servlet 3.0의 비동기 처리와 같은 기능을 사용하는 동안 보안 컨텍스트를 올바르게 관리할 수 있다

@GetMapping("/login")
public String login(HttpServletRequest request, MemberDto memberDto) throws ServletException, IOException {
  request.login(memberDto.getUsername(),memberDto.getPassword()); 
  System.out.println("PreAuthorize");
  return "/index";
}

@GetMapping("/users")
public List<User> users(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  boolean authenticate = request.authenticate(response); 
  if(authenticate){
      UserService.users(); 
  }
  return Collection.emptyList(); 
}

2. Spring MVC 통합

@AuthenticationPrincipal

• Spring Security는 Spring MVC 인수에 대한 현재 Authentication.getPrincipal()을 자동으로 해결 할 수 있는 ⭐️AuthenticationPrincipalArgumentResolver 를 제공한다 • Spring MVC 에서 @AuthenticationPrincipal 을 메서드 인수에 선언하게 되면 Spring Security 와 독립적으로 사용할 수 있다
• AuthenticationPrincipalArgumentResolver가 어노테이션의 작업을 구현하여 실행하는 과정을 수행하는것
• 📌기본적으로 인증을 받지 못한 사용자는 Principal이 anonymouseUser 익명 사용자 문자열로 들어온다 따라서 객체명, 필드명이 존재하지 않는다.

  @Target({ ElementType.PARAMETER, ElementType.TYPE }) 
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @AuthenticationPrincipal(expression = "#this == 'anonymouseUser' ? null : User")
  public @interface CurrentUser {
  

}

//#this 현재 Principal을 의미

![](https://velog.velcdn.com/images/may_yun/post/392e2ee2-fa29-4e43-8ee9-8201403f67d8/image.png)

![](https://velog.velcdn.com/images/may_yun/post/425700e1-8c7e-4903-9a02-3d7d58970076/image.png)


## 차이
- Authentication 내의 Principal 객체를 의미한다. 이미 해당 Principal 객체가 존재해야하는 것. Authentication에서 Principal 객체를 바로 가져오는 것
![](https://velog.velcdn.com/images/may_yun/post/9772c9fc-d9ea-4e26-a64d-432331d68dea/image.png)

- Principal에 속하는 Userdetails안에 값을 사용하기 위한것 
customer의 객체, 필드 등

![](https://velog.velcdn.com/images/may_yun/post/52ce6e6e-4c55-431b-918e-d0491fb52fb4/image.png)

---

# 3. Spring MVC 비동기 통합 

- Spring Security 는 Spring MVC Controller 에서 Callable 을 실행하는 비동기 스레드에 SecurityContext 를 자동으로 설정하도록 지원한다
- Spring Security 는 WebAsyncManager 와 통합하여 SecurityContextHolder 에서 사용 가능한 SecurityContext 를 Callable 에서 접근 가능하도록 해 준다
- 부모 스레드와 자식 스레드가 있을 때 부모스레드의 SecurityContext를 자식스레드에서도 사용할 수 있도록 자동 설정되는 것

## WebAsyncManagerIntegrationFilter
- SecurityContext 와 WebAsyncManager 사이의 통합을 제공하며 WebAsyncManager 를 생성하고 SecurityContextCallableProcessingInterceptor를 WebAsyncManager 에 등록한다

## WebAsyncManager
- 스레드 풀의 비동기 스레드를 생성하고 Callable 를 받아 실행시키는 주체로서 등록된 SecurityContextCallableProcessingInterceptor 를 통해 현재 스레드 가 보유하고 있는 SecurityContext 객체를 비동기 스레드의 ThreadLocal 에 저장시킨다

![](https://velog.velcdn.com/images/may_yun/post/4ff44c8f-cd44-44a9-9c72-394759ae6416/image.png)

- 비동기 스레드가 수행하는 Callable 영역 내에서 자신의 ThreadLocal 에 저장된 SecurityContext 를 참조할 수 있으며 이는 부모 스레드가 가지고 있는 SecurityContext 와 동일한 객체이다
- @Async 나 다른 비동기 기술은 스프링 시큐리티와 통합되어 있지 않기 때문에 비동기 스레드에 SecurityContext 가 적용되지 않는다 즉 Callable 영역내에서만 가능하다.
- Callable으로 반환이 되어야한다

![](https://velog.velcdn.com/images/may_yun/post/5076f99e-fda9-439e-bc5a-63485513c957/image.png)

- mode 설정으로 Callable 구현하지 않고 SecurityContext객체를 공유할 수 있도록 사용할 수 있다
```java
SecurityContextHolder.setStrategyName(SecurityContextHolder.MODE_INHERITABLETHREADLOCAL); 

• 스프링 시큐리티는 인증이 성공하거나 실패하게 되면 AuthenticationSuccessEvent 또는 AuthenticationFailureEvent 를 발생시킨다
• 이벤트를 수신하려면 ApplicationEventPublisher 를 사용하거나 시큐리티에서 제공하는 AuthenticationEventPublisher 를 사용해서 발행해야 한다
• AuthenticationEventPublisher 의 구현체로 DefaultAuthenticationEventPublisher 가 제공된다

🚩 DefaultAuthenticationEventPublisher는 예외(실패)와 이벤트를 매핑하고 있다 예를 들어 A예외가 발생하면 a이벤트 발행 따라서 예외만 전달하더라도 해당 이벤트를 발행하도록 되어있다

이벤트 발행

1. ApplicationEventPublisher.publishEvent(ApplicationEvent)
2. AuthenticationEventPublisher.publishAuthenticationSuccess(Authentication) , AuthenticationEventPublisher.publishAuthenticationFailure(AuthenticationException, Authentication)

이벤트 수신

발행된 이벤트 타입을 수신에 넣어야 수신할 수 있다

@Component
public class AuthenticationEvents {
@EventListener
public void onSuccess(AuthenticationSuccessEvent success) {...}
@EventListener
public void onFailure(AbstractAuthenticationFailureEvent failures) {...} 
}

상위 이벤트는 각각의 이벤트가 수신될 때 마다 수신된다

구현

AuthenticationEventPublisher 활용

🚩 DefaultAuthenticationEventPublisher는 예외(실패)와 이벤트를 매핑하고 있다 예를 들어 A예외가 발생하면 a이벤트 발행 따라서 예외만 전달하더라도 해당 이벤트를 발행하도록 되어있다 이를 커스텀하게 만들어서 원하는 이벤트를 발행하도록 할 수 있다

//매핑
Collections.singletonMap(CustomException.class, CustomAuthenticationFailureEvent.class);

authenticationEventPublisher.setAdditionalExceptionMappings(mapping); // CustomException 을 던지면 CustomAuthenticationFailureEvent 를 발행하도록 추가 함
authenticationEventPublisher.setDefaultAuthenticationFailureEvent(CustomDefaultAuthenticationFailureEvent.class); // 기본 이벤트 설정

//발행
authenticationEventPublisher.publishAuthenticationFailure(new CustomException("CustomException "), authentication);

//수신
@EventListener
public void onFailure(CustomAuthenticationFailureEvent failures) { 
// 커스텀 예외에 대해 이벤트를 수신할 수 있다 System.out.println(" failures = " + failures.getException().getMessage());
}

Authorization Events

• 순수한 AOP 기술만 가지고도 메서드 보안을 구현할 수 있는 것
• joinpoint: Advice를 적용할 수 있는 대상 자체를 의미한다. (클래스, 필드, 메서드 중 어느곳에 적용할 것인지 만약 클래스 단위로 적용한다면 joinpoint는 클래스가 되는 것) 단, 스프링에서는 메서드에만 Advice를 적용할 수 있도록 한정한다 따라서 joinpoint 또한 메서드에 한정.
• joinpoint 대상에서 실행되어야 하는 지점, 조건이 pointCut이 된다.

초기화

• CGLibAopProxy : 프록시 객체를 생성하는 객체

구현 예제

• MethodInterceptor를 구현받을 때 aop로 구현

public class CustomMethodInterceptor implements MethodInterceptor {
private final AuthorizationManager<MethodInvocation> authorizationManager;
public CustomMethodInterceptor(AuthorizationManager<MethodInvocation> authorizationManager) { this.authorizationManager=authorizationManager; //메서드보안검사를수행할인가관리자를전달한다
}
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); 
if(//권한 심사 
authorizationManager.check(() ->authentication, invocation).isGranted()) {
returninvocation.proceed(); //실제대상객체를호출한다 }else{
throw new AccessDeniedException("Access Denied"); }
}
}

@Bean
public MethodInterceptor customMethodInterceptor() {
AuthorizationManager<MethodInvocation> authorizationManager = AuthenticatedAuthorizationManager.authenticated(); return new CustomMethodInterceptor(authorizationManager); // AOP 어라운드 어드바이스를 선언한다
}

@Bean
public Pointcut servicePointcut() {
AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
pointcut.setExpression("execution(* io.security.Myservice.*(..))"); // AOP 수행 대상 클래스와 대상 메소드를 지정한다 return pointcut;
}

@Bean
public Advisor serviceAdvisor(MethodInterceptor customMethodInterceptor, Pointcut servicePointcut) { // 초기화 시 Advisor 목록에 포함된다 return new DefaultPointcutAdvisor(servicePointcut, customMethodInterceptor);
}

• DefaultPointcutAdvisor : 스프링시큐리티에서 기본적으로 생성하는 Advisor Pointcut, MethodInterceptor를 담고 있다

• 인가 즉 권한부여는 특정자원에 접근할 수 있는 사람을 결정하는 것을 의미 (신원 확인 후 어떤 권한을 부여할 것인가)
• Spring Security 는 GrantedAuthority 클래스를 통해 권한 목록을 관리하고 있으며 사용자의 Authentication 객체와 연결한다

• 스프링 시큐리티는 Authentication 에 GrantedAuthority 권한 목록을 저장하며 이를 통해 인증 주체에게 부여된 권한을 사용하도록 한다

권한 관련된 내용들이 문자열로 저장되어있다 SimpleGrantedAuthority 생성시 접두사를 사용하여 ROLE_USER 등의 권한으로 저장되어 Collection에 담기고 Authentication 인증 객체안에 collection으로 GrantedAuthority가 저장된다

접두사 커스텀

스프링 시큐리티는 ROLE_접두사를 기본적으로 사용하나 커스텀하여 사용이 가능하다

@Bean
static GrantedAuthorityDefaults grantedAuthorityDefaults() { 
        return new GrantedAuthorityDefaults("MYPREFIX_");
}

//hasRole("ADMIN") => ROLE_ADMIN
hasRole("ADMIN") => MYPREFIX_ADM//IN

AuthorizationManager 인가관리자

verify()는 디폴트로 check()으로 구현된 메서드를 호출한다

요청기반 인가 관리자

• 요청 기반의 인증된 사용자 및 특정권한을 가진 사용자의 자원접근 허용여부를 결정하는 인가 관리자 클래스들을 제공
• 대표적으로 AuthorityAuthorizationManager, AuthenticatedAuthorizationManager 와 대리자인 RequestMatcherDelegatingAuthorizationManager 가 있다

스프링 시큐리티 인가처리

• 스프링시큐리티가 내부에 가지고 있는 정보
• client에게 받아야 하는 정보

위 둘을 권한 심사하는 것

⭐️내부 구조

1. 클라이언트 요청
2. 요청에 대한 인가처리 authorizationFilter
3. 필터가 요청을 받고 securityContextHolder로 보내서 인증 객체를 가져온다
4. request 요청정보와 인증객체(권한 정보를가지고 있다)를 authorizatinoManager(인가관리자)에 보낸다
5. 적절한 인가 관리자를 배정(위임)하는것 AuthorizationManager에서 requestMatcher를 통해 URL을 찾을 때 목록의 순회를 돌아서 if문으로 해당 조건이 있는지 확인하는 과정을 거친다
6. 요청자원 접근에 대한 최종 승인 혹은 거부 결과 반환
7. 인증방식에 따라 적절한 Strategy를 선택해서 인증 여부 확인

AuthenticatedAuthorizationManager 흐름도 / 구조

AuthorityAuthorizationManager

• 매핑은 EndPoint 기준으로 mapping된다 따라서 requestMatchers가 4개라도 엔드포인트가 5개이면 5개 매핑

요청 기반 Custom_AuthorizationManager 구현 하여 권한 심사하기

• 스프링 시큐리티 인가 설정 시 선언적 방식이 아닌 프로그래밍 방식으로 구현할 수 있으며 access(AuthorizationManager) API 를 사용한다
• access() 에는 AuthorizationManager< RequestAuthorizationContext > 타입의 객체를 전달할 수 있으며 사용자의 요청에 대한 권한 검사를 access() 에 지정한 AuthorizationManager 가 처리하게 된다
• access() 에 지정한 AuthorizationManager 객체는 RequestMatcherDelegatingAuthorizationManager 의 매핑 속성에 저장된다

  http.authorizeHttpRequests(auth -> auth.requestMatcher().access(AuthorizationManager)

1. 특정한 엔드포인트에 대한 권한 검사를 수행하기 위해 AuthorizationManager 를 구현하여 설정한다
2. "/user", "/myPage", "/admin" 요청 패턴의 권한 검사는 AuthorityAuthorizationManager 가 처리한다 "/api“ 요청 패턴의 권한 검사는 CustomAuthorizationManager 가 처리

public class CustomAuthorizationManager implements AuthorizationManager<RequestAuthorizationContext> { 

private static final String REQUIRED_ROLE = "ROLE_SECURE";

@Override
public AuthorizationDecision check(Supplier<Authentication> authentication, RequestAuthorizationContext object) { 
  //인증 정보 가져오기    
  Authentication auth = authentication.get();
  //인증정보가없거나인증되지않은경우
  if (auth == null || !auth.isAuthenticated() || auth instanceof AnonymousAuthenticationToken) { 
      return new AuthorizationDecision(false);
  }
  // "ROLE_SECURE" 권한을 가진 사용자인지 확인
  boolean hasRequiredRole = auth
    .getAuthorities()
    .stream()
    .anyMatch(grantedAuthority -> REQUIRED_ROLE.equals(grantedAuthority.getAuthority())
  );

  return new AuthorizationDecision(hasRequiredRole); 
  }
}

RequestMatcherDelegatingAuthorizationManager 인가 설정 응용하기

• RequestMatcherDelegatingAuthorizationManager 의 mappings 속성에 직접 RequestMatcherEntry 객체를 생성하고 추가한다

요청 패턴에 매핑된 AuthorizationManager 객체를 반환 요청 패턴을 저장한 RequestMatcher 객체를 반환

사용

http.authorizeHttpRequests(auth -> auth
.anyRequest().access(new CustomRequestMatcherDelegatingAuthorizationManager())

모든 요청에 적용하기 때문에 url을 따로 지정하지 않아도 된다

1.RequestMatcherDelegatingAuthorizationManager 내부적으로 무조건 생성되고 mappings에 add함 이것은 변경할 수 없는 필수 절차이다. 2. 1번에 생성된 manager가 custom으로 만든 manager안에 들어가 있는 것이다. 3. 2번 객체안에 또 RequestMatcherDelegatingAuthorizationManager를 넣었지만 이 구조는 테스트용 구조로 좋은 구조는 아니다. 원리를 알기위해 학습용 구현

• springSecurityConfig

  //하드코딩으로 수동적인 방법
  

@Bean public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {

return http.authorizeHttpRequests(auth -> auth .anyRequest() .access(authorizationManager(null))) .build(); }

@Bean public AuthorizationManager authorizationManager(HandlerMappingIntrospector introspector){ List<RequestMatcherEntry<AuthorizationManager>> mappings = new ArrayList<>();

RequestMatcherEntry<AuthorizationManager> requestMatcherEntry1 = new RequestMatcherEntry<>(new MvcRequestMatcher(introspector, "/user"), AuthorityAuthorizationManager.hasAuthority("ROLE_USER"));

RequestMatcherEntry<AuthorizationManager> requestMatcherEntry2 = new RequestMatcherEntry<>(new MvcRequestMatcher(introspector, "/admin"), AuthorityAuthorizationManager.hasRole("ADMIN"));

RequestMatcherEntry<AuthorizationManager> requestMatcherEntry3 = new RequestMatcherEntry<>(AnyRequestMatcher.INSTANCE, new AuthenticatedAuthorizationManager<>());

mappings.add(requestMatcherEntry1); mappings.add(requestMatcherEntry2); mappings.add(requestMatcherEntry3);

return new CustomRequestMatcherDelegatingAuthorizationManager(mappings); }

```java
public class CustomRequestMatcherDelegatingAuthorizationManager implements AuthorizationManager<RequestAuthorizationContext> { 

private final RequestMatcherDelegatingAuthorizationManager manager;

  public CustomRequestMatcherDelegatingAuthorizationManager(List<RequestMatcherEntry<AuthorizationManager<RequestAuthorizationContext>>> mappings) { 
    Assert.notEmpty(mappings, "mappings cannot be empty");
    manager = RequestMatcherDelegatingAuthorizationManager.builder()
      .mappings(maps -> maps.addAll(mappings))
      .build();
    }

  @Override
  public AuthorizationDecision check(Supplier<Authentication> authentication, RequestAuthorizationContext object) { 
  //단순 manager에 위임하는 일
  //TODO: 중복되는 위임 과정이 존재하기 때문에 개선 필요
      return manager.check(authentication,object.getRequest());
  }

  @Override
  public void verify(Supplier<Authentication> authentication, RequestAuthorizationContext object) { 
      AuthorizationManager.super.verify(authentication, object);
  } 

}

• 요청에 대한 권한 검사를 RequestMatcherDelegatingAuthorizationManager 객체가 수행하도록 한다 • RequestMatcherDelegatingAuthorizationManager > CustomRequestMatcherDelegatingAuthorizationManager > RequestMatcherDelegatingAuthorizationManager 구조는 조금 더 개선이 필요하다

메서드 기반 인가 관리자

• 스프링 시큐리티는 메서드 기반의 인증된 사용자 및 특정권한을 가진 사용자의 자원접근 허용여부를 결정하는 인가 관리자 클래스들을 제공한다
• PreAuthorizeAuthorizationManager, PostAuthorizeAuthorizationManager, Jsr250AuthorizationManager, SecuredAuthorizationManager 가 있다
• 🚩 요청기반과의 차이점 : 메서드 기반 권한 부여는 내부적으로 AOP 방식에 의해 초기화 설정이 이루어지며 메서드의 호출을 MethodInterceptor(advice) 가 가로 채어 처리하고 있다 처리과정과 초기화과정이 메서드 기반과 요청기반 인가 처리는 다르다

• 권한에 따른 메서드가 매핑이되어 스프링시큐리티에 저장된다

  @PreAuthorize("hasAuthority('ROLE_USER')") 
  public List<User> users() {
  
    System.out.println("users: " + UserRepositiry.findAll()); 
  }

• 메서드 호출자의 관점

위 두가지를 비교하여 인가 처리 진행하는 것

⭐️초기화 과정 (AOP)

📌보안이 설정된 메소드가 있는 경우 그 빈의 프록시 객체를 자동으로 생성하는것이고 없다면 생성되지않는다 생성된 proxy 객체로 어떠한 작업을 진행하기 때문.

메서드 기반 Custom AuthorizationManager 구현

• 사용자 정의 AuthorizationManager 를 생성함으로 메서드 보안을 구현할 수 있다

@EnableMethodSecurity(prePostEnabled=false) 
//클래스 단위에 적용. 
//시큐리티가 제공하는 클래스들을 비활성화한다. 그렇지않으면 중복해서 검사하게 된다

//메서드에 어노테이션 사용
@Bean 
@Role(BeanDefinition.ROLE_INFRASTRUCTURE) 
public Advisor preAuthorize() {

    return AuthorizationManagerBeforeMethodInterceptor.preAuthorize(new MyPreAuthorizationManager()); 

}

포인트 컷 메서드 보안 구현

위의 메서드 보안 기반 권한 규칙을 어노테이션 사용을 하지않고 선언할 수 있다

• 메서드 보안은 AOP를 기반으로 구축되었기 때문에 어노테이션이 아닌 패턴 형태로 권한 규칙을 선언할수있으며 이는 요청 수준의 인가와 유사한 방식이다
• 자체 어드바이저(Advisor)를 발행하거나 포인트컷(PointCut)을 사용하여 AOP 표현식을 애플리케이션의 인가 규칙에 맞게 매칭할 수 있으며 이를 통해 어노테이션을 사용하지 않고도 메소드 수준에서 보안 정책을 구현할 수 있다

📌 AspectJExpressionPointcut을 사용하기 위해서 의존성 추가해야 한다.

implementation 'org.springframework.boot:spring-boot-starter-aop:3.4.0'

여러가지 표현식이 존재한다.

포인트컷 사용의 장점 유연한 적용 범위 지정: 애너테이션 기반 접근 제어(@PreAuthorize 등)는 주로 특정 메소드나 클래스에 직접 부착하는 방식으로 접근 제어를 수행한다. 반면 포인트컷을 사용하면 메소드 시그니처(메소드명 패턴), 패키지 구조, 파라미터 타입 등 다양한 기준을 통해 원하는 범위에 접근 제어를 유연하게 적용할 수 있다.

비침투적(Non-invasive) 접근 제어: 포인트컷을 사용하면 대상 코드(비즈니스 로직)에는 별다른 주석이나 어노테이션을 추가하지 않고도 권한 검사를 적용할 수 있다. 즉, 보안 로직이 애플리케이션 로직에 덜 침투적이며, 관심사의 분리가 더욱 명확해진다.

재사용성과 유지보수성 향상: 특정 패키지 혹은 특정 네이밍 컨벤션에 따라 접근 제어를 일괄 적용하거나 변경할 때, 포인트컷 정의만 수정하면 전체 적용 대상에 영향을 줄 수 있다. 이를 통해 재사용성과 유지보수성을 높일 수 있다.

복잡한 규칙 적용 용이: 애너테이션만으로 처리하기 애매한 복잡한 권한 규칙(예: 특정 파라미터 값 조건, 특정 리턴 타입에 따른 접근 제어 등)도 AOP 포인트컷 표현식과 어드바이스 로직을 조합하면 유연하게 처리할 수 있다.

참고

만약 PRE_FILTER와 PRE_AUTHORIZE 둘다 설정되어있는 경우 PRE_FILTER가 먼저 수행된다.

: 기본적으로 스프링시큐리티에서 권한과 역할은 계층적이거나 상하관계로 구분하지 않는다. 그래서 인증 주체가 다양한 역할과 권한을 부여 받아야 한다

RoleHirerachy는 역할간의 계층구조를 정의하고 관리하는데 사용되며 보다 간편하게 역할간의 계층 구조를 설정하고 이를 기반으로 사용자에 대한 액세스 규칙을 정의 할 수 있다

<property name="hierarchy"> 
<value>
ROLE_A > ROLE_B
ROLE_B > ROLE_C
ROLE_C > ROLE_D
</value> 
</property>

• setHirerachy • 역할 계층을 설정하고 각 역할에 대해 해당 역할의 하위계층에 속하는 모든 역할 집합을 미리 정해 놓는다 • 역할 계층 : ROLE_A > ROLE_B > ROLE_C

• getReachableGrantedAuthorities • 모든 도달 가능한 권한의 배열을 반환한다 • 도달가능한권한은직접할당된권한에더해역할계층에서이들로부터도달가능한모든권한을의미한다 • 직접 할당된 권한 : ROLE_B • 도달 가능한 권한 : ROLE_B, ROLE_C

• 사용 규칙

  • 권한의 범위를 >, =, < 등으로 관계 표현을 해줘야한다
  • 다음 권한으로 넘어갈때 개행을 해줘야한다

@Bean
static RoleHierarchy roleHierarchy() {
  RoleHierarchyImpl hierarchy = new RoleHierarchyImpl(); 

  hierarchy.setHierarchy("ROLE_ADMIN > ROLE_MANAGER\n" +
    "ROLE_MANAGER > ROLE_USER\n" +
    "ROLE_USER > ROLE_GUEST"); 
  return hierarchy;
}

권한의 역할 계층을 설정하면 RoleHierarchy가 알아서 도달 가능한 권한을 부여한다

• 스프링시큐리티에서RequestMatcher인스턴스를등록하여무시해야할요청을지정할수있다
• 주로 정적자원(이미지,CSS,JavaScript파일 등)에 대한 요청이나 특정 엔드포인트가 보안필터를 거치지 않도록 설정할 때 사용

사용 방법

@Bean
public WebSecurityCustomizer webSecurityCustomizer() { 

  return (webSecurity) -> {
  webSecurity
    .ignoring()
    .requestMatchers(PathRequest.toStaticResources()
    .atCommonLocations()); 
   };

}

enum으로 정의되어있다.

📌 Ignoring 보다 permitAll 권장 이전 스프링시큐리티 버전에는 모든 요청마다 세션을 확인해야 해서 성능 저하가 있었지만 스프링 시큐리티 6 부터는 권한 부여 규칙에서 필요한 경우를 제외하고는 세션을 확인하지 않는다.

지연로딩으로 성능 문제가 해결되었기 때문에 모든 요청에 대해서 permitAll을 사용할 것을 권장하며 정적 자원에 대한 요청일지라도 안전한 헤더를 작성할 수 있어 더 안전하다. 스프링시큐리티 보안필터를 거치지 않는 경우 XSS 인젝션 공격에 취약할 수 있다하지만 permitAll로 필터를 거치는 경우 보안적인 측면에서 안전할 수 있다

http
.authorizeHttpRequests(auth -> auth
//filter를 거쳐야한다
.requestMatchers("/css/**", "/images/**", "/js/**", "/webjars/**", "/favicon.*", "/*/icon-*").permitAll() 
//filter를 거치지않는다
.requestMatchers(PathRequest.toStaticResources().atCommonLocations()).permitAll() 
.anyRequest().authenticated());

• prometheus: metric 데이터 조회,저장

• grafana: 시각화 위 두 오픈소스를 같이 설치할 수 있는 Prometheus Operator를 이용하여 설치 https://suave-zinc-9c8.notion.site/Telemetry-1ce6909121cb4565bdd13080739e75e7

cloud9 환경 설정 https://www.notion.so/terraform-23390af706ba4605862eedaf420b74d3?pvs=4

ubuntu:~/environment $ cd k8s-demo
ubuntu:~/environment/k8s-demo $ terraform init

사전 작업 k8s 클러스터 설치 / Ingress controller 설치

• 이전 실습 내용 정리
  • weave scope 삭제
    • kubectl delete -f https://github.com/weaveworks/scope/releases/download/v1.13.2/k8s-scope.yaml
• K8S Cluster 생성

  //위치 k8s-demo
  $ terraform apply --auto-approve

• Terraform 코드 내용 변경
  • 노드 리소스 증가
    • Auto Scaling Group의 Desired Capacity를 변경 (2→3)
    • t3.medium으로 노드 스케일 업
    • capacity type - SPOT
  • EKS Add-ons 및 Add-on의 실행 권한에 맞는 Role 추가
    • aws-ebs-csi-driver, vpc-cni

      #main.tf
      provider "aws" {
      region = local.region
      }
      

provider "kubernetes" { host = module.eks.cluster_endpoint cluster_ca_certificate = base64decode(module.eks.cluster_certificate_authority_data) token = data.aws_eks_cluster_auth.this.token }

data "aws_eks_cluster_auth" "this" { name = module.eks.cluster_name }

data "aws_availability_zones" "available" {}

locals { name = basename(path.cwd) region = "ap-northeast-2"

vpc_cidr = "10.0.0.0/16" azs = slice(data.aws_availability_zones.available.names, 0, 3)

tags = { Cluster = local.name } }

################################################################################

Cluster

################################################################################

module "eks" { source = "terraform-aws-modules/eks/aws" version = "~> 19.16"

cluster_name = local.name cluster_version = "1.27" cluster_endpoint_public_access = true

vpc_id = module.vpc.vpc_id subnet_ids = module.vpc.private_subnets

eks_managed_node_groups = { default_node_group = { instance_types = ["t3.medium"] capacity_type = "SPOT"

  min_size     = 2
  max_size     = 5
  desired_size = 2

}

}

node_security_group_additional_rules = { ingress_cluster_api_ephemeral_ports_tcp = { description = "Cluster API to kubeseal services" protocol = "tcp" from_port = 8080 to_port = 8080 type = "ingress" source_cluster_security_group = true } }

cluster_addons = { aws-ebs-csi-driver = { service_account_role_arn = module.ebs_csi_addon_irsa_role.iam_role_arn } vpc-cni = { resolve_conflicts = "OVERWRITE" service_account_role_arn = module.vpc_cni_addon_irsa_role.iam_role_arn } }

tags = local.tags }

module "load_balancer_controller_irsa_role" { source = "terraform-aws-modules/iam/aws//modules/iam-role-for-service-accounts-eks"

role_name = "load-balancer-controller" attach_load_balancer_controller_policy = true

oidc_providers = { ex = { provider_arn = module.eks.oidc_provider_arn namespace_service_accounts = ["kube-system:aws-load-balancer-controller"] } }

tags = local.tags }

module "ebs_csi_addon_irsa_role" { source = "terraform-aws-modules/iam/aws//modules/iam-role-for-service-accounts-eks"

role_name = "ebs-csi-controller" attach_ebs_csi_policy = true

oidc_providers = { ex = { provider_arn = module.eks.oidc_provider_arn namespace_service_accounts = ["kube-system:ebs-csi-controller-sa"] } }

tags = local.tags }

module "vpc_cni_addon_irsa_role" { source = "terraform-aws-modules/iam/aws//modules/iam-role-for-service-accounts-eks"

role_name = "vpc-cni" attach_vpc_cni_policy = true vpc_cni_enable_ipv4 = true

oidc_providers = { main = { provider_arn = module.eks.oidc_provider_arn namespace_service_accounts = ["kube-system:aws-node"] } }

tags = local.tags }

################################################################################

Supporting Resoruces

################################################################################

module "vpc" { source = "terraform-aws-modules/vpc/aws" version = "~> 5.0"

name = local.name cidr = local.vpc_cidr

azs = local.azs public_subnets = [for k, v in local.azs : cidrsubnet(local.vpc_cidr, 8, k)] private_subnets = [for k, v in local.azs : cidrsubnet(local.vpc_cidr, 8, k + 3)] database_subnets = [for k, v in local.azs : cidrsubnet(local.vpc_cidr, 8, k + 6)]

create_database_subnet_group = true

enable_nat_gateway = true single_nat_gateway = true

public_subnet_tags = { "kubernetes.io/role/elb" = 1 }

private_subnet_tags = { "kubernetes.io/role/internal-elb" = 1 }

tags = local.tags }

![](https://velog.velcdn.com/images/may_yun/post/ddbfeb16-ae1c-4bb7-99af-bfb331a14497/image.png)

- Ingress Controller 설치 (Grafana 외부 접속 시 사용)
    - 위치: k8s-demo
    - https://github.com/attachnplay/fastcampus-pay-bootstrap/blob/main/install_ingress_controller.md

AWS Load Balancer Ingress Controller 설치
Terraform 기반으로 K8S Cluster를 실행 후에 설치 진행

Kubeconfig 설정

aws eks --region ap-northeast-2 update-kubeconfig --name k8s-demo

K8S Cluster 연결 확인

kubectl get no

Helm charts repo 추가

helm repo add eks https://aws.github.io/eks-charts

AWS Load Balancer Ingress Controller 설치

!! 590974975982 부분은 본인 AWS 계정으로 변경

helm install aws-load-balancer-controller eks/aws-load-balancer-controller
-n kube-system --set clusterName=k8s-demo --set serviceAccount.create=true
--set serviceAccount.name=aws-load-balancer-controller
--set serviceAccount.annotations."eks.amazonaws.com/role-arn"="arn:aws:iam::123123123123:role/load-balancer-controller"

#123123123123이 숫자는 본인의 AWS 계정과 연동하면 됨

helm 설치
https://whchoi98.gitbook.io/k8s/eks-2/helm

---

## Prometheus + Grafana 설치

- Prometheus Operator 사용
    - https://github.com/attachnplay/kube-prometheus
    - Physical Volume 관련 설정 추가함
- Prometheus 설치
    - [https://prometheus-operator.dev/docs/user-guides/getting-started/](https://prometheus-operator.dev/docs/prologue/quick-start/)

git clone git@github.com:attachnplay/kube-prometheus.git

cd kube-prometheus

Create the namespace and CRDs, and then wait for them to be availble before creating the remaining resources

kubectl create -f manifests/setup

Wait until the "servicemonitors" CRD is created. The message "No resources found" means success in this context.

until kubectl get servicemonitors --all-namespaces ; do date; sleep 1; echo ""; done

kubectl create -f manifests/

![](https://velog.velcdn.com/images/may_yun/post/f30c7342-c7f4-4040-85d9-e4ce65fb4b19/image.png)

![](https://velog.velcdn.com/images/may_yun/post/ff55da9a-0448-4513-b9e3-3fefcea1736c/image.png)

![](https://velog.velcdn.com/images/may_yun/post/c1b0cde2-0567-47a8-a954-cfd08bfb2c0c/image.png)

![](https://velog.velcdn.com/images/may_yun/post/1f6227d8-1c42-4687-9017-cfc5fa4c0a8b/image.png)

![](https://velog.velcdn.com/images/may_yun/post/57839d5a-56a7-4546-a14f-ed8c533269f7/image.png)

- grafana url: 

📌 XTERNAL-IP pending

Cloud9에서 k9s를 실행하면서 grafana-loadbalancer-svc의 External-IP가 Pending 상태로 나오는 이유는 Kubernetes 클러스터의 LoadBalancer 타입 서비스가 External IP를 할당하지 못한 것과 관련이 있습니다. 이는 일반적으로 Cloud9 환경과 관련된 네트워크 설정 또는 Kubernetes 클러스터의 LoadBalancer 구현 문제 때문입니다.

주요 원인 및 해결 방법
1. 클라우드 제공자 LoadBalancer 지원 여부
Cloud9은 AWS에서 실행되며 Kubernetes 클러스터가 AWS에서 운영 중일 경우, LoadBalancer 서비스는 AWS의 Elastic Load Balancer(ELB)를 통해 External IP를 할당합니다.

문제: 클러스터가 적절한 IAM 권한이나 설정을 가지지 않으면 ELB 생성이 실패합니다.
해결 방법:
Kubernetes 클러스터에 적절한 IAM 역할이 부여되었는지 확인합니다.
bash
코드 복사

-> localhost:3000으로 접속

---

## Log 기록을 위한 Loki 설치
: 운영 수준의 구성은 다소 무겁기 때문에 Loki 사용 방법 확인을 목적으로 함

https://grafana.com/docs/loki/latest/setup/install/

- monolithic 구성으로 설치

helm repo add grafana https://grafana.github.io/helm-charts

helm repo update

helm pull grafana/loki

tar zxf (내려받은 파일 예, loki-5.39.0).tgz

![](https://velog.velcdn.com/images/may_yun/post/43c5ab7e-7bbd-4613-be88-f895f9341256/image.png)

![](https://velog.velcdn.com/images/may_yun/post/3563b372-7d93-4f65-b4f0-846c661dbc16/image.png)

$ vim values-dev.yaml

loki: commonConfig: replication_factor: 1 schemaConfig: configs: - from: "2024-04-01" store: tsdb object_store: s3 schema: v13 index: prefix: loki_index_ period: 24h pattern_ingester: enabled: true limits_config: allow_structured_metadata: true volume_enabled: true retention_period: 672h # 28 days retention compactor: retention_enabled: true delete_request_store: s3 ruler: enable_api: true

minio: enabled: true

deploymentMode: SingleBinary

singleBinary: replicas: 1

Zero out replica counts of other deployment modes

backend: replicas: 0 read: replicas: 0 write: replicas: 0

ingester: replicas: 0 querier: replicas: 0 queryFrontend: replicas: 0 queryScheduler: replicas: 0 distributor: replicas: 0 compactor: replicas: 0 indexGateway: replicas: 0 bloomCompactor: replicas: 0 bloomGateway: replicas: 0

** vim 에서 붙여넣기 할 때 형식이 제대로 안될 경우
:set paste 를 하고 i(insert)모드를 눌러서 다시 붙여넣기

![](https://velog.velcdn.com/images/may_yun/post/c452f6b3-ba29-46c0-96d2-92412c7a7a09/image.png)

![](https://velog.velcdn.com/images/may_yun/post/122143f6-e79f-4d48-a778-480c4a2d16ce/image.png)

X-Scope-OrgID : 1

---

command 클래스: 쓰기 작업 요청 정의

package com.yun.money.adapter.axon.command;

import com.yun.common.SelfValidating;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.*;
import org.axonframework.modelling.command.TargetAggregateIdentifier;

@Getter
@ToString
@NoArgsConstructor(access = AccessLevel.PRIVATE)
@EqualsAndHashCode(callSuper = false)
public class MemberMoneyCreateCommand extends SelfValidating<MemberMoneyCreateCommand> {
    @NotNull
    @NotEmpty
    @TargetAggregateIdentifier // 명령이 어느 Aggregate에 전달될지 식별
    private String membershipId;

    public MemberMoneyCreateCommand(String membershipId) {
        this.membershipId = membershipId;
        this.validateSelf();
    }
}

Aggregate 클래스

1. Aggregate 클래스: 명령 처리를 위한 클래스
@Aggregate 명시

2. @AggregateIdentifier: ID 필드에 Aggregate의 고유 식별자 (Aggregate ID)
private String id;

3. 명령 핸들러: CreateOrderCommand를 처리
@CommandHandler 명시
public MemberMoneyAggregate(MemberMoneyCreateCommand command) {
    //명령 실행시 command가 존재하는지 유효성 검사를 할 수 있다.
    log.info("MemberMoneyAddCommand Handler");
    //이벤트 발행 (MemberMoneyCreateEvent)
    apply(new MemberMoneyCreateEvent(id, command.getMembershipId()));
}

4. 이벤트 소싱 핸들러: MemberMoneyCreateEvent를 처리하여 상태를 업데이트
@EventSourcingHandler
public void on(MemberMoneyCreateEvent event) {
    log.info("MemberMoneyAddEvent Sourcing Handler");
    id = UUID.randomUUID().toString();
    membershipId = event.getMembershipId();
    balance = 0;
}

5. 다음 명령 핸들러: UpdateOrderStatusCommand를 처리
@CommandHandler
public void handle(UpdateOrderStatusCommand command) {
    // 상태 변경 가능 여부를 검증
    if (!"CREATED".equals(this.status)) {
            throw new IllegalStateException("Order cannot be updated in current state");
    }
    // 이벤트를 발행 (OrderStatusUpdatedEvent)
    apply(new OrderStatusUpdatedEvent(command.getOrderId(), command.getNewStatus()));
}

6. 이벤트 소싱 핸들러: OrderStatusUpdatedEvent를 처리하여 상태를 업데이트
@EventSourcingHandler
public void on(OrderStatusUpdatedEvent event) {
    this.status = event.getNewStatus();
}

Event 클래스 : 상태 변경의 결과

package com.yun.money.adapter.axon.event;

import com.yun.common.SelfValidating;
import com.yun.money.adapter.axon.command.MemberMoneyCreateCommand;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;

@Getter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = false)
public class MemberMoneyCreateEvent extends SelfValidating<MemberMoneyCreateCommand> {
    private String aggregateIdentifier;
    private String membershipId;
}

Query Model

Query Model은 이벤트를 구독하고 읽기 전용 데이터베이스 업데이트.

package com.yun.moneyqueryservice.adapter.in.axon;

import com.yun.moneyqueryservice.application.port.out.GetMemberAddressInfoPort;
import com.yun.moneyqueryservice.application.port.out.InsertMoneyIncreaseEventByAddress;
import com.yun.moneyqueryservice.application.port.out.MemberAddressInfo;
import lombok.extern.slf4j.Slf4j;
import org.axonframework.eventhandling.EventHandler;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class MoneyAdjustEventHandler {
    //⭐️RequestFirmbankingFinishedEvent를 구독하여 읽기 모델 업데이트
    @EventHandler
    public void handler(RequestFirmbankingFinishedEvent event
            , GetMemberAddressInfoPort getMemberAddressInfoPort
            , InsertMoneyIncreaseEventByAddress insertMoneyIncreaseEventByAddress) {
        log.info("money adjust event receiced : {}", event.toString());

        //고객 주소 정보
        MemberAddressInfo memberAddressInfo = getMemberAddressInfoPort.getMemberAddressInfo(event.getMembershipId());

        //⭐️dynamoDB insert : 읽기 데이터베이스에 주문 저장
        String address = memberAddressInfo.address();
        int moneyAmount = event.getMoneyAmount();
        log.info("dynamo insert: {}, {}", address, moneyAmount);
        insertMoneyIncreaseEventByAddress.insertMoneyIncreaseEventByAddress(address, moneyAmount);
    }
}

DynamoDBAdapter 읽기 전용 DB

package com.yun.moneyqueryservice.adapter.out.aws.dynamodb;

import com.yun.moneyqueryservice.application.port.out.GetMemberAddressInfoPort;
import com.yun.moneyqueryservice.application.port.out.InsertMoneyIncreaseEventByAddress;
import com.yun.moneyqueryservice.application.port.out.MemberAddressInfo;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.*;

import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;

@Slf4j
@RequiredArgsConstructor
@Component
public class DynamoDBAdapter implements GetMemberAddressInfoPort, InsertMoneyIncreaseEventByAddress {
    @Value("money.query.table")
    private String TABLE_NAME;
    @Value("money.dynamo.access")
    private String ACCESS_KEY;
    @Value("money.dynamo.secret")
    private String SECRET_KEY;
    private final DynamoDbClient dynamoDbClient;
    private final MoneySumByAddressMapper mapper;

    public DynamoDBAdapter() {
        this.mapper = new MoneySumByAddressMapper();
        AwsBasicCredentials awsBasicCredentials = AwsBasicCredentials.create(ACCESS_KEY, SECRET_KEY);
        this.dynamoDbClient = DynamoDbClient.builder()
                .region(Region.AP_NORTHEAST_2)
                .credentialsProvider(StaticCredentialsProvider.create(awsBasicCredentials))
                .build();
    }

    /*@Override
    public void insertMoneyIncreaseEventByAddress(String addressName, int moneyIncrease) {
        //1. raw event insert
        String pk = addressName + "#" + LocalDateTime.now();
        int sk = moneyIncrease;
        putItem(pk, sk);

        //2. 지역 정보 잔액 증가
        //2-1. 지역별/일별 정보
        String summaryPk = pk + "summary";
        int summarySk = -1;
        MoneySumByAddress item = getItem(summaryPk, summarySk);
        if (item == null) {
            putItem(summaryPk, summarySk, moneyIncrease);
        }

        //합산 TODO: domain으로 분리
        int balance = item.getBalance();
        balance += moneyIncrease;
        //update

        //2-2. 지역별 정보
        String addressPk = addressName;
        int addressSk = -1;
        MoneySumByAddress addressItem = getItem(addressPk, addressSk);
        if (addressItem == null) {
            putItem(addressPk, addressSk, moneyIncrease);
        }
        //합산 TODO: domain으로 분리
        int addressItemBalance = addressItem.getBalance();
        addressItemBalance += moneyIncrease;
        putItem(addressPk, addressSk, addressItemBalance);
    }*/

    @Override
    public void insertMoneyIncreaseEventByAddress(String addressName, int moneyIncrease) {
        // 3개의 일을 해야될 것이에요.

        // 1. raw event insert (Insert, put)
        // PK: 강남구#230728 SK: 5,000, balance, 5,000
        String pk = addressName + "#" + "230728";
        int sk = moneyIncrease;
        putItem(pk, sk, moneyIncrease);

        // 2. 지역 정보 잔액 증가시켜야 해요. (Query, Update)
        // 2-1. 지역별/일별 정보
        //  - PK: 강남구#230728#summary SK: -1 balance: + 5,000
        String summaryPk = pk + "#summary";
        int summarySk = -1;
        MoneySumByAddress moneySumByAddress = getItem(summaryPk, summarySk);
        if (moneySumByAddress == null) {
            putItem(summaryPk, summarySk, moneyIncrease);
        } else{
            int balance = moneySumByAddress.getBalance();
            balance += moneyIncrease;
            updateItem(summaryPk, summarySk, balance);
        }

        // 2-2. 지역별 정보
        // - PK: 강남구 SK: -1 balance: + 5,000
        String summaryPk2 = addressName;
        int summarySk2 = -1;
        MoneySumByAddress moneySumByAddress2 = getItem(summaryPk2, summarySk2);
        if (moneySumByAddress2 == null) {
            putItem(summaryPk2, summarySk2, moneyIncrease);
        } else{
            int balance2 = moneySumByAddress2.getBalance();
            balance2 += moneyIncrease;
            updateItem(summaryPk2, summarySk2, balance2);
        }
    }

    @Override
    public MemberAddressInfo getMemberAddressInfo(String membershipId) {
        return null;
    }

    private MoneySumByAddress getItem(String pk, int sk) {
        try {
            HashMap<String, AttributeValue> attrMap = new HashMap<>();
            attrMap.put("PK", AttributeValue.builder().s(pk).build());
            attrMap.put("SK", AttributeValue.builder().n(Integer.toString(sk)).build());

            GetItemRequest request = GetItemRequest.builder()
                    .tableName(TABLE_NAME)
                    .key(attrMap)
                    .build();

            GetItemResponse response = dynamoDbClient.getItem(request);

            if (response.hasItem()) {
                mapper.mapToMoneySumByAddress(response.item());
            }

        } catch (DynamoDbException e) {
            log.error("Error getting an item from the table: {} ", e.getMessage());
        }
        return null;
    }

    private void putItem(String pk, int sk) {
        try {
            HashMap<String, AttributeValue> attrMap = new HashMap<>();
            attrMap.put("PK", AttributeValue.builder().s(pk).build());
            attrMap.put("SK", AttributeValue.builder().s(Integer.toString(sk)).build());

            PutItemRequest request = PutItemRequest.builder()
                    .tableName(TABLE_NAME)
                    .item(attrMap)
                    .build();

            dynamoDbClient.putItem(request);
        } catch (DynamoDbException e) {
            log.error("Error adding an item to the table: {} ", e.getMessage());
        }
    }

    private void putItem(String pk, int sk, int balance) {
        try {
            HashMap<String, AttributeValue> attrMap = new HashMap<>();
            attrMap.put("PK", AttributeValue.builder().s(pk).build());
            attrMap.put("SK", AttributeValue.builder().s(Integer.toString(sk)).build());
            attrMap.put("Balance", AttributeValue.builder().n(Integer.toString(balance)).build());

            PutItemRequest request = PutItemRequest.builder()
                    .tableName(TABLE_NAME)
                    .item(attrMap)
                    .build();

            dynamoDbClient.putItem(request);
        } catch (DynamoDbException e) {
            log.error("Error adding an item to the table: {} ", e.getMessage());
        }
    }

    private void queryItem(String pk) {
        try {
            // PK 만 써도 돼요.
            HashMap<String, Condition> attrMap = new HashMap<>();
            attrMap.put("PK", Condition.builder()
                    .attributeValueList(AttributeValue.builder().s(pk).build())
                    .comparisonOperator(ComparisonOperator.EQ)
                    .build());

            QueryRequest request = QueryRequest.builder()
                    .tableName(TABLE_NAME)
                    .keyConditions(attrMap)
                    .build();

            QueryResponse response = dynamoDbClient.query(request);
            response.items().forEach((value) -> log.info("value: {}", value));
        } catch (DynamoDbException e) {
            log.error("Error getting an item from the table: {} ", e.getMessage());
        }
    }

    private void updateItem(String pk, int sk, int balance) {
        try {
            HashMap<String, AttributeValue> attrMap = new HashMap<>();
            attrMap.put("PK", AttributeValue.builder().s(pk).build());
            attrMap.put("SK", AttributeValue.builder().s(Integer.toString(sk)).build());

            String balanceStr = String.valueOf(balance);
            // Create an UpdateItemRequest
            UpdateItemRequest updateItemRequest = UpdateItemRequest.builder()
                    .tableName(TABLE_NAME)
                    .key(attrMap)
                    .attributeUpdates(
                            new HashMap<String, AttributeValueUpdate>() {{
                                put("balance", AttributeValueUpdate.builder()
                                        .value(AttributeValue.builder().n(balanceStr).build())
                                        .action(AttributeAction.PUT)
                                        .build());
                            }}
                    ).build();


            UpdateItemResponse response = dynamoDbClient.updateItem(updateItemRequest);

            // 결과 출력.
            Map<String, AttributeValue> attributes = response.attributes();
            if (attributes != null) {
                for (Map.Entry<String, AttributeValue> entry : attributes.entrySet()) {
                    String attributeName = entry.getKey();
                    AttributeValue attributeValue = entry.getValue();
                    System.out.println(attributeName + ": " + attributeValue);
                }
            } else {
                System.out.println("Item was updated, but no attributes were returned.");
            }
        } catch (DynamoDbException e) {
            System.err.println("Error getting an item from the table: " + e.getMessage());
        }
    }
}

CQRS

command(데이터변동)과 query(데이터 조회)를 분리함으로써 비즈니스 로직이 포함된 API를 구현하는 패턴이다.

API Aggregation

클라이언트와 서버 간 통신의 효율성을 높이기 위한 설계로 여러 API 호출을 하나의 API로 집계(aggregation)하여 클라이언트가 한 번의 호출로 필요한 데이터를 얻을 수 있도록 하는 설계 방식이며 주로 API Gateway나 Aggregator 서비스를 통해 구현된다.

• 여러 마이크로서비스로 분리된 데이터를 통합하여 한 번에 제공.
• 클라이언트가 여러 개의 API를 직접 호출하지 않도록 함.
• 응답 시간이 느려질 수 있음(여러 API 호출로 인해).
• Aggregator API가 병목이 될 가능성.

단점으로 요청한 데이터가 많을수록 해당 서비스에서 많은 API를 호출받게 될 것인데 이때 DB 부하 측면에서 괜찮다고해도 응답 시간이 느려질 수 있다.이를 해결하기 위해 CQRS 패턴 도입

API Aggregation + CQRS

CQRS 기반의 시스템에서 API Aggregation을 통해 클라이언트 응답 성능을 최적화

이벤트를 발행(produce)하고 비동기 방식으로 필요한 곳에서 consume 한다

발생(produce)는 누락될 가능성이 거의 없다 (성공률이 높다) 이벤트 자체만으로는 어떤 도메인과도 직접적인 의존성이 없는 느신한 결합을 가능하게 만든다

1. Event Sourcing

Event Sourcing는 데이터 상태를 저장하는 대신, 시스템의 상태 변화를 나타내는 이벤트들의 순서를 기록하고 이 기록을 기반으로 현재 상태를 재구성하는 방법론입니다.

• 핵심 개념: 데이터의 상태 변경이 이벤트로 저장됩니다. 시간 순서로 저장된다. 모든 상태는 기록된 이벤트를 재생(Replay)하여 복원됩니다. 이벤트는 이벤트 스트림으로 저장.

• 특징: 이력 관리: 시스템의 모든 변경 사항을 추적하고, 과거 상태를 복원할 수 있습니다. 디버깅과 감사: 이벤트 로그를 통해 왜 특정 상태가 되었는지 추적 가능. Event Store: 전통적인 DB 대신 이벤트 저장소를 사용.

• 사용 예: 금융 시스템 (거래 기록 추적). 비즈니스 규칙이 복잡한 도메인. 이벤트 기반 시스템의 데이터 무결성 보장.

• 장점: 데이터 변경이력 추적과 감시에 유용하다.

은행 계좌 은행은 현재 잔액만 저장하는 것이 아니라, 모든 입출금 내역을 기록합니다. 예를 들어:

• 잔액: 0원
• 이벤트: 2023-11-01 → 1000원 입금 2023-11-02 → 500원 출금 2023-11-03 → 200원 입금
• 현재 잔액: 1000 - 500 + 200 = 700원 여기서 중요한 점은 "현재 잔액을 따로 저장하지 않고, 입출금 기록만을 가지고도 잔액을 계산할 수 있다"는 것

쇼핑몰 주문 시스템 상황: 고객이 쇼핑몰에서 상품을 주문하고, 결제, 배송 등의 상태가 변하는 과정을 관리해야 합니다.

1. 상태 변화 이벤트 Event Sourcing에서는 주문 상태를 아래처럼 이벤트로 기록합니다:

• 이벤트 기록: OrderCreated (주문 생성됨) → "주문 번호 1234, 고객: Alice, 상품: 책" PaymentCompleted (결제 완료됨) → "주문 번호 1234, 결제 금액: 20,000원" OrderShipped (배송 시작됨) → "주문 번호 1234, 배송 시작" OrderDelivered (배송 완료됨) → "주문 번호 1234, 배송 완료"

2. 현재 상태 복원 사용자는 이벤트를 재생(Replay)하여 현재 주문 상태를 재구성할 수 있습니다: 주문 생성됨 → 결제 완료됨 → 배송 시작됨 → 배송 완료됨 결과: 주문 상태 = "배송 완료"
3. 장점 이력 관리: 과거의 상태를 복원할 수 있음. (예: "주문이 배송 중이던 시점은 언제였지?") 디버깅: 문제가 생긴 시점을 파악 가능. (예: "결제가 실패했었다면 왜 그랬을까?") 복구: 특정 시점까지 상태를 되돌리기 쉽다.

2. Event-Driven

Event-Driven(이벤트 중심)은 이벤트를 중심으로 시스템이 동작하는 패턴으로, 이벤트가 발생했을 때 이를 감지하고 처리하는 방식입니다.

• 핵심 개념: 이벤트 프로듀서가 이벤트를 발생시키고, 이벤트 컨슈머가 이를 처리. 비동기적으로 동작하며, 느슨하게 결합된 시스템 설계.

• 특징: 비동기성: 이벤트가 발생하면 즉시 처리되거나, 적절한 시점에 처리됨. 느슨한 결합: 컴포넌트 간 직접적인 의존성 감소. 확장성: 이벤트 기반으로 컴포넌트를 쉽게 추가 가능.

• 사용 예: 알림 시스템 (SMS, 이메일). IoT 환경 (센서 데이터 처리). 메시징 플랫폼 (Kafka, RabbitMQ).

이벤트 기준으로 모든 데이터의 변경을 처리, 조회 비즈니스를 이벤트를 기반으로 구현하는 방법 (이벤트 소싱 포함)

데이터의 변경

• 동기
• 비동기 : membership-svc > 변경 요청 이벤트 소비(consume) > 도메인의 최종 버전 정보를 변경

데이터의 조회 하나의 도메인(DB)를 특정할 수 있는 key(PK)를 조건으로 최종 버전 정보를 조회

장애나 서버, 인프라에 문제가 발생할 지라도 앱이 복구되면 메세지 브로커(이벤트)에 의존해서 일관성(트랜잭션)을 구현할 수 있다.

• request-response driven에서 100번의 요청을 했을 때 100번의 프로세싱을 해야하지만 event-driven의 경우 100번의 요청을 받아 1번의 insert로 자원의 효율적 사용이 가능하다.

3. Event-Driven Architecture (EDA)

Event-Driven Architecture (EDA)는 Event-Driven 개념을 전체 시스템 설계에 적용한 구조로, 시스템 구성 요소가 이벤트를 생성, 소비, 처리하며 상호 작용합니다.

• 핵심 개념: 시스템이 이벤트 중심으로 설계됨. 프로듀서와 컨슈머가 독립적으로 동작하며, 이벤트 버스를 통해 통신.

• 특징: 확장성: 다양한 마이크로서비스가 이벤트 기반으로 확장 가능. 유연성: 변경 사항이 특정 컴포넌트에만 영향을 미침. 이벤트 브로커: Kafka, RabbitMQ, AWS SNS/SQS와 같은 브로커 사용.

• 사용 예: 마이크로서비스 아키텍처에서 서비스 간 통합. 실시간 데이터 처리 시스템. 대규모 분산 시스템.

전체적으로 아키텍처의 모든것을 이벤트를 기반으로 구현

단점

1. 이벤트가 한번 잘못 발행, 혹은 consume 이후 잘못된 처리를 하는 순간 모든 데이터 정합성과 트랜잭션이 크게 망가질 수 있는 상황이 생길수 있다
   • 백업, 통제 정책 등을 잘 수립해야 한다.
   • 너무 risky한 비즈니스에서는 오히려 안 어울릴 수 있다 이때 솔루션으로 eventuate, axon framework가 있다.

     Event-Driven Architecture
     ├── Event-Driven
     │     ├── Event Sourcing (이벤트를 저장하고 상태 복원)
     │     └── Saga 트랜잭션 오케스트레이션 (분산 트랜잭션 관리)
     └── 시스템 간 통합 (이벤트를 기반으로 서비스 연결)

차이점

이 세 가지 개념은 서로 관련되어 있으나, 다루는 범위와 목적이 다릅니다. Event Sourcing은 데이터 관리에 집중하고, Event-Driven은 동작 방식에 초점을 맞추며, EDA는 시스템 전반의 설계를 아우릅니다.

기술적 동작 방법

• 이벤트 저장소: 모든 이벤트는 이벤트 저장소(Event Store)에 기록됩니다. 예: Kafka, Event Store DB, DynamoDB 등.
• 이벤트 재생: 시스템이 재시작될 때, 이벤트를 순서대로 읽고 현재 상태를 재구성합니다.
• CQRS와의 결합: Event Sourcing은 보통 CQRS(Command Query Responsibility Segregation)와 함께 사용됩니다. Command: 상태를 변경하는 작업 → 이벤트를 생성하여 저장. Query: 현재 상태를 조회 → 이벤트를 기반으로 상태를 재구성.

Event Sourcing과 CQRS를 조합하는 이유

Event Sourcing에서는 데이터의 최종상태를 바로 조회할 수 없다 따라서 데이터를 조회하려면 이벤트를 차례로 수행하여 현재 상태를 조회해야하기 때문에 조회에 비효율적이다

CQRS를 조합할 경우 읽기 모델과 쓰기 모델을 분리하여, 읽기 작업(Query)에서 이벤트 수행없이 최적화된 데이터를 바로 조회할 수 있다.

Event Sourcing으로 쓰기 작업을 처리하고, CQRS의 Query Model을 사용해 읽기 성능을 개선하는 방법을 사용

• 읽기 전용 데이터베이스: Query Model은 캐시나 읽기 전용 데이터베이스로 설계 가능
• Event Sourcing으로 이력을 관리하고, CQRS로 다양한 방식으로 이력을 조회하고 활용할 수 있다
• CQRS는 Event Sourcing의 비동기 이벤트 처리 방식과 자연스럽게 통합

Axon Framework

Axon Framwork

• event sourcing 기반으로, 데이터를 관리할 수 있는 도구를 제공하고 이 도구를 사용하여 CQRS, DDD를 구현할 수 있도록 돕는다.
• springboot 프로젝트에 의존성으로 사용하여 다양한 어노테이션 기반을 위 기능을 구현할 수 있다.

Axon server

• Axon Framework를 사용하여 배포된 어플리케이션들의 조율자 역할
• Axon Framework를 사용하는 어플리케이션들로부터 발행된 이벤트들을 저장하는 역할
• 각 어플리케이션들의 상태 관리, imbedding된 큐잉을 내재하여 유량 조절
• 고가용성에 집중된 내부 구현이 되어있고

📌보통 요청기반 권한 부여는 컨트롤러에서 받도록하고 메서드 기반 권한 부여는 서비스단에서 필터링하여 이중 보안으로 사용한다

클라이언트 요청(일반적으로 브라우저로 URL로 요청하는 것) request(경로 등)를 통해서 서버가 어떤 권한을 부여할 것인지 모델링 하는 것 HttpSecurity 인스턴스를 사용하여 권한 규칙을 선언한다.

위 설정을 통해 스프링시큐리티가 서버측에 설정한 권한을 사용할 것이라 알리는 것

• 요청, 권한 규칙 -> 어떠한 요청에 대하여 , 어떠한 권한을 줄 것인가

authorizeHttpRequests() API

1. requestMatchers()

: HTTP 요청의 URL 패턴, HTTP 메소드, 요청 파라미터 등을 기반으로 제어

서버가 보호해야할 자원

• 매개변수를 통해 동일한 API만 사용을 달리할 수 있다.
• 문자열로 URL 필터를 주는 방법, 여러개의 파라미터를 지정할 수 있고 이는 서버가 보호해야할 자원이다.
• 파라미터로 requestMatcher를 전달
• 메소드와 파라미터 전달

보호된 자원을 어떤식으로 보호할 것인지 명시해야한다.

당연한 말이지만 인가는 인증을 받은 사용자에 한해 권한을 확인하는 것. ⭐️⭐️ 스프링 시큐리티는 클라이언트 요청에 대하여 위에서부터 아래로 순차대로 처리하고 하위의 권한을 확인하지 않는다 ⭐️ 좁은 범위의 경로를 먼저 정의하고 그것보다 큰 범위의 경로를 다음으로 설정하여 걸러내야한다.

2. securityMatcher() / securityMatchers(Customizer < RequestMatcherConfigurer> )

: 특정 패턴에 해당하는 요청에만 보안 규칙(보안 권한 부여하는 것)을 적용하도록 설정할 수 있으며 중복해서 정의할 경우 마지막에 설정한 것으로 대체한다

• 패턴 설정

  //api로 시작하는지부터 확인하는 것 
  //api로 시작하는 경우에만 authorizeHttpRequests 권한 확인
  http
  .securityMatcher("/api/**")
  .authorizeHttpRequests(
    auth -> auth.requestMatchers(...)
  )

• 내부 흐름
  • HttpSecurity 를 /api/로 시작하는 URL에만 적용하도록 구성한다 Spring MVC가 클래스 경로에 있으면 MvcRequestMatcher 가 사용되고, 그렇지 않으면 AntPathRequestMatcher 가 사용된다

securityMatchers(Customizer < RequestMatcherConfigurer > )

: 다중 패턴 설정 특정 패턴에 해당하는 요청을 단일이 아닌 다중 설정으로 구성해서 보안 규칙을 적용할 수 있으며 현재의 규칙은 이전의 규칙을 대체하지 않는다

//패턴1
http. securityMatchers((matchers) -> matchers.requestMatchers("/api/**", "/oauth/**")); 
//패턴2
http. securityMatchers((matchers) -> matchers.requestMatchers("/api/**").requestMatchers("/oauth/**")); 
//패턴3
http.securityMatchers((matchers) -> matchers.requestMatchers("/api/**") .securityMatchers((matchers) -> matchers.requestMatchers("/oauth/**"));

    @Bean
    public SecurityFilterChain securityFilterChain2(HttpSecurity http) throws Exception {
        http
                .authorizeHttpRequests(authorize -> authorize.anyRequest().authenticated());
        return http.build();
    }

    @Bean
    @Order(1) ⭐️//좁은 범위부터 필터링 실행하여야 한다.
    public SecurityFilterChain securityFilterChain2(HttpSecurity http) throws Exception {
        http
                .securityMatchers(matchers -> matchers.requestMatchers("/open-banking/oauth/"))
                .authorizeHttpRequests(authorize -> authorize.anyRequest().permitAll());
        return http.build();
    }

권한 규칙 종류

권한의 경우 계층적 개념을 적용할 수 있지만 (ex: admin이 manager를 포함하고 있다) 위에서 권한을 확인하는 것은 단순 문자열로 비교하는 것이다

표현식 및 커스텀 권한 구현

• access는 new WebExpressionAuthorizationManager() 즉, AuthorizationManager의 구현체가 반드시 들어가야 한다.
• 매개변수는 표현식 구문을 전달한다.
• 적용하기의 첫번째 reqeust는 구문 조건식에 부합하면 requestMatchers의 경로로 이동할 수 있다는 의미이다.

1. access에 (권한)들어가는 AuthorizationManager의 구현체에 들어갈 빈을 생성하여 주입할 수 있다.
2. requestMatcher에 들어갈 URI를 만들 수 있다 (엔드포인트).

메서드 기반 권한부여

@PreAuthorize, @PostAuthorize

• 메서드 기반 권한 부여는 서비스단에서 필터링하여 이중 보안으로 사용한다 컨트롤러에서 사용한다고 안되는것은 아니지만 요청기반은 컨트롤러 메서드 기반은 서비스에서 사용하는것이 목적에 부합하다 볼 수 있다
• Spring Security 는 요청 수준의 권한 부여뿐만 아니라 메서드 수준에서의 권한 부여를 지원
• 메서드 수준 권한 부여를 활성화 하기 위해서는 설정 클래스에 @EnableMethodSecurity 어노테이션을 추가해야 한다
• SpEL(Spring Expression Language) 표현식을 사용하여 다양한 보안 조건을 정의할 수 있다

@PreAuthorize

: 메소드가 실행되기 전에 특정한 보안 조건이 충족되는지 확인하는 데 사용되며 보통 서비스 또는 컨트롤러 레이어의 메소드에 적용되어 해당 메소드가 호출되기 전에 사용자의 인증 정보와 권한을 검사한다

@Secured

: 어노테이션을 메소드에 적용하면 지정된 권한(역할)을 가진 사용자만 해당 메소드를 호출할 수 있으며 더 풍부한 형식을 지원하는 @PreAuthorize 사용을 권장한다 @Secured는 아주 단순한 권한만 지정할 수 있다

• 어노테이션을 사용하려면 스프링 시큐리티 설정에서 @EnableMethodSecurity(securedEnabled = true) 설정을 활성화해야 한다

본 어노테이션은 잘 사용하지 않는다

@Secured("ROLE_USER")
public void performUserOperation() {
// ROLE_USER 권한을 가진 사용자만 이 메소드를 실행할 수 있습니다.
}

@PostAuthorize

: @PostAuthorize 어노테이션은 메소드가 실행된 후에 보안 검사를 수행하는 데 사용된다 • @PreAuthorize 와는 달리, @PostAuthorize는 메소드 실행 후 결과에 대한 보안 조건을 검사하여 특정 조건을 만족하는 경우에만 사용자가 결과를 받을 수 있도록 한다

PostAuthorize 조건을 충족해야지만 결과를 반환한다

@PreFilter

: 메소드가 실행되기 전에 메소드에 전달된 컬렉션 타입의 파라미터에 대한 필터링을 수행하는데 사용. 사용자가 보내온 컬렉션(배열, 리스트, 맵, 스트림) 내의 객체들을 특정 기준에 따라 필터링하고 그 중 보안 조건을 만족하는 객체들에 대해서만 메소드가 처리하도록 할 때 사용된다

@PostFilter

: 메소드가 반환하는 컬렉션 타입의 결과에 대해 필터링을 수행하는 데 사용된다 • @PostFilter 어노테이션은 메소드가 컬렉션을 반환할 때 반환되는 각 객체가 특정 보안 조건을 충족하는지 확인하고 조건을 만족하지 않는 객체들을 결과에서 제거한다

JSR-250

: JSR-250 기능을 적용하면 @RolesAllowed, @PermitAll 및 @DenyAll 어노테이션 보안 기능이 활성화 된다

• JSR-250 어노테이션을 사용하려면 스프링 시큐리티 설정에서 @EnableMethodSecurity(jsr250Enabled = true) 설정을 활성화해야 한다

@RolesAllowed("USER") public void editDocument() {
// 'ROLE_USER' 권한을 가진 사용자만 문서를 편집할 수 있습니다.
}

@PermitAll
public void viewDocument() { //모든사용자가문서를볼수있습니다.
}

@DenyAll
public void hiddenMethod() {
// 어떠한 사용자에게도 접근이 허용되지 않습니다.
}

메타 주석 사용

: 메서드 보안은 애플리케이션의 특정 사용을 위해 편리성과 가독성을 높일 수 있는 메타 주석을 지원한다

• 어노테이션을 생성하여 해당 어노테이션을 사용하여 가독성을 높일 수 있다

특정 주석 활성화

: Method Security 의 사전 구성을 비활성화한 다음 @PostAuthorize 를 활성화한다

@EnableMethodSecurity(prePostEnabled = false) 
class MethodSecurityConfig {

@Bean 
@Role(BeanDefinition.ROLE_INFRASTRUCTURE) 
Advisor postAuthorize() {
    return AuthorizationManagerAfterMethodInterceptor.postAuthorize(); }

}

커스텀 빈을 사용하여 표현식 구현

: 사용자 정의 빈을 생성하고 새로운 표현식으로 사용할 메서드를 정의하고 권한 검사 로직을 구현한다

클래스 레벨 권한 부여

: 모든 메소드는 클래스 수준의 권한 처리 동작을 상속하나 메서드에 어노테이션을 선언한 메소드는 클래스 수준의 어노테이션을 덮어쓰게 된다 (메소드 우선 적용)

• 클래스 수준

@Controller 
@PreAuthorize("hasAuthority('ROLE_USER')") 
public class MyController {

@GetMapping("/endpoint")
public String endpoint() { ... } 

}

📌 인터페이스에도 동일한 규칙이 적용되지만 클래스가 두 개의 다른 인터페이스로부터 동일한 메서드의 어노테이션을 상속받는 경우에는 시작할 때 실패한다.

그래서 구체적인 메소드에 어노테이션을 추가함으로써 모호성을 해결할 수 있다

@Controller 
@PreAuthorize("hasAuthority('ROLE_USER')") 
public class MyController {

@GetMapping("/endpoint")
@PreAuthorize("hasAuthority('ROLE_ADMIN')") // 이 설정이 우선적으로 동작한다
public String endpoint() { ... }

}

sameSite : 크로스 사이트 간 쿠키 전송에 대한 제어를 핸들링하는 것 쿠키 설정할 때 지정.

• 스프링시큐리티에서는 SameSite 속성에 대한 지원을 제공하지 않지만 spring Session에서는 해당 속성을 지원한다.

1. Strict :

• 사용자가 A서비스에 접속을하여 서비스는 사용자에게 쿠키를 발급한다
• 세션쿠키라 가정했을 때 브라우저에 저장된다
• 사용자가 A -> A로 요청할 경우 자동적으로 브라우저가 전달해주나, A -> B로 이동하고 다시 B -> A로 다시 요청할 경우 쿠키가 전송되지 않는다.
• 가장 제한적인 방식으로 만약 사용자가 A 쇼핑몰에서 물건을 장바구니에 담고 PG사를 통해 결제를 한 경우 두 도메인이 다르기 때문에 쿠키값은 유실되고 결제 후 다시 A 쇼핑몰로 왔을 때 로그인 페이지로 다시 이동하는 현상이 발생할 수 있다. 보안에는 완벽하지만 편의성이 떨어진다.

2. Lax :

• 구글 크롬 80 버전부터 기본 값 Lax
• 사용자가 읽기전용 메소드, a태그, window.location.replace, 302리다이렉트 등을 통해 이동할 경우에는 타 사이트 이동시에도 쿠키를 전송해준다. 하지만 iframe, img 를 문서에 삽입하거나 AJAX 통신 등은 쿠키가 전송되지 않는다.
• 대부분은 Lax로 기본설정이 되어 있다.

3. none :

• 보안에 좋지 않다
• 모든 경우에 쿠키가 전송되는 것
• HTTPS인 경우 SameSite none으로 설정된 쿠키는 Secure 설정이 안된경우 생성이 안된다 SameSite=None; Secure

Spring Session SameSite 사용방법

dependency

implementation group: 'org.springframework.session', name: 'spring-session-core', version: '3.2.1'

코드

• ⭐️@EnableSpringHttpSession : JSESSIONID(WAS가 발급)가 아닌 SESSION 으로 발급된다.

  @Configuration 
  ⭐️@EnableSpringHttpSession 
  @Bean
  public CookieSerializer cookieSerializer() {//HttpSession 쿠키 설정
    DefaultCookieSerializer serializer = new DefaultCookieSerializer(); 
    serializer.setUseSecureCookie(true);//쿠키를 보안쿠키로 사용하겠다
    serializer.setUseHttpOnlyCookie(true);//http통신에만 쿠키를 사용하겠다
    serializer.setSameSite("Lax");//sameSite 설정 기본값이 Lax이다.
    return serializer;
  }
  @Bean
  public SessionRepository<MapSession> sessionRepository() {
      return new MapSessionRepository(new ConcurrentHashMap<>());//session을 저장할 저장소 
  }
  }

참고

• https://web.dev/articles/samesite-cookies-explained?hl=ko
• https://coding-factory.tistory.com/843

• 웹 사이트는 사용자가 이미 인증을 받았기 때문에 인증받은 쿠키로 접속을 하면 누가 됐든 인증 받은 상태로 인식한다. 사용자의 브라우저가 자동으로 보낼 수 있는 인증 정보 예를 들어 쿠키나 기본 인증 세션등과 함께 공격용 페이지와 함께 웹사이트로 요청이 된다
• 위와 같은 공격을 막기위해 스프링시큐리티에서는 CSRF 기능 활성화를 하여 이를 방어한다

• 데이터를 변경할 수 있는 메서드에 대해서만 CSRF 토큰 검사를 수행한다.
• 쿠키에 토큰을 요구하는 것은 위험하다.

기능

• 쿠키나 세션을 사용하지 않는 경우에는 CSRF 기능을 비활성화 하는 것이 효율적이다. 이유는 POST, DELETE와 같은 검사가 필요한 메서드를 요청할때마다 토큰을 보내주고 관리해야하기 때문에 비효율적일 수 있다.

• CSRF 기능이 활성화 되어 있을때는 스프링시큐리티에서 form hidden 타임으로 _csrf 토큰값을 보낸다 이를 잘 확인하여 요청 헤더 또는 매개변수에 넣어서 보내도록 해야한다.

CSRF 토큰 유지

스프링시큐리티는 기본적으로 CSRF 토큰이 생성되면 세션에 저장을 한다.

⭐️

• formLogin의 경우 스프링시큐리티가 input 타입 hidden으로 _csrf 토큰값을 value에 생성해서 서버에 보내준다
• 기본적으로 CSRF 기능이 켜져 있기 때문에 헤더나 파라미터로 해당 토큰값을 보내줘야한다

1. 세션에 토큰 저장

• CsrfTokenRespository: 인터페이스 일회성 토큰이 아닌 발급받은 토큰을 유지하여 영속화하여 사용할 수 있도록 한다.
• 세션과 토큰 구현체를 통해 토큰을 유지할 수 있다
• 토큰은 (디폴트)기본적으로 세션에 저장되도록 초기화 된다

헤더와 매개변수로 왔을 때 아래와 같은 이름으로 토큰을 읽는다

• HTTP 요청 헤더 일 때: X-CSRF-TOKEN
• 요청 매개변수 일 때 : _csrf

2. 쿠키에 토큰 저장

쿠키는 response에 담아서 브라우저에 저장이 된다 일반 스크립트에서는 읽을 수 없고 http 통신에서만 읽을 수 있다

쿠키는에 토큰을 저장하는 것은 설정하는 방식이 두가지가 있다 둘 중 한가지만 선택해야한다

 쿠키로 저장해서 쿠키로 읽는 것
 보안을 위해서 스크립트로 읽을 수 없도록 되어있다. http 통신으로만 읽을 수 있다. (선호)
방법1. http.csrf(csrf -> csrf.csrfTokenRepository(repository));

 쿠키를 클라이언트(프론트엔드) 자바스트립트로 읽을 수 있도록 설정. 
방법2. http.csrf(csrf -> csrf.csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()));

• 쿠키명 : XSRF-TOKEN
• 세션과의 차이 : 쿠키명이 다르다

CSRF 토큰 처리

• 📌CsrfTokenRequestHandler : 토큰의 유효성을 검사하는 클래스

• 설정해주지 않아도 스프링시큐리티가 자동으로 디폴트값으로 초기화 된다. 위에서는 설정하는 방법
• 클라이언트 요청마다 UUID 값으로 생성된 CSRF 토큰값을 난수로 인코팅하는 클래스가 XorCsrfRequestAtttributeHandler(구현체) 이다. 서버에서 받은 토큰값은 인코딩된 토큰 값이고 원본 토큰 값을 얻기 위해 디코딩한다. 즉 인코딩/디코딩 기능을 가지고 있는 것이고 CsrfTokenRequestHandler는 원본 그대로를 비교한다.
• 인코딩된 토큰값을 클라이언트에게 보내는 것 (HTML hidden 타입)
• 토큰 UUID는 기본적으로 세션에 저장된다. 서버에서 받은 토큰값은 인코딩된 값이기 때문에 이를 디코딩하여 원본 토큰 값과 비교를 한다. 이렇게 유효성을 검사하는 것
• 클라이언트가 보는 값 -> 인코딩 된 토큰값 (actualToken) / 서버에서 만든 원본 토큰값 csrfToken 따라서 인코딩된 값을 디코딩해주는 작업을 한다 CsrfFilter.class

CSRF 토큰 지연 로딩

: 토큰을 매요청마다 가져오는 것이 아니라 세션으로부터 CSRF 토큰이 꼭 필요할때 호출하겠다는 것

• null로 보내는 경우 모든 지연로딩이 실행되어 값이 반환된다. 따라서 값을 바로 가져오는 것. (성능상 권장하지 않음)
• SecurityContext가 서플라이어로 감싸서 사용되는 것 처럼 많은 부분이 지연로딩으로 변경되었다.

CSRF 토큰을 springMVC에서 사용하는 방법

기본적으로 세션에서 데이터가 변경되지 않는 메소드 요청을 하는 경우에는 csrf 토큰이 생성되지 않는다. POST, PUT, DELETE등의 데이터 변경을 요청하는 메소드의 경우에 토큰이 생성되는데 이때도 메소드 검증을 하기전에 csrf를 준비하는 단계에서 request 요청에 csrf토큰으로 지연 로딩으로 저장이된다. 이를 컨트롤러에서 호출하여 사용하는 것

CsrfToken token = HttpServletRequest.getAttribute(CsrfToken.class.getName());
token.getToken();

or

HttpServletRequest.getAttribute("_csrf");

springboot에서 CsrfToken을 매개변수로 받아서 바로 사용할 수 있다. 내부적으로는 위의 코드와 비슷한 맥락으로 실행

CSRF 통합

1. HTML Forms

• csrf token 값을 hidden 값으로 포함해야한다. 위 코드를 작성하지 않아도 자동으로 포함하는 뷰가 있다.
  • thymeleaf (최근 뷰를 사용한다면 많이 사용하는 방법)
  • spring 폼 태그 라이브러리