1. 기존에 서버를 배포하던 방식

기존에는 수동으로 배포를 진행하였다. 보통 배포하는 서버는 EC2를 사용하고, Docker를 이용해서 배포하였다.

1. Gradle을 사용해서 Spring 프로젝트를 빌드하여 jar 파일을 만든다.
2. Dockerfile을 사용하여서 도커 이미지를 만든다.
   1. 사용한 Dockerfile은 다음과 같다.
   2. FROM openjdk:11 ARG JAR_FILE=build/libs/*.jar COPY ${JAR_FILE} app.jar ENTRYPOINT ["java","-jar","/app.jar"]
3. 생성된 Docker 이미지를 Docker hub에 push한다.
4. EC2를 ssh를 통해 접속한다
5. EC2에서 docker hub의 이미지를 pull해서 가져온다.
6. sudo docker pull (도커HOST)/(이미지 이름) // sudo docker pull jakeheon/MZTI
7. docker run을 통해 실행한다.
8. // 그냥 실행 sudo docker run jakeheon/MZTI // 백그라운드 실행 sudo docker run -it -d jakeheon/MZTI // 포트 80으로 실행 sudo docker run -it -d -p 80:8080 jakeheon/MZTI

문제점

해당 방식은 수동으로 진행하는 것이라서 시간도 걸리고 불편하다. 그리고 여러 사람이 같이 협업을 할 경우 충돌 문제가 생길 수 있다. 특정 branch에 올릴 때 해당 branch를 배포 자동화하려고 하였다.

2. GithubAction 사용해서 자동으로 CI/CD 진행하기

1. GithubAction이란?

자동으로 CI, CD를 도와주는 Github 내장 프로그램

2. GithubAction VS Jenkins

Github Actions or Jenkins? Making the Right Choice for You

3. GithubAction으로 간단한 Spring Project 배포하기

1. 먼저 Spring Project를 하나 만들고 Github Repository와 연결해준다.
   1. 사용 기술 : java 11, springboot 2.7.15
2. github에 직접 들어가서 Action탭에서 yml파일을 작성해준다.
   1. 해당 yml 파일에 적힌대로 실제 코드가 git에 push되면 알아서 실행을 해준다.
   2. 만약 실패할 경우… 메일로 실패했다고 전달해온다. (며칠간 100개는 받은것 같다..)
   3. 먼저 아래의 코드를 실행할 때 secret키들은 따로 저장해두어야 한다.
      1. Github Repository에 setting에 action setting에 들어가서 설정할 수 있다.
      2. 이 부분은 다른 블로그에도 많이 있으므로 따라하면 된다.
   4. 정말 간단한데.. 하나씩 test해보면서 로그를 보고 어디가 문제인지 찾으면 된다. (너무 고생한것들을 트러블 슈팅에 기록하였다.)
   5. 여기서 ‘- name: ‘ 이게 하나의 단위이다. 이 상태대로 stage가 나누어지기 때문에 log를 볼때 해당 사항을 잘 살펴보면 된다.
   6. name: Java CI with Gradle on: push: branches: [ "main" ] pull_request: branches: [ "main" ] permissions: contents: read jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Grant execute permission for gradlew and build run: | chmod +x gradlew ./gradlew build - name: Set up JDK 11 uses: actions/setup-java@v3 with: java-version: '11' distribution: 'temurin' - name: init with Gradle uses: gradle/gradle-build-action@v2 - name: Build with Gradle run: | chmod +x ./gradlew ./gradlew clean build - name: Set up Docker Buildx uses: docker/setup-buildx-action@v1 with: version: v0.7.0 - name: Docker build & push to docker repo run: | docker login -u ${{ secrets.DOCKER_HUB_USERNAME }} -p ${{ secrets.DOCKER_HUB_PASSWORD }} docker build -t jakeheon/githubaction -f Dockerfile . docker push jakeheon/githubaction - name: Build and deploy uses: appleboy/ssh-action@master id: deploy with: host: ${{ secrets.HOST }} username: ubuntu key: ${{ secrets.KEY }} envs: GITHUB_SHA script: | sudo docker stop $(sudo docker ps -aq) sudo docker rm -f $(docker ps -qa) sudo docker pull jakeheon/githubaction sudo docker run -it -d -p 80:8080 jakeheon/githubaction
3. yml파일 내용 간단 설명gradle로 빌드할 수 있도록 권한을 주는 코드이다. 만약 이 부분에서 잘못된다면 아마 Spring project의 위치 문제일 것이다. run 제일 첫번째 줄에 directory 실행 위치를 찍어보면 알 수 있다. 아래 트러블 슈팅에서 더 자세히 설명하겠다.차례대로 JDK 11을 사용하겠다는 의미와 Gradle을 통해 build하는 과정이다. 아마 이 부분은 위와 같이 directory 문제가 아니라면 오류가 생기지 않을 것이다.Docker를 통해 로그인을 하고, build한 뒤 push 하는 코드이다. Dockerfile의 위치를 잘 확인해야 한다. 지금 여기에는 jakeheon/githubaction으로 내가 만들 이미지로 되어있는데 해당 내용도 secret에 두는 것이 좋은것 같다. 본인이 원하는 호스트와 이미지를 Dockerfile을 이용해서 만드는 코드이다.
   • EC2에 접속해서 배포하는 코드이다. EC2에 접속할 때 필요한 HOST와 KEY를 secret에 저장해둔다. pem.key의 경우 EC2에서 다운받은걸 모두 복사해서 secret에 넣어두면 된다. HOST는 접속하는 EC2의 주소를 의미하므로 ip주소나 DNS주소를 입력하면 된다.
   • 나머지는 원래 배포하던 코드랑 같다. 먼저 실행하고 있는 docker container를 stop 시켜준 뒤, 컨테이너를 삭제하고, 이미지를 Pull 받아서 실행한다.
4. - name: Build and deploy uses: appleboy/ssh-action@master id: deploy with: host: ${{ secrets.HOST }} username: ubuntu key: ${{ secrets.KEY }} envs: GITHUB_SHA script: | sudo docker stop $(sudo docker ps -aq) sudo docker rm -f $(docker ps -qa) sudo docker pull jakeheon/githubaction sudo docker run -it -d -p 80:8080 jakeheon/githubaction
5. - name: Set up Docker Buildx uses: docker/setup-buildx-action@v1 with: version: v0.7.0 - name: Docker build & push to docker repo run: | docker login -u ${{ secrets.DOCKER_HUB_USERNAME }} -p ${{ secrets.DOCKER_HUB_PASSWORD }} docker build -t jakeheon/githubaction -f Dockerfile . docker push jakeheon/githubaction
6. - name: Set up JDK 11 uses: actions/setup-java@v3 with: java-version: '11' distribution: 'temurin' - name: init with Gradle uses: gradle/gradle-build-action@v2 - name: Build with Gradle run: | chmod +x ./gradlew ./gradlew clean build
7. - name: Grant execute permission for gradlew and build run: | chmod +x gradlew ./gradlew build

3. 트러블 슈팅

1. Spring 프로젝트와 Dockerfile 위치 문제

문제 원인

매번 내가 github repository를 만들 때 잘못하고 있었던 것이다.. (이번으로 다른 프로젝트도 수정해야 할 것같다)

.git의 위치를 항상 Spring project 바깥에 두어서 github action이 해당 프로젝트에 들어올려면 폴더 하나를 더 거쳐야하는 문제가 생겼었다.

예를 들자면, TestRepositorySpring이라는 Spring boot 프로젝트를 생성했을 때 repository이름도 TestRepository라고 한다면 TestRepository 에 .git 파일과 TestRepositorySpring이라는 스프링 프로젝트 파일이 존재하는 것이다. 그럼 github action을 실행하기 위해서는 cd 명령어로 TestRepositorySpring으로 들어가야하는 문제가 생긴다…

동일하게 Dockerfile을 통해 빌드할 때도 Dockerfile을 TestRepositorySpring 안에 있으므로 안되는 문제가 생긴다.

보통 다른 블로그나 글들을 찾아봤을때 나와 같은 문제는 없었던 것 같다. (나만 계속 이상하게 하고 있는 것이므로..) 호오오옥시 나랑 동일한 문제가 있는 것 같다면 아래 방법으로 해결하면 된다.

해결 방법

1. Spring Project 안에 들어가서 실행해야할 Dockerfile빌드라던가 jar 빌드 등을 할 때, yml에 cd를 통해 해당 폴더로 이동 뒤에 실행한다. (실수하거나 깜빡할 수 있으므로 2번을 그냥.. 하는게 맞는것 같다)
2. .git을 Spring 프로젝트 안에 둔다.

2. jar 파일 빌드 문제(Error: Invalid or Corrupt jar file /app.jar)

문제 원인

이건 신기하게 Action은 다 성공해서 체크 모양이 떴는데 실제 반영이 안된 문제였다. 그래서 뭐가 문제인지 한참을 고민하다가 EC2에서 docker pull을 받아온 다음에 docker를 실행시켰더니 다음과 같은 메시지가 떴었다.

로그를 봤을 때 빌드는 성공적으로 된 것을 확인했는데 저런 오류 메시지가 발생하였다면 .jar파일이 겹쳐서 생긴문제이다. 즉, gradle로 빌드할 때 (프로젝트 이름)-plain.jar도 생기고, (프로젝트 이름).jar 2개가 생기므로 겹쳐서 오류가 발생한 것이다. 이걸 하나로 만들어줘야 해결된다.

해결 방법

build.gradle에 다음과 같이 작성하면 plain.jar는 생기지 않는다.

jar {
    enabled = false
}

3. 기존 실행하던 컨테이너 중단, 종료 문제

문제 원인

이제 진짜 다 되었다! 했을 때 생긴문제.. Action도 다 잘되고 성공한 것을 보고 처음 배포했을 때 서버ip주소로 잘 접속되는 것까지 확인했는데 생긴 문제다. 이제 코드를 바꿔서 push해서 테스트 해봐야지~ 했는데 실패했다. (바뀌지 않았다.)

실제 EC2에 접속해서 docker 로그를 확인해보니 기존에 실행하던 이미지와 겹쳐서 실행이 안되던 것이였다. 즉, 기존에 잘 돌아가고 있는 컨테이너를 중지하고 새로 배포한 이미지를 컨테이너에 올려야되는데 중지를 안해서 생긴 문제였다. (물론 위에 yml 파일은 해당 오류를 해결한 코드이다.)

해결 방법

yml에 Build and deploy script 맨 위에 다음과 같은 코드를 추가한다. docker container를 stop하고 remove하는 코드이다.

sudo docker stop $(sudo docker ps -aq)
sudo docker rm -f $(docker ps -qa)

4. EC2에 접속할 때 필요한 pem.key를 어떻게 두어야할지 몰랐을 때

문제 원인과 해결 방법

이것도 처음에 너무 고민이였다.. 사실 pem key를 제대로 이해를 안하고 있었던 것 같다. pem key도 단순히 해시 알고리즘을 통해서 바뀐 String일텐데.. 그 생각을 못했던 것 같다. pem.key를 그대로 열어서 secret에 모두 복사해서 붙여넣으면 된다!

4. 앞으로 해결할 기능들

1. Docker-Compose를 이용하여서 데이터베이스와 함께 배포해보기

2. jar로 빌드된 것을 cache를 이용하여서 속도를 빠르게 하기

3. Spring 프로젝트 이외에 React나 언어의 프로젝트도 배포해보기

4. 온프레미스 환경에 배포해보기

세션

사용자가 웹 브라우저를 킨다고 가정해보자. 예를 들어서 http://www.naver.com을 웹 브라우저에 입력하였다. 최초로 웹브라우저에 들어가면 일단 서버는 해당 주소에 맞는 controller 메서드를 찾아서 html을 사용자에게 리턴해줄 것이다.
그런데 다음에 접속할 때는 상황이 다르다. 서버는 이제 사용자가 누구인지 알아서 거기에 따른 맞춤 광고나 정보들을 제공해준다. 다음에 요청할 때는 세션 ID라는 것이 같이 전송되기 때문이다. 여기서 세션 이라는 것을 처음 접할 수 있다.

웹 브라우저는 세션 ID를 받아서 특정한 설정을 안해주는데도, 자동으로 웹 브라우저에 쿠키라는 저장 영역에 세션ID가 담기게 된다. 이 쿠키라는 영역에 담기는 세션 ID는 언제 생기냐 하면, 최초로 사용자가 서버에 요청했을 때 생기게 된다.

만약에 최초 요청이 아니라, 두번째, 세번째 요청일 시 세션 ID를 header 영역에 달고 요청하게 되는 것이다. (header안에 쿠키라는 영역이 있다)

세션ID는 그럼 뭘 확인해주는가? 세션 ID는 처음 접속했는지, 아니면 2번째, 3번째 접속했는지를 알 수 있다.

여기서 그럼 이런 생각을 할 수도 있다. 세션 ID를 위조해서 header의 쿠키에 넣어서 전달하면, 내가 아닌 다른 사람으로 서버가 인식한다는 것이니까, 위조를 할 수 있는 것 아닐까?

그럼 세션 ID를 위조할 수는 없을까?

이를 방지하기 위해서 세션 ID를 만들어줄때마다 서버는 세션ID의 목록을 가지고 있어야 된다.

즉, 세션ID는 최초 요청 시에 만들어지고, 웹 브라우저는 계속 요청할때마다 세션ID를 들고간다.

그럼 세션ID는 언제 사라지게 되는 것일까? 3가지 경우가 있다.

1. 서버 쪽에서 session 목록을 날려버릴 때
2. 사용자가 브라우저를 닫을 때 (종료할 때) -> 서버에 값이 살아있지만 특정 시간(보통 30분)이 지나면 이것도 사라짐
3. 특정 시간이 지났을 시 -> "우리가 세션이 종료되었습니다. 다시 로그인해주세요" 이런 메시지가 오는 경우 생각

세션을 사용한 로그인

세션을 로그인할 때 사용한다면 로직은 다음과 같다.

1. 유저가 처음에 서버에 요청을 한다.
2. 서버는 세션에 세션ID를 하나 만들어주고(ex> 1234) 서버 세션공간에 기록해둔다.
3. 서버는 유저에게 응답(response)를 돌려준다.
4. 유저가 다음 요청을 하게 될 때는 세션 1234를 쿠키에 넣어서 이번엔 로그인을 요청한다.
5. 서버는 DB에 로그인 정보가 있는지 확인한다.
6. 해당하는 user가 있다면, 서버의 세션에서 세션ID가 1234인 곳에 user 정보를 저장하게 된다.
7. 그럼 이제 다음번에 사용자가 예를 들어 사용자 프로필 화면에 접속했다고 하면, 세션 있는지 먼저 확인한다
8. 세션이 있다면 DB에서 사용자 정보를 찾아서 서버에 응답해준다.
9. 해당 정보를 돌려준다!

즉, 세션을 통해서 그 사용자 인증도 할 수 있고, 민감한 정보를 요청할 때 세션을 통해서 세션값이 있는지 확인하고 정보가 존재하는지 확인한다.

세션의 단점

세션의 단점에 대해서 생각하려면 사용자가 많을 때를 가정해봐야 한다.
만약 서버가 100명을 처리할 수 있는 서버인데, 1000명이 동시에 접속했다고 가정해보자. 그럼 900명은 대기해야한다. 그래서 회사는 서버를 늘리고 싶어한다. 늘리면 당연히 1000명을 받을 수 있을텐데 문제는 세션이다.

세션은 서버에 같이 존재하는데, 만약 이전 서버에 로그인해서 세션에 기록되었다면 새로 늘린 서버에 접속하면 해당 서버의 세션에는 로그인 정보가 없기 때문에 로그인이 잘 되었는지 이용자에게 전달해줄 수 없는 문제가 생긴다.

이걸 해결하려면 몇 가지를 생각해볼 수 있다.

1. 먼저 Sticky Server라는 것을 만든다. 이 서버는 이제 최초에 들어온 사람은 로드 밸런싱 이런거 없이 무조건 처음 접속한 서버로만 들어가게 강제하는 것이다.
2. 아니면 세션 전체를 복제시켜서 서버마다 세션을 저장해줄 수 있다.
3. 또, 세션에 저장하는 게 아니라 다른 한 군데 데이터베이스에 값을 넣고 이걸 세션이라고 생각해서 공유해서 사용하는 것이다.

문제는 해결책들이 기존의 세션의 장점을 사라지게 한다.

세션은 일단 서버에 인메모리 즉, 속도가 빠르다는 장점이 있는데, 3번째 방법은 데이터베이스를 따로 둔다는 것은 하드디스크에서 읽어와야 하기 때문에 속도가 느려진다. (하드디스크에 접속한다는 것은 I/O가 일어난다는 것이기 때문에..)

그래서 현재 세션을 사용하는 서버들은 DB가 아니라 메모리 공유 서버를 사용한다. 그래서 모든 서버들이 메모리 서버에 접근하는데 여기서 나오는 대표적인 인메모리 데이터베이스가 Redis이다.

세션을 사용하지 않고, JWT 토큰을 사용하는 방법이 더 많이 사용된다. JWT 토큰에 대해서도 정리해보겠다.

웹 브라우저가 HTTP 요청을 하게 되면 HTTP Header, Body 등 웹 브라우저에서 보낸 다양한 정보가 서버로 넘어가게 된다.

웹 브라우저가 HTTP 요청을 하면 해당 메시지를 서버가 받아서 메시지를 파싱도 하고, URL이 뭔지 판단도 하고, content-type도 넘어오니까, 원하는 정보를 몇 글자인지 보고 파싱해서 사실하면 로직을 처리할 수 있다. 거기에 response를 client에게 전달해 주면 된다. 그러나, 이런 작업은 반복적인 작업도 많고, 단순한 비즈니스 로직 하나를 처리하기 위해서도 귀찮은 일이 생긴다. 이걸 더 편리하게 해 주기 위해서 나온 게 서블릿이다.

서블릿은 이런 HTTP 작업을 단순화해 준다. HTTP 요청 정보를 편리하게 사용할 수 있는 HttpServletRequest 객체와 HTTP 응답 정보를 편리하게 사용할 수 있는 HttpServletresponse 객체를 제공해 줘서, 개발자는 HTTP 스펙을 쉽게 사용할 수 있게 되는 것이다.

서블릿(Servlet)

• 자바 웹 애플리케이션 개발을 위한 기술로, 동적인 웹 콘텐츠를 생성하는 데 사용
• HTTP 요청과 응답을 처리하기 위한 자바 클래스
• 서블릿 컨테이너(예: Apache Tomcat)에서 실행되며, 요청에 대한 처리와 스레드 관리를 담당

HTTP 요청과 응답을 서블릿이 어떻게 처리해주는지 알아보자.

1. HTTP 요청이 들어오면 WAS는 Request 객체랑 Response 객체를 새로 만들어서 서블릿 객체를 호출한다.
2. 그럼 Request 객체에서 HTTP로 어떤 요청이 들어왔는지 확인하고
3. 해당 로직을 처리한 다음(해당 로직을 처리 주는 것이 바로 서블릿 객체이다)
4. Response 객체에 Client에게 전달해야 할 응답 정보를 담아서 전달해 준다. 이때 WAS가 HTTP 응답 정보를 생성해 준다.
5. Client가 해당 정보로 렌더링 해서 이제 보여준다.

서블릿 컨테이너

WAS 안에는 서블릿 컨테이너라는 게 있는데 서블릿 컨테이너가 서블릿 객체를 자동으로 생성해 준다. 호출도 해주고, 관리까지(예를 들면 WAS 종료될 때 서블릿도 같이 종료시키는) 해준다. 톰캣은 서블릿 컨테이너의 종류 중 하나이다.

즉, WAS는 웹 서버와 서블릿 컨테이너로 구성된다고 생각하면 된다. 사실 경계가 모호하기 때문에 종류로 생각하는 게 편하다. 

웹 서버는 nginx와 apache가 해당하는 것이고, 서블릿 컨테이너는 apache tomcat(아파치 톰캣)이 해당한다.

서블릿 컨테이너의 장점 중 하나는 싱글톤으로 관리된다라는 사실이다. 싱글톤은 객체를 하나만 생성해놓고 서로 공유해서 사용하는 디자인 패턴을 의미한다. 만약 사용자가 10000명 이상으로 온다면 비즈니스 로직으로 개게를 엄청나게 만들어야 되는데, 싱글톤을 사용하면 하나를 공유해서 사용하면 되므로 딱 봐도 이점이 느껴진다.

그렇다고, request랑 response를 다 공유하는 건 아니다. 웹 브라우저에서 사용자마다 전달해오는 데이터는 당연히 다를 것이다.

(내 아이디 비번과 다른 사람의 아이디 비번이 다른 것과 마찬가지이다)

request, response 객체는 따로 생성하지만 비즈니스 로직인 서블릿은 공유해서 사용하는 것이다. 항상 재사용한다. 그래서 모든 고객 요청은 동일한 서블릿 객체 인스턴스에 접근하게 된다. (그래서 공유 변수 사용에 주의해야 한다)

또 다른 중요한 장점은 서블릿 컨테이너는 멀티 스레드 처리도 지원을 한다는 사실이다. 

위에 그림처럼 request가 생기면 서블릿을 호출하게 되는데, 그럼 서블릿은 누가 호출하는 건가??

쓰레드가 호출하게 된다. 스레드는 애플리케이션의 흐름이라고 알고 있는데, 말 그대로이다. 스레드가 아무 작업을 안 하고 쉬고 있다가, 만약에 요청이 들어오면 스레드를 할당해 줘서 서블릿을 호출해 주는 시스템인 것이다. 요청하고 응답까지 다 하면, 스레드는 다시 휴식하게 되는 것이다. 

다중 요청이 들어올 때도, 쓰레드가 여러 개면 해결이 될 것 같다. 요청마다 스레드를 생성해 주면 되는 것이다. 이렇게 생각했는데 이 방법은 당연히 단점이 있다. 

장점으로는 동시 요청을 처리하면서, 하나의 쓰레드가 지연되어도, 나머지 스레드는 정상 동작하기 때문에 상관이 없다.

그렇지만 쓰레드는 생성 비용이 매우 비싸고, 고객의 요청이 올 때마다 새로운 스레드를 생성하면 응답 속도가 늦어지고, 고객 요청이 너무 많이 오면 결국 임계점을 넘기면 서버가 죽을 수도 있는 것이다. 

근데 WAS는 멀티 스레드를 다 처리해주기 때문에 멀티 스레드 관련 코드를 신경 안 써도 된다.

웹 서블릿의 동작 원리

@WebServlet(name = "helloServlet", urlPatterns = "/hello")
public class HelloServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        System.out.println("HelloServlet.service");
        System.out.println("request = " + request);
        System.out.println("response = " + response);

        String username = request.getParameter("username");
        System.out.println("username = " + username);

        response.setContentType("text/plain");
        response.setCharacterEncoding("utf-8");
        response.getWriter().write("hello " + username);


    }
}

위의 코드를 한번 살펴보자. @WebServlet 어노테이션을 선언해주면 이제 서블릿 컨테이너가 관리를 해주게 되는 것이다. 

서블릿은 클라이언트의 요청을 HTTP 형태로 받는다. @WebServlet 어노테이션의 Parameter로는 name과 urlPatterns를 받는다.

단어 그대로, name은 서블릿의 이름이고, urlPattern은 클라이언트에서 요청하는 URL이다. 이 둘을 매핑해 주는 것이다.

만약 HTTP를 통해 매핑된 URL이 호출되면 서블릿 컨테이너는 다음 메서드를 실행한다.

protected void service(HttpServletRequest request, HttpServletResponse response);

위의 함수 파라미터 그대로 해석하면 request에는 클라이언트 요청, response는 서블릿이 이제 대답을 준다. 해당 함수를 어떻게 커스터마이징하고 조작하는 역할을 이제 서블릿 컨테이너 안의 서블릿이 해주는 것이다. 그 조작을 service함수 내에서 하면 되는 것이다.

그래서 서블릿의 이름과 urlPattern은 중복되게 하면 안된다. 

그럼 위의 코드에서 request 객체와 response 객체에는 어떤 것들이 오는지 로그를 찍어보자.

apache.catalina는 tomcat쪽 라이브러리이다.(서블릿 컨테이너 쪽 라이브러리)

HttpServletRequest나 HttpServletResponse는 interface이다.

이제 Tomcat이나 Jetty 등등 이런 WAS 서버들이 서블릿 표준 스펙을 구현하는 것이다. 여기 찍히는 것은 Tomcat의 구현체라고 볼 수 있다.

쿼리 파라미터

서블릿의 장점 중 하나는 쿼리 파라미터를 아주 쉽게 읽을 수 있게 해 준다는 사실이다.

request로 query parameter를 전송하면 request 객체에서 getParameter를 사용하면 해당 query 파라미터를 읽어낼 수 있다.

응답 메시지를 보여줄려면 response에 넣어줘야 한다.

setContentType를 text/plain으로 준다면 단순 문자열을 전송해 주는 것이다.

setCharacterEncoding은 utf-8로 둔다.

그럼 여기까지 정보는 Header에 들어가게 된다.

나머지는 response.getWriter().write() 를 통해서 보내준다.

모든 HTTP 요청 응답 정보들을 보고 싶으면 아래와 같이 설정하면 된다. (application.properties)

logging.level.org.apache.coyote.http11=debug

지금까지의 동작 과정

1. 스프링부트로 프로젝트를 생성 후 실행 → 스프링부트 안에 있는 내장 톰캣 서버를 띄워준다.
2. 톰캣 서버는 내부에 서블릿 컨테이너를 가지고 있다.
3. 서블릿 컨테이너를 통해서 내부에 서블릿을 다 생성해준다. → HelloServlet 생성
4. GET /hello?username=kim HTTP/1.1 Host: localhost:8080 웹브라우저가 이런 형식으로 HTTP 메시지를 만들어서 서버에 요청을 한다.
5. 서버는 Request, Response 객체를 만들어서 HelloServlet의 Service 메서드를 호출하면서 response 객체를 만들어서 웹 브라우저에게 전달해 준다.
6. HTTP 응답에서 Content-Length는 웹 애플리케이션 서버가 자동으로 생성해 준다. (WAS가 해줌)

HttpServletRequest의 역할

위에서 말했듯이 HTTP 요청 메시지를 개발자가 직접 파싱 하기 어려우니까, 서블릿은 개발자가 HTTP 요청 메시지를 편리하게 사용할 수 있도록 개발자 대신에 HTTP 요청 메시지를 파싱 한다. 그리고 그 결과를 HttpServletRequest 객체에 담아서 제공한다.

추가적인 역할

1. 임시 저장소 기능 : HTTP 요청이 시작부터 끝날 때까지 유지되는 임시 저장소 기능
   1. 저장 : request.setAttribute(name, value)
   2. 조회 : request.getAttribute(name)
2. 세션 관리 기능 : request.getSession(create: true)

클라이언트에서 HTTP를 통해 서버로 전달하는 방법

1. GET - 쿼리 파라미터
   1. 검색, 필터, 페이징 등에서 많이 사용하는 방식
   2. 서버는 HttpServletRequest를 가지고 정보를 쉽게 가져올 수 있다
2. POST - HTML Form
   1. content-type: application/x-www-form-urlencoded
   2. 메시지 바디에 쿼리 파라미터 형식으로 전달 → 똑같이 request.getParameter로 꺼낼 수 있다!
   3. 클라이언트 입장에서는 차이가 있는데, 서버 입장에서는 둘의 형식이 동일한 것이다
   4. 회원가입, 상품 주문에 사용
3. HTTP message body에 데이터를 직접 담아서 요청
   1. HTTP API에서 주로 사용, JSON형식으로 사용
   2. POST, PUT, PATCH
   3. String으로 주고 받는 방식(잘 쓰이지 않음)

@WebServlet(name = "requestBodyStringServlet",urlPatterns = "/request-body-string")
public class RequestBodyStringServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        ServletInputStream inputStream = request.getInputStream();
        String messageBody = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);
        System.out.println("messageBody = " + messageBody);
        response.getWriter().write("OK");

    }
}

• getInputStream을 하면 메시지 body의 내용을 byte코드로 바로 얻을 수 있다
• byte 코드를 String으로 바꿔야 하는데 Spring에 StreamUtils라는 유틸리티 클래스를 사용하면 된다.
  • 인코딩 정보를 알려줘야 한다
• 지금 이건 String 형식으로 주고 받는 것이다.
• JSON으로 주고 받는 방식이 보통 사용되는데 코드는 아래와 같다.

@WebServlet(name = "requestBodyJsonServlet", urlPatterns = "/request-body-json")
public class RequestBodyJsonServlet extends HttpServlet {

    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // request
        ServletInputStream inputStream = request.getInputStream();
        String messageBody = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);

        System.out.println("messageBody = " + messageBody);
        HelloData helloData = objectMapper.readValue(messageBody, HelloData.class);
        System.out.println("helloData.username = " + helloData.getUsername());
        System.out.println("helloData.age = " + helloData.getAge());

    }
}

// HelloData
@Getter @Setter
public class HelloData {

    private String username;
    private int age;

}

• 스프링은 JSON 라이브러리를 기본적으로 jackson이라는 것을 사용한다.
• ObjectMapper를 선언하고 readValue를 통해서 class타입으로 변환할 수 있다. 여기서는 HelloData로 변환을 하였다.
• 나중에는 MVC가 제공하는 기능을 통해서 더 쉽게 JSON을 파싱할 수 있다

서블릿과 자바로 동적으로 변경해야 하는 부분을 보여주고 싶을 때 템플릿 엔진을 사용할 수 있다. 템플릿 엔진을 사용하면 HTML 문서에서 필요한 곳만 코드를 적용해서 동적으로 변경할 수 있다.

템플릿 엔진에는 JSP, Thymleaf, Freemarker, Velocity 등이 있다. 이전에는 JSP가 많이 사용되었었지만, 스프링은 현재 Thymeleaf를 사용하는 걸 추천한다.

단순히 서블릿만을 사용하기에는 HTML을 다루기가 너무 힘들기 때문에 JSP나 타임리프 같은 것들을 사용하게 된다.

JSP(JavaServer Pages)

• 서블릿을 기반으로 하는 웹 페이지 개발을 위한 기술
• HTML 코드 내에 자바 코드를 삽입하여 동적인 웹 콘텐츠를 생성할 수 있다
• JSP 파일은 서블릿으로 변환되어 서블릿 컨테이너에서 실행

서블릿과 JSP의 한계

분리되어 있지 않다. 이게 제일 핵심 단점이다. 서블릿과 JSP를 사용하다 보면 비즈니스 로직이랑 화면(View)랑 분리되지 않아서 지저분하고 나중에 코드를 볼 때도 복잡하여 유지보수가 어렵다. 

그래서 등장하게 된 것이 MVC 패턴이다.

MVC 패턴

MVC 패턴은 컨트롤러와 뷰라는 영역으로 서로 역할을 나눈다. MVC 용어에서 알 수 있듯이 여기서 V는 view이고, C는 Controller이다.
M은 모델인데, 모델은 뷰에 출력할 데이터를 담아두고 뷰가 필요한 데이터를 모두 모델에 담아서 전달한다. 덕분에 뷰는 비즈니스 로직이나 데이터 접근 같은 걸 몰라도 되고, 화면만 렌더링 하면 되는 것이다.

그리고, Service로도 이후에 나눈다. Controller에 비즈니스 로직을 둘 수도 있지만 이렇게 되면 또 컨트롤러가 부담을 많이 지는 문제가 발생하기 때문에 Service 계층을 따로 나누어서 처리한다. Controller는 서비스 계층을 호출하는 역할만 하면 된다.

MVC 패턴과 관련된 프레임워크도 많았었는데, 어노테이션 기반의 스프링 MVC가 나오면서 거의 정리되었다. 

MVC 패턴의 한계

MVC 패턴의 한계라기보다는 MVC 패턴을 개선하는 방안이다. MVC 패턴은 요청하는 부분과 응답하는 부분, 즉 request response 코드가 controller마다 따로 구성되어 있다. 중복된 코드는 항상 개선점에 해당한다. 그래서 FrontController라는 것이 고안되었다.

FrontController 패턴

• Front Controller 패턴은 소프트웨어 디자인 패턴 중 하나로, 웹 애플리케이션에서 중앙 집중화된 컨트롤러 역할을 수행하는 컴포넌트
• 이 패턴은 클라이언트의 모든 요청을 하나의 진입점으로 보내고, 해당 요청을 처리하기 위해 적절한 핸들러(컨트롤러)로 라우팅 하는 구조를 가지고 있다
• Front Controller를 제외한 나머지 Controller는 서블릿을 사용하지 않아도 된다.

스프링 웹 MVC에서 보면 FrontController를 사용한다. 우리가 DispatcherServlet으로 알고 있는 것이 FrontController 패턴으로 구현되어 있다. 프런트 컨트롤러 서블릿이 클라이언트 요청을 다 받고 프런트 컨트롤러가 요청에 맞는 컨트롤러를 찾아서 호출하는 즉, 입구를 하나로 만드는 전략이다.

개선점

위의 서블릿 코드에서 override 된 service코드를 보면 HttpServletRequest랑 HttpServletResponse를 계속하여 쓰게 되는데, 해당 코드가 컨트롤러 입장에서는 필요 없다. Controller는 View로 객체를 전달하기만 하면 되는데, 해당 객체를 Model 객체라고 한다. 그럼 이제 우리가 아는 구조가 나오게 된다.

전형적인 Front Controller 패턴의 구조는 다음과 같다:

1. 클라이언트는 요청을 Front Controller에게 전송
2. Front Controller는 요청을 받아 해당 요청을 처리할 적절한 핸들러(컨트롤러)로 라우팅
3. 핸들러는 요청을 처리하고 필요한 작업을 수행한 후 응답을 생성
4. Front Controller는 핸들러로부터 받은 응답을 클라이언트에게 전송

뷰 리졸버 (View Resolver)

뷰 리졸버(View Resolver)는 컨트롤러가 처리한 결과를 어떤 뷰로 보여줄지를 결정하는 역할을 한다.
뷰 리졸버는 뷰의 논리적인 이름을 실제 뷰 객체로 변환하여 반환하는 기능을 담당한다.

웹 애플리케이션은 MVC (Model-View-Controller) 아키텍처를 따르는데, 이 구조에서 컨트롤러는 요청을 처리하고 필요한 작업을 수행한 후 결과를 뷰에 전달한다. 뷰 리졸버는 컨트롤러가 반환한 뷰의 논리적인 이름을 실제 뷰 객체로 매핑하여 클라이언트에게 보여줄 뷰를 결정하게 되는 것이다.

Spring MVC

• Spring Framework에서 제공하는 웹 애플리케이션 개발을 위한 모듈
• Model-View-Controller(MVC) 아키텍처 패턴을 기반으로 한다
• 요청을 처리하는 컨트롤러(Controller), 데이터를 처리하는 모델(Model), 화면을 표현하는 뷰(View)로 구성
• 애노테이션 기반의 설정과 느슨한 결합을 통해 유연하고 효율적인 웹 애플리케이션 개발을 지원
• 요약하면, 서블릿은 자바 기반의 웹 애플리케이션 개발을 위한 기술이고, JSP는 서블릿을 기반으로 동적인 웹 페이지를 개발하기 위한 기술
• Spring MVC는 Spring Framework에서 제공하는 모듈로, 웹 애플리케이션 개발을 위한 MVC 패턴을 구현하는 방식
• Spring MVC는 서블릿과 JSP를 기반으로 하며, 개발자에게 편의성과 유연성을 제공하여 웹 애플리케이션 개발을 보다 쉽게 할 수 있도록 도와준다

참고 : 인프런 김영한 님 스프링 MVC 편

이전에 웹 브라우저의 세션을 이용해서 로그인과 회원가입을 구현하고 쿠키에 저장하는 방법을 통하여 로그인 회원가입을 처리해본 경험이 있다.
하지만 세션과 쿠키를 사용하는 것에는 단점들이 있다. 먼저 jwt는 STATELESS하므로 상태를 저장하지 않는 RESTful API에 적합하였고, 모바일 환경에서도 쉽게 사용할 수 있다는 장점이 있었다.

해당 내용을 바탕으로 JWT와 스프링 시큐리티를 사용하여 로그인, 회원가입, JWT 토큰을 이용한 나의 정보 확인 이렇게 3가지 기능을 동작하도록 만들었다.

먼저 3가지 기능에 해당하는 내가 만든 API endpoint는 다음과 같다.

1. /members/login
2. /members/signup
3. /members/check

이제 스프링 시큐리티와 JWT를 알아보면서 해당 기능들을 구현해보겠다.

스프링 시큐리티, 사용이유

원리 : 서블릿 필터를 이용한다.

Spring의 내부 원리는 사용자(client)가 api를 호출하면 servlet container(tomcat)가 받고, request 받은 것을 spring의 dispatcherservlet에게 요청하게 된다. 요청에 따라서 controller에게 전달하고 서블릿 컨테이너가 응답을 받아서 사용자에게 전달한다.

servlet container에서 spring dispatcher servlet까지 전달될때까지 개입을 할 수 있는데, 개입을 필터를 적용해서 할 수 있다. 즉, servlet 객체들이 dispatcher servlet에 도착하기 전에 필터체인을 통과한 뒤에 dispatcherservlet에 도착하게 되는 것이다.

따라서 필터에서는 DispatcherServlet의 빈에 직접적으로 접근할 수 없다. 그러나 Spring Security의 SecurityFilterChain을 사용하는 경우에는 DispatcherServlet의 빈에 접근할 수 있다.

Spring Security는 내부적으로 DispatcherServlet과 연동하여 보안 관련 작업을 처리하기 때문에, 필터 체인을 통과한 후에 DispatcherServlet의 빈에 접근할 수 있다. 스프링 시큐리티와 DispatcherServlet 간에는 위임이 필요하며, SecurityFilterChain을 통해 이러한 위임이 이루어진다.

(chain이라는 말은 여러 개의 연결고리라는 뜻인데, 필터를 여러 가지 등록하는 것을 chain을 따라 인증을 진행한다고 생각하면 된다.)

개발자가 spring security를 해서 구현하는 방법이 여러 가지이다. filter 자체를 이해해서 filter를 구현하는 방법이 있고, 필터에서 돌아가는 여러 가지 함수 메소드들을 오버라이딩해서 일부를 커스터마이징할 수도 있다. (나는 일부 흐름만 커스터마이징하였다.)

JWT

JWT는 JSON Web Token의 약자이다. 정보를 JSON 형태로 전송하는 토큰이라는 의미이다. JWT는 URL로 이용할 수 있는 문자열로만 구성되어 있고 서버와의 통신에서 사용된다.

JWT의 구조

• 헤더(Header) : 검증과 관련된 내용, 해싱 알고리즘과 토큰 타입 지정
• 내용(Payload) : 토큰에 담는 정보. 여기에 포함된 속성들은 클레임이라고 한다.
• 서명(Signature) : 인코딩된 헤더, 인코딩된 내용, 비밀키, 헤더의 알고리즘으로 서명이 생성됨.

https://jwt.io/#debugger-io
여기에 들어가면 JWT를 생성할 수 있고 디코딩된 정보도 볼 수 있다.

스프링 시큐리티와 JWT 적용하기

UsernamePasswordAuthenticationFilter를 통한 인증 과정

1. 클라이언트가 사용자의 아이디와 비밀번호를 포함한 인증 요청을 서버로 전송한다.
2. 요청을 받게 되면 서블릿 필터에서 SecurityFilterChain으로 작업이 위임된다. (DispatcherServlet의 bean에 접근하기 위해)
3. SecurityFilterChain 중에서 AuthenticationFilter에서 인증을 처리한다. 아무 설정하지 않았으면 AuthenticationFilter 중에서 UsernamePasswordAuthenticationFilter가 인증을 처리한다.
4. AuthenticationFilter는 요청받은 username이랑 password를 가지고 UsernamePasswordAuthenticationToken에서 토큰을 생성한다.
5. 그러면 만든 토큰을 AuthenticationManager에게 전달한다. AuthenticationManager는 인터페이스이고 이를 구현한 것은 ProvideManager이다.
6. ProvideManager는 인증을 해주어야 하기 때문에 AuthenticationProvider로 토큰을 전달한다. 해당 Provider에서 인증을 수행하고 성공하게 되면 ProvideManager로 권한을 담은 토큰을 전달한다.
7. AuthenticationProvider는 UserDetailsService에 토큰의 정보를 전달한다.
8. UserDetailsService는 전달받은 정보를 통해 데이터베이스에서 일치하는 사용자를 찾아서 UserDetails 객체를 생성한다
9. 생성된 UserDetails객체는 다시 AuthenticationProvider로 전달되고, Provider에서 인증이 성공하면 ProviderManager로 권한을 담은 토큰을 전달하게 된다.
10. 그럼 ProviderManager는 다시 검증된 토큰을 AuthenticationFilter로 전달한다.
11. AuthenticationFilter는 토큰을 SecurityContextHolder에 있는 SecurityContext에 저장한다.

UsernamePasswordAuthenticationFilter는 접근 권한을 확인하고 인증이 실패할 경우 화면을 보내는 역할을 한다.

이전에 SpringSecurity와의 변경점(feat. WebSecurityConfigureAdapter 상속받는 방법 없어짐)

스프링 공식문서에 나와있는 JWT 적용방식을 응용하여서 구현해보겠다. JWT 샘플코드는 아래의 것을 사용하였다.
https://github.com/spring-projects/spring-security-samples/tree/main/servlet/spring-boot/java/jwt/login

SecurityConfiguration 구현

일단 책이랑 정보를 찾아보았을 때 WebSecurityConfigureAdapter를 상속받아서 스프링 시큐리티를 설정한다고 하였으나 실제로 IntelliJ에서 해당 클래스가 deprecated되어서 현재는 위의 document를 응용해서 구현하였다. (Security 5.7부터 바뀌었다고 한다)
Spring Blog에도 해당 내용이 나와있다.
https://spring.io/blog/2022/02/21/spring-security-without-the-websecurityconfigureradapter
(기존에는 WebSecurityConfigurerAdapter를 상속받아 설정을 오버라이딩 하는 방식이었는데 바뀐 방식에서는 상속받아 오버라이딩하지 않고 모두 Bean으로 등록을 한다.)

document에서는 authorize.anyRequest().authentication()으로 되어있다. 그렇게 되면 로그인 하지 않으면, 권한이 없으므로 login 페이지로 계속 이동하기 때문에 일단 permitAll()을 해놓고 login 페이지가 잘 보이는 것을 확인하고 구현을 시작하였다. 공식문서의 SecurityConfig 페이지는 아래와 같고, 여기서 rule을 추가시키겠다.

@Configuration  
public class SecurityConfig {  
    @Bean  
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {  
    http  
        .authorizeHttpRequests((authorize) -> authorize  
        .anyRequest().permitAll()  
    )  
        .httpBasic(withDefaults())  
        .formLogin(withDefaults());  
    return http.build();  
    }  
}

Rule 추가하기

위의 코드에서는 anyRequest()가 되어 있어서 어떤 url이든 인증이 필요하다. anyRequest()를 mvcMatchers()(아니면 antMatchers사용)를 사용하고 안에 parameter로 url을 넣을수도 있고, 아니면 HTTPMethod중 GET이나 POST 같은 것들로 지정해줄 수도 있다. 로그인과 회원가입, swagger 문서들은 jwt 토큰이 있을 수가 없다. 그래서 해당 url은 인증의 범위에서 제외시켜주었다.

// SecurityConfig
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig {

    private final JwtTokenProvider jwtTokenProvider;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                .httpBasic().disable()
                .csrf().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                .antMatchers("/members/login").permitAll()
                .antMatchers("/members/signup").permitAll()
                .antMatchers("/members/check").permitAll()
                .antMatchers("/swagger-ui/index.html").permitAll()
                .anyRequest().authenticated()
                .and()
                    .addFilterBefore(new JwtAuthenticationFilter(jwtTokenProvider), UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }
}

• httpBasic().disable() : Spring Securtiy를 처음 의존성을 추가하면 BASE64를 이용하여 비밀번호가 나온다(https://jobdong7757.tistory.com/205 참고) 그걸 disable하는 내용이다. (사용안하고 jwt 사용할 거니까)
• csrf().disalbe() : 쿠키 기반이 아니라 jwt 기반이므로 사용하지 않는다
• `sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) : Spring Security 세션 정책 : 세션을 생성 및 사용하지 않는다.
• antMatchers({허용할 endpoint}) : 여기에는 인증이 필요없는 endpoint를 작성해서 permitAll() 해주면 된다.
• addFilterBefore(new JwtAuthenticationFilter(jwtTokenProvider), UsernamePasswordAuthenticationFilter.class) : JWT 인증 필터를 UsernamePasswordAuthenticationFilter.class 앞에 적용하겠다는 의미로 jwtTokenProvider를 이후에 작성할 예정이다.

PasswordEncoder

PasswordEncoder는 스프링 시큐리티에서 비밀번호를 안전하게 저장하고 검증하기 위해 사용되는 인터페이스이다. PasswordEncoder를 구현한 구체적인 클래스는 비밀번호를 해싱하고, 솔트(salt)를 적용한다.

PasswordEncoderFactories.createDelegatingPasswordEncoder()는 스프링 시큐리티에서 제공하는 PasswordEncoder의 구현체를 생성하는 메서드이다. 이 메서드는 현재 스프링 시큐리티의 기본 비밀번호 인코더를 생성하고 반환한다.

주로 사용자의 비밀번호를 저장하기 전에 해당 비밀번호를 해싱하여 안전하게 저장하고, 로그인 시 비밀번호를 검증하는 등의 작업에 PasswordEncoder를 사용할 수 있다.

jwt 토큰과 jwt 인증 필터를 어떻게 사용하면 될까

jwt 토큰을 어떻게 사용할지 정리해보겠다. (이메일을 아이디처럼 사용할 것이다. 회원의 데이터베이스에 id로 저장되는 것과 다른 것이다.)
먼저, 회원가입을 할 때는 이메일과 비밀번호만 받으면 된다. 해당 정보를 입력하였을 때, 나는 회원가입이 성공하면 id, 이메일, 생성시간 3가지를 전달받는다.

그리고 로그인을 할 때는 이메일, 비밀번호를 입력하면 된다. 그럼 나는 반환 값으로 이메일, grantType(여기서는 Bearer), accessToken, refreshToken같은 인증 토큰을 전달받으면 된다.

그럼 이후부터 api 요청을 할 때, accessToken을 header에 넣어서 보내야 api가 요청이 되게 한다. 그 의미는 인증된 사용자라는 뜻이기 때문이다.

accessToken과 refreshToken을 따로 두는 것은, accessToken이 탈취될 위험이 있기 때문에, accessToken의 기한을 짧게 두고 해당 기한이 만료되면 새로 발급받기 위해 기한이 긴 refresToken을 이용해서 새로 발급받으면 되기 때문이다.

그럼 하나하나 구현을 해보겠다.

Member Controller 구성

먼저 로그인이랑 회원가입을 할 수 있도록 controller를 구성한 다음, service를 구현할 생각을 하였다. (맨 처음에 적용할 endpoint 적용)

@RestController
@RequiredArgsConstructor
@RequestMapping("/members")
public class MemberController {
    private final MemberService memberService;

    @PostMapping("/login")
    @ResponseStatus(HttpStatus.ACCEPTED)
    public MemberLoginResponseDto login(@RequestBody MemberLoginRequestDto memberLoginRequestDto) {
        String email = memberLoginRequestDto.getEmail();
        String password = memberLoginRequestDto.getPassword();
        return memberService.login(email, password);
    }

    @PostMapping("/signup")
    @ResponseStatus(HttpStatus.CREATED)
    public MemberSignUpResponseDto signup(@Valid @RequestBody MemberSignUpRequestDto memberSignUpRequestDto) {
        String email = memberSignUpRequestDto.getEmail();
        String password = memberSignUpRequestDto.getPassword();
        return memberService.signup(email, password);
    }

    @GetMapping("/check")
    @ResponseStatus(HttpStatus.OK)
    public MemberSignUpResponseDto checkMember(HttpServletRequest request) {
        return memberService.checkMember(request);
    }

}

회원가입

회원가입을 먼저 구현해 보겠다. 위의 controller에서 memberService의 signup함수를 구현하면 된다.
일단 중복 이메일을 체크해야 하므로, 중복된 이메일을 처리해주었다. 그리고 아직은 role에 대한 것을 해야할 요구조건이 없으므로 Role은 USER로 저장해주었다. (그럼 모든 권한이 가능하게 아래에서 처리하게 하였다.)

// MemberService의 signup 함수
    @Transactional
    public MemberSignUpResponseDto signup(String email, String password) {
        // 중복된 이메일 체크
        if (memberRepository.findByEmail(email).isPresent()) {
            throw new RuntimeException("중복된 이메일이 존재합니다");
        }
        Member member = Member.builder()
                .email(email)
                .password(password)
                .createdAt(LocalDateTime.now())
                .updatedAt(LocalDateTime.now())
                .build();
        Member savedMember = memberRepository.save(member);
        MemberSignUpResponseDto responseDto = new MemberSignUpResponseDto(savedMember.getId(), savedMember.getEmail(), savedMember.getCreatedAt());
        return responseDto;
    }

먼저 중복된 이메일을 체크하고, Member 도메인의 builder 패턴으로 입력받은 이메일과 비밀번호로 만들어준다.

@Getter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Entity
public class Member extends BaseEntity {
    @Id @Column(updatable = false, unique = true, nullable = false, length = 250)
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 100)
    private String email;

    @Column(nullable = false, length = 250)
    private String password;

    @CreatedDate
    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
    LocalDateTime createdAt;

    @LastModifiedDate
    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
    LocalDateTime updatedAt;

    @Builder
    public Member(String email, String password, LocalDateTime createdAt, LocalDateTime updatedAt) {
        this.email = email;
        this.password = password;
        this.createdAt = createdAt;
        this.updatedAt = updatedAt;
    }
}

UserDetails
UserDetails 인터페이스는 스프링 시큐리티에서 사용자의 정보와 권한을 제공하기 위한 인터페이스이다. 사용자의 인증과 권한 부여를 처리하는 과정에서 스프링 시큐리티가 UserDetails 객체를 통해 사용자 정보를 관리하고 제공한다. (하지만, 현재로서는 권한을 부여할 필요는 없어서 해당 내용은 제외하였다.)

UserDetails 인터페이스는 다음과 같은 주요 메서드를 정의하고 있다.

1. getUsername(): 사용자의 고유한 식별자인 사용자 이름을 반환
2. getPassword(): 사용자의 비밀번호를 반환
3. getAuthorities(): 사용자의 권한 목록을 반환. 각 권한은 GrantedAuthority 인터페이스를 구현한 객체로 표현된다.
4. isAccountNonExpired(): 사용자 계정의 유효 기간이 만료되었는지 여부를 반환
5. isAccountNonLocked(): 사용자 계정이 잠겨있는지 여부를 반환
6. isCredentialsNonExpired(): 사용자의 인증 정보(비밀번호)의 유효 기간이 만료되었는지 여부를 반환
7. isEnabled(): 사용자 계정이 활성화되었는지 여부를 반환

UserDetails 인터페이스를 통해 애플리케이션에서 보안 관련 작업을 보다 쉽게 구현할 수 있다.

로그인 구현하기

로그인은 이메일과 비밀번호를 받으면 인증을 처리하고 jwt token을 만들어주어야 하기 때문에 처음 배우는 부분이 많았다. 하나하나 차례대로 보겠다.

MemberService에 있는 login함수

@Transactional  
public MemberLoginResponseDto login(String email, String password) {  
    // 1. Login ID/PW 를 기반으로 Authentication 객체 생성  
    // 이때 authentication 는 인증 여부를 확인하는 authenticated 값이 false
    UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(email, password);  

    // 2. 실제 검증 (사용자 비밀번호 체크)이 이루어지는 부분  
    // authenticate 매서드가 실행될 때 CustomUserDetailsService 에서 만든 loadUserByUsername 메서드가 실행  
    Authentication authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken);  

    // 3. 인증 정보를 기반으로 JWT 토큰 생성  
    TokenInfo tokenInfo = jwtTokenProvider.generateToken(authentication);  

    return new MemberLoginResponseDto(email, tokenInfo.getGrantType(), tokenInfo.getAccessToken(), tokenInfo.getRefreshToken());  
}

• UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(email, password) : UsernamePasswordAuthenticationToken 객체는 사용자의 인증 정보를 담고 있으며, 인증 매니저에게 전달하여 실제로 사용자를 인증하는 과정에서 사용된다.
• Authentication authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken); :
  AuthenticationFilter는 생성한 authenticationToken AuthenticationManager에게 전달한다. AuthenticationManager은 실제로 인증을 처리할 여러개의 AuthenticationProvider를 가지고 있다. 그럼 UserDetailService에서 해당 내용을 기반으로 조회를 한다.

UsernamePasswordAuthenticationToken 클래스
UsernamePasswordAuthenticationToken은 스프링 시큐리티에서 사용자의 인증을 처리할 때 사용되는 객체이다. 주로 사용자가 제출한 아이디(여기서는 email)와 비밀번호(password) 정보를 포함하여 인증 작업에 필요한 정보를 전달하는 데 사용된다.

UsernamePasswordAuthenticationToken은 인증 매커니즘에서 인증을 수행하는 과정에서 생성되고 사용된다. 일반적으로 사용자가 로그인 페이지에서 사용자 이름과 비밀번호를 입력하면, 스프링 시큐리티는 UsernamePasswordAuthenticationToken 객체를 생성하여 사용자가 제출한 인증 정보를 담아 인증 처리를 시작한다.

UsernamePasswordAuthenticationToken은 Authentication 인터페이스를 구현한 클래스로, 사용자의 인증 정보를 담고 있다. Authentication은 스프링 시큐리티에서 인증에 필요한 정보를 캡슐화하는 인터페이스이다.

UsernamePasswordAuthenticationToken은 주로 AuthenticationManager에 의해 처리되며, 인증 과정에서 제공된 사용자 이름과 비밀번호를 사용하여 사용자를 인증한다. 인증이 성공하면 Authentication 객체가 인증된 상태로 반환되고, 인증 실패시에는 예외가 발생할 수 있다.

CustomUserDetailsService

@Service
@RequiredArgsConstructor
public class CustomUserDetailsService implements UserDetailsService {

    private final MemberRepository memberRepository;
    private final PasswordEncoder passwordEncoder;

    @Override
    public UserDetails loadUserByUsername(String email) throws RuntimeException {
        return memberRepository.findByEmail(email)
                .map(this::createUserDetails)
                .orElseThrow(() -> new RuntimeException("해당하는 유저를 찾을 수 없습니다."));
    }

    // 해당하는 User 의 데이터가 존재한다면 UserDetails 객체로 만들어서 리턴
    private UserDetails createUserDetails(Member member) {
        return User.builder()
                .username(member.getEmail())
                .password(passwordEncoder.encode(member.getPassword()))
                .build();
    }
}

CustomUserDetailsService 클래스가 Authentication authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken); 에서 동작되는 원리

1. AuthenticationManager는 인증 요청에 필요한 사용자 정보를 DB에서 가져와야 한다. 이때 loadUserByUsername 메서드가 호출된다.
2. loadUserByUsername 메서드는 UserDetailsService 인터페이스를 구현한 CustomUserDetailsService에서 구현된다. 해당 메서드는 주어진 사용자 이름(username)을 기반으로 사용자 정보를 조회하고, UserDetails 객체를 반환한다.
3. AuthenticationManager는 loadUserByUsername 메서드를 통해 반환된 UserDetails 객체를 사용하여 인증 과정을 진행한다. 인증 과정에서는 사용자가 입력한 인증 정보와 UserDetails 객체에 저장된 정보를 비교하여 인증을 수행한다.
4. AuthenticationManager는 인증 결과인 Authentication 객체를 생성하여 반환한다. 이때 Authentication 객체는 인증된 사용자 정보와 권한 정보를 포함한다.

이제 DB에 사용자가 있다는 사실을 인증받은 것이므로 해당 내용을 바탕으로 jwtToken을 생성하는 jwtTokenprovider를 만들면 된다.

토큰 정보 클래스 만들기

클라이언트가 요청하면 서버는 jwt token을 클라이언트에게 response로 주어야 한다.
해당 정보를 클래스로 만들어보자.

@Builder  
@Data  
@AllArgsConstructor  
public class TokenInfo {  
    private String grantType;  // Bearer
    private String accessToken;  
    private String refreshToken;  
}

grantType
grant typedms 클라이언트가 어떤 유형의 인증 흐름을 사용하여 액세스 토큰을 요청하는지 나타낸다.
그 중에서 Bearer를 사용할 건데, Bearer 토큰은 서버에 상태를 저장하지 않고, 클라이언트가 요청을 보낼 때마다 토큰의 유효성을 검증한다. 그래서 이후에 HTTP 요청을 보낼때 헤더에 붙여서 보내면 인증된 사용자인지 검증할 수 있는 것이다.

JwtTokenProvider 클래스

JwtTokenProvider는 사용자 인증과 인가를 처리하는 데 사용되는 클래스이다. JWT (JSON Web Token)을 생성, 유효성 검사 및 해석하는 데 사용되고, 주로 Spring Security와 함께 사용되며, 사용자의 인증 정보를 JWT 토큰으로 인코딩하여 전달하고, 토큰의 유효성을 검사하여 사용자를 인증하고 권한을 부여한다. secret key를 사용해서 jwt token을 만들 것이다.

yml 파일에 secret key 추가

토큰을 암호화하고 복호화할 때 HS256 알고리즘을 사용하려면 secret key를 설정해주어야 한다. 해당 코드를 yml 파일에 적어주자. (아무거나 해당 길이만 맞으면 된다!)

jwt:  
    secret: VlwEyVBsYt9V7zq57TejMnVUyzblYcfPQye08f7MGVA9XkHa

JwtTokenProvider 클래스

// 토큰 생성  
@Slf4j
@Component
public class JwtTokenProvider {

    private final Key key;

    @Value("${jwt.secret}")
    String salt;

    private final long at_exp = 1000L * 60 * 30;
    private final long rt_exp = 1000L & 60 * 60;
    // secret key를 가지고 key값 저장
    public JwtTokenProvider(@Value("${jwt.secret}") String salt) {
        this.key = Keys.hmacShaKeyFor(salt.getBytes(StandardCharsets.UTF_8));
    }

    // 토큰 생성
    public TokenInfo generateToken(Member member) {
        // Access Token 생성
        Claims claims = Jwts.claims().setSubject(member.getEmail());
        claims.put("memberId", member.getId());

        long now = (new Date()).getTime();
        Date accessTokenExpiresIn = new Date(now + at_exp);
        String accessToken = Jwts.builder()
                .setClaims(claims)
                .setExpiration(accessTokenExpiresIn)
                .signWith(key, SignatureAlgorithm.HS256)
                .compact();

        // Refresh Token 생성
        String refreshToken = Jwts.builder()
                .setExpiration(new Date(now + rt_exp))
                .signWith(key, SignatureAlgorithm.HS256)
                .compact();

        return TokenInfo.builder()
                .grantType("Bearer")
                .accessToken(accessToken)
                .refreshToken(refreshToken)
                .build();
    }

    // JWT 토큰을 복호화하여 토큰에 들어있는 정보를 꺼내는 메서드
    public Authentication getAuthentication(String accessToken) {
        // 토큰 복호화
        Claims claims = parseClaims(accessToken);

        // UserDetails 객체를 만들어서 Authentication 리턴
        UserDetails principal = new User(claims.getSubject(), "", Collections.emptyList());
        return new UsernamePasswordAuthenticationToken(principal, "", Collections.emptyList());
    }

    // 토큰 정보를 검증하는 메서드
    public boolean validateToken(String token) {
        try {
            Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
            return true;
        } catch (RuntimeException e) {
            throw e;
        }

    }

    private Claims parseClaims(String accessToken) {
        try {
            return Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(accessToken).getBody();
        } catch (RuntimeException e) {
            throw e;
        }
    }

    // Bearer 제외부분
    public String getToken(String token) {
        token = token.substring(7).trim();
        return token;
    }

    public String getEmail(String token) {
        return Jwts.parserBuilder().setSigningKey(salt.getBytes()).build().parseClaimsJws(token).getBody().getSubject();
    }

    public String resolveToken(HttpServletRequest request) {
        return request.getHeader("Authorization");
    }
}

1. authentication.getAuthorities()를 통해 사용자의 권한 정보를 가져온다. 권한은 GrantedAuthority 객체로 표현되며, getAuthority()를 사용하여 권한 이름을 추출한다. 여러 권한이 있을 경우 쉼표로 구분하여 문자열로 합친다.
2. 현재 시간을 기준으로 액세스 토큰의 만료 시간을 계산한다. new Date(now + ac_exp)를 통해 현재 시간으로부터 30분 후의 시간을 나타내는 accessTokenExpiresIn을 생성한다.
3. Jwts.builder()를 사용하여 JWT 빌더를 생성한다. setSubject(authentication.getName())로 JWT의 subject(주체)를 사용자명으로 설정한다. 권한은 필요없으므로 empty로 둔다.
4. setExpiration(accessTokenExpiresIn)으로 액세스 토큰의 만료 시간을 설정한다. signWith(key, SignatureAlgorithm.HS256)로 시크릿 키와 알고리즘을 사용하여 토큰을 서명한다. compact()를 호출하여 토큰을 문자열로 변환한다.
5. refreshToken을 생성한다. 액세스 토큰과 동일한 방식으로 빌더를 생성하고, 만료 시간을 현재 시간으로부터 24시간 후로 설정한다.
6. TokenInfo 객체를 생성하고, grantType을 "Bearer"로 설정하고, 생성된 액세스 토큰과 리프레시 토큰을 할당한다.

이 코드는 사용자의 인증 정보를 JWT 토큰으로 변환하여 반환하는 메서드로, 액세스 토큰과 리프레시 토큰을 생성하여 TokenInfo 객체로 래핑하여 반환한다.

JwtAuthenticationFilter

JWT 인증을 하기 위해 사용되는 필터로 JwtAuthenticationFilter를 통과하고 UsernamePasswordAuthenticationFilter를 진행하게 된다.
해당 과정은 토큰이 유효한지 검사하고 토큰 정보를 추출하는 함수이다.

@RequiredArgsConstructor
public class JwtAuthenticationFilter extends GenericFilterBean {

    private final JwtTokenProvider jwtTokenProvider;

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 1. Request Header 에서 JWT 토큰 추출
        String token = resolveToken((HttpServletRequest) request);

        // 2. validateToken 으로 토큰 유효성 검사
        if (token != null && jwtTokenProvider.validateToken(token)) {
            // 토큰이 유효할 경우 토큰에서 Authentication 객체를 가지고 와서 SecurityContext 에 저장
            Authentication authentication = jwtTokenProvider.getAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        chain.doFilter(request, response);
    }

    // Request Header 에서 토큰 정보 추출
    private String resolveToken(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

먼저 아래와 같은 내용으로 spring project를 하나 만들어주었다.

해당 애플리케이션을 실행하면 콘솔창에 아래와 같은 내용이 나온다. 해당 정보를 복사하여, id에는 user를 입력하고 로그인할 수 있다.

처음 애플리케이션이 실행되면 Spring Security는 Bean 중에서 type이 SecurityFilterChain인 것을 찾는다.

SecurityFilterChain을 한번 살펴보겠다.

SecurityFilterChain은 springframework.security.web의 것이고, 이것은 인터페이스이므로 스프링 bean 선언으로 이동하자.

interface 옆에 아이콘을 클릭하면 이동할 수 있다.

defaultSecurityFilterChain이라고 되어 있다. 매개변수로는 HTTPSecurity를 받고 여기서는 http.authorizeRequests()로 모든 Request는 인증되어야한다고 되어있다. 그래서 위의 화면처럼 우리는 로그인 화면에서 비밀번호를 입력해야 다른 화면으로 넘어갈 수 있는 것이다. formLogin은 Spring Security에서 기본적으로 제공해주는 로그인 화면이다. (아까 본 화면)

스프링으로 모든 endpoint를 자동으로 보호하기 때문에 우리가 Endpoint에 직접 접근이 불가능했던 이유이다.

(HttpBasic은 formlogin이 작동하지 않을 경우를 위해서 만든 라인이다.)

이후에 jwt 토큰을 사용하여 로그인하는 글을 포스팅해보겠다.

보안 용어

인증(authentication)

인증(authentication)은 사용자가 누구인지 확인하는 단계이고 보통 로그인을 의미한다.
사용자는 아이디와 패스워드를 입력하면 로그인은 데이터베이스에 등록되어있는지 일치 여부를 확인하고, 서버는 응답으로 사용자에게 토큰(token)을 전달한다.

인가(authorization)

인가(authorization)은 사용자가 애플리케이션 내부의 리소스에 접근할 때 사용자가 해당 리소스에 접근할 권리가 있는지를 확인하는 과정을 의미한다. 로그인한 사용자가 게시판에 접근해서 글을 보려고 하는 경우 게시판 접근 등급을 확인해서 접근을 허가하거나 거부하는 것이 인가이다.
인증 단계에서 발급받은 토큰이 인가 내용을 포함하고 있으며, 사용자가 리소스에 접근하면서 토큰을 함께 전달하는 식으로 진행하여 서버는 토큰을 통해 권한 유무 등을 확인해서 인가를 수행한다.

접근 주체(principal)

접근 주체는 애플리케이션 기능을 사용하는 주체를 의미한다. 인증과 인과 과정을 거쳐서 접근 주체에게 부여된 권한을 확인하는 과정을 거친다.

스프링 시큐리티 (Spring Security)

스프링 시큐리티도 일종의 보안 프레임워크이기 때문에 공부가 필요했다.

동작 구조

스프링 시큐리티는 서블릿 필터(Servlet Filter)를 기반으로 동작하며, 스프링이 가지는 서블릿 컨테이너인 DispatcherServlet 앞에, 필터가 배치되어 있다.

필터체인이라는 것이 Dispatcher Servlet 앞에 존재해서 클라이언트가 request를 보내면 먼저 맞닥뜨리게 된다.

필터체인

필터 체인(Filter Chain)은 웹 애플리케이션에서 요청을 처리하는 과정에서 여러 개의 필터가 순차적으로 실행되는 구조를 말한다. 필터 체인은 클라이언트로부터의 요청이 서블릿에 도달하기 전과 응답이 클라이언트에게 전달되기 전에 요청과 응답을 가공하거나 검증하는 역할을 수행한다.

필터 체인 동작 순서

클라이언트로부터의 요청이 서블릿 컨테이너에 도달하면, 요청은 필터 체인의 시작 지점인 필터 체인의 진입점으로 전달되어서 필터 체인의 첫 번째 필터부터 순차적으로 실행된다. 마지막 필터가 실행되고 나면 요청이 서블릿에 도착해서 실제 작업을 수행하고 응답도 똑같이 필터 체인의 뒤에서부터 전달된다.

스프링 시큐리티의 사용 이유

ApplicationFilterChain은 서블릿 컨테이너에서 기본적으로 제공되는 필터 체인의 구현이다. 물론, Spring Security를 사용하지 않고도 ApplicationFilterChain을 통해 보안과 관련된 인증과 인가를 처리할 수 있다. 

 보안과 관련된 인증과 인가 작업은 일반적으로 서블릿 필터를 사용하여 처리할 수 있다. 예를 들어, 사용자의 인증 정보를 확인하고 세션 관리를 수행하는 필터를 구현하여 인증 작업을 처리할 수 있다. 또한, 요청에 따라 특정 리소스에 대한 접근 권한을 확인하는 필터를 구현하여 인가 작업을 처리할 수도 있다.

ApplicationFilterChain은 필터 체인 내에서 필터들을 연결하여 원하는 순서로 실행할 수 있기 때문에, 보안 관련 필터들을 적절히 구성하면 보안 요구사항을 처리할 수 있지만 직접 필터를 구현하고 관리해야 한다는 점에서 Spring Security와 비교하면 개발 및 유지보수의 복잡성이 높아질 수 있기 때문에 Spring Security를 사용하게 된다. (프레임워크의 장점!)

Spring Security는 보안에 특화된 기능과 설정을 제공하여 보다 쉽고 강력한 보안 솔루션을 제공한다. Spring Security를 사용하면 인증, 인가, 세션 관리, CSRF 방어, XSS 방어 등의 보안 기능을 편리하게 구현하고 관리할 수 있다.

그래서 스프링 프레임워크에서 필터 체인을 활용하여 다양한 기능을 구현할 수 있으며, Spring Security의 SecurityFilterChain은 그 중 하나의 예이다.

두 FilterChain은 서로 다른 목적을 가지고 있다. ApplicationFilterChain은 서블릿 컨테이너에서 일반적인 필터 체인을 관리하고 실행하는 역할을 수행하며, SpringFilterChain은 Spring Security에서 보안 관련 필터 체인을 관리하고 실행하는 역할을 수행하게 된다.

스프링 시큐리티 동작

클라이언트가 애플리케이션에 request를 보내면 서블릿 컨테이너가 필터와 서블릿을 매칭해버린다. 스프링 시큐리티는 사용하고자 하는 필터체인을 서블릿 컨테이너의 필터 사이에서 동작시키기 위해 DelegatingFilterProxy를 사용한다.

DelegatingFilterProxy는 서블릿 컨테이너의 생명주기와 스프링 애플리케이션 컨텍스트 사이에서 다리 역할을 수행하는 필터 구현체이다. 표준 서블릿 필터를 구현하고 있으며, 역할을 위임할 필터체인 프록시를 내부에 가지고 있다. 필터체인 프록시는 스프링부트의 자동 설정에 의해 자동 생성된다.

DelegatingFilterProxy

DelegatingFilterProxy는 Spring Framework에서 제공하는 필터의 대리자(Delegate) 역할을 수행하는 클래스이다.

일반적으로 서블릿 필터(Filter)는 서블릿 컨테이너에서 직접 관리된다. 근데, Spring Framework에서는 DelegatingFilterProxy를 사용하여 필터의 관리를 Spring의 ApplicationContext로 위임할 수 있다.
(위임의 이유는 스프링의 의존성 주입할 수 있고, 스프링의 여러 기능을 사용할 수 있기 때문이다)

DelegatingFilterProxy를 사용하면 이후에 클라이언트의 요청이 들어오면 DelegatingFilterProxy가 요청을 가로채서 등록된 필터 빈(Bean)을 찾아서 실행한다.

즉, DelegatingFilterProxy는 서블릿 필터의 대리자 역할을 수행하여 Spring ApplicationContext 내에서 등록된 필터 빈을 실행시키는 역할을 한다. 이를 통해 Spring의 의존성 주입(Dependency Injection)이 가능하며, 필터가 Spring 관리 빈으로 선언되어 다른 Spring 구성 요소와 함께 사용될 수 있게 되는 것이다. 

DelegatingFilterProxy는 Spring Security 필터 체인을 연결하는 데 사용된다. Spring Security에서는 보안 필터 체인을 구성하고, DelegatingFilterProxy를 통해 이를 등록하여 필터 체인을 관리하는 것이다.

필터체인 프록시는 스프링 시큐리티에서 제공하는 필터로서 보안 필터체인(SecurityFilterChain)을 통해 많은 보안 필터(Security Filter)를 사용할 수 있다. 필터체인 프록시에서 사용할 수 있는 보안 필터체인은 List 형식으로 담을 수 있게 설정되어있어서 URI 패턴에 따라 특정 보안필터 체인을 선택해서 사용하게 된다.

보안 필터체인에서 사용하는 필터는 여러가지가 있고, 필터마다 실행되는 순서가 다르다.
보안 필터체인은 WebSecurityConfigurerAdapter 클래스를 상속받아서 설정할 수 있다. 필터체인 프록시는 여러 보안 필터체인을 가질 수 있고, 여러 개의 보안 필터체인을 만들기 위해서는 WebSecurityConfigurerAdapter 클래스를 상속받는 클래스를 여러 개 생성하면 된다.

스프링 시큐리티에서는 디폴트로는 SecurityFilterChain에서 사용하는 필터 중 UsernamePasswordAuthenticationFilter를 통해 인증을 처리한다.

SecurityFilterChain
SecurityFilterChain은 보안 필터의 체인이다. Spring Security는 필터 기반 아키텍처를 사용하여 요청에 대한 인증 및 인가 작업을 처리한다. SecurityFilterChain은 다양한 필터를 포함하고 있으며, 각 필터는 특정한 보안 작업을 수행한다.

예를 들어, UsernamePasswordAuthenticationFilter는 사용자 이름/암호 인증을 처리하고, AccessDecisionManager는 권한 검사를 수행한다.

이제 개념적인 부분을 공부해보았으니 직접 구현을 하면서 로그인, 회원가입에 적용해봐야겠다. 

일전에 EC2를 사용해서 Spring Boot 프로젝트를 배포해본 적이 있었다.

이번에 참여하게된 JSCODE 게시판 서비스를 고도화해나가는 프로젝트에서 멘토님이 Elastic BeanStalk를 사용하여 배포하라는 요구사항을 주어서, Elastic BeanStalk를 처음 사용해보았다.

EC2를 통해서 배포하였을 때는 운영체제가 설치되어 있는(linux) 컴퓨터 하나를 터미널로 다루는 느낌이었다. java 설치부터 docker나 필요한 기술을 설치하고 jar파일을 scp나 프로그램을 통해 EC2 서버로 가져와서 실행하면 잘 되었다.

Elastic BeanStalk를 처음 써봐서 그런지 더 쉽게 사용하는 Heroku같은 느낌의 서비스라고 하는데 실제로는 고생을 좀 겪었다. (EC2도 돌이켜보면 훨씬 더 많이 겪었던 것 같긴하다.. )

다시 볼 때는 이것만 보면 되게 정리해보겠다.(제발)

업로드 한 뒤에 생기는 문제들

502 Bad Gateway 문제

1. 첫번째 해결방법

이 문제는 애플리케이션 로드 밸런서가 기본적으로 EC2 인스턴스에서 nginx 서버의 port 80을 가리키기 때문에 발생한다. nginx는 기본적으로 포트 5000으로 요청을 전달하도록 구성되어 있지만, 애플리케이션 서버는 포트 8080에서 실행된다.

• 이 문제는 PORT라는 이름의 환경 속성을 사용하여 해결할 수 있으며 8080 구성 > 환경 속성으로 이동하여 속성을 추가한다

https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/java-se-nginx.html

[Configuring the reverse proxy - AWS Elastic Beanstalk

The port that your application listens on doesn't affect the port that the nginx server listens to receive requests from the load balancer.

docs.aws.amazon.com](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/java-se-nginx.html)

• 이렇게 하던가, 아니면 application.yml에서 port를 5000번으로 열리도록 하면 된다. 아래 내용만 yml에 추가해주면 된다.이렇게 해서 해결되면 성공이다.
• server: port: 5000

5000번으로 port를 열었는데, local에서 실행이 안되는 경우!*
5000번으로 열고 확인할려고 local에서 실행했는데, 안되는 경우가 있을 것이다. port가 이미 사용중이라고 뜨는 경우였는데, kill -9 명령어로 계속 죽여도 다시 살아난다(ㄷㄷ)
나의 경우에는 mac에서 5000포트를 airplay를 사용하는 경우 때문에 생겼었다. 설정에 들어가서 해당 airplay를 꺼두면 local에서 실행이 된다.
물론, 배포할때는 아무 문제 없기 때문에 local에서 5000번 포트로 돌릴때만 문제가 된다.
https://jaynamm.tistory.com/entry/%EB%A7%A5%EB%B6%81%EC%97%90%EC%84%9C-5000%EB%B2%88-%ED%8F%AC%ED%8A%B8%EA%B0%80-%EC%82%AC%EC%9A%A9%EC%A4%91%EC%9D%B4%EB%8B%A4-MacOS-Montrey

이렇게 해도 계속 오류인 경우 -> log를 살펴보자

나는 이렇게 해서 업로드가 되었지만 warning이 계속 뜨는 오류가 발생하였다.

해당 오류를 확인하기 위해서 log를 확인하였다.

No Active Profile Set

: 실제 502 Gateway의 오류가 나왔을 때, 로그에서 확인한 오류이다. Spring은 잘 실행되는데, Spring에서 오류가 생겼다.

그럼 서버는 제대로 실행하려고 하는데 서비스의 오류일 가능성이 높다. 서비스에서 오류가 생길만한 건 데이터베이스 서버밖에 없었다. (나머지는 local에서 잘 실행되므로..)

나의 경우는 데이터베이스 연결의 문제였다. 이때는 하나하나씩 차례대로 진행하여서 로컬에서 먼저 데이터베이스의 엔드포인트를 통해서 접속이 되는지 확인해야 한다.

데이터베이스 보안 그룹 열어주기!

AWS EC2(Elastic BeanStalk도 결국 EC2 생성해주는 것이다!)에서 보안 그룹 규칙을 통해서 EC2 인스턴스로 들어오고 나가는 트래픽을 세부적으로 제어할 수 있도록 해준다. 예를 들어 80번 포트는 모든 사람들이 접근할 수 있도록 열어주고 SSH 통해 접속하는 22번은 나만 접근하도록 허용할 수도 있다.
VPC
VPC는 하나의 네트워크 그룹이다.

인바운드 규칙
인바운드란 외부에서 인스턴스로 들어오는 요청을 의미한다. 유형을 선택하면 프로토콜과 포트가 자동으로 선택이 된다.

아웃바운드 규칙
아웃바운드는 인스턴스에서 외부로 나가는 트래픽인데, 디폴트 값이 모두 허용이기 때문에 건들지 않았다.

데이터베이스 설정을 위해서는 인바운드 규칙을 수정했어야 한다. MySQL 서버가 접속 되도록 해야하기 때문이다.
인바운드 규칙 편집에 들어가서 유형 중 MYSQL/AURORA를 선택하면 프로토콜과 포트가 TCP, 3306으로 자동 설정된다.
그리고 소스 유형을 AnyWhere IPv4를 선택하여 규칙을 저장한다. 그럼 데이터베이스 보안 그룹 설정이 완료된다.

어떤게 데이터베이스 endpoint?

여기서 문제가 어떤게 해당 Elastic BeanStalk랑 연결된 데이터베이스인지가 의문이였다. 먼저 처음 Elastic BeanStalk 환경 구성을 설정해줄때 데이터베이스를 추가했을 것이다.

해당 페이지의 환경에 들어가면 아래와 같은 화면이 있다. 해당 내용이 존재하면 RDS 창에 들어가면 데이터베이스가 생성되어 있다는 의미이다. 거기서 endpoint를 찾아야 한다! RDS를 AWS 검색창에 검색해서 들어가자.

그럼 아래와 같은 창 중에서 elastic bean stalk에서 만든 이름과 유사한 DB 식별자가 있다!(인스턴스 확인하면서 맞는지 체크한다)

해당 DB식별자 안으로 들어가면 엔드포인트가 나와있다. 해당 엔드포인트를 통해서 로컬에서 돌아가는지 먼저 확인해보았다.

나는 MySQL을 사용하기 때문에, workbench에서 확인하였다. +버튼을 클릭하여 접속한다.

그리고 Connection Name은 그냥 앱 이름, Hostname은 엔드 포인트를 입력하면 되고, password는 우리가 Elastic BeanStalk에 설정한 비밀번호를 입력해주면 된다!

그래서 잘 연결된다면, DB설정이 잘된 것이다. 해당 DB 엔드포인트를 yml파일에 설정해주고 jar로 배포해주면 된다!

(만약 안된다면, DB가 연결이 안된 것이므로 Elastic BeanStalk에 들어가 DB를 다시 확인해주어야 한다.)

이제 위에서 뜬 No Active Profile Set 오류는 뜨지 않았다. database가 없다는 오류가 떠서, 그냥 해당 workbench에서 board라는 db를 만들어주었다!

(해결)
일단 보안그룹 설정에 대해서 확실히 몰랐던 것이 컸던 것 같다. 인바운드 규칙과 아웃바운드 설정을 먼저 살펴봐야한다.
또, ElasticBeanStalk는 새로운 서비스라기 보다는 EC2에서 하던 것 그대로인데 더 편리하게 설정해 주는 거라고 생각하면 될 것 같다.
똑같이 EC2 인스턴스가 생기고 RDS가 생기므로, 결국 EC2에 대한 설정과 동일하다.
Elastic BeanStalk는 단일 서비스일때는 유용하게 사용할 수 있을 것 같다.

EC2와 Elastic BeanStalk의 차이

1. 관리 수준:
   • EC2: Amazon EC2는 InfraStructure 서비스로, 가상 서버를 프로비저닝(운영체제 선택, 네트워크, 보안 등등의 설정)하고 관리해야 한다. 서버의 운영 체제 선택, 네트워크 구성, 보안 설정, 스케일링 등을 직접 관리해야 한다.
   • Elastic Beanstalk: Elastic Beanstalk은 관리형 플랫폼 서비스로, 애플리케이션 배포와 관리를 단순화한다. 코드를 업로드하면 Elastic Beanstalk이 인프라와 런타임 환경을 자동으로 프로비저닝하고 애플리케이션을 배포한다. 서버 인스턴스, 로드 밸런서, 스케일링 등의 관리 작업은 Elastic Beanstalk이 자동으로 처리한다.
2. 배포 방식:
   • EC2: EC2는 단일 가상 서버 또는 가상 서버 그룹으로 애플리케이션을 배포한다. 서버 인스턴스를 직접 프로비저닝하고 로드 밸런서를 구성하여 트래픽을 분산시켜야 한다.
   • Elastic Beanstalk: Elastic Beanstalk은 애플리케이션을 여러 개의 EC2 인스턴스로 배포한다. Elastic Beanstalk이 자동으로 로드 밸런싱, 자동 스케일링, 로깅 및 모니터링을 처리하므로 개발자는 배포에 집중할 수 있다.
3. 확장성:
   • EC2: EC2는 가상 서버 인스턴스를 수동으로 확장하거나 축소해야 한다. 서버 수준에서 수평 스케일링이 이루어지며, 필요한 만큼의 가상 서버를 추가하거나 제거하여 처리량을 조정할 수 있다.
   • Elastic Beanstalk: Elastic Beanstalk은 애플리케이션 수준에서 자동으로 확장된다. 트래픽이 증가하면 Elastic Beanstalk이 필요한 수의 EC2 인스턴스를 자동으로 생성하고 관리한다. 이로 인해 애플리케이션의 확장성이 향상된다.

Elastic BeanStalk를 사용했을 때 편리했던 점은 업로드 할 때 따로 프로그램을 사용하거나 리눅스 명령어 필요없이 jar 파일을 바로 업로드하면 된다는 점이다. 또, EC2가 바로 생기고 데이터베이스가 바로 연결된다.(물론 보안 그룹 설정을 못해서 한참 고생하였다)

아래는 멘토님께서 알려주신 방법이다. 하나하나 차례대로 확인해보면 좋을 것 같다. (덕분에 너무 잘 해결할 수 있었던 것 같다)

Elastic Beanstalk가 제대로 실행되지 않아서 디버깅을 해야 할 때 / Elastic Beanstalk 디버깅 방법

1. 이벤트 확인하기

2. 로그 확인하기

3. EC2에 직접 들어가서 서버 실행시켜보기

여기서 아래에 연결 부분을 복사하여 접속하면 된다.

$ sudo su # root 권한으로 변경하기
$ cd /var/app/current # EB를 통해 업로드한 파일이 있는 디렉토리이다.

해당 위치에서 직접 명령어를 하나하나 쳐보면서 잘 작동하는지 디버깅 해보고, 여기서 디버깅 해봄으로써 에러 코드를 바로바로 직접 확인할 수 있어서 어디에 버그가 존재하는지 쉽게 찾을 수 있다.