[AWS] Spring Boot 배포

📢 해당 프로젝트는 AWS의 EC2, RDS, LoadBalancer, Route53, S3와 Docker, Github action을 사용해 배포한 경험을 공유합니다. 

 

 

Nginx(웹서버)가 필요한 이유는?

웹서버가 없다면 DB에서 데이터를 처리해야하는 동적 요청은 물론 정적 요청까지 WAS 서버에서 처리해야 한다.

NGINX는 정적 요청을 처리함으로써 WAS 서버의 부담을 줄여준다. 추가적으로 요청을 어느 서버로 보낼지 결정하는 로드밸런서 의 역할과 캐시서버의 역할, 민감 정보를 숨겨주는 역할, SSL 인증 처리까지 할 수 있다.

 

Load Balancer가 필요한 이유는?

로드밸런서는 요청을 여러 서버로 분산시켜 서버의 과부하를 막는다.

추가적으로 ALB의 경우 Auto scaling과 SSL 인증 처리를 할 수 있다. 

 

Nginx와 Load Balancer가 둘다 필요할까?

ALB(Application Load Balancer)와 Nginx는 WAS 서버 전의 요청을 처리해주 점, 로드밸런싱과 SSL 인증 처리를 할 수 있는 점에서 비슷하다. 

나는 이번 프로젝트에서 사용한 서버가 1대이기 때문에 로드밸런싱이 필요하지 않았고, 도메인을 연결하고 SSL 인증을 처리하는 과정에서 Nginx와 ALB 중 어떤 것을 사용해야하는지, 꼭 둘다 사용할 필요가 있는지 고민했다.

 

결론만 말하자면, Nginx로 SSL 인증을 처리하려면 EC2에서 SSL 인증서를 생성하고 이를 주기적으로 갱신하는 작업이 필요했다. 반면에,  AWS Certificate Manager에서 SSL 인증서를 발급받고 이를 ALB에 부착하면 갱신하는 작업이 필요 없었다. 따라서, 나는 후자의 방법을 선택했다. 

 

후자 아키텍처 플로우

 

ALB에서 80 포트를 통해 들어오는 HTTP 요청과 443 포트를 통해 들어오는 HTTPS 요청을 받아들이도록 리스너를 설정한다. HTTPS 요청이 들어오면, ALB를 통해 대상그룹(EC2 서버의 묶음)으로 전송한다. (HTTPS를 리스너로 등록하기 위해서는 SSL 인증서가 필요->부착해두었음) HTTP 요청은 443 포트로 리다이렉트시켜 HTTPS 요청으로 자동 변경한다. 

 

NGINX의 경우 SSL 인증을 처리하지 않기에 80 포트를 통해서만 요청이 들어온다.

들어온 요청을 톰캣 서버의 포트인 8080으로 연결한다. 

 

여기서 HTTPS 통신이 이뤄지는 초록색 부분 외에는 SSL 인증이 처리되지 않기에 보안상의 문제가 발생할 수 있다.

따라서, ALB와 서버가 동일한 데이터센터 내에 있게 하거나 private VPC로 연결하면, 안전하게 통신할 수 있다.

 

S3 presigned URL을 사용한 이유는?

 

일반적으로 S3를 사용하는 서비스의 경우 위와 같은 방식으로 파일을 업로드/다운로드해왔다.

하지만, 큰파일을 서버에 보내게 된다면 1) 서버의 리소스 사용량 증가 2) HTTP에서 큰파일을 여러번의 작은 요청으로 분할하여 전송함으로써 전송 속도 감소 등 성능에 악영향을 미친다.

 

이를 해결하기 위해 S3에서 제공하는 Presigned Url을 사용함으로써 아래와 같이 파일을 직접적으로 서버에 올리는 것을 막았다. 

Presigned Url이란 S3 버킷의 소유자가 미리 파일 업로드/다운로드 권한에 대해 서명을 해준뒤 사용자에게 해당 Url을 제공하는 기능이다. 이로써 클라이언트가 서버를 거치지 않고 파일을 저장소에 직접 업로드/다운로드 할 수 있어 서버의 자원을 절약할 수 있다.

 

cf. 이번 글에는 카카오 토큰 ID 기반으로 유저마다 폴더를 생성한 후, 그 폴더에 이미지를 업로드하는 과정이 추가되어 있다.

---

실제 구축 경험을 통해 살펴보자.

 

RDS 설정

mySQL과 RDS 연동

퍼블릭액세스를 허용한 RDS 생성

mysql workbanch에서 Hostname에 RDS endpoint를, port에 mysql 포트(3306)를 삽입

(현재 IPv4 하나만을 무료로 사용가능하므로, RDS나 로드밸런서 사용시 추가 IPv4비용이 발생, EC2를 이용해 RDS 외부연결(RDS 연결시 EC2 컴퓨팅 리소스에 연결 선택 후 퍼블릭 엑세스 비허용)을 사용하면 비용 감소 가능) 

 

 

폴더 구조

 

 

deploy.yml ( github action이 돌리는 파일 ) 설정

Github action = 서버에 접속해 docker를 실행 + main에 푸쉬된 커밋을 복사 = CI/CD

deploy.yml 파일이 실행되면서, ec2에 docker 이미지를 pull하여 자동 배포 

name: Java CI with Gradle

on:
  push:
    branches: [ "main" ]

permissions:
  contents: read

jobs:
  build:
    runs-on: ubuntu-latest # ec2 ubuntu로 만듦
    steps:
      - name: checkout
        uses: actions/checkout@v3

      - name: Set up JDK 17
        uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
          java-version: '17'


      ## create application.yml
      - name: make application.yml
        run: |
          
          cd ./src/main/resources
          touch ./application.yml
          
          echo "${{ secrets.APPLICATION }}" >> ./application.yml # application.yml 전체 -> 공백처리 해둘것, 깃이그노어에 올리지 말것
        shell: bash


      ## gradle build
      - name: Build with Gradle
        run: |
          chmod +x ./gradlew
          ./gradlew clean build -x test


      ## 이미지 빌드 및 도커허브에 push
      - name: web docker build and push
        run: |
          docker login -u ${{ secrets.DOCKER_USERNAME }} -p ${{ secrets.DOCKER_PASSWORD }} # 도커 허브 아이디, 비밀번호
          docker build -t ${{ secrets.DOCKER_REPO }}/docker-web . # 도커 허브 레포 이름
          docker push ${{ secrets.DOCKER_REPO }}/docker-web 
          docker build -f ./config/nginx/Dockerfile -t ${{ secrets.DOCKER_REPO }}/docker-nginx .
          docker push ${{ secrets.DOCKER_REPO }}/docker-nginx

      - name: Create Remote Directory
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.HOST }}
          username: ubuntu
          key: ${{ secrets.KEY }}
          script: mkdir -p ~/srv/ubuntu # ec2상에 경로 설정

      - name: copy source via ssh key
        uses: burnett01/rsync-deployments@4.1
        with:
          switches: -avzr --delete
          remote_path: ~/srv/ubuntu
          remote_host: ${{ secrets.HOST }} # ec2 DNS 주소
          remote_user: ubuntu
          remote_key: ${{ secrets.KEY }} # pem 키

      ## 이미지 pull 및 docker compose up
      - name: executing remote ssh commands using password
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.HOST }}
          username: ubuntu
          key: ${{ secrets.KEY }}
          script: |
            sh ~/srv/ubuntu/config/scripts/deploy.sh
            cd /home/ubuntu/srv/ubuntu/
            sudo chmod 666 /var/run/docker.sock
            sudo docker rm -f $(sudo docker ps -qa)
            sudo docker pull ${{ secrets.DOCKER_REPO }}/docker-web
            sudo docker pull ${{ secrets.DOCKER_REPO }}/docker-nginx
            docker-compose up -d  # docker-compose.yml 실행
            docker image prune -f

 

APPLICATION 파일에는 application.yml파일의 내용을, HOST 파일에는 EC2 ip 주소를, KEY 파일에는 .pem키를 삽입

 

 

Jetbrain 환경변수 설정 

${} 안의 내용은 채워 넣을 것 

로컬에서 작업한 application.yml에서 중 아래 내용을 그대로 깃허브에 노출시키면 해킹위협이 있으므로,

jetbrains 기준 run > edit configuraiton > enviroment variable을 통해 ${}처리하는 걸 권장

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://${RDS_ENDPOINT}:3306/${RDS_DATABASE}?serverTimezone=Asia/Seoul
    username: admin
    password: ${RDS_PASSWORD}
  security:
    oauth2:
      client:
        registration:
          kakao:
            client-id: ${KAKAO_CLIENT_ID}
            client-name: Kakao
            redirect-uri: http://localhost:8080/login/oauth2/code/kakao
            scope: profile_nickname, profile_image, account_email
            authorization-grant-type: authorization_code
            client-authentication-method: POST
        provider:
          kakao:
            authorization_uri: https://kauth.kakao.com/oauth/authorize
            token_uri: https://kauth.kakao.com/oauth/token
            user-info-uri: https://kapi.kakao.com/v2/user/me
            user_name_attribute: id
  jpa:
    hibernate:
      ddl-auto: update
    properties:
      generate-ddl: true
      format_sql: true
      use_sql_comments: true
  session:
    store-type: jdbc
    jdbc.initialize-schema: always
  jwt:
    secretKey: ${SECRET_KEY}
    blacklist:
      access-token: BlackList_AccessToken_
  mvc:
    pathmatch:
      matching-strategy: ant_path_matcher
  redis:
    host: 127.0.0.1
    port: 6379

springdoc:
  version: 0.0.1
  default-consumes-media-type: application/json # media-type 디폴트값 설정
  default-produces-media-type: application/json
  swagger-ui:
    path: /swagger-ui.html

app:
  deployment:
    url: ${request_URL}
    processor:
      url: ${redirect_URL}


cloud:
  aws:
    credentials:
      access-key: ${S3_ACCESS_KEY}
      secret-key: ${S3_SECRET_KEY}
      s3:
        bucket: ${S3_BUCKET}
      region:
        static: ap-northeast-2
      stack:
        auto: false

 

 

NGINX 파일 설정

nginx > nginx.conf

nginx에서 80번 포트로 들어온 요청을 Spring 서버의 8080번 포트로 연결

server {

  listen 80;
  client_max_body_size 0;

  location / {
    proxy_pass http://web:8080;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_redirect off;
  }

}

 

nginx > scripts

#!/bin/bash

# Installing docker engine if not exists
if ! type docker > /dev/null
then
  echo "docker does not exist"
  echo "Start installing docker"
  sudo apt-get update
  sudo apt install -y apt-transport-https ca-certificates curl software-properties-common
  curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
  sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
  sudo apt update
  apt-cache policy docker-ce
  sudo apt install -y docker-ce
fi

# Installing docker-compose if not exists
if ! type docker-compose > /dev/null
then
  echo "docker-compose does not exist"
  echo "Start installing docker-compose"
  sudo curl -L "https://github.com/docker/compose/releases/download/1.27.3/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
  sudo chmod +x /usr/local/bin/docker-compose
fi

 

 

Docker 파일 설정

nginx > Dockerfile

FROM nginx
COPY ./config/nginx/nginx.conf /etc/nginx/conf.d/default.conf

 

docker-compose.yml 

web 이미지와 nginx 이미지 생성 후 어떻게 공유할지 설정

nginx에서 80번 포트로 들어온 요청을 Spring(web) 서버의 8080번 포트로 연결

version: '3'
services:

  web:
    container_name: web
    image: ${{ secrets.DOCKER_REPO }}/docker-web
    expose:
      - "8080"
    ports:
      - "8080:8080"
    environment:
      - TZ=Asia/Seoul

  nginx:
    container_name: nginx
    image: ${{ secrets.DOCKER_REPO }}/docker-nginx
    ports:
      - "80:80"
    depends_on:
      - web
    environment:
      - TZ=Asia/Seoul

 

Dockerfile

FROM openjdk:17
EXPOSE 80
ARG JAR_FILE=/build/libs/docker-0.0.1-SNAPSHOT.jar # 아래 사진에서 bootjar 실행하여 경로 가져오기
COPY ${JAR_FILE} app.jar # app.jar로 복사
ENTRYPOINT ["java","-jar","/app.jar"]

 

 

이제 프로젝트를 main 브랜치에 push 하면, deploy.yml 파일이 돌아가며 자동 배포 (CI/CD) 

 

 

Docker hub에 이미지 Push

도커허브에 아래처럼 이미지가 push된 상태를 확인했다면,

 

AWS EC2 연결에서 실행 중인 도커 및 경로 확인

docker pull ${{ secrets.DOCKER_REPO }}/docker-web

docker pull ${{ secrets.DOCKER_REPO }}/docker-nginx

docker ps 

web이 안뜨거나 바로 종료된다면,

docker ps -a

를 통해 

 

docker logs {container ID}

로 error 확인 -> error를 고친 후 재배포 

 

 

도메인 연결

1. 가비아에서 도메인 구입 (morak.shop)

2. AWS certification manager에서 SSL 인증서 받기

3. Route53 호스팅 영역 생성 

4. Route53 CNAME 레코드 생성 

5. 가비아에 네임서버 AWS로 바꾸기 

6. 로드밸런서 대상그룹 만들기 

7. 로드밸런서 생성하여 아까 만든 대상 그룹과 인증서 추가 

8. HTTP를 HTTPS로 리다이렉트 설정

9. ' '(빈칸) 생성 후 로드밸런서를 Route53의 라우팅대상으로 등록

 

 

Swagger로 인터넷에서 명세서 확인

https://morak.shop/swagger-ui/ 에서 명세서 확인 가능

헤더에 JWT토큰 넣은 후, API 테스트 진행

 

 

 

---

+ 추가

S3와의 연동

1. 버킷 생성: 엑세스 차단 설정을 해제

2. 사용자 생성: AWS console > IAM > 엑세스 관리 > 사용자 > 사용자 추가 클릭 > 직접 정책연결 > AmozonS3FullAccess 를 선택 > 사용자 생성을 클릭
(S3에 접근하기 위해서는 IAM 사용자에게 S3 접근 권한을 주고, 엑세스 키를 만들어 액세스 키, 비밀 엑세스 키로 접근)

3. 엑세스 키 생성: AWS Console > IAM > 엑세스 관리자 > 사용자 > 생성한 사용자 이름 클릭 > 보안 자격 증명 > 엑세스 키 만들기 클릭 -> 엑세스 키 생성 완료 화면에서 생성된 공개키와 비밀키를 확인

4. 스프링 연동하기

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.services.s3.AmazonS3Client;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;



@Configuration
public class S3Config {
	@Value("${cloud.aws.credentials.access-key}")
	private String accessKey;
	@Value("${cloud.aws.credentials.secret-key}")
	private String secretKey;
	@Value("${cloud.aws.region.static}")
	private String region;

	@Bean
	public AmazonS3Client amazonS3Client() {
		BasicAWSCredentials awsCredentials= new BasicAWSCredentials(accessKey, secretKey);
		return (AmazonS3Client)AmazonS3ClientBuilder.standard()
			.withRegion(region)
			.withCredentials(new AWSStaticCredentialsProvider(awsCredentials))
			.build();
	}
}

 

applicaiton.yml 파일에 아래 설정 추가

cloud:
  aws:
    credentials:
      access-key:
      secret-key:
    s3:
      bucket: moraktest
    region:
      static: ap-northeast-2
    stack:
      auto: false

 

 

파일업로드 API 생성

프론트에서 이미지를 헤더와 함께 업로드하면 헤더에서 카카오ID 추출

S3에서 해당 카카오ID 명으로 폴더를 만들고 이미지를 저장

이미지 PresignedURL을 발급받아 RDS에 저장한 후, 프론트로 PresignedURL 전달

   @Operation(summary = "작업물 이미지 등록")
    @PostMapping("/upload")
    public ResponseEntity<List<String>> uploadFiles(HttpServletRequest httpRequest,
                                                    @RequestParam("files") List<MultipartFile> files) {
        try {
            List<String> preSignedUrls = new ArrayList<>();
            User user = jwtTokenProvider.getUserInfoByToken(httpRequest);
            Portfolio portfolio = portfolioRepository.findPortfolioByUser(user);

            for (MultipartFile file : files) {
                // 파일이 없으면 스킵
                if (file == null) {
                    continue;
                }

                String fileName = file.getOriginalFilename();

                // S3 Presigned URL 및 objectKey 생성
                Map<String, Serializable> presignedUrlInfo = s3service.getPreSignedUrl(httpRequest, fileName);
                String preSignedUrl = removeQueryString(presignedUrlInfo.get("preSignedUrl").toString());
                String objectKey = presignedUrlInfo.get("objectKey").toString();

                ObjectMetadata metadata = new ObjectMetadata();
                metadata.setContentType(file.getContentType());
                metadata.setContentLength(file.getSize());

                // S3에 파일 업로드
                s3service.uploadFileToS3(objectKey, file, metadata);
                preSignedUrls.add(preSignedUrl);
            }

            // 업로드된 파일의 개수만큼 Presigned URL을 사용하여 포트폴리오에 이미지 URL을 저장
            switch (preSignedUrls.size()) {
                case 4:
                    portfolio.uploadImageUrls(preSignedUrls.get(0), preSignedUrls.get(1), preSignedUrls.get(2), preSignedUrls.get(3));
                    break;
                case 3:
                    portfolio.uploadImageUrls(preSignedUrls.get(0), preSignedUrls.get(1), preSignedUrls.get(2), null);
                    break;
                case 2:
                    portfolio.uploadImageUrls(preSignedUrls.get(0), preSignedUrls.get(1), null, null);
                    break;
                case 1:
                    portfolio.uploadImageUrls(preSignedUrls.get(0), null, null, null);
                    break;
                default:
                    break;
            }

            portfolioRepository.save(portfolio);
            return ResponseEntity.ok(preSignedUrls);
        } catch (IOException e) {
            e.printStackTrace();
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

 

Presigned Url 발급

 

카카오 ID 폴더에 이미지가 저장되는 것을 확인