코딩몽키졸업

docker를 이용한 mysql Replication 서버 구축

헝그리개발자 — Tue, 28 Mar 2023 18:08:03 +0900

DB Replication이란?

DB 서버를 복제하는 기술이다.

일반적인 애플리케이션은 읽기 작업 비중이 쓰기 작업 보다 월등히 많다.

DB Replication을 사용하면 쓰기 전용 소스 서버를 하나 두고 읽기 전용 레플리카 서버를 여러대 두어서 서버의 부하를 줄일 수 있다.

보통 쓰기 전용 DB 서버를 master 서버라고 부르고 읽기 전용 서버를 slave 서버라고 부른다.

Replication Flow

출처: https://jongmin92.github.io/2019/11/13/Database/mysql-replication/

Master 서버에서 변경 사항을 Binary Log에 기록한다.
Slave 서버에 변경이 발생함을 통지한다.
Slave 서버는 I/O Thread를 이용해서 Binary Log를 읽는다.
변경 사항을 Relay Log에 기록한다.
SQL Thread를 이용해서 변경 사항을 반영한다.

Master Config 파일 설정

mysql 서버를 실행하기 전에 설정파일이 필요하다.

.cnf 파일은 MySQL 서버가 실행될 때 읽는 설정 파일이다.

default path는 /etc/my.cnf이다.

각각의 경로에 .cnf 확장자로 설정 파일을 생성해주자

# ~/Docker/mysql/master/config_file.cnf

[mysqld]
log-bin=mysql-bin
server-id = 1
binlog_cache_size = 5M
max_binlog_size = 512M
expire_logs_days = 30

mysql은 쓰기 작업시 /var/lib/mysql/ 경로에 바이너리 로그 파일을 남긴다.

log-bin : 바이너리 로그 파일명

server-id : Replication Group에서 서버를 식별하기 위한 id 값

binlog_cache_size : 바이너리 로그를 메모리에 버퍼링했다가 디스크로 기록된다. 해당 버퍼링용 메모리의 크기를 지정

max_binlog_size : 바이너리 로그 파일 최대 크기

expire_logs_days : 바이너리 로그를 보관할 날짜

Slave Config 파일 설정

Slave 서버는 Master 서버의 바이너리 로그를 읽어서 변경 내역을 Relay log에 기록하고 재실행하여 Master 서버와 동기화한다.

# ~/Docker/mysql/slave/config_file.cnf

[mysqld]
server-id = 2
relay_log = relay_log
relay_log_purge = TRUE
read_only

relay_log : CHANGE MASTER 명령을 실행하면 레플리카 서버는 기본 경로에 relay log를 생성한다. 이때 path를 지정하는 옵션

relay_log_purge : TRUE나 1로 설정하면 필요하지 않은 오래된 릴레이 로그를 자동으로 삭제한다.

read_only : 읽기 전용으로 설정하는 변수

Docker란?

도커는 프로그램을 컨테이너라는 독립된 환경으로 실행하고 관리할 수 있는 오픈소스 기술이다.

도커를 사용하면 쉽게 master/slave mysql container를 관리할 수 있다.

도커 버전 확인

$ docker -V

도커 MySQL 이미지 다운로드

$ docker pull mysql

$ docker pull mysql:8.0.22

도커 MySQL 이미지 컨테이너 생성 및 실행

아래의 명령어로 master/slave 컨테이너를 실행해준다.

docker run --name mysql-master -v ~/Docker/mysql/master:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD={password} -d mysql:latest

docker run --name mysql-slave -v ~/Docker/mysql/slave:/etc/mysql/conf.d --link mysql-master -e MYSQL_ROOT_PASSWORD={password} -d mysql:latest

—name : 컨테이너명

-e : 환경 변수 수정

-d : detached 모드로 실행, 백그라운드 모드로 실행

-p : 포트포워딩 {hostPort}:{containerPort}

-v : {Volume명}:{container 내부 mount될 경로}

—link : container끼리 ip 주소가 아닌 host명으로 접근하기 위해서 사용, slave 서버는 master 서버와 container간 통신을 하기 위해 사용

실행중인 container 확인

master, slave 두 컨테이너가 띄워지면 성공

> docker ps
CONTAINER ID   IMAGE                 COMMAND                   CREATED          STATUS          PORTS                               NAMES
6f4d80001a14   mysql:latest          "docker-entrypoint.s…"   34 minutes ago   Up 34 minutes   3306/tcp, 33060/tcp                 mysql-slave
ea5e5a9dd5cb   mysql:latest          "docker-entrypoint.s…"   34 minutes ago   Up 34 minutes   3306/tcp, 33060/tcp                 mysql-master

master 서버 접속

docker exec -it mysql-master bash

mysql -u root -p
Enter password:

mysql>

master 서버 상태 확인

아래는 바이너리 로그를 확인하는 명령어이다.

현재 mysql-bin.000003 라는 이름의 바이너리 로그에 기록하고 있으며 현재까지 기록된 위치는 2179라는 것을 의미한다.

Position은 실제 바이트 수를 의미한다.

mysql> show master status;
+------------------+----------+--------------+------------------+-------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+------------------+----------+--------------+------------------+-------------------+
| mysql-bin.000003 |     2179 |              |                  |                   |
+------------------+----------+--------------+------------------+-------------------+

Replication용 유저 생성

slave 서버가 master 서버로부터 바이너리 로그를 읽어오기 위해선 해당 권한을 가진 유저를 생성해야한다.

mysql> CREATE USER 'replication_user'@'%' IDENTIFIED WITH mysql_native_password BY 'replication_pass';

mysql> GRANT REPLICATION SLAVE ON *.* TO 'replication_user'@'%';

IDENTIFIED WITH mysql_native_password BY :

유저 인증 방식을 mysql_native_password로 지정한다. mysql 8 버전 default 유저 인증 방식은 caching_sha2_password인데 패스워드를 sha2 방식으로 암호화하지 않으면 에러가 발생한다.

REPLICATION SLAVE : Replication용 유저는 해당 권한을 가져야 한다.

mysql> use mysql;

mysql> select user, host, plugin from user;
+------------------+-----------+-----------------------+
| user             | host      | plugin                |
+------------------+-----------+-----------------------+
| replication_user | %         | mysql_native_password |
| root             | %         | caching_sha2_password |
| mysql.infoschema | localhost | caching_sha2_password |
| mysql.session    | localhost | caching_sha2_password |
| mysql.sys        | localhost | caching_sha2_password |
| root             | localhost | caching_sha2_password |
+------------------+-----------+-----------------------+

Sample 데이터 입력

CREATE DATABASE practice;

CREATE TABLE IF NOT EXISTS `practice`.`replication`
(
    `id`          bigint(20) NOT NULL AUTO_INCREMENT,
    `name`     varchar(255) DEFAULT NULL,
    PRIMARY KEY (`id`)
) ENGINE = InnoDB;

USE practice;

INSERT INTO replication(name) VALUES('sixhustle');

Master 서버 백업

Master 서버의 현재까지 변경사항을 백업하고 이를 .sql 파일로 dump한다.

bash-4.4# mysqldump -u root -p --opt --single-transaction --hex-blob --master-data=2 --routines --triggers --all-databases > master-dump.sql;
Enter password:

-u : 계정명

-p : 패스워드

—opt : 사람들이 가장 많이 사용하는 옵션을 모아 놓은 것

—single-transaction : innodb 엔진을 사용할 경우 lock 없이 일관된 데이터 덤프를 받으려면 추가해줘야함

--hex-blob : BINARY, VARBINARY, BLOB, BIT 컬럼에 대해서 값을 명시할 때 hexadecimal 형태로 기술하게 함

--master-data : dump 파일 안에 어느 바이너리 로그 위치까지 사용할 것인지 CHANGE MASTER 절로 자동으로 작성해준다. 2는 주석형태로 작성한다는 의미

—routines : stored routines 정보를 모두 포함시킨다.

—triggers : triggers 정보를 모두 포함시킨다.

—all-databases : 데이터베이스 전부를 dump

덤프 파일을 host 서버에 copy 한다.

docker cp mysql-master:/master-dump.sql .

Master & Slave 서버 동기화

카피된 덤프 파일을 slave container로 copy한다.

docker cp master-dump.sql mysql-slave:/.

slave 컨테이너 shell 창에 접속한 뒤, 덤프파일을 import하여 DB 변경 내용을 동기화한다.

bash-4.4# mysql -u root -p < master-dump.sql
Enter password:

Replication 설정

dump 파일을 생성할 때 --master-data 옵션으로 생성된 CHANGE MASTER 절을 복사한다.(주석으로 되어있다)

vi master-dump.sql

-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin.000003', MASTER_LOG_POS=2179;

Slave 서버에 접속한 뒤, 복사한 CHANGE MASTER 절을 실행한다.

mysql> CHANGE MASTER TO 
MASTER_HOST='mysql-master',
MASTER_USER='replication_user',
MASTER_PASSWORD='replication_pass',
MASTER_LOG_FILE='mysql-bin.000003',
MASTER_LOG_POS=2179;

slave thread를 시작한다.

mysql> START SLAVE;

slave 상태를 출력하여 정상적으로 연동되었는지 확인한다.

Last_Errno, Last_Error, Last_IO_Errno, Last_IO_Error 가 비어있다면 정상 연동된 것이다.

mysql> SHOW SLAVE STATUS\\G;
*************************** 1. row ***************************
               Slave_IO_State: Waiting for source to send event
                  Master_Host: mysql-master
                  Master_User: replication_user
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: mysql-bin.000003
          Read_Master_Log_Pos: 2179
               Relay_Log_File: relay_log.000002
                Relay_Log_Pos: 636
        Relay_Master_Log_File: mysql-bin.000003
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes
              Replicate_Do_DB:
          Replicate_Ignore_DB:
           Replicate_Do_Table:
       Replicate_Ignore_Table:
      Replicate_Wild_Do_Table:
  Replicate_Wild_Ignore_Table:
                   Last_Errno: 0
                   Last_Error:
                 Skip_Counter: 0
          Exec_Master_Log_Pos: 2179
              Relay_Log_Space: 840
              Until_Condition: None
               Until_Log_File:
                Until_Log_Pos: 0
           Master_SSL_Allowed: No
           Master_SSL_CA_File:
           Master_SSL_CA_Path:
              Master_SSL_Cert:
            Master_SSL_Cipher:
               Master_SSL_Key:
        Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
                Last_IO_Errno: 0
                Last_IO_Error:
               Last_SQL_Errno: 0
               Last_SQL_Error:
  Replicate_Ignore_Server_Ids:
             Master_Server_Id: 1
                  Master_UUID: a0e6d99b-cd31-11ed-b4a4-0242ac110003
             Master_Info_File: mysql.slave_master_info
                    SQL_Delay: 0
          SQL_Remaining_Delay: NULL
      Slave_SQL_Running_State: Replica has read all relay log; waiting for more updates
           Master_Retry_Count: 86400
                  Master_Bind:
      Last_IO_Error_Timestamp:
     Last_SQL_Error_Timestamp:
               Master_SSL_Crl:
           Master_SSL_Crlpath:
           Retrieved_Gtid_Set:
            Executed_Gtid_Set:
                Auto_Position: 0
         Replicate_Rewrite_DB:
                 Channel_Name:
           Master_TLS_Version:
       Master_public_key_path:
        Get_master_public_key: 0
            Network_Namespace:

정리

이번 포스팅에선 Docker를 이용해서 MySQL Replication 서버를 구축해보았다.

다음 포스팅에선 애플리케이션단에서 DB Replication을 설정하는 방법에 대해서 다뤄보겠다.

Reference

https://poiemaweb.com/docker-mysql

https://jupiny.com/2017/11/07/docker-mysql-replicaiton/

https://velog.io/@sixhustle/mysql-replication

Selenium 라이브러리로 웹 크롤러 제작하기

헝그리개발자 — Tue, 14 Mar 2023 15:38:20 +0900

이번 포스팅에선 Selenium 라이브러리를 이용해서 웹 크롤러를 제작한 과정을 공유해보려고 한다.

Selenium이란?

서버에서 브라우저의 환경을 구현할 수 있는 오픈소스 라이브러리이다.

주로 브라우저 기반 End Test에 사용되지만 크롤링 같은 다양한 목적을 위해 사용할 수 있다.

Selenium을 사용한 이유?

크롤러를 개발할 때 처음에는 jsoup 라이브러리를 사용했다.

하지만 jsoup는 치명적인 단점이 있다.

jsoup 라이브러리는 uri 접속시 최초 로딩되는 페이지만 읽어 들일 수 있다.

요즘의 웹 페이지는 SPA 방식으로 최초에 index 페이지를 로딩하고나서 유저의 동적인 action에 의해 동적으로 페이지를 랜더링하는 방식을 사용한다.

HTML, CSS, JavaScript를 사용하는 기본적인 PWA 페이지도 최초 웹 페이지 로딩 시간을 줄이기 위해 root 페이지를 경량화하고 유저의 action에 의해 추가적으로 페이지를 동적으로 로딩하는 방식을 채택하고 있다.

따라서 jsoup는 적합하지 않고 서버에서 브라우저 환경을 똑같이 구현할 수 있는 Selenium 라이브러리를 사용했다.

WebDriver

Selenium의 핵심 코어가되는 인터페이스이다.

Chrome/Chromium, Firefox, Internet Explorer, Edge, Safari 같은 다양한 공급사의 브라우저를 사용할 수 있다.

WebDriver를 통해 실제 사용자가 브라우저를 조작하는 것처럼 브라우저를 제어할 수 있다.

텍스트를 입력하거나, 링크를 클릭하고, 마우스를 이동하는 등의 action을 제공한다.

Wait

대부분의 웹 페이지는 동적으로 생성되기 때문에 완전히 로드되기까지 일정 시간이 필요하다.

Selenium은 대기 기능을 지원하고 일정 대기 시간동안 element를 찾지 못하면 WebDriverException을 발생시킨다.

다음의 세 가지 wait를 지원한다.

implicit wait
explicit wait
fluent wait

1. Implicit Wait(비추천)

암시적 대기는 모든 findElement() 함수에 대해서 최대 대기 시간을 지정하는 방법이다.

코드의 중복을 줄일 수 있다는 장점이 있지만 개인적으로 추천하지 않는다.

예시)

driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

Implicit Wait을 추천하지 않는 이유
Implicit Wait은 브라우저의 페이지를 자주 변경해야할 때 findElement()가 동작하기 전에 페이지가 변경되어버리는 경우가 생기기 때문에 StaleElementReferenceException 가 자주 발생하게 된다.
따라서 필자의 경우 Explicit Wait을 사용하여 element가 완전히 로드될 때까지 기다리고 element를 읽은 뒤에 페이지가 정상적으로 이동되도록 구현했다.

2. Explicit Wait(추천)

명시적 대기는 특정 element에 대해서만 최대 대기 시간을 지정하는 방법이다. Selenium에서 지원하는 조건들은 아래의 공식 문서에서 찾을 수 있다.

https://www.selenium.dev/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html

ExpectedConditions

An expectation for checking whether the given frame is available to switch to. If the frame is available it switches the given driver to the specified web element.

www.selenium.dev

예시)

new WebDriverWait(driver, Duration.ofSeconds(3)).until(ExpectedConditions.elementToBeClickable(By.xpath("//a/h3")));

Explicit wait 와 Implicit wait 를 혼용해서 사용하면 안되는 이유
두가지 유형을 동시에 사용하면 충돌이 발생할 수 있다.
예를 들어 요소를 클릭할 수 있을 때까지 기다리는 명시적 대기와 암시적 대기가 동시에 사용된다면, 요소가 실제 클릭할 수 있게 되기 전에 암시적 대기에 의해 스크립트를 계속 실행할 수도 있다.

3. Fluent wait

유연한 대기는 Explicit Wait의 확장된 방법이다.

기존의 Explicit Wait 기능을 지원하고 추가적으로 polling 빈도 수를 지정할 수 있다.

Implicit Wait와 Explicit Wait의 default polling period는 500ms이다.

polling은 리얼 타임 웹을 구현하기 위해 서버와 클라이언트간에 송수신 주기를 조절하는 방식을 의미한다.

polling 주기가 짧을수록 서버 부하가 커지고 실시간성이 높아진다.

Selenium에서 말하는 polling은 조건을 만족하는 element를 찾는 일종의 동기화하는 행위를 의미한다.

pollingEvery() 함수는 polling 빈도수를 조절하는 함수이고 ignoring() 함수는 polling 중 무시할 exception을 정의할 때 사용한다.

Wait wait = new FluentWait(WebDriver reference)
.withTimeout(Duration.ofSeconds(SECONDS))
.pollingEvery(Duration.ofSeconds(SECONDS))
.ignoring(Exception.class);

thread.sleep()를 사용을 지양해야 하는 이유
Selenium의 wait을 사용하지 말고 그냥 java에서 지원하는 thread.sleep() 함수를 사용하면 되지 않냐고 생각할 수 있을 것이다.
하지만 wait을 사용하면 thread.sleep()을 사용할 때보다 더 적은 대기 시간으로 로직을 구현할 수 있다.
2초만에 로딩되는 element를 찾기 위해 thread.sleep()를 이용해서 5초 동안 대기한다고 가정해보자.
결과적으로 그 차이인 3초만큼 실행 시간이 늘어나게 된다.
Selenium의 wait은 최대 대기 시간 전에 조건에 해당하는 element를 찾으면 그 즉시 대기를 종료하기 때문에 더 효율적이다.

Selenium 사용하기

의존성 추가
드라이버 설치

1. 의존성 추가

build.gradle 파일에 다음 행을 추가해주자

implementation 'org.seleniumhq.selenium:selenium-java:4.8.1'

2. 드라이버 설치

WebDriver를 사용하기 위해선 사용할 브라우저에 해당하는 드라이버를 설치해야한다.

Chrome을 사용할 경우 아래의 사이트에 접속해서 Driver를 다운로드 받는다.

https://chromedriver.chromium.org/downloads

ChromeDriver - WebDriver for Chrome - Downloads

Current Releases If you are using Chrome version 111, please download ChromeDriver 111.0.5563.64 If you are using Chrome version 110, please download ChromeDriver 110.0.5481.77 If you are using Chrome version 109, please download ChromeDriver 109.0.5414.74

chromedriver.chromium.org

설치된 zip 파일의 압축을 풀고 /usr/local/bin 경로로 드라이버를 복붙한다.

> cp chromedriver /usr/local/bin

이후 자바단에서 설치된 드라이버 경로를 명시해주면 된다.

System.setProperty("webdriver.chrome.driver", "/usr/local/bin/chromedriver");

WebDriver driver = new ChromeDriver();  // success!!

예제 코드

예제 코드는 '네이버'와 '카카오' 두 회사에서 채용 공고 데이터를 크롤링하는 과정을 다뤄보았다.

CrawlerController

크롤러가 최초로 호출되는 클래스이다.

Collection Injection을 통해 JobCrawler 인터페이스를 구현하는 모든 구현체들을 DI하도록 했다.

Task Scheduler를 사용하여 일정한 시간마다 동작하도록 구현했다.

@RestController
public class CrawlerController {

    private final List<JobCrawler> jobCrawlers;

    public CrawlerController(List<JobCrawler> jobCrawlers) {
        this.jobCrawlers = jobCrawlers;
    }

    @Scheduled(cron = "0 0 0 1/1 * ? *")
    public void crawling() {
        for (JobCrawler jobCrawler : jobCrawlers) {
            jobCrawler.crawling();
        }
    }
}

cron expression은 cron trigger를 설정할 때 사용하는 표현식으로 아래의 포스팅을 참고하면 쉽게 이해할 수 있다.

https://sjparkk-dev1og.tistory.com/32

Spring - Scheduler 설정 방법 및 사용방법

Spring - Scheduler 설정 방법 및 사용방법 일정 시간마다 실행해줘야하는 기능이 있어서 찾아보니 스프링에서 제공해주는 스프링 스케줄러를 이용하기로 했다. 스프링 스케줄러는 일정한 시간간격

sjparkk-dev1og.tistory.com

TaskSchedulerConfig

애플리케이션에서 @Scheduled 어노테이션을 사용하기 위해선 @EnableScheduling 어노테이션을 추가해줘야한다.

@EnableScheduling
public class TaskSchedulerConfig {

}

JobCrawler

crawling 추상 메서드를 포함하는 인터페이스이다.

public interface JobCrawler {

    void crawling();
}

NaverRecruitCrawler

네이버 채용 홈페이지를 크롤링하는 클래스이다.

JobCrawler 인터페이스를 구현한다.

crawling 메서드를 오버라이딩하는데 다음의 과정을 수행한다.

Chrome Web Driver 실행
상세 공고 링크 리스트에 담기
- 네이버 채용 홈페이지는 무한 스크롤 페이지이기 때문에 전체 데이터가 랜더링될 때까지 scroll down하는 action을 실행한다.
- 네이버 채용홈페이지는 공고마다 annoId를 부여한다.
- 메인 페이지의 모든 annoId를 찾아서 리스트에 담는다.
상세 공고 페이지 리스트를 순회하여 Recruit 타입 오브젝트로 파싱
- 상세 공고 페이지 url : https://recruit.navercorp.com/rcrt/view.do?annoId={annoId}
DB에 저장
- upsert 하여 중복되어 데이터가 저장되는 것을 방지한다

HTML 파싱 중에 예외가 발생하면 InvalidUrlException, ElementParseException 같은 커스텀 예외가 발생하고 인터셉터가 이를 가로채서 예외 처리 작업을 수행한다.

@Component
@Slf4j
public class NaverRecruitCrawler implements JobCrawler {

    private final RecruitMapper recruitMapper;
    private static final String NAVER_URL = "<https://recruit.navercorp.com/rcrt/list.do?subJobCdArr=1010001%2C1010002%2C1010003%2C1010004%2C1010005%2C1010006%2C1010007%2C1010008%2C1010020%2C1020001%2C1030001%2C1030002%2C1040001%2C1050001%2C1050002%2C1060001&sysCompanyCdArr=&empTypeCdArr=&entTypeCdArr=&workAreaCdArr=&sw=&subJobCdData=1010001&subJobCdData=1010002&subJobCdData=1010003&subJobCdData=1010004&subJobCdData=1010005&subJobCdData=1010006&subJobCdData=1010007&subJobCdData=1010008&subJobCdData=1010020&subJobCdData=1020001&subJobCdData=1030001&subJobCdData=1030002&subJobCdData=1040001&subJobCdData=1050001&subJobCdData=1050002&subJobCdData=1060001>";
    private static final String NAVER_DETAIL_URL = "<https://recruit.navercorp.com/rcrt/view.do?annoId=>";
    private static final long SCROLL_PAUSE_TIME = 3000L;

    public NaverRecruitCrawler(RecruitMapper recruitMapper) {
        this.recruitMapper = recruitMapper;
    }

    @Override
    @Transactional
    public void crawling() {
        log.info("================== Naver Recruits Crawling Start ===================");

        WebDriver driver = runWebDriver();

        List recruitDetailLinks = getRecruitDetailLinks(driver);

        List crawledRecruits = parseLinkToRecruit(driver, recruitDetailLinks);

        for (Recruit crawledRecruit : crawledRecruits) {
            recruitMapper.upsertRecruits(crawledRecruit);
        }

        driver.quit();

        log.info("================== Naver Recruits Crawling End =====================");
    }

    private WebDriver runWebDriver() {
        // WebDriver 경로 설정
        System.setProperty("webdriver.chrome.driver", "/usr/local/bin/chromedriver");

        // WebDriver option
        ChromeOptions options = new ChromeOptions();
        options.addArguments("--start-maximized");          // 최대크기로
        options.addArguments("--headless");                 // Browser를 띄우지 않음
        options.addArguments("--disable-gpu");              // GPU를 사용하지 않음, Linux에서 headless를 사용하는 경우 필요함.
        options.addArguments("--no-sandbox");               // Sandbox 프로세스를 사용하지 않음, Linux에서 headless를 사용하는 경우 필요함.
        options.addArguments("--disable-popup-blocking");    // 팝업 무시
        options.addArguments("--disable-default-apps");     // 기본앱 사용안함

        return new ChromeDriver(options);
    }

    private List getRecruitDetailLinks(WebDriver webDriver) {
        List result = new ArrayList<>();

        WebDriverWait wait = new WebDriverWait(webDriver, 10);

        JavascriptExecutor javascriptExecutor = (JavascriptExecutor) webDriver;

        try {
            webDriver.get(NAVER_URL);

            Long beforeHeight = (Long) javascriptExecutor.executeScript(
                "return document.body.scrollHeight;");
            while (true) {
                javascriptExecutor.executeScript("window.scrollTo(0, document.body.scrollHeight);");
                Thread.sleep(SCROLL_PAUSE_TIME);
                Long afterHeight = (Long) javascriptExecutor.executeScript(
                    "return document.body.scrollHeight;");
                if (beforeHeight.equals(afterHeight)) {
                    break;
                } else {
                    beforeHeight = afterHeight;
                }
            }

            List webElements = wait.until(
                ExpectedConditions.visibilityOfAllElementsLocatedBy(
                    By.xpath("//*[@class='card_link']")));

            for (WebElement e : webElements) {
                String annoId = e.getAttribute("onclick").replaceAll("[^0-9]", "");
                String link = String.format("%s%s", NAVER_DETAIL_URL, annoId);
                result.add(link);
            }

        } catch (InvalidArgumentException e) {
            webDriver.quit();
            throw new InvalidUrlException();
        } catch (InterruptedException e) {

        }

        return result;
    }

    private List parseLinkToRecruit(WebDriver webDriver, List recruitDetailLinks) {
        List result = new ArrayList<>();

        WebDriverWait wait = new WebDriverWait(webDriver, 10);

        for (String link : recruitDetailLinks) {
            try {
                webDriver.get(link);

                String title = wait.until(ExpectedConditions.visibilityOfElementLocated(
                    By.xpath("//h4[@class='card_title']"))).getText();

                String career = wait.until(ExpectedConditions.visibilityOfElementLocated(
                    By.xpath("//dl[@class='card_info']/dd[4]"))).getText();

                String workerType = wait.until(ExpectedConditions.visibilityOfElementLocated(
                    By.xpath("//dl[@class='card_info']/dd[5]"))).getText();

                String duration = wait.until(ExpectedConditions.visibilityOfElementLocated(
                    By.xpath("//dl[@class='card_info']/dd[6]"))).getText();
                String dueDate = null;
                if (duration.contains("~")) {
                    String[] temp = duration.split(" ~ ");
                    dueDate = temp[1];
                }

                result.add(new Recruit.Builder(title, CompanyType.NAVER.getValue(), link)
                    .career(career)
                    .dueDate(dueDate)
                    .workerType(workerType)
                    .build());
            } catch (InvalidArgumentException e) {
                webDriver.quit();
                throw new InvalidUrlException();
            } catch (WebDriverException e) {
                webDriver.quit();
                throw new ElementParseException();
            }
        }

        return result;
    }
}

xpath란?
DOM(Document Object Model)문서 내의 모든 요소를 정의하고 해당 요소에 접근하기 위한 경로

KakaoRecruitCrawler

카카오 채용 홈페이지를 크롤링하는 클래스이다.

JobCrawler 인터페이스를 구현한다.

crawling 메서드를 오버라이딩하는데 다음의 과정을 수행한다.

Chrome WebDriver 실행
카카오 채용 메인 페이지에 접속해서 채용 상세 페이지 링크 List에 담기
- 카카오 채용 메인 페이지는 네이버와 다르게 페이지 테이블 형식으로 구현되어 있다.
- https://careers.kakao.com/jobs?page={currentPage} 경로로 조회할 수 있는 모든 상세 공고 url 읽기
List를 순회하여 Recruit 타입 오브젝트로 파싱
- 상세 공고 페이지 url : https://careers.kakao.com/jobs/{id}
DB 데이터와 크롤링한 데이터 중복 제거
- HashSet 자료구조를 사용해서 O(N) 시간 복잡도로 구현
- 크롤러 중복 제거시 Collection의 removeAll() 함수를 사용하고 removeAll()은 내부적으로 contains() 와 remove() 함수를 호출한다. Contains()와 remove() 함수의 시간복잡도가 O(1)인 HashSet 자료구조를 사용해서 결과적으로 O(N)의 시간 복잡도로 구현했다.
- HashSet 객체의 contains()는 내부적으로 hashCode() 호출한다. 따라서 Recruit 객체의 동등성과 동일성을 보장하기 위해 HashCode()와 equals()를 overriding 해줬다.
DB에 저장

@Slf4j
@Component
public class KakaoRecruitCrawler implements JobCrawler {

    private final RecruitMapper recruitMapper;
    private static final String KAKAO_URL = "<https://careers.kakao.com/jobs>";

    public KakaoRecruitCrawler(RecruitMapper recruitMapper) {
        this.recruitMapper = recruitMapper;
    }

    @Override
    @Transactional
    public void crawling() {
        log.info("================== Kakao Recruits Crawling Start ===================");

        WebDriver webDriver = runWebDriver();

        List recruitDetailLinks = getRecruitLinks(webDriver);

        List recruits = parseLinkToRecruit(webDriver, recruitDetailLinks);

        List recruitsToAdd = deduplicate(recruits);

        for (Recruit recruit : recruitsToAdd) {
            recruitMapper.save(recruit);
        }

        webDriver.quit();

        log.info("================== Kakao Recruits Crawling End =====================");
    }

    private WebDriver runWebDriver() {
        // WebDriver 경로 설정
        System.setProperty("webdriver.chrome.driver", "/usr/local/bin/chromedriver");

        // WebDriver option
        ChromeOptions options = new ChromeOptions();
        options.addArguments("--start-maximized");          // 최대크기로
        options.addArguments("--headless");                 // Browser를 띄우지 않음
        options.addArguments("--disable-gpu");              // GPU를 사용하지 않음, Linux에서 headless를 사용하는 경우 필요함.
        options.addArguments("--no-sandbox");               // Sandbox 프로세스를 사용하지 않음, Linux에서 headless를 사용하는 경우 필요함.
        options.addArguments("--disable-popup-blocking");    // 팝업 무시
        options.addArguments("--disable-default-apps");     // 기본앱 사용안함

        return new ChromeDriver(options);
    }

    private List deduplicate(List recruits) {
        List findRecruits = recruitMapper.findByCompany(CompanyType.KAKAO.getValue());

        Set recruitsSet = new HashSet<>(recruits);
        Set findRecruitsSet = new HashSet<>(findRecruits);

        recruitsSet.removeAll(findRecruitsSet);

        return new ArrayList<>(recruitsSet);
    }

    private List parseLinkToRecruit(WebDriver webDriver, List recruitDetailLinks) {
        List result = new ArrayList<>();

        WebDriverWait wait = new WebDriverWait(webDriver, 20);

        for (String link : recruitDetailLinks) {

            try {
                webDriver.get(link);

                String title = wait.until(ExpectedConditions.visibilityOfElementLocated(
                    By.xpath("//strong[@class='tit_jobs']"))).getText();

                String career = null;
                if (title.contains("신입") && title.contains("경력")) {
                    career = "경력무관";
                } else if (title.contains("경력")) {
                    career = "경력";
                } else if (title.contains("신입")) {
                    career = "신입";
                }

                String workerType = wait.until(ExpectedConditions.visibilityOfElementLocated(
                    By.xpath("//dl[@class='list_info']/dd[2]"))).getText();

                String dueDate = wait.until(ExpectedConditions.visibilityOfElementLocated(
                    By.xpath("//dl[@class='list_info']/dd[3]"))).getText();

                String address = wait.until(ExpectedConditions.visibilityOfElementLocated(
                    By.xpath("//dl[@class='list_info']/dd[4]"))).getText();

                result.add(new Builder(title, CompanyType.KAKAO.getValue(), link)
                    .career(career)
                    .dueDate(dueDate)
                    .workerType(workerType)
                    .address(address)
                    .build());
            } catch (InvalidArgumentException e) {
                webDriver.quit();
                throw new InvalidUrlException();
            } catch (WebDriverException e) {
                webDriver.quit();
                throw new ElementParseException();
            }
        }

        return result;
    }

    private List getRecruitLinks(WebDriver webDriver) {
        List result = new ArrayList<>();

        int currentPage = 1;

        WebDriverWait wait = new WebDriverWait(webDriver, 20);

        while (true) {
            try {
                webDriver.get(String.format("%s?page=%d", KAKAO_URL, currentPage));

                wait.until(ExpectedConditions.visibilityOfElementLocated(
                    By.xpath("//*[@id=\\"mArticle\\"]/div/ul[@class='list_jobs']")));
            } catch (InvalidArgumentException e) {
                webDriver.quit();
                throw new InvalidUrlException();
            } catch (WebDriverException e) {  // 마지막 페이지
                break;
            }

            try {
                List webElements = wait.until(
                    ExpectedConditions.visibilityOfAllElementsLocatedBy(
                        By.xpath("//ul[@class='list_jobs']/child::a")));

                for (WebElement e : webElements) {
                    String href = e.getAttribute("href");
                    if (href == null) {
                        webDriver.quit();
                        throw new ElementParseException();
                    }
                    result.add(String.format("%s", href));
                }
            } catch (WebDriverException e) {
                webDriver.quit();
                throw new ElementParseException();
            }

            currentPage += 1;
        }

        return result;
    }
}

Recruit

채용 공고 엔티티 클래스이다.

다음의 이유로 빌더 패턴을 적용했다.

객체 생성시 필수 인자와 선택 인자를 구별
객체 생성시 가독성 향상
객체의 immutable함 보장

@Getter
@Alias("recruit")
@ToString
public class Recruit {

    private Long id;
    private String title;
    private String career;
    private String dueDate;
    private String company;
    private String address;
    private String workerType;
    private String link;
    private LocalDateTime addDateTime;
    private LocalDateTime updateDateTime;

    public Recruit() {
    }

    protected Recruit(Long id, String title, String career, String dueDate, String company,
        String address, String workerType, String link, LocalDateTime addDateTime,
        LocalDateTime updateDateTime) {
        this.id = id;
        this.title = title;
        this.career = career;
        this.dueDate = dueDate;
        this.company = company;
        this.address = address;
        this.workerType = workerType;
        this.link = link;
        this.addDateTime = addDateTime;
        this.updateDateTime = updateDateTime;
    }

    private Recruit(Builder builder) {
        id = builder.id;
        title = builder.title;
        career = builder.career;
        dueDate = builder.dueDate;
        company = builder.company;
        address = builder.address;
        workerType = builder.workerType;
        link = builder.link;
        addDateTime = builder.addDateTime;
        updateDateTime = builder.updateDateTime;
    }

    @Override
    public int hashCode() {
        return Objects.hash(getTitle(), getCompany(), getLink());
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof Recruit)) {
            return false;
        }
        Recruit recruit = (Recruit) o;
        return getTitle().equals(recruit.getTitle()) && getCompany().equals(recruit.getCompany())
            && getLink().equals(recruit.getLink());
    }

    public static class Builder {

        // 필수 매개변수
        private final String title;
        private final String company;
        private final String link;

        // 선택 매개변수
        private Long id = 0L;
        private String career = null;
        private String dueDate = null;
        private String address = null;
        private String workerType = null;
        private LocalDateTime addDateTime = null;
        private LocalDateTime updateDateTime = null;

        public Builder(String title, String company, String link) {
            this.title = title;
            this.company = company;
            this.link = link;
        }

        public Builder id(Long id) {
            this.id = id;
            return this;
        }

        public Builder career(String career) {
            this.career = career;
            return this;
        }

        public Builder dueDate(String dueDate) {
            this.dueDate = dueDate;
            return this;
        }

        public Builder address(String address) {
            this.address = address;
            return this;
        }

        public Builder workerType(String workerType) {
            this.workerType = workerType;
            return this;
        }

        public Builder addDateTime(LocalDateTime addDateTime) {
            this.addDateTime = addDateTime;
            return this;
        }

        public Builder updateDateTime(LocalDateTime updateDateTime) {
            this.updateDateTime = updateDateTime;
            return this;
        }

        public Recruit build() {
            return new Recruit(this);
        }
    }
}

GlobalExceptionHandler

Interceptor를 통해서 예외 처리 로직을 분리했다.

크롤러 동작시 InvalidUrlException, ElementParseException 같은 JobCrawlerException 타입 런타임 예외가 발생하면 인터셉터가 이를 가로채서 일괄 처리한다.

아래 코드는 에러 발생시 개발자에게 메일로 공지하는 방식으로 구현했다.

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {

    @Value("${admin.email}")
    private String adminEmail;

    private final MailSendManager mailSendManager;

    public GlobalExceptionHandler(MailSendManager mailSender) {
        this.mailSendManager = mailSender;
    }

    @ExceptionHandler(value = {JobCrawlerException.class})
    protected ResponseEntity<ErrorResponse> handleJobCrawlerException(JobCrawlerException e)
        throws MessagingException {
        log.error("JobCrawlerException : {}", e.getErrorCode());
        mailSendManager.sendMail(adminEmail, "Job Crawler RuntimeException 발생", String.format(
            "exception name : %s\\nerror code : %s\\nerror message : %s", e.getClass().toString(),
            e.getErrorCode(), e.getErrorCode().getDetail()));
        return ErrorResponse.toResponseEntity(e.getErrorCode());
    }
}

코드 참조

https://github.com/KIM-KYOUNG-OH/ChatBot

GitHub - KIM-KYOUNG-OH/ChatBot: 금일 업데이트된 채용 공고 및 뉴스 기사를 제공하는 카카오톡 챗봇입니

금일 업데이트된 채용 공고 및 뉴스 기사를 제공하는 카카오톡 챗봇입니다. Contribute to KIM-KYOUNG-OH/ChatBot development by creating an account on GitHub.

github.com

정리

이번 포스팅에선 Selenium 라이브러리를 사용해서 웹 크롤러를 제작한 과정을 공유해보았다.

웹 크롤러를 개발하면서 고도화하거나 부족한 부분이 많은 것 같은데 다음 포스팅에서는 아래의 키워드에 대해서 다뤄볼 계획이다.

배치 서버를 통해 크롤링 부하 분산
DB side 중복 제거 vs java side 중복 제거
InterruptedException 처리
에러 발생시 Logging & Notification 전략
E2E 테스트

Reference

https://www.selenium.dev/documentation/

https://bonigarcia.dev/webdrivermanager/

https://www.guru99.com/implicit-explicit-waits-selenium.html#fluent-wait

https://www.tcpschool.com/xml/xml_xpath_pathExpression

https://deonggi.tistory.com/162

http://happinessoncode.com/2017/10/09/java-thread-interrupt/

[Design Pattern] 과도한 if 절 타입 분기 코드 개선하기

헝그리개발자 — Thu, 16 Feb 2023 03:23:39 +0900

이번 포스팅에선 if 절이 과도하게 사용되어 오염된 비즈니스 레이어 결합도를 객체지향 패턴을 통해 낮추는 방법에 대해서 다뤄보려고 한다.

문제 분석

아래 코드는 이전 포스팅에서 다루었던 코드이다.

https://steadycode.tistory.com/89

카카오 챗봇 응답 템플릿 작성하기

이번 포스팅에선 ‘채용공고 크롤러’ 사이드 프로젝트를 진행하면서 카카오 챗봇을 구현한 내용을 상세히 기록하고자 한다. 카카오 챗봇 카카오 봇 시스템은 유저로부터 스킬 요청을 받고 스

steadycode.tistory.com

@RestController
public class RecruitController {

    private final RecruitService recruitService;
    private final Map<String, String> companies = Map.of("kakao", "카카오", "naver", "네이버");

    public RecruitController(RecruitService recruitService, ObjectMapper objectMapper) {
        this.recruitService = recruitService;
        this.objectMapper = objectMapper;
    }

    @PostMapping("/api/new-recruits/{company}")  // company : {kakao, naver, all}
    public CommonResponse getNewRecruitsAfterYesterdayByListCard(@PathVariable(name = "company") String company) {
        List<Recruit> findRecruits;
        if(company.equals("all")) {
            findRecruits = recruitService.getAllRecruitsAfterYesterday();
        } else {
            findRecruits = recruitService.getRecruitsByCompanyAfterYesterday(companies.get(company));
        }

        CommonResponse result;
        if(findRecruits.size() != 0) {
            result = ListCardResponse.of(findRecruits);
        } else {
            result = SimpleTextResponse.empty();
        }

        return result;
    }
}

해당 코드의 문제점은 다음과 같다.

과도한 타입 분기로 인한 높은 결합도
낮은 유지보수성
가독성 감소

현재는 company 타입이 “kakao”, “naver”, “all” 밖에 없지만 시스템이 고도화되어서 타입 변수가 1000개로 늘어났다고 가정해본다면 else if 절이 1000줄 추가로 작성되게 될 것이다.

기능이 추가되거나 변경될 때마다 business layer 코드를 건드려야하고 그 변경의 여파가 어디까지 퍼질지 예측할 수 없는 위험이 있다.

해결 방안

결합도를 낮춰서 Controller 의 과도한 책임을 분산시킬 필요가 있어 보인다.

결합도는 캡슐화를 통해 낮출 수 있다.

캡슐화는 객체지향 디자인 패턴의 핵심 원리중 하나로서 내부 구현을 감추는 것을 의미한다.

business layer에선 추상화된 인터페이스에만 의존하도록 하고 해당 인터페이스를 구현하는 구현체들을 생성하여 런타임에 주입되도록 설계한다.

개선된 코드

company 타입을 추상화하는 인터페이스 CompanyCondition을 두고 이를 구현하는 EntireCompany, Kakao, Naver 객체를 생성한다.

그리고 business layer 에선 CompanyCondition에만 의존하고 구현부를 캡슐화한다.

CompanyCondition

public interface CompanyCondition {
    public Boolean isSatisfiedBy(CompanyType companyType);

    List<Recruit> getRecruitsByCondition();
}

EntireCompany

@Component
public class EntireCompany implements CompanyCondition {

    private final RecruitMapper recruitMapper;

    public EntireCompany(RecruitMapper recruitMapper) {
        this.recruitMapper = recruitMapper;
    }

    @Override
    public Boolean isSatisfiedBy(CompanyType companyType) {
        return companyType == CompanyType.ALL;
    }

    @Override
    public List<Recruit> getRecruitsByCondition() {
        LocalDateTime yesterday = LocalDateTime.now().minusDays(1);

        return recruitMapper.findAll().stream()
                .filter(d -> d.getAddDateTime().isAfter(yesterday))
                .collect(Collectors.toList());
    }
}

Kakao

@Component
public class Kakao implements CompanyCondition {

    private final RecruitMapper recruitMapper;

    public Kakao(RecruitMapper recruitMapper) {
        this.recruitMapper = recruitMapper;
    }

    @Override
    public Boolean isSatisfiedBy(CompanyType companyType) {
        return companyType == CompanyType.KAKAO;
    }

    @Override
    public List<Recruit> getRecruitsByCondition() {
        LocalDateTime yesterday = LocalDateTime.now().minusDays(1000);

        List<Recruit> find = recruitMapper.findByCompany(CompanyType.KAKAO.getValue());
        return find.stream()
                .filter(d -> d.getAddDateTime().isAfter(yesterday))
                .collect(Collectors.toList());
    }
}

Naver

@Component
public class Naver implements CompanyCondition {

    private final RecruitMapper recruitMapper;

    public Naver(RecruitMapper recruitMapper) {
        this.recruitMapper = recruitMapper;
    }

    @Override
    public Boolean isSatisfiedBy(CompanyType companyType) {
        return companyType == CompanyType.NAVER;
    }

    @Override
    public List<Recruit> getRecruitsByCondition() {
        LocalDateTime yesterday = LocalDateTime.now().minusDays(1);

        return recruitMapper.findByCompany(CompanyType.NAVER.getValue()).stream()
                .filter(d -> d.getAddDateTime().isAfter(yesterday))
                .collect(Collectors.toList());
    }
}

RecruitController

복잡한 if 문을 Service 내부로 캡슐화했다.

기존에 Controller에 부여된 과한 책임을 분리했다.

@RestController
@Slf4j
public class RecruitController {

    private final RecruitService recruitService;

    public RecruitController(RecruitService recruitService) {
        this.recruitService = recruitService;
    }

    @PostMapping("/api/new-recruits/{company}")
    public CommonResponse getNewRecruitsAfterYesterdayByListCard(@PathVariable(name = "company") String company) {
        CompanyType companyType = CompanyTypeConverter.from(company);  // string to enum
        List<Recruit> findRecruits = recruitService.getRecruitsByCompany(companyType);
        return parseToChatBotTemplate(findRecruits);
    }

    private CommonResponse parseToChatBotTemplate(List<Recruit> findRecruits) {
        if(findRecruits.size() != 0) {
            return ListCardResponse.of(findRecruits);
        } else {
            return SimpleTextResponse.empty();
        }
    }
}

RecruitService

Collection Injection 을 통해 구현체 리스트를 멤버로 가진다.

Service 객체는 단지 인터페이스의 추상 메서드를 실행할 뿐이고 런타임에 조건에 만족하는 구현체가 동작한다.

@Service
public class RecruitService {

    private final List<CompanyCondition> companyConditions;

    public RecruitService(List<CompanyCondition> companyConditions) {
        this.companyConditions = companyConditions;
    }

    public List<Recruit> getRecruitsByCompany(CompanyType companyType) {
        return companyConditions.stream()
                .filter(companyCondition -> companyCondition.isSatisfiedBy(companyType))
                .findFirst().get().getRecruitsByCondition();
    }
}

이제 기능을 확장하고자 할 때 더이상 service layer를 건드는 위험을 감수하지 않아도 된다.

company 타입을 추가하려면 단순히 CompanyCondition 을 implements하는 구현체만 생성하면 된다.

기능을 추가할 때 인터페이스의 하위 구현체를 생성하는 방식으로 기존 코드에 영향을 주지 않으면서 개발할 수 있는 원칙을 OCP 원칙이라고 한다.

코드 참조

https://github.com/KIM-KYOUNG-OH/ChatBot

정리

객체 지향 디자인 패턴을 이용해서 기존의 코드를 개선해보았다.

대규모 시스템으로 갈수록 코드가 복잡해지고 유지보수가 어려워지기 때문에 이를 위한 해결책으로 객체지향 패턴을 고려해볼 수 있을 것 같다.

카카오 챗봇 응답 템플릿 작성하기

헝그리개발자 — Tue, 14 Feb 2023 15:49:25 +0900

이번 포스팅에선 ‘채용공고 크롤러’ 사이드 프로젝트를 진행하면서 카카오 챗봇을 구현한 내용을 상세히 기록하고자 한다.

카카오 챗봇

출처: https://i.kakao.com/docs/skill-build#스킬-서버-이해하기

카카오 봇 시스템은 유저로부터 스킬 요청을 받고 스킬 서버와 통신하여 알맞은 데이터를 응답해준다.

여기서 스킬이란 카카오 챗봇 시스템내에서 사용하는 동적 데이터 요청 기능 단위를 말한다.

스킬은 스킬 서버 API와 1대1 매핑된다.

다음의 순서로 개발해보도록 하겠다.

API 생성
스킬 등록
블록에 매핑
테스트

1. API 생성

스킬 타입으로 ListCard와 SimpleText를 선택했다.

ListCard는 한번의 요청으로 데이터를 간략한 블록 리스트 형태로 제공할 수 있다.

한번의 요청으로 여러 데이터를 응답해야하므로 ListCard 타입을 선택했다.

만약 반환할 데이터가 없다면 SimpleText로 반환할 데이터가 없다는 알림을 출력했다.

응답 JSON 포맷은 아래처럼 공식 문서에 정의된 형식에 맞춰서 응답해줘야 한다.

{
  "version": "2.0",
  "template": {
    "outputs": [
      {
        "listCard": {
          "header": {
            "title": "챗봇 관리자센터를 소개합니다."
          },
          "items": [
            {
              "title": "챗봇 관리자센터",
              "description": "새로운 AI의 내일과 일상의 변화",
              "imageUrl": "<https://t1.kakaocdn.net/openbuilder/sample/img_001.jpg>",
              "link": {
                "web": "<https://namu.wiki/w/%EB%9D%BC%EC%9D%B4%EC%96%B8(%EC%B9%B4%EC%B9%B4%EC%98%A4%ED%94%84%EB%A0%8C%EC%A6%88)>"
              }
            },
            {
              "title": "챗봇 관리자센터",
              "description": "카카오톡 채널 챗봇 만들기",
              "imageUrl": "<https://t1.kakaocdn.net/openbuilder/sample/img_002.jpg>",
              "action": "block",
              "blockId": "62654c249ac8ed78441532de",
              "extra": {
                "key1": "value1",
                "key2": "value2"
              }
            },
            {
              "title": "Kakao i Voice Service",
              "description": "보이스봇 / KVS 제휴 신청하기",
              "imageUrl": "<https://t1.kakaocdn.net/openbuilder/sample/img_003.jpg>",
              "action": "message",
              "messageText": "Kakao i Voice Service",
              "extra": {
                "key1": "value1",
                "key2": "value2"
              }
            }
          ],
          "buttons": [
            {
              "label": "구경가기",
              "action": "block",
              "blockId": "62654c249ac8ed78441532de",
              "extra": {
                "key1": "value1",
                "key2": "value2"
              }
            }
          ]
        }
      }
    ]
  }
}

{
    "version": "2.0",
    "template": {
        "outputs": [
            {
                "simpleText": {
                    "text": "간단한 텍스트 요소입니다."
                }
            }
        ]
    }
}

예제 코드

Recruit

채용공고 엔티티 클래스이다.

mybatis는 reflection을 통해 필드값에 접근하기 때문에 기본 생성자를 생성해준다.

@Getter
public class Recruit {
    private Long id;
    private String title;
    private String career;
    private String dueDate;
    private String company;
    private String address;
    private String workerType;
    private String link;
    private LocalDateTime addDateTime;
    private LocalDateTime updateDateTime;
    
    public Recruit() {}
    
    private Recruit(Builder builder) {
        id = builder.id;
        title = builder.title;
        career = builder.career;
        dueDate = builder.dueDate;
        company = builder.company;
        address = builder.address;
        workerType = builder.workerType;
        link = builder.link;
        addDateTime = builder.addDateTime;
        updateDateTime = builder.updateDateTime;
    }

    public static class Builder {
        // 필수 매개변수
        private final String title;
        private final String company;
        private final String link;

        // 선택 매개변수
        private Long id = 0L;
        private String career = null;
        private String dueDate = null;
        private String address = null;
        private String workerType = null;
        private LocalDateTime addDateTime = null;
        private LocalDateTime updateDateTime = null;

        public Builder(String title, String company, String link) {
            this.title = title;
            this.company = company;
            this.link = link;
        }

        public Builder id(Long id) {
            this.id = id;
            return this;
        }

        public Builder career(String career) {
            this.career = career;
            return this;
        }

        public Builder dueDate(String dueDate) {
            this.dueDate = dueDate;
            return this;
        }

        public Builder address(String address) {
            this.address = address;
            return this;
        }

        public Builder workerType(String workerType) {
            this.workerType = workerType;
            return this;
        }

        public Builder addDateTime(LocalDateTime addDateTime) {
            this.addDateTime = addDateTime;
            return this;
        }

        public Builder updateDateTime(LocalDateTime updateDateTime) {
            this.updateDateTime = updateDateTime;
            return this;
        }

        public Recruit build() {
            return new Recruit(this);
        }
    }
}

ListCardResponse

ListCard 타입 응답 템플릿 클래스이다.

DB에서 조회한 채용 공고 리스트를 파라미터로 넘겨주면 인스턴스를 생성하는 static 메서드를 정의한다.

ListCard는 최대 15개의 데이터만 표시할 수 있고 3개의 블록(말풍선)으로 나누어 출력한다는 제약사항이 있다.

따라서 loop을 돌면서 5개씩 묶어서 저장한다.

엔티티 데이터는 title, description, imageUrl 필드에 매핑된다.

{
    "version": "2.0",
    "template": {
        "outputs": [
            {
                "listCard": {
                    "header": {
                        "title": "6월 21일 신규 채용 공고 (1/1)"
                    },
                    "items": [
                        {
                            "title": "[Up-data!] 2022 kakao Data 경력 개발자 영입",
                            "description": "카카오/경력/정규직/2022년 7월 8일 까지/판교",
                            "imageUrl": "<https://t1.kakaocdn.net/kakaocorp/corp_thumbnail/Kakao.png>",
                            "link": {
                                "web": "<https://careers.kakao.com/jobs/P-12703?page=1>"
                            }
                        },
                        {
                            "title": "카카오의 사회공헌 서비스를 만들어갈 서버∙백엔드 개발자 모집",
                            "description": "카카오/정규직/영입종료시/판교",
                            "imageUrl": "<https://t1.kakaocdn.net/kakaocorp/corp_thumbnail/Kakao.png>",
                            "link": {
                                "web": "<https://careers.kakao.com/jobs/P-12691?page=1>"
                            }
                        }
                    ]
                }
            }
        ]
    }
}

@Getter
@Slf4j
public class ListCardResponse implements CommonResponse {
    private final String version;
    private final Template template;
    private static final Map<string, string=""> logoUrlMap = Map.of("카카오", "<https://t1.kakaocdn.net/kakaocorp/corp_thumbnail/Kakao.png>", "네이버", "<https://blog.kakaocdn.net/dn/XEAGa/btqB10c0bQ1/RZk86MYViwrP4OaBdpfhn0/img.png>");

    private ListCardResponse(String version, Template template) {
        this.version = version;
        this.template = template;
    }

    public static ListCardResponse of(List recruits) {
        String now = LocalDate.now().getMonthValue() + "월 " + LocalDate.now().getDayOfMonth() + "일";
        List outputs = new ArrayList<>();
        int totalCount = recruits.size();  // 공고 개수
        int totalPage = totalCount % 5 == 0 ? totalCount / 5 : totalCount / 5 + 1;  // 블록 수
        int currentPage = 1;  // 현재 블록 페이지
        int currentIndex = 0;  // 블록 첫 인덱스

        while(currentIndex < totalCount) {
            List items = new ArrayList<>();
            for(int i = currentIndex; i < totalCount; i++) {
                Recruit recruit = recruits.get(i);
                StringBuilder sb = new StringBuilder();
                sb.append(recruit.getCompany());

                if(recruit.getCareer() != null) {
                    sb.append("/").append(recruit.getCareer());
                }

                if(recruit.getWorkerType() != null) {
                    sb.append("/").append(recruit.getWorkerType());
                }

                if(recruit.getDueDate() != null) {
                    sb.append("/").append(recruit.getDueDate());
                }

                if(recruit.getAddress() != null) {
                    sb.append("/").append(recruit.getAddress());
                }

                Item item = new Item(recruit.getTitle(), sb.toString(), logoUrlMap.get(recruit.getCompany()), new Link(recruit.getLink()));
                items.add(item);
                if(i == totalCount - 1 || i - currentIndex == 4) {
                    outputs.add(new Output(new ListCard(new Header(now + " 신규 채용 공고 (" + currentPage++ + "/" + totalPage + ")"), items)));
                    currentIndex = i + 1;
                    break;
                }
            }
        }

        return new ListCardResponse("2.0", new Template(outputs));
    }

    @Getter
    private static class Template{
        private final List outputs;

        private Template(List outputs) {
            this.outputs = outputs;
        }
    }

    @Getter
    private static class Output{
        private final ListCard listCard;

        private Output(ListCard listCard) {
            this.listCard = listCard;
        }
    }

    @Getter
    private static class ListCard {
        private final Header header;
        private final List items;

        private ListCard(Header header, List items) {
            this.header = header;
            this.items = items;
        }
    }

    @Getter
    private static class Header {
        private final String title;

        private Header(String title) {
            this.title = title;
        }
    }

    @Getter
    private static class Item {
        private final String title;
        private final String description;
        private final String imageUrl;
        private final Link link;

        public Item(String title, String description, String imageUrl, Link link) {
            this.title = title;
            this.description = description;
            this.imageUrl = imageUrl;
            this.link = link;
        }
    }

    @Getter
    private static class Link {
        private final String web;

        private Link(String web) {
            this.web = web;
        }
    }
}

SimpleTextResponse

SimpleText 타입 응답 템플릿 클래스이다.

조회된 데이터가 없다면 알림문구를 띄우기 위해 정의한다.

{
    "version": "2.0",
    "template": {
        "outputs": [
            {
                "simpleText": {
                    "text": "X월 X일 신규 추가된 채용공고가 존재하지 않습니다.\\n신규 채용정보는 매일 오전 8시에 업데이트됩니다."
                }
            }
        ]
    }
}

@Getter
public class SimpleTextResponse implements CommonResponse{
    private final String version;
    private final Template template;

    private SimpleTextResponse(String version, Template template) {
        this.version = version;
        this.template = template;
    }

    public static SimpleTextResponse empty() {
        String now = LocalDate.now().getMonthValue() + "월 " + LocalDate.now().getDayOfMonth() + "일";
        List<Output> outputs = new ArrayList<>();
        outputs.add(new Output(new SimpleText(now + " 신규 추가된 채용공고가 존재하지 않습니다.\\n신규 채용정보는 매일 오전 8시에 업데이트됩니다.")));

        return new SimpleTextResponse("2.0", new Template(outputs));
    }

    @Getter
    private static class Template{
        private final List<Output> outputs;

        private Template(List<Output> outputs) {
            this.outputs = outputs;
        }
    }

    @Getter
    private static class Output{
        private final SimpleText simpleText;

        private Output(SimpleText simpleText) {
            this.simpleText = simpleText;
        }
    }

    @Getter
    private static class SimpleText {
        private final String text;

        private SimpleText(String text) {
            this.text = text;
        }
    }
}

CommonResponse

ListCardResponse 객체와 SimpleTextResponse를 추상화한 인터페이스이다.

public interface CommonResponse {}

RecruitController

스킬 서버의 채용 공고 조회 API를 정의한 Controller 클래스이다.

if 절에 의한 과도한 타입 분기는 유지보수에 취약한 구조를 가져올 수 있다.

이에 관한 부분은 다음 포스팅에서 다루겠다.

@RestController
public class RecruitController {

    private final RecruitService recruitService;
    private final Map<String, String> companies = Map.of("kakao", "카카오", "naver", "네이버");

    public RecruitController(RecruitService recruitService, ObjectMapper objectMapper) {
        this.recruitService = recruitService;
        this.objectMapper = objectMapper;
    }

    @PostMapping("/api/new-recruits/{company}")  // company : {kakao, naver, all}
    public CommonResponse getNewRecruitsAfterYesterdayByListCard(@PathVariable(name = "company") String company) {
        List<Recruit> findRecruits;
        if(company.equals("all")) {
            findRecruits = recruitService.getAllRecruitsAfterYesterday();
        } else {
            findRecruits = recruitService.getRecruitsByCompanyAfterYesterday(companies.get(company));
        }

        CommonResponse result;
        if(findRecruits.size() != 0) {
            result = ListCardResponse.of(findRecruits);
        } else {
            result = SimpleTextResponse.empty();
        }

        return result;
    }
}

2. 스킬 등록

카카오 챗봇 관리자 센터에서 스킬 서버로 요청할 스킬을 등록해준다.

3. 블록에 매핑

미리 짜놓은 시나리오에 맞춰 출력할 데이터 블록을 스킬과 매핑시켜준다.

4. 테스트

아래와 같이 동적 데이터가 정상 출력되는 것을 볼 수 있다.

정리

이번 포스팅에선 카카오 챗봇을 이용해서 동적 데이터를 출력하는 방법에 대해서 정리해 보았다.

글을 작성하면서 비즈니스 레이어가 구현체에 너무 많이 의존되어서 변경에 취약한 구조를 띄는 것을 발견했다.

다음 포스팅에선 이를 어떻게 하면 개선할 수 있을지 다뤄보겠다.

[Jenkins] 원격 Jenkins 서버로 CI/CD 환경 구현하기

헝그리개발자 — Thu, 9 Feb 2023 15:42:59 +0900

이번 포스팅에선 jenkins pipeline 생성 방법과 jenkinsfile script를 작성하여 애플리케이션을 배포하는 방법에 대해서 다뤄보고자 한다.

CI/CD Flow

github로부터 소스코드 pull
build & test
빌드된 jar 파일 배포 서버로 전송
애플리케이션 서버에 접속
전송된 jar 파일 실행하여 애플리케이션 배포

Jenkins Global Configuration 설정

JDK, Git, Gradle 등의 설정을 미리 생성해놓고 여러 Jenkins Project에서 참조하여 사용할 수 있도록 한다.

JDK 설정

JAVA_HOME 값을 출력하여 jenkins console에 등록한다.

$ echo $JAVA_HOME

Git 설정

git 커멘드 경로도 등록해준다.

$ which git

Jenkins Pipeline 생성

Jenkins Pipeline은 코드를 통해서 지속적인 배포 환경을 구축할 수 있는 Jenkins 모듈이다.

Jenkins와 Github 연동시 SSH 연동 방식을 사용하는데 Credentials에 미리 생성한 Credential을 선택해준다.

Jenkins와 Github 연동 방법은 이전 포스팅에서 다뤘다.

https://steadycode.tistory.com/87

[Jenkins] Jenkins Github 연동하기

이번 포스팅에선 Jenkins와 Github간 연동 방법에 대해서 다뤄 보겠다. 공개키/비밀키 생성 실행중인 젠킨스 사용자를 확인한다. ps aux | grep jenkins 현재 사용자를 jenkins로 변경하고 shell command 실행 권

steadycode.tistory.com

Jenkinsfile Script 경로 지정

jenkins 서버가 빌드시 jenkinsfile에 정의된 내용대로 동작하는데 해당 script 파일의 경로를 지정해준다.

민감 데이터 등록

민감 데이터는 Github에 공개되어선 안되기 때문에 Jenkins Credential에 등록하고 Script에서 참조하도록 한다.

Jenkins Credential 등록

‘Secret text’ 타입을 선택하고 key-value 형태로 민감 데이터를 credential로 등록한다.

아래 예시 처럼 Script 단에서 credential(id) 형태로 전역 변수에 할당하고 $variable 변수로 매핑한다.

pipeline {
    agent any
    environment {
        DEPLOY_SERVER_ID = credentials('deployServerId')
        DEPLOY_SERVER_PASSWORD = credentials('deployServerPassword')
    }

        stage('Send Jar') {
        steps {
            sh 'sshpass -p $DEPLOY_SERVER_PASSWORD ssh -p 12308 $DEPLOY_SERVER_ID@106.10.59.248 rm -rf build/fire_inform-0.0.1-SNAPSHOT.jar'
            sh 'sshpass -p $DEPLOY_SERVER_PASSWORD scp -P 12308 -o StrictHostKeyChecking=no /var/lib/jenkins/workspace/pipeline/build/libs/fire_inform-0.0.1-SNAPSHOT.jar $DEPLOY_SERVER_ID@106.10.59.248:build'
        }
    }
}

Jenkinsfile 작성

본격적으로 script를 작성해보자

다음 경로에 Jenkinsfile을 생성한다.

Jenkins Pipeline Script에는 ‘Scripted Pipeline’과 ‘Declarative Pipeline’ 두 가지 syntax가 존재하는데 ‘Declarative Pipeline’를 사용했다.

Declarative Pipeline는 지원하지 않는 플러그인이 존재하여 개발자의 자유도를 낮출 수 있지만 단순하고 가독성이 높다는 특징이 있다.

pipeline {
    agent any
    environment {
        DEPLOY_SERVER_ID = credentials("deployServerId")
        DEPLOY_SERVER_PASSWORD = credentials("deployServerPassword")
        SECRET_KEY = credentials('SECRET_KEY')
        DB_USERNAME = credentials('DB_USERNAME')
        DB_PASSWORD = credentials('DB_PASSWORD')
        DB_URL = credentials('DB_URL')
        DB_PORT = credentials('DB_PORT')
    }

    stages {
        stage("Clean Up") {
            steps {
                sh "pwd"
                sh "rm -rf *"
            }
        }

        stage("Checkout") {
            steps {
                git url: "<https://github.com/f-lab-edu/ChatBot.git>", branch: "main",
                credentialsId: "cbf50f14-c18f-4bc0-a792-668780641040"
            }
        }

        stage("Build") {
            steps {
                sh "./gradlew clean build"
            }
        }

        stage("Send Jar") {
            steps {
                sh 'sshpass -p $DEPLOY_SERVER_PASSWORD ssh -p 12308 $DEPLOY_SERVER_ID@106.10.59.248 rm -rf build/fire_inform-0.0.1-SNAPSHOT.jar'
                sh 'sshpass -p $DEPLOY_SERVER_PASSWORD scp -P 12308 -o StrictHostKeyChecking=no /var/lib/jenkins/workspace/pipeline/build/libs/fire_inform-0.0.1-SNAPSHOT.jar $DEPLOY_SERVER_ID@106.10.59.248:build'
            }
        }

        stage("Send Shell Script") {
            steps {
                sh 'sshpass -p $DEPLOY_SERVER_PASSWORD ssh -p 12308 $DEPLOY_SERVER_ID@106.10.59.248 rm -rf build/deploy.sh'
                sh 'sshpass -p $DEPLOY_SERVER_PASSWORD scp -P 12308 -o StrictHostKeyChecking=no /var/lib/jenkins/workspace/pipeline/deploy.sh $DEPLOY_SERVER_ID@106.10.59.248:build'
            }
        }

        stage("Connect Deploy Server") {
            steps {
                sh 'sshpass -p $DEPLOY_SERVER_PASSWORD ssh -p 12308 $DEPLOY_SERVER_ID@106.10.59.248 sh build/deploy.sh'
            }
        }
    }
}

1. Clean Up 단계

소스코드를 clone 받기 전에 비워주는 단계

2. Checkout 단계

Github Repository에서 소스코드를 clone 받는 단계이다.

credentialsId에 Github 연동 암호키 정보를 담은 Credential의 ID값을 입력해준다.

2. Build 단계

gradle wrapper를 이용해서 빌드한다.

3. Send Jar 단계

필자는 jenkins 서버와 애플리케이션 서버를 별도로 배포했기 때문에 빌드된 jar 파일을 애플리케이션 서버로 전송한다.

Checkout 단계에서 생성된 jar의 파일 경로는 /var/lib/jenkins/workspace/flab/build/libs/fire\_inform-0.0.1-SNAPSHOT.jar 이다.

sshpass 는 원격 컴퓨터에 보안 접속할 때 사용하는 명령어이다.

sshpass -p 'ssh접속비밀번호' ssh 'ssh접속계정'@'ssh접속주소' '명령어'

파일 전송시 SCP 프로토콜을 이용한다.

SCP(Secure Copy)는 원격 호스트 간에 파일을 전송하는 프로토콜이며 SSH기반이다.

scp로 전송할 배포 서버 경로
- -P : 호스트 포트 번호
- build : 디렉토리명
- -o StrictHostKeyChecking=no : 호스트간 키 인증 과정 스킵

# 이전 파일 삭제
sshpass -p $DEPLOY_SERVER_PASSWORD ssh -p 12308 $DEPLOY_SERVER_ID@106.10.59.248 rm -rf build/fire_inform-0.0.1-SNAPSHOT.jar

# jar 파일 애플리케이션 서버로 전송
sshpass -p $DEPLOY_SERVER_PASSWORD scp -P 12308 -o StrictHostKeyChecking=no /var/lib/jenkins/workspace/pipeline/build/libs/fire_inform-0.0.1-SNAPSHOT.jar $DEPLOY_SERVER_ID@106.10.59.248:build

4. Send Shell Script 단계

애플리케이션 서버에서 실행할 동작을 정의해 놓은 Shell 스크립트를 전송한다.

# 이전 파일 삭제
sshpass -p $DEPLOY_SERVER_PASSWORD ssh -p 12308 $DEPLOY_SERVER_ID@106.10.59.248 rm -rf build/deploy.sh

# deploy.sh script 파일 전송
sshpass -p $DEPLOY_SERVER_PASSWORD scp -P 12308 -o StrictHostKeyChecking=no /var/lib/jenkins/workspace/pipeline/deploy.sh $DEPLOY_SERVER_ID@106.10.59.248:build

전송할 script의 내용은 아래와 같다.

java 이름으로 동작하는 프로세스의 pid를 찾고 있다면 해당 프로세스를 종료한다.
백그라운 스레드로 애플리케이션을 실행한다.

#!/bin/sh

pid=`pgrep -f java`
if [ $pid ]
then
    kill -9 $pid;
    echo '$pid process kill complete'
else
    echo 'pid is empty'
fi

sleep 5

nohup java -jar build/fire_inform-0.0.1-SNAPSHOT.jar &

5. Connect Deploy Server 단계

sh : .sh 확장자의 파일 실행

sshpass -p $DEPLOY_SERVER_PASSWORD ssh -p 12308 $DEPLOY_SERVER_ID@106.10.59.248 sh build/deploy.sh

정리

Jenkins를 통해 소스 코드를 빌드하고 원격 서버에서 애플리케이션을 배포하는 방법에 대해서 알아보았다.

github actions 를 이용하면 git merge 시 자동으로 테스트 및 배포하는 기능도 지원하는데 추후 학습해보겠다.

소스 코드

https://github.com/KIM-KYOUNG-OH/ChatBot

Reference

[Jenkins] Jenkins Github 연동하기

헝그리개발자 — Thu, 9 Feb 2023 13:15:12 +0900

이번 포스팅에선 Jenkins와 Github간 SSH 연동 방법에 대해서 다뤄 보겠다.

SSH란?

Secure SHell은 네트워크 상의 원격 컴퓨터에 접속하여 명령을 실행할 수 있도록 해주는 프로토콜이다.

기존에는 Telnet 방식을 사용했는데 암호화를 제공하지 않기 때문에 보안상 취약하다는 단점을 보완한 방법이 SSH이다.

암호화 방식에는 대칭키 방식과 비대칭키 방식 두가지를 사용한다.

비대칭키 방식은 클라이언트와 서버간 인증시 사용한다.

대칭키 방식은 클라이언트와 서버간 데이터를 주고받을 때 사용한다.

비대칭키 방식

비대칭 키 방식은 두 호스트 간에 공개키와 개인키 쌍으로 인증하는 방식이다.

공개키는 .pub, 개인키는 .pem의 형식을 띈다.

공개키는 유출되어도 크게 문제가 되지 않는 키이며 공개키로 암호화된 데이터는 개인키로만 복호화할 수 있다.

개인키는 발행한 쪽만 알고 있는 키이며 개인키로 암호화한 데이터는 공개키로만 복호화할 수 있다.

사용자 인증 Flow

3 way handshaking 과정으로 사용자를 인증한다.

출처: https://medium.com/@labcloud/ssh-암호화-원리-및-aws-ssh-접속-실습-33a08fa76596

클라이언트(Jenkins)가 공개키와 개인키 발행후 공개키를 서버에 전달
공개키를 서버에 파일로 저장
서버는 난수의 해시값을 생성
공개키로 암호화한다.
클라이언트에게 다시 전달한다.
클라이언트는 해당 데이터를 개인키로 복호화한다.
복호화한 값을 서버로 보낸다.
서버는 처음 값과 응답받은 값을 비교하여 두 같이 같다면 두 호스트간의 인증이 완료된다.

서버 인증 Flow

위 과정에서 클라이언트와 서버 역할만 바꾸면 된다.

대칭키 방식

대칭키 방식은 두 호스트 간에 정보를 주고받을 때 사용한다.

대칭키 방식은 비대칭키 방식과 다르게 한 개의 키만 사용한다.

대칭키로 암호화된 데이터는 대칭키로만 복호화할 수 있다.

두 호스트간 데이터 전송 Flow

클라이언트 인증과 서버 인증이 끝나면 내부적으로 대칭키(세션키)를 생성하여 주고 받게 된다.
데이터를 대칭키로 암호화하여 상대측에 전송한다.
데이터를 수신한 측은 데이터를 대칭키로 복호화한다.
데이터 송신이 끝나면 대칭키를 폐기하고 다시 접속시마다 새로운 대칭키를 생성한다.

공개키/개인키 생성

실행중인 젠킨스 사용자를 확인한다.

ps aux | grep jenkins

현재 사용자를 jenkins로 변경하고 shell command 실행 권한을 준다.

sudo -u jenkins /bin/bash

.ssh 디렉토리를 생성한다.

mkdir /var/lib/jenkins/.ssh
cd /var/lib/jenkins/.ssh

ssh 키를 생성한다.

아래의 명령어를 실행하면 공개키와 비밀키를 생성한다.

ssh-keygen 은 Linux SSH 패키지에 포함되어 있는 프로그램이다.

-t : key 암호화 알고리즘 타입

-f : key file의 filename

명령을 실행하면 다음의 두 키가 생성된다.

공개키 : github_ansible-in-action.pub
개인키 : github_ansible-in-action

ssh-keygen -t rsa -f /var/lib/jenkins/.ssh/github_ansible-in-action

Github repository에 공개키 등록

생성한 공개키 코드값을 복사해서 github repository setting으로 이동 후 공개키를 등록한다.

cat /var/lib/jenkins/.ssh/github_ansible-in-action.pub

jenkins 서버에 비밀키 등록

생성한 개인키 값을 jenkins credential 로 저장한다.

credential 은 jenkins 서버 프로세스에서 사용할 민감 데이터를 의미한다.

cat /var/lib/jenkins/.ssh/github_ansible-in-action

kind
- credential 타입
Username
- 각 Jenkins Job에서 보여줄 인증키 이름
Private Key
- 타겟 value
- jenkins 서버에서 생성한 비밀키를 붙여넣는다.

연동 테스트

커넥션 테스트용도로 간단한 Jenkins Item을 생성한다.

아래의 내용을 입력한다.

github repository url
Credentials로 등록한 private key
branch 선택

정상 Build 되면 연동 성공이다.

콘솔로 결과를 확인하고 싶으면 /var/lib/jenkins/workspace 로 이동해서 확인하면 된다.

$ cd /var/lib/jenkins/workspace

정리

이번 포스팅에선 Github과 jenkins를 연동하는 방법을 알아보았다.

다음 포스팅에서 jenkins script를 직접 작성하여 구체적인 CI/CD 동작을 구현해보겠다.

Reference

[Spring Security] JWT을 이용한 소셜 로그인 구현

헝그리개발자 — Wed, 1 Feb 2023 22:35:46 +0900

JWT이란?

Json Web Token의 약자로서 암호화된 데이터를 전송하기 위한 Json 기반의 인터넷 표준이다.

유저 인증시 사용하는 토큰으로, 유저의 인증 정보를 서버가 아닌 클라이언트가 들고 있기 때문에 서버의 부담을 덜 수 있다.

서버는 유저 요청시 토큰이 유효한지만 판별하면 된다.

JWT을 쓰는 이유?

이전 포스팅에서 다룬 Session-Cookie 인증 방식은 다음과 같은 단점이 있다.

휘발성 메모리 영역에 저장된다.
- 세션은 결국 메모리 위에서 동작하기 때문에 만에 하나 서버가 종료되면 세션이 초기화되고 모든 유저는 다시 로그인해야한다.
분산 서버 환경에서 문제가 될 수 있다.
- 분산 서버 환경에선 서버의 상태를 stateless하게 설계해야하는데 세션&쿠키 인증 방식은 필연적으로 서버가 유저의 상태 정보를 유지해야한다.
- 분산 서버 환경에서 유저가 로그인한 이력이 있더라도 다른 세션 저장소를 가진 서버가 요청을 받았기 때문에 다시 로그인해야하는 문제가 발생한다.

JWT 인증 방식은 서버가 유저 상태 정보를 들고 있지 않기 때문에 분산 서버 환경에서 유리하기 때문에 사용한다.

JWT의 구조

jwt은 header, payload, signature로 이루어진다.

다음은 HMAC 암호화 방식을 이용한 것이다.

HMAC은 임의의 시크릿 키를 포함한 암호화 방식이다.

출처: https://jwt.io/

header에는 사용할 토큰 타입과 알고리즘의 종류가 담긴다.
payload에는 유저 이름과 권한 정보와 같은 Claim 정보가 담긴다.
signature에는 header에서 선정한 알고리즘으로 header + payload + 서버에서 생성한 secret key 를 암호화한 데이터가 담긴다.

각각은 Base64 알고리즘으로 인코딩되어있다.

JWT을 이용한 인증 Flow

출처: https://inpa.tistory.com/entry/WEB- -JWTjson-web-token-란- -정리#Token_인증

클라이언트는 id, password를 이용해서 로그인한다.
서버는 header, payload, signature 세가지 정보로 토큰을 생성함
- 중요한 것은 signature로, 유저가 정상 인증된 시점에 서버가 서명을 했다는 증명을 나타낸다.
만들어진 토큰을 클라이언트에게 전달하고 브라우저의 스토리지 영역에 토큰을 저장한다.
클라이언트는 다음 요청때마다 토큰을 같이 보낸다.
서버는 토큰이 유효한지 검증해보고 유효하다면 올바른 요청으로 인식하고 애플리케이션 프로세스를 진행한다.
- 토큰 유효성 검증시 서버가 가진 시크릿 키로 signature를 다시 생성해서 요청과 일치하는지만 확인하면 된다.

JWT의 한계

JWT는 다음의 한계를 가진다.

토큰 데이터 길이가 길어서 네트워크 부하가 발생
토큰 탈취 문제
payload에 민감한 데이터를 담을 수 없다.
서버쪽에서 유저의 접속 유무를 알 수 없다.

Access Token & Refresh Token 방식

토큰 탈취의 위험성을 줄이기 위해 토큰의 수명을 관리하기 위해 사용한다.

Access Token

실제 정보가 담긴 토큰이며 수명이 30분 정도로 매우 짧다.

Refresh Token

만료된 Access Token을 재발급하기 위한 토큰으로 Access Token보다 수명이 길고 DB에서 관리한다.

하지만 결국 Refresh Token도 탈취 위험이 있기 때문에 http only, secure http, ssl을 적용해야한다.

인증 Flow

예제 코드

build.gradle

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-security'
	implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
	runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.5', 'io.jsonwebtoken:jjwt-jackson:0.11.5'
}

jjwt 라이브러리를 사용했다.

application.yml

server:
  port: 8080 # 사용 포트
  servlet:
    context-path: /
    encoding:
      charset: UTF-8
      enabled: true
      force: true

spring:
  datasource:
    url: {url}
    username: {username}
    password: {password}
    driver-class-name: com.mysql.cj.jdbc.Driver

  jpa:
    hibernate:
      ddl-auto: update #create update none
      naming:
        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
      show-sql: true

  security:
    oauth2:
      client:
        registration:
          naver:
            client-id: {id}
            client-secret: {secret}
            scope:
              - name
              - email
            client-name: Naver # 클라이언트 네임은 구글 페이스북도 대문자로 시작하더라.
            authorization-grant-type: authorization_code  # 코드를 부여받는 방식
            redirect-uri: 

        # 네이버는 OAuth2.0 공식 지원대상이 아니라서 별도로 "naver"라는 provider를 등록해줘야함
        # provider 등록을 안하면 "clientRegistrationRepository"에 "naver"라는 id로 등록된 provider가 없다고 에러남
        # 요청주소도 다르고, 응답 데이터도 다르기 때문이다.
        provider:
          naver:
            authorization-uri: <https://nid.naver.com/oauth2.0/authorize>
            token-uri: <https://nid.naver.com/oauth2.0/token>
            user-info-uri: <https://openapi.naver.com/v1/nid/me>
            user-name-attribute: response # 회원정보를 json의 response 키값으로 리턴해줌.

jwt:
  access-token-key: {access-token-key}
  refresh-token-key: {refresh-token-key}

app:
  oauth2:
    authorized-redirect-uri:   # 인증후 리다이렉트 주소

access-token-key: Access Token을 발급하기 위한 private key
refresh-token-key: Refresh Token을 발급하기 위한 private key
authorized-redirect-uri
- 인증 이후 리다이렉트될 uri를 가리킴
- SPA의 경우 서버 URI와 미들웨어 URI가 달라서 CORS 이슈가 발생할 수 있다.

SecurityConfig

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)  // 선택적으로 권한 처리시 @Secured나 @PreAuthorize 사용
@RequiredArgsConstructor
public class SecurityConfig {

    private final PrincipalOauth2UserService principalOauth2UserService;
    private final CookieAuthorizationRequestRepository cookieAuthorizationRequestRepository;
    private final OAuth2AuthenticationSuccessHandler oAuth2AuthenticationSuccessHandler;
    private final OAuth2AuthenticationFailureHandler oAuth2AuthenticationFailureHandler;
    private final JwtAuthenticationFilter jwtAuthenticationFilter;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf().disable()
                        .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);

        http.authorizeRequests()
                .antMatchers("/user/**").authenticated()
                .antMatchers("/manager/**").access(String.format("hasRole('%s') or hasRole('%s')", UserRole.ROLE_MANAGER.getRole(), UserRole.ROLE_ADMIN.getRole()))
                .antMatchers("/admin/**").access(String.format("hasRole('%s')", UserRole.ROLE_ADMIN.getRole()))
                .anyRequest().permitAll();

        http.formLogin();

        http.oauth2Login()
                .authorizationEndpoint()
                    .baseUri("/oauth2/authorization")
                    .authorizationRequestRepository(cookieAuthorizationRequestRepository)
                .and()
                .userInfoEndpoint()
                    .userService(principalOauth2UserService)
                .and()
                .successHandler(oAuth2AuthenticationSuccessHandler)
                .failureHandler(oAuth2AuthenticationFailureHandler)
                .and()
                .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }
}

sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
- 서버는 세션을 유지하지 않는다.
oauth2Login()
- authorizationEndpoint()
  - 소셜 로그인 제공사 서버에 보내는 요청에 관련된 설정이다.
  - authorizationRequestRepository()
    - 인가 처리 동안 OAuth2AuthorizationRequest를 유지하는 레포지토리를 설정한다.
    - 디폴트 구현체는 HttpSessionOAuth2AuthorizationRequestRepository 이지만 세션이 아닌 쿠키에 저장할 것이기 때문에 커스텀 구현체를 주입한다.
- userInfoEndpoint()
  - userService()
    - 성공적으로 인증한 로그인 정보를 가지고 비스니스 로직을 처리할 커스텀 구현체를 주입한다.
- successHandler()
  - 인증 성공시 동작할 구현체 주입
- failureHandler()
  - 인증 실패시 동작할 구현체 주입
- addFilterBefore()
  - 모든 요청마다 인가 작업을 처리할 filter 구현체 주입

User

@Entity
@Getter
@Builder
@ToString
public class User {

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

    @Column(unique = true)
    private String username;

    private String password;
    private String email;

    @Enumerated(EnumType.STRING)
    private UserRole UserRole;

    @Enumerated(EnumType.STRING)
    private AuthProvider authProvider;

    private String refreshToken;
    private Timestamp createDate;
    private Timestamp updateDate;

    public User() {}

    public User(Long id, String username, String password, String email, UserRole UserRole, AuthProvider authProvider, String refreshToken, Timestamp createDate, Timestamp updateDate) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.email = email;
        this.UserRole = UserRole;
        this.authProvider = authProvider;
        this.refreshToken = refreshToken;
        this.createDate = createDate;
        this.updateDate = updateDate;
    }
}

CookieAuthorizationRequestRepository

@Component
public class CookieAuthorizationRequestRepository implements AuthorizationRequestRepository<OAuth2AuthorizationRequest> {
    public static final String OAUTH2_AUTHORIZATION_REQUEST_COOKIE_NAME = "oauth2_auth_request";
    public static final String REDIRECT_URI_PARAM_COOKIE_NAME = "redirect_uri";
    private static final int COOKIE_EXPIRE_SECONDS = 180;

    @Override
    public OAuth2AuthorizationRequest loadAuthorizationRequest(HttpServletRequest request) {
        return CookieUtil.getCookie(request, OAUTH2_AUTHORIZATION_REQUEST_COOKIE_NAME)
                .map(cookie -> CookieUtil.deserialize(cookie, OAuth2AuthorizationRequest.class))
                .orElse(null);
    }

    @Override
    public void saveAuthorizationRequest(OAuth2AuthorizationRequest authorizationRequest, HttpServletRequest request, HttpServletResponse response) {
        if (authorizationRequest == null) {
            CookieUtil.deleteCookie(request, response, OAUTH2_AUTHORIZATION_REQUEST_COOKIE_NAME);
            CookieUtil.deleteCookie(request, response, REDIRECT_URI_PARAM_COOKIE_NAME);
            return;
        }

        CookieUtil.addCookie(response, OAUTH2_AUTHORIZATION_REQUEST_COOKIE_NAME, CookieUtil.serialize(authorizationRequest), COOKIE_EXPIRE_SECONDS);
        String redirectUriAfterLogin = request.getParameter(REDIRECT_URI_PARAM_COOKIE_NAME);

        if (StringUtils.isNotBlank(redirectUriAfterLogin)) {
            CookieUtil.addCookie(response, REDIRECT_URI_PARAM_COOKIE_NAME, redirectUriAfterLogin, COOKIE_EXPIRE_SECONDS);
        }
    }

    @Override
    public OAuth2AuthorizationRequest removeAuthorizationRequest(HttpServletRequest request) {
        return this.loadAuthorizationRequest(request);
    }

    @Override
    public OAuth2AuthorizationRequest removeAuthorizationRequest(HttpServletRequest request, HttpServletResponse response) {
        return AuthorizationRequestRepository.super.removeAuthorizationRequest(request, response);
    }

    public void removeAuthorizationRequestCookies(HttpServletRequest request, HttpServletResponse response) {
        CookieUtil.deleteCookie(request, response, OAUTH2_AUTHORIZATION_REQUEST_COOKIE_NAME);
        CookieUtil.deleteCookie(request, response, REDIRECT_URI_PARAM_COOKIE_NAME);
    }
}

oauth2_auth_request 쿠키에는 Authorization Code가 Authentication Request 형태로 저장되어 있다.
redirect_uri는 인증 완료후 리다이렉트할 주소 정보가 담겨있다.

PrincipalOAuth2UserService

@Service
@Slf4j
@RequiredArgsConstructor
public class PrincipalOauth2UserService extends DefaultOAuth2UserService {

    private final UserService userService;

    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
        OAuth2User oAuth2User = super.loadUser(userRequest);

        UserJoinRequest userJoinRequest = parseToUserJoinRequest(userRequest, oAuth2User);

        User find = userService.findByUsername(userJoinRequest.getUsername()).orElseGet(() -> saveOAuthUser(userJoinRequest));

        return new PrincipalDetails(find, oAuth2User.getAttributes());
    }

    private UserJoinRequest parseToUserJoinRequest(OAuth2UserRequest userRequest, OAuth2User oAuth2User) {
        log.info("======global login======");
        log.info("getClientRegistration : {}", userRequest.getClientRegistration());
        log.info("getAccessToken : {}", userRequest.getAccessToken().getTokenValue());
        log.info("getAdditionalParameters : {}", userRequest.getAdditionalParameters());
        log.info("getAttributes : {}", oAuth2User.getAttributes());
        log.info("getAuthorities : {}", oAuth2User.getAuthorities());

        AuthProvider authProvider = AuthProvider.valueOf(userRequest.getClientRegistration().getRegistrationId().toUpperCase());
        Map<String, Object> attributes = oAuth2User.getAttributes();
        OAuth2UserInfo oAuth2UserInfo = OAuth2UserInfoFactory.getOAuth2UserInfo(authProvider, attributes);
        String username = String.format("%s_%s", authProvider.getProviderId(), oAuth2UserInfo.getId());
        String password = "defaultPassword";
        String email = oAuth2UserInfo.getEmail();
        return UserJoinRequest.builder()
                .username(username)
                .password(password)
                .email(email)
                .userRole(UserRole.ROLE_USER)
                .authProvider(authProvider)
                .build();
    }

    private User saveOAuthUser(UserJoinRequest userJoinRequest) {
log.info("최초 소셜 로그인이 감지되어 회원가입합니다.");
        return userService.saveUser(userJoinRequest);
    }
}

Access Token의 username 정보를 바탕으로 유저 정보를 db로부터 가져온다.

OAuth2AuthenticationSuccessHandler

@Slf4j
@Component
@RequiredArgsConstructor
public class OAuth2AuthenticationSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {

    @Value("${app.oauth2.authorized-redirect-uri}")
    private String redirectUri;
    private final TokenProvider tokenProvider;
    private final CookieAuthorizationRequestRepository authorizationRequestRepository;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authentication) throws IOException, ServletException {
        String targetUrl = determineTargetUrl(request, response, authentication);

        if (response.isCommitted()) {
            log.debug("Response has already been committed");
            return;
        }

        clearAuthenticationAttributes(request, response);
        getRedirectStrategy().sendRedirect(request, response, targetUrl);
    }

    protected String determineTargetUrl(HttpServletRequest request, HttpServletResponse response, Authentication authentication) {
        Optional<String> redirectUri = CookieUtil.getCookie(request,REDIRECT_URI_PARAM_COOKIE_NAME)
                .map(Cookie::getValue);

        if (redirectUri.isPresent() && !isAuthorizedRedirectUri(redirectUri.get())) {
            throw new BadRequestException("redirect URIs are not matched");
        }
        String targetUrl = redirectUri.orElse(getDefaultTargetUrl());

        // JWT 생성
        String accessToken = tokenProvider.createAccessToken(authentication);
        tokenProvider.createAndSaveRefreshToken(authentication, response);

        return UriComponentsBuilder.fromUriString(targetUrl)
                .queryParam("accessToken", accessToken)
                .build().toUriString();
    }

    protected void clearAuthenticationAttributes(HttpServletRequest request, HttpServletResponse response) {
        super.clearAuthenticationAttributes(request);
        authorizationRequestRepository.removeAuthorizationRequest(request, response);
    }

    private boolean isAuthorizedRedirectUri(String uri) {
        URI clientRedirectUri = URI.create(uri);
        URI authorizedUri = URI.create(redirectUri);

        return authorizedUri.getHost().equalsIgnoreCase(clientRedirectUri.getHost())
                && authorizedUri.getPort() == clientRedirectUri.getPort();
    }
}

Token Provider에게 토큰 생성 처리를 위임하고 생성된 토큰을 Client에게 전달한다.

OAuth2AuthenticationFailureHandler

@Component
@RequiredArgsConstructor
@Slf4j
public class OAuth2AuthenticationFailureHandler extends SimpleUrlAuthenticationFailureHandler {

    private final CookieAuthorizationRequestRepository cookieAuthorizationRequestRepository;

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        String targetUrl = CookieUtil.getCookie(request,REDIRECT_URI_PARAM_COOKIE_NAME)
                .map(Cookie::getValue)
                .orElse("/");

        targetUrl = UriComponentsBuilder.fromUriString(targetUrl)
                .queryParam("error", exception.getLocalizedMessage().replaceAll("[\\\\[\\\\]]", ""))
                .build().toUriString();

        cookieAuthorizationRequestRepository.removeAuthorizationRequestCookies(request, response);
        getRedirectStrategy().sendRedirect(request, response, targetUrl);
    }
}

OAuth 로그인 실패시 쿠키를 삭제하고 에러를 담아 Client에게 보낸다.

TokenProvider

@Slf4j
@Component
public class TokenProvider {

    private final Key accessTokenKey;
    private final Key refreshTokenKey;
    private static final LongACCESS_TOKEN_EXPIRE_TIME= 1000L * 60 * 60;
    private static final LongREFRESH_TOKEN_EXPIRE_TIME= 1000L * 60 * 60 * 24 * 7;
    private final UserRepository userRepository;

    public TokenProvider(@Value("${jwt.access-token-key}") String SECRET_KEY, @Value("${jwt.refresh-token-key}") String REFRESH_TOKEN_KEY, UserRepository userRepository) {
        this.userRepository = userRepository;
        byte[] encodedAccessTokenKey = Base64.getEncoder().encodeToString(SECRET_KEY.getBytes()).getBytes();
        this.accessTokenKey = Keys.hmacShaKeyFor(encodedAccessTokenKey);
        byte[] encodedRefreshTokenKey = Base64.getEncoder().encodeToString(REFRESH_TOKEN_KEY.getBytes()).getBytes();
        this.refreshTokenKey = Keys.hmacShaKeyFor(encodedRefreshTokenKey);
    }

    public String createAccessToken(Authentication authentication) {
        Date now = new Date();
        Date expiredDate = new Date(now.getTime() +ACCESS_TOKEN_EXPIRE_TIME);

        PrincipalDetails userDetails = (PrincipalDetails) authentication.getPrincipal();

        String username = userDetails.getUsername();
        String role = authentication.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.joining(","));

        return Jwts.builder()
                .setSubject(username)
                .claim("role", role)
                .setIssuedAt(now)
                .setExpiration(expiredDate)
                .signWith(accessTokenKey)
                .compact();
    }

    public void createAndSaveRefreshToken(Authentication authentication, HttpServletResponse response) {
        Date now = new Date();
        Date expiredDate = new Date(now.getTime() +REFRESH_TOKEN_EXPIRE_TIME);

        String refreshToken = Jwts.builder()
                .setIssuedAt(now)
                .setExpiration(expiredDate)
                .signWith(refreshTokenKey)
                .compact();

        PrincipalDetails userDetails = (PrincipalDetails) authentication.getPrincipal();
        String username = userDetails.getUsername();
        userRepository.updateRefreshTokenByUsername(username, refreshToken);

        CookieUtil.addSameSiteCookie(response, "refresh_token", refreshToken, (int) (REFRESH_TOKEN_EXPIRE_TIME/ 1000));
    }

    // Access Token 을 검사하고 얻은 정보로 Authentication 객체 생성
    public Authentication getAuthentication(String accessToken) {
        Claims claims = parseClaims(accessToken);
        User find = userRepository.findByUsername(claims.getSubject()).orElseThrow(() -> new UsernameNotFoundException("username is not found"));

        Collection<? extends GrantedAuthority> authorities = Arrays.stream(claims.get("role").toString().split(","))
                        .map(SimpleGrantedAuthority::new).collect(Collectors.toList());

        PrincipalDetails principal = new PrincipalDetails(find);

        return new UsernamePasswordAuthenticationToken(principal, "", authorities);
    }

    public Boolean validateToken(String token) {
        try {
            Jwts.parserBuilder()
                    .setSigningKey(accessTokenKey)
                    .build()
                    .parseClaimsJws(token);
            return true;
        } catch (ExpiredJwtException e) {
			log.info("만료된 JWT 토큰입니다.");
        } catch (UnsupportedJwtException e) {
			log.info("지원되지 않는 JWT 토큰입니다.");
        } catch (IllegalStateException e) {
			log.info("JWT 토큰이 잘못되었습니다");
        }
        return false;
    }

    // Access Token 만료시 갱신때 사용할 정보를 얻기 위해 Claim 리턴
    private Claims parseClaims(String accessToken) {
        try {
            return Jwts.parserBuilder()
                    .setSigningKey(accessTokenKey)
                    .build()
                    .parseClaimsJws(accessToken)
                    .getBody();
        } catch (ExpiredJwtException e) {
            return e.getClaims();
        }
    }
}

Access Token과 Refresh Token을 생성 및 검증한다.

코드 참조

https://github.com/KIM-KYOUNG-OH/Education-Lab

Reference

[Spring Security] 소셜 로그인 구현하기(OAuth2.0, naver)

헝그리개발자 — Mon, 16 Jan 2023 14:52:20 +0900

OAuth란?

OAuth는 유저가 따로 아이디나 비밀번호를 제공하지 않고 구글이나 네이버, 페이스북 같은 타사 인증을 대신 사용하는 표준화한 인증방식이다.

OAuth를 왜 쓸까?

과거 제공사별로 상이했던 인증 절차를 OAuth 프로토콜로 표준화함
유저 인증은 타사에 맡기고 AccessToken만 받아서 개인 정보를 받아서 사용함(개인 정보를 DB로 관리하지 않아도 됌)
유저가 별도의 아이디나 비밀번호를 기억할 필요 없음
유저의 가입 부담을 줄여줌(주로 스타트업 서비스에서 유저의 진입 장벽을 낮춰줌)

OAuth Flow

출처:  https://www.rfc-editor.org/rfc/rfc6749#page-8

클라이언트가 인증 서버에 Authorization Code 요청
Authorization Code 반환
Authorization Code 로 토큰 서버에 Access Token 요청
Access Token 반환
Access Token 으로 리소스 서버 API 호출
타겟 리소스 반환

Spring Security + OAuth2 사용하기

소셜 로그인 제공사에서 오픈 API 등록 신청
oauth 의존성 추가
application.yml 작성
security 설정 빈 생성

1. 소셜 로그인 제공사에서 오픈 API 등록 신청

이번 포스팅에선 네이버 오픈 API를 사용했다.

링크 : https://developers.naver.com/apps/#/register?api=nvlogin

등록이 완료후 client-id와 client-secret을 받을 수 있다.

추가적으로 Redirect URL을 등록해주어야 한다.

Redirect URL이란 OAuth 로그인 인증이 완료되면 다시 base URL로 돌아와야하는데 그 url 주소를 말한다.

스프링에서 제공하는 default redirect url template은 {baseUrl}/login/oauth2/code/{registrationId} 이다.

2. oauth 의존성 추가

build.gradle

dependencies {
		implementation 'org.springframework.boot:spring-boot-starter-oauth2-client'
}

3. application.yml 작성

네이버는 OAuth2.0 공식 지원대상이 아니라서 "naver"라는 id로 custom provider를 등록해줘야한다.

provider 등록을 안하면 "clientRegistrationRepository"에 "naver"라는 id로 등록된 provider가 없다고 에러가 발생한다.

security:
    oauth2:
      client:
        registration:
          naver:  # 네이버 소셜 로그인 registration id
            client-id: {client-id}
            client-secret: {client-secret}
            scope:
              - name
              - email
            client-name: Naver
            authorization-grant-type: authorization_code  # 코드를 부여받는 방식
            redirect-uri: 

        # 네이버는 OAuth2.0 공식 지원대상이 아니라서 별도로 "naver"라는 provider를 등록해줘야함
        # provider 등록을 안하면 "clientRegistrationRepository"에 "naver"라는 id로 등록된 provider가 없다고 에러남
        provider:
          naver:
            authorization-uri: <https://nid.naver.com/oauth2.0/authorize>
            token-uri: <https://nid.naver.com/oauth2.0/token>
            user-info-uri: <https://openapi.naver.com/v1/nid/me>
            user-name-attribute: response # 회원정보를 json의 response 키값으로 리턴해줌.

4. security 설정 빈 생성

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)  // 선택적으로 권한 처리시 @Secured나 @PreAuthorize 사용
public class SecurityConfig {

    private final PrincipalOauth2UserService principalOauth2UserService;

    public SecurityConfig(PrincipalOauth2UserService principalOauth2UserService) {
        this.principalOauth2UserService = principalOauth2UserService;
    }

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf().disable()  // csrf 보안 설정 여부
                .authorizeRequests()  // url에 대한 인증 설정
                .antMatchers("/user/**").authenticated()  // 인증되어야만 url 정상 처리
                .antMatchers("/manager/**").access("hasRole('MANAGER') or hasRole('ADMIN')")  // 특정 권한이 있어야만 url 정상 처리
                .antMatchers("/admin/**").access("hasRole('ADMIN')")
                .anyRequest().permitAll()  // 그외는 인증을 요구하지 않음
                .and()
                .formLogin()  // spring security에서 제공하는 로그인 form을 사용함
                .and()
                .oauth2Login()  // OAuth2 인증을 사용함
                .userInfoEndpoint()  // OAuth login 성공 이후 동작 정의함
                .userService(principalOauth2UserService);  // principalOauth2UserService 커스텀 서비스에게 처리 위임
        return http.build();
    }
}

PrincipalOauth2UserService는 OAuth2 인증시 사용하는 커스텀 객체인데 아래 예제 코드에서 설명하겠다.

소셜 로그인 동작 Flow

"http://{baseUrl}/oauth2/authorization/{registrationId}”을 호출하면 Spring Security Oauth2 Client는 타사에서 제공하는 로그인 페이지를 요청한다.
제공사 인증 서버는 로그인이 완료되면 authorization code를 애플리케이션 서버로 전송함
Authorization Code 로 Access Token 을 발급
Access Token으로 제공사 리소스 서버에 사용자 정보를 요청
spring security는 서버 세션안의 스프링만 별도로 사용하는 영역(Security ContextHolder)에 Access Token과 User 정보를 저장한다
- User 정보는 Authentication 타입 객체안에 OAuth2User 타입 객체에 저장된다
클라이언트는 Access Token id 를 쿠키로 저장한다.

예제 코드

PrincipalDetails

자체 로그인시 UserDetails타입 객체를 사용하고 OAuth 로그인시 OAuth2User 타입 객체를 사용한다.
아래 코드에선 UserDetails와 OAuth2User 두 가지 타입 모두 다중 상속 받도록 작성했다.

@Getter
public class PrincipalDetails implements UserDetails, OAuth2User {

    private final User user;
    private Map<String, Object> attributes;

    // 로컬 로그인시 동작
    public PrincipalDetails(User user) {
        this.user = user;
    }

    // oauth 로그인시 동작
    public PrincipalDetails(User user, Map<String, Object> attributes) {
        this.user = user;
        this.attributes = attributes;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        Collection<GrantedAuthority> collect = new ArrayList<>();
        collect.add(new GrantedAuthority() {
            @Override
            public String getAuthority() {
                return user.getRole();
            }
        });

        return collect;
    }

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

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

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

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

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

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

    @Override
    public Map<String, Object> getAttributes() {
        return attributes;
    }

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

PrincipalOauth2UserService

제공사 API로부터 가져온 유저 정보를 핸들링하는 Service Layer 커스텀 객체이다.

유저 정보를 OAuth2User 타입 객체에 담아서 리턴하는 loadUser() 함수를 정의해준다.

최초 소셜 로그인시 유저 정보를 DB에 저장하는 코드를 추가했다.

@Service
@Slf4j
@RequiredArgsConstructor
public class PrincipalOauth2UserService extends DefaultOAuth2UserService {

    private final UserService userService;

    // "/login/oauth2/code/{providerId}" 요청시 자동으로 동작
    // 소셜 로그인시 결과가 OAuth2User 타입 객체에 담김
    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
        OAuth2User oAuth2User = super.loadUser(userRequest);

        UserJoinRequest userJoinRequest = parseToUserJoinRequest(userRequest, oAuth2User);

        User find = userService.findByUsername(userJoinRequest.getUsername()).orElseGet(() -> saveOAuthUser(userJoinRequest));

        return new PrincipalDetails(find, oAuth2User.getAttributes());
    }

    private UserJoinRequest parseToUserJoinRequest(OAuth2UserRequest userRequest, OAuth2User oAuth2User) {
        log.info("getClientRegistration : {}", userRequest.getClientRegistration());
        log.info("getAccessToken : {}", userRequest.getAccessToken().getTokenValue());
        log.info("getAdditionalParameters : {}", userRequest.getAdditionalParameters());

        log.info("getAttributes : {}", oAuth2User.getAttributes());
        log.info("getAuthorities : {}", oAuth2User.getAuthorities());

        String providerId = userRequest.getClientRegistration().getRegistrationId();
        Map<String, Object> response = oAuth2User.getAttribute("response");
        String userId = (String) response.get("id");
        String username = String.format("%s_%s", providerId, userId);
        String password = "defaultPassword";
        String email = (String) response.get("email");
        String role = "USER";
        return UserJoinRequest.builder()
                .providerId(providerId)
                .username(username)
                .password(password)
                .email(email)
                .role(role)
                .build();
    }

    private User saveOAuthUser(UserJoinRequest userJoinRequest) {
        log.info("최초 소셜 로그인이 감지되어 회원가입합니다.");
        return userService.saveUser(userJoinRequest);
    }
}

아래는 소셜 로그인 성공시 로그에 찍히는 내용이다.

현재 코드는 네이버 API만 사용했지만 제공사마다 리소스 요청 API 응답 포맷이 다르기 때문에 추상화할 필요가 있어보인다.

getClientRegistration : ClientRegistration{registrationId='naver', clientId='clientId', clientSecret='clientSecret', clientAuthenticationMethod=org.springframework.security.oauth2.core.ClientAuthenticationMethod@4fcef9d3, authorizationGrantType=org.springframework.security.oauth2.core.AuthorizationGrantType@5da5e9f3, redirectUri='<http://localhost:8080/login/oauth2/code/naver>', scopes=[name, email], providerDetails=org.springframework.security.oauth2.client.registration.ClientRegistration$ProviderDetails@86135fc3, clientName='Naver'}
getAccessToken : {accessTokenValue}
getAdditionalParameters : {}
getAttributes : {resultcode=00, message=success, response={id=jO_Dgs23LK3fkkopR21-Asdfqw2341F, email=hong@naver.com, name=홍길동}}
getAuthorities : [ROLE_USER, SCOPE_email, SCOPE_name]

로그인 동작 테스트

Spring Session안에 Authentication 객체를 로그에 찍어보면 아래 처럼 정상적으로 저장된 것을 확인할 수 있다.

/test/login==========
authentication : User(id=9, username=naver_jO_Dgs23LK3fkkopR21-Asdfqw2341F, password=$2a$10$ZqmKiZ2RDDsjGPqw89yke.btVJNgd7HScimR7weoI.UqlseYLrVZ6, email=hong@naver.com, role=USER, providerId=naver, createDate=null)

정리

이번 포스팅에선 OAuth와 Spring Security를 이용한 소셜 로그인 구현에 대해서 알아보았다.

다음 포스팅에선 JWT에 대해서 알아보겠다.

코드 참조

https://github.com/KIM-KYOUNG-OH/Education-Lab

refer

[Spring Security] 웹사이트 자체 로그인 구현하기

헝그리개발자 — Thu, 12 Jan 2023 18:30:57 +0900

Spring Security는 애플리케이션에 대한 인증, 권한 부여 등의 보안 기능을 제공하는 java 프레임워크다.

다음과 같은 이유로 Spring Security를 사용해보았다.

대략적인 애플리케이션 수준의 보안 아키텍처를 검증된 프레임워크인 Spring Security를 통해서 간접 학습
OAuth2.0 이나 JWT 같은 기술에 대한 라이브러리를 포함하고 있어서 개발 비용 절약
ioc 컨테이너를 이용하여 외부 리소스와 비즈니스 로직 분리

Spring Security란?

애플리케이션에 대한 인증, 권한 부여 등의 보안 기능을 제공하는 프레임워크다.

spring security는 다음과 같은 특징을 가진다.

세션-쿠키 인증 방식을 지원한다.

서버는 세션 저장소에 유저에 대한 정보를 저장하고 클라이언트는 session id를 쿠키(JSESSIONID)로 들고있다가 요청할 때마다 Http Request에 쿠키를 담아 보내서 서버가 이를 검증한다.

Filter의 흐름에 따라 처리한다.

DispatcherServlet과 Controller 사이에서 동작하는 Interceptor와 다르게 Filter는 Dispatcher Servlet으로 도달하기 전에 동작한다.

Spring Security Architecture

AuthenticationFilter가 http request을 받음
요청에 담긴 아이디 비밀번호를 바탕으로 UsernamePasswordAuthenticationToken을 발급
- username과 password의 유효성 검사 같이 Filter단에서 추가 로직을 추가하려면 UsernamePasswordAuthenticationFilter 를 상속 받는 custom 객체를 생성해야한다.
생성된 token을 AuthenticationManager에게 전달
AuthenticationManager는 AuthenticationProvider들 중 해당하는 Provider에게 실제 인증 처리를 위임한다.
- AuthenticationProvider를 상속 받는 구현체는 authenticate 함수를 overriding해야함
- db에서 유저 정보를 조회해서 비밀번호가 일치하는지 확인함
UserDetailsService가 아이디를 이용하여 DB로부터 유저 정보를 가져온다
- UserDetailsService는 인터페이스이기 때문에 이를 implements 하는 클래스를 작성해야함
UserDetailsService가 DB를 통해 조회한 데이터는 UserDetails 타입 객체에 담긴다.
데이터를 Provider에게 반환
Provider가 UserDetailsService로부터 반환받은 비밀번호와 Token안의 비밀번호를 비교하여 일치하지 않는 경우 BadCredentialsException을 발생시킨다.
- 성공시 Authentication 객체를 생성하여 결과를 반환한다.
인증 완료된 Token을 AuthenticationFilter에게 반환하고 LoginSuccessHandler에게 전달한다.
LoginSuccessHandler는 Authentication 객체를 SpringContextHolder안에 저장한다.
- SpringContext는 spring security만을 위해 할당된 서버 session 영역이다.

Spring Security 사용하기

spring security 의존성 추가
Spring Security Configuration 설정

1. spring security 의존성 추가

build.gradle

dependencies {
		implementation 'org.springframework.boot:spring-boot-starter-security'
}

2. Spring Security Configuration 설정

spring security 3.2부터는 자바 빈 설정을 지원한다.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)  // 선택적으로 권한 처리시 @Secured나 @PreAuthorize 사용
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf().disable()  // csrf 보안 설정 여부
                .authorizeRequests()  // url에 대한 인증 설정
                .antMatchers("/user/**").authenticated()  // 인증되어야만 url 정상 처리
                .antMatchers("/manager/**").access("hasRole('MANAGER') or hasRole('ADMIN')")  // 특정 권한이 있어야만 url 정상 처리
                .antMatchers("/admin/**").access("hasRole('ADMIN')")
                .anyRequest().permitAll()  // 그외는 인증을 요구하지 않음
                .and()
                .formLogin();  // spring security에서 제공하는 로그인 form을 사용함
        return http.build();
    }
}

예제 코드

PrincipalDetails

자체 로그인시 UserDetails타입 객체를 사용한다.

import com.project.educationLab.domain.user.entity.User;
import lombok.Getter;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.ArrayList;
import java.util.Collection;

@Getter
public class PrincipalDetails implements UserDetails {
    
    private final User user;

    public PrincipalUserDetails(User user) {
        this.user = user;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        Collection<GrantedAuthority> collect = new ArrayList<>();
        collect.add(new GrantedAuthority() {
            @Override
            public String getAuthority() {
                return user.getRole();
            }
        });

        return collect;
    }

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

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

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

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

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

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

PrincipalDetailsService

자체 로그인시 동작하는 UserDetailsService타입 서비스 객체이다.

loadUserByUsername() 메서드를 오버라이딩한다.

package com.project.educationLab.domain.auth.service;

import com.project.educationLab.domain.auth.dto.PrincipalDetails;
import com.project.educationLab.domain.user.entity.User;
import com.project.educationLab.domain.user.repository.UserRepository;
import lombok.RequiredArgsConstructor;
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.Service;

@Service
@RequiredArgsConstructor
public class PrincipalDetailsService implements UserDetailsService {
    
    private final UserRepository userRepository;

    // "/login" 요청시 자동으로 동작
    // 로컬 로그인시 결과가 UserDetails 타입 객체에 담김
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User find = userRepository.findByUsername(username).orElseThrow(() ->
                new UsernameNotFoundException("username is not found"));
        return new PrincipalDetails(find);
    }
}

서버 세션 정보 조회 방법

@Controller
@RequiredArgsConstructor
@Slf4j
public class AuthController {

    @GetMapping("/test/login")
    public @ResponseBody String testLogin(Authentication authentication) {
        log.info("/test/login==========");
        PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal();
        log.info("authentication : {}", principalDetails.getUser());
        return "세션 정보 확인하기";
    }
}

위와 같은 방법으로 서버 세션안의 Authentication안의 UserDetails 타입 객체의 유저 정보를 조회할 수 있다.

>> /test/login==========
>> authentication : User(id=12, username=testUser, password=$2a$10$BW1qmL3FW5nuRs2dHYoEIOZxgM9goOGoSa.vJlyFNfu4z7mIztC.6, email=test@naver.com, role=USER, providerId=null, createDate=null)

로그인 동작 테스트

위와 같이 로그인후 브라우저의 메모리 영역에 JSESSIONID라는 이름의 쿠키가 저장된 것을 확인할 수 있다.

정리

이번 글에선 Spring Security와 자체 로그인을 구현하는 법을 간단히 알아보았다.

다음 글에선 OAuth2를 이용한 소셜 로그인 구현 방법에 대해서 다뤄보겠다.

코드 참조

https://github.com/KIM-KYOUNG-OH/Education-Lab

Reference

[Java] CentOS 환경에서 Java 설치

헝그리개발자 — Tue, 19 Apr 2022 19:15:40 +0900

yum 업데이트

$ yum update

java 설치

JRE와 JDK는 별도의 패키지이다
java-버전-openjdk는 JRE
java-버전-openjdk-devel은 JDK
JDK안에 JRE가 포함되있으므로 JDK를 받자

JRE 설치 확인

$ java -version

$ yum list installed java*openjdk

JDK 설치 확인

$ javac -version

$ yum list installed java*jdk-devel

설치할 JDK 찾기

$ yum list java*jdk-devel

JDK 설치

$ yum install java-X.X.X-openjdk-devel.x86_64

$JAVA_HOME 환경변수 설정

$JAVA_HOME 환경 변수에 사용할 JDK의 경로를 담는다
$JAVA_HOME을 설정해주지 않으면 javac를 호출할 때마다 앞에 JDK의 경로를 입력해주어야 한다

$JAVA_HOME: javac 명령어를 사용할 때 여러 JDK 중에 어떤 것을 사용할 것인지 경로를 지정해주는 것

$JAVA_HOME 값 확인

echo 명령어는 특정 text를 출력하는 명령어이다

$ echo $JAVA_HOME

javac 위치 확인

which는 특정 명령어의 경로를 찾는 명령어이다

$ which javac
/usr/bin/javac

readlink는 심볼릭 링크에 연결된 파일 경로를 찾는 명령어이다
- 심볼릭 링크는 바로가기이므로 여러 depth로 연결되있다
- -f 플래그로 재귀적으로 탐색해서 원본 파일 경로를 찾는다

$ readlink -f /usr/bin/javac
/usr/lib/jvm/java-11-openjdk-11.0.14.1.1-1.el7_9.x86_64/bin/javac

$JAVA_HOME 환경변수 설정

/etc/profile: root 계정(모든 사용자)에 적용

$ vi /etc/profile

JAVA_HOME 변수에 jdk의 경로를 지정하여 추가

export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-11.0.14.1.1-1.el7_9.x86_64

source 명령어로 변경 내용 적용

$ source /etc/profile

$JAVA_HOME 동작 확인

$ echo $JAVA_HOME
/usr/lib/jvm/java-11-openjdk-11.0.14.1.1-1.el7_9.x86_64

$ $JAVA_HOME/bin/javac -version
javac 11.0.14.1

$PATH 설정

$PATH: 명령어를 실행할 수 있는 경로들의 집합

$ vi /etc/profile

$JAVA_HOME/bin 경로를 추가

PATH=$PATH:$JAVA_HOME/bin

source 명령어로 변경 내용 적용

$ source /etc/profile

$PATH 동작 확인

$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/usr/lib/jvm/java-11-openjdk-11.0.14.1.1-1.el7_9.x86_64/bin

$ javac -version
javac 11.0.14.1

Reference

https://zetawiki.com/wiki/CentOS_JDK_설치