• [개발생각] REDIS에서 아토믹처리를 하려면

    REDIS를 깊게 사용하다보면, 트랜잭션처리 기능에 욕심이 생긴다. read_committed조회, rollback처리 이런것 있으면..이런생각 ㅋ

    REDIS는 기본적으로 완벽한 트랜잭션을 제공하는 다른 RDS의 성격이 아니다.

    빠르고 연산을 아토믹하게 처리하는 성격이고 또 그렇게 설계되었기 때문에, RDS에서의 트랜잭션처리를 완벽하게 구현할수도 없고,

    그렇게 사용하는게 개발메카니즘/철학과도 맞지않는 사용법이라고 생각한다.

    다만 우리는 REDIS사용을 할때, 아토믹한 처리의 여러가지 방법이 존재하기에 이 방법은 잘 알고있어야 한다.

    아토믹 처리의 방법중에는 크게 MULTI와 LUA SCRIPT방법 2가지가 있다.

    1) MULTI

    MULTI명령어 이후의 명령어는 순서를 보장하고, 다른 명령어가 끼어들지못하게 한다.

    (중요!!! 여러개 명령어를 실행할때, 중간에 하나의 명령어가 실패되어도, 롤백처리는 하지않고, 다음 명령어를 계속 실행 한다)

    ex)

    MULTI
    SET a 1 //즉시 실행 안되고 실행큐에 쌓임
    INCR a  //즉시 실행 안되고 실행큐에 쌓임
    EXEC // 이 시점에 레디스는 큐에 쌓아둔 명령어 위에 (SET, INCR)을 아토믹하게 처리(실행)함.

    여기서 중요한건, 위에 a라는 값의 읽기 보장을 위해서는, WATCH 명령어를 꼭 같이 사용해 줘야한다는 것이다. (일관된 읽기 기능)

    2) LUA SCRIPT

    LUA SCRIPT를 레디스 서버로 보내고, 해당 스크립트안에서 REDIS명령어를 수행하게 한다.

    스크립트의 실행은 원자적이기에, 해당 스크립트안에서는 원자성을 보장한다.

    (중요!! 스크립트안에서 여러개 명령어를 실행할때, 중간에 명령어가 실패되면, 스크립트 실행은 그 시점에 중단된다.

    하지만 롤백처리는 안된다.)

    ex)

    val script = DefaultRedisScript<String>().apply {
        scriptText = """
            local v = redis.call('GET', KEYS[1])
            return v
        """.trimIndent()
        resultType = String::class.java
    }
    
    val result = redisTemplate.execute(
        script,
        listOf("test")
    )

    결국 추천할만한 방법은 2번 스크립트 방식이지만, 스크립트를 레디스에 등록하여 사용하는부분에서 관리 포인트가 있다는점이

    단점이기도 하다. 

    레디스를 단순하게 GET, SET으로만 사용하는 단순한 비즈니스로직이 아닌, 정산/이체등 좀더 크리티컬한 비즈니스 로직을 사용해야할때는 원자성을 꼭 고려해야한다. 그러기 위해서는 위의 방법의 장단점을 잘 알고있어야 하지않을까 한다.

    그리고 특히, RDS에서 제공하는 격리수준도 꼭 고려하여 개발을 하여야할것이다.

    레디스에서 제공하지않는 격리수준을 어떻게 완충하여, 개발할것인가를 고민하는게 가장 중요하다!

  • [개발생각] 붉은사막…펄어비스…

    붉은 사막 오픈 하루전이다. 오늘 메타크리점수가 오픈되었고, 78점으로 주식은 하한가 크리를 먹었다..쩝 (주주로써 가슴아프다)

    요즘 개발에서 드는 생각와 붉은 사막과 오버랩되는것이 있다.

    과연, 유저를 위한 시스템인가? 나만의 생각을 유저의 생각이라고 포장하여 만든 시스템인가?

    서비스를 만들때, 초기 설계/기획을 할때, 가장 주의해야하는 부분이 아닌가 한다.

    연차 자랑은 아니고, 연차가 많기에 이런 경우를 많이 겪었기에 기우가 생긴다.

    대부분의 나의 안좋은 경험은 아래와 같았다.

    기획 : “유저들은 이런 기능을 원합니다! 이렇게 해주세요!”

    개발 : “음.. 어떤 데이터에 기반해서 유저들이 원한다고 판단했을까요?”

    기획 : “…..”

    기획 : “이 기능은 유저들이 정말 필요로 하는 기능이고, 요청사항도 많이 들어오니, 꼭 만들었으면 해요. “

    개발 : “이 기능을 사용하는 유저들은 혹시 모수가 어떻게 될까요?, 요청 사항(CS)의 건수와 의견은 어떤내용일까요?”

    기획 : “….”

    너무나 많이 봐왔다..

    나의 생각을 일반화 시켜서 만드는 서비스, 소위말하는 일반화의 오류.. 일부를 보고 그럴것이다 라고 단정하는 설계, 정확한 근거, 객관적인 지표를 바탕으로 결정하지않은, 나의 생각이 맞다는 생각에서 오는 결정들..

    정말 많이 겪었다.

    그리고 그런 대부분의 프로젝트는 망했다.

    또는 가까스로 평타를 치고, 책임을 모면하는 선에서 넘어가고,

    프로젝트원들은 안좋은 경험을 안고, 다시는 그 프로젝트를 언급하지 않고, 그렇게 사라졌다.

    (악몽을 다시 기억하고싶지않은 마음이랄까 ㅋ)

    여기서 위에 저 말이 나는 엄청나게 중요하다고 생각한다.

    “어떤 데이터에 기반해서 유저들이 원한다고 판단했을까요?”

    얼마나 중요하고, 꼭 들어야 하는 말일까?

    이 질문에 대답하지 못한다면, 근거가 부족한것이고, 기획자는 다시 기획을 해야한다.

    어떤 이유에서는 기획/설계단에서의 결정은 정확한, 또는 수집된 다수의 데이터등 객관화된 정보를 바탕으로 결정을 해야하고, 

    그렇지 못한 결정이라면, 집단지성으로 푸는게 차라리 더 낫다.

    근거가 없는 나혼자만의 생각 1인보다, 그문제를 같이 고민하는 여러명의 집단지성의 결정을 따르는것이 차라리 더 낫기 때문이다.

    결정에 근거가 명확하지않다면, 집단지성을 이용하자!

    펄어비스의 붉은 사막… 제발.. 위에 내가 경험한 부분이 없었으면 한다..ㅠㅠ

    (메타크리를 보니, 위의 경험이 자꾸 떠오른다 ㅠ)

  • [개발생각] testFixtures에 대해서

    테스트코드는 작성해야만 하는것, 하지만 유지보수에 대한 생각은 많이 안해도 되는것으로 생각하기 쉽다.

    테스트 코드를 잘 작성해야, 프로젝트의 퀄리티가 올라가는 부분에 대해서는 말하지 않아도 누구나 인지하고 있을듯하다.

    따라서, 테스트 코드를 어떻게 잘 작성을 하는가에 많은 개발자들은 초점을 맞추고있다.

    물론, 이 부분도 정말 중요하지만, 간과하면 안되는 부분이 있다.

    테스트 코드를 어떻게 유지보수를 하면서 잘 관리해 나가느냐 또한 잘 작성하느냐와 더불어 엄청나게 중요한 부분이라는 것이다.

    실제 비즈니스 코드는 리팩토링을 매번 하지만,

    테스트 코드를 쉽게 짜도록 하는 유틸이나, 기능에 대한 부분은 아예 작성하지 않거나, 리팩토링을 하지않으며, 신경을 덜 쓰게 된다.

    테스트 코드의 유지보수성을 높이기 위해서는, 테스트 코드 또한 서로의 영역(모듈)에서 클래스(구현체)기능들을 잘 만들고,

    테스트 코드에서 조합하고, 유기적으로 결합하여, 테스트 코드가 잘돌아가고 쉽게 개발자가 테스트 코드를 작성하도록 해야한다.

    이런 목적에 부합하는 플러그인이 있어서 하나 소개한다.(사용 예는 하와이API를 보시라!!)

    `java-test-fixtures`

    라는 플러그인이다.

    원칙적으로 모듈내의 test코드 영역은 다른 모듈에서 사용할수없다. 

    implementation으로 해당 모듈 디펜던시를 선언하여도 test영역의 코드는 가져오지 않는다.

    하지만, java-test-fixtures 플러그인을 이용하면, 모듈에서 해당 test영역의 코드를 가져올수있다. 

    더 자세히 말하면,

    testFixtures라는 폴더에 코드를 작성한 코드를 다른 모듈의 test구동시 가져와서 사용할수있다.

    (test영역을 가져오게되면, 해당 모듈에서 작성한 테스트 코드도 포함되기에,

    플러그인에서는 별도의 폴더를 선언하여 작성하는 룰을 만든것같다. )

    A라는 모듈에서 테스트 자동화를 위해 특정 기능을 만들어서 썼는데, 다른 B라는 모듈에 테스트에서도 사용을 하면 좋을때가 있다.

    이런경우라면, 기존에는 A모듈의 해당 코드를 B모듈로 복사해와서 쓰는방법밖에 없었다.

    하지만, java-test-fixtures 플러그인를 이용하면, B모듈에서

    testImplementation(testFixtures(project("A모듈")))

    위와 같이 설정을 하면, A모듈에 작성된 코드들(testFixtures폴더)을 import해서 test코드 작성시 사용할수있다.

    서비스를 만들때, 기능을 모듈별로 쪼개고,

    import하여 조합해서 사용하는 기존의 방식을 테스트코드를 작성하는 경우에도 활용할수있다는 것이다!!!

    이렇게 되면, 테스트코드 또한 ddd로 작성을 할수있게 된다. (이게 핵심!!!!)

    (인프라와 도메인, 어플리케이션에 맞는 코드를 적성하고, 도메인에서는 인프라의 구현체를 사용할수있고,

    어플리케이션에서는 도메인서비스를 자연스럽게 테스트코드에도 사용할수있게된다.)

    왜 테스트코드도 ddd구조로 작성하려고 하지않았을까?!

    그 중요성과 다르게 테스트코드를 너무 얕게 바라본건 아닐까? 다시한번 생각해본다..

  • [자작게임] 무한의 채굴

    유니티로 각잡고 게임한번 만들어보자고해서, 스터디해서 만들어본 방치형 광물 채굴 게임…

    유니티를 사람들은 쉽게 생각하지만, 잘 만들려면 유니티를 정말 심도 깊게 스터디해야한다는것을 느꼈다.

    쉽게 시작할수있지만, 쉽게 끝낼수는 없는 3D엔진툴이랄까?  ㅋ

    유니티에서 드로우콜 이라는 개념이 있는데, 이건 간단히 이야기하면,

    최초 CPU가 GPU에게 “이 오브젝트를 화면에 그려줘”라고 데이터와 함께 요청하는 명령의 단위이다.

    드로우콜이 많으면 많을수록 성능은 떨어지게 된다. 지속적으로 CPU가 요청을 해야하니, 병목이 생기고 성능이 떨어지기 때문이다.

    따라서, 드로우콜을 요청할때, 같은 객체를 한번에 그릴수있게 만들어, 다수의 객체를 그리게 만들거나, 팔레트, 메시를 하나로 합치거나 같이 사용하여, 드로우콜을 줄이는 방법으로 튜닝을 하게된다. 이부분이 게임에서 마지막 2% 폴리싱 단계라고 해야할까? 여기서 게임의 품질이 결정된다고 해도 과언이 아니게 된다.

    게임 동영상 : https://youtube.com/shorts/-sAMpy20hX4

    몇번 자작게임을 만들었었는데, 결국 이 폴리싱 과정에서 좌절하고 포기했던 기억이 있다.

    하지만 이번에는 좀더 각을 잡고, 정신차려서 만들어봤다.

    나름 퀄리티나 기획은 좋았고, 결과도 잘 나온듯하다.

    그런데… 재미가 없다는게..치명적인 단점 ㅋㅋ

    유니티 게임을 만들면서, 유니티에도 코루틴이라는 개념이 있는데, 이부분이 코틀린의 코루틴과 많이 비슷하면서도 다른점이 있어서 흥미로웠다. 유니티에서의 코루틴의 개념을 서버 프로그래밍에서도 적용하면, 재미있는 부분이 있을것같다는 생각이 들었다.

    서버 프로그래머라도, 다른 부분, 앱, 게임등 다른 분야의 프로그래밍을 접해보는것 또한 기술의 스펙트럼이나, 이해도, 창의력을 키우는데,

    도움이 되겠구나 라는 생각을 다시한번 갖게 해준 시도였다.

    특히 게임 제작에서 프로그래밍은 병렬 처리가 기본이 되는 프로그래밍이기에, 병렬/비동기 처리개념으로 모든 기능을 생각해야한다는 부분이 힘들었지만, 그만큼 기술적으로 성장하는 경험이 될수있다.

    다음에는 정말 제대로 한번 만들어 보자!! 액션 RPG게임으로 도전!!

  • [스터디] 코틀린에서 infix함수 활용에 대해서

    코틀린에서 infix함수를 잘 사용하면, 정말 깔끔한 코드를 만들고 유지할수있다. 적극사용하자!

    코틀린에서 infix 함수는
    점(.)과 괄호 없이 함수 호출을 할 수 있게 만드는 기능이다.

    (확장함수나, 함수 표현식이 아닌 호출 표현)

    그래서 코드가 마치 우리가 일반적으로 사용하는 인간의 언어, 즉 자연어처럼 읽히게 만들 수 있다.

    한가지 예로) a+b를 더하는 함수는 아래와 같이 정의하고, 사용도 아래와 같이 사용한다.

    fun add(a: Int, b: Int): Int {
        return a + b
    }
    
    add(1, 2)

    일반적으로 우리는 이렇게 함수를 만들고 사용한다.

    하지만 코틀린에서 infix함수로 정의를 하면, 더 깔끔하게 표현할수있다.

    infix fun Int.plus(other: Int): Int {
        return this + other
    }
    
    1 plus 2

    사용함에 있어서 훨씬, 우리의 자연어와같이 사용할수있다.

    map에서 값을 넣을때 key to value로 넣을때가 있는데, 이때 to도 infix함수이다.

    특히 infix함수는 kotlin에서 custom dsl을 만들때, 정말 유용하게 쓰인다.

    이전에 챗봇 시나리오 작성을 위한 dsl을 코틀린으로 만든적이있었는데,

    이때는 거의 dsl의 구성은 빌더패턴과, 람다함수, 그리고 infix함수의 조합으로 구성된다고 볼수있다.

    kotlin의 고급기술중에 custom dsl이 있는데, 담에는 이부분에 대해서 한번 정리를 해야겠다.

    (시간이 가면, 점점 잊혀지기에.. 자료로 남겨둬야겠다)

  • [아이디어] 대용량 앱푸시 예약발송 기능 어떻게 만들까?

    앱 푸시 메세지 발송 기능을 만들어야 한다면, 그리고 예약시간에 정확히 발송해야 한다면? 어떻게 설계를 해야할까?

    물론 내가 말하는 모든 가설은 대용량/대량 트래픽을 기본으로 하고있다. 따라서 좀더 고민을 해야하는 포인트들이 많다.

    우선은, 기본적인 것은 카프카 큐를 이용해, 발송대상 이벤트를 받고 해당 이벤트를 컨슘하며, 푸시를 보내는 설계는 기본일듯하다.

    여기서 가장 큰 문제는 바로 예약 발송을 어떻게 구현을 할까이다..

    이 부분이 상당히 어렵기도하고 까다롭기도 하다.

    예약 발송 구현을 위한 방법은 다양하다. 가장 합리적이고, 괜찮은 방법을 몇개 생각해 봤다.

    1) 레디스의 ZSET을 이용하는 방법이다.

    레디스의 ZSET는 SORTED SET으로 키값을 정렬하여 리스트로 가지고있다.

    이 키값을 범위조회로 가져올수있다. (복잡도 : O(log N))

    따라서, 예약시간을 키로 ZSET에 넣어두고, 배치나 스케줄을 통해 현재 시간에 해당하는 이벤트를 조회하여 발송큐로 발행한다.

    해당 발송큐에서 앱푸시 메세지를 발송하게 설계하는 방식이다.

    ZSET은 자체적으로 키에 대해서 Map과 Sorted List 2개의 자료구조를 가지고 있기에, 빠르게 조회/관리가 가능하다.

    따라서 대량 대용량 데이터를 넣고, 조회하는데 부담없이 사용할수있다.

    주의할점은 ZSET으로 조회한 값을 ZREM으로 삭제하는 케이스만 레이스 컨디션이 일어나지만 않게 하면 된다.

    이 부분은 Lua script를 통해서 조회와 조회된 데이터를 삭제하는 명령어를 아토믹하게 엮어주게 구성을 하면 문제가 없을듯하다.

    2) 카프카의 토픽을 시간 단위로 여러개를 만들고, 이벤트를 시간단위 토픽으로 이동시킨다.

    PUSH_D (날짜별 토픽)

    PUSH_H (시간별 토픽)

    PUSH_M (분별 토픽)

    발송이벤트를 처음에는 날짜별 토픽(PUSH_D)으로 발행하고, 해당 토픽에서 현재 날짜를 비교하여 예약날짜가 아니라면, 리큐하도록 큐에 다시넣는다, 그리고 예약날짜의 이벤트라면, 해당 이벤트를 시간별 토픽(PUSH_H)으로 이동시킨다. 해당 토픽에서 현재 시간을 비교하여, 예약 시간이 아니라면, 리큐하도록 큐에 다시넣고, 예약시간이 맞다면, 다시 분별 토픽(PUSH_M)으로 이동시킨다.

    해당 토픽에서 현재 분과 예약분이 맞다면, 메세지를 발송시킨다.

    마치 시간의 단위에 따른 체이닝이 되는 느낌으로 설계하는게 포인트다.

    이렇게 시간단위로 토픽을 만들고 지속적으로 이벤트를 이동시키면서 최종 토픽에서 발송을 시키는 방법이 있다.

    카프카큐를 적극적으로 이용하기에 대량 트래픽에 장점이 많지만, 리큐에 따른 시스템 부하여부도 신경을 써야한다.

    여기서 왜 굳이 여러 토픽으로 넘어가야하나?! 리큐의 횟수를 줄이려는 의도가 가장크다.

    시간단위가 큰 단위부터 점점 작은 단위로 넘어가기에 그나마 리큐의 횟수가 많이 줄어들게된다. 완충작용이랄까?!!

    3) ESPER를 이용하는 방법이다.

    레디스에서 시간순서의 SET기능과 유사하게 ESPER에 이벤트를 발행하고, 쿼리를 통해 현재 시간을 구하게 만들수있다.

    esper는 자체 쿼리를 지원하기에, 아마 아래와 비슷한 쿼리 하나면, 끝나지 않을까? ㅎㅎㅎ

    select * from PushEvent where eventTime = current_timestamp

    esper에 이벤트를 발행하고, 위 쿼리를 실행하면, 리스너로 현재시간에 발송해야하는 이벤트를 리스너로 보내준다.

    해당 이벤트를 잡아서 카프카 큐에 넣고, 발송만 하면 된다.

    esper는 정말 이벤트 cep중에는 가장 강력하긴하다.

    이런 실시간 처리기능설계등에서 좀더 적극적으로 사용하고 싶은 욕구가 막 올라오긴한다.

    이 방법은 상당히 깔끔하고 간단하다.

    하지만, esper는 기본적으로 클러스터구성이 아닌 싱글노드로 동작하고 (엔터프라이즈…유료),

    서버다운등에 따른 HA복구등이 없기에, 서버가 내려가거나 다운되면, epser안에 발행한 이벤트가 사라질수있다.

    따라서, 복구 전략을 꼭 만들어두어야 한다.

    복구 전략은 아마 카프카에 복구시점의 offset을 찾아서, 다시 컨슘해서 esper에 복구할 이벤트를 다시 적재하는 방법이 가장 심플하면서 강력할것같다.

    4) 데이터베이스에 예약발송 내역을 저장하고 폴링하여, 큐로 발송하는 방법이다.

    이 방법은… 기본적인 것이라 그냥 설명은 생략!!! 

    장단점도 명확한 기본적인 방법이니..

    여기서 가장 중요한 부분은 바로 하나의 발송내역 테이블을 여러 디비 커넥션들이 읽어가며 발송하고, 발송내역을 컬럼에 마킹하는 과정에서 다른 커넥션이 변경이전의 상태로 조회를 하게 되는 케이스가 발생하고 중복으로 데이터를 읽어 중복 발송하는 케이스가 발생한다.

    이부분을 엄청 신경 써야한다. 한개의 디비 커넥션으로 순차적으로 읽어가면 해결이 되긴하지만,

    이러면 성능이 안나오니..결국 여러개의 디비 커넥션이 경쟁적으로 조회하여, 발송을 하게 만들어야 하기때문이다.

    이부분은 각각의 디비커넥션, 즉 쓰레드들이 샤딩된 별개의 범위를 읽게하여 같은 영역을 조회하는 것을 원천적으로 막는 방법이 있고,

    다른 방법으로는 select for update 구문에 skip locked 옵션을 주어, 로우학을 걸어 동시성을 막고, 동시성이 걸려 락획득을 못한 다른 쓰레드들은 대기하지않고, 다음 로우를 자연스럽게 읽을수있게 옵션을 설정하면, 해결을 할수있다. (중요!!!)

    웬만하면 이 방법은 대용량 트래픽상황에서는 안쓰고 싶다..

    내가 앱 예약발송 기능을 만들어야 한다면, 레디스나 ESPER를 이용한 방법으로 구현을 할것같다..특히 레디스..ㅎㅎ

  • [개발생각] 원팀이 무얼까?

    원팀이 뭐냐는 질문을 최근 받았다. 평상시 나는 공상을 많이하는 사람이다.

    그 여러 공상중에서도 ‘원팀’에 대한 것도 많이 했었어서, 내생각을 확고히 말할수있었다.

    다만 평상시 엄청나게 공상했던, 그 답변을 모두 이야기하지못한 부분이 있기에, 그 나머지썰을 풀려고 한다.

    개발직군에서 특히, 회사에서의 ‘원팀’의 개념은 좀더 철저하고 엄격하다랄까??

    프로에서의 ‘원팀’은 아무리 누군가가 우리는 ‘원팀!!’,  ‘최고의 팀!’이라고 외친다고 원팀이 되지않는다.

    약간의 사기충전면에서의 도움정도 된다랄까?

    ‘원팀’의 마인드는 모두가 마음속에서 서서히 생겨난다.

    그 마음속에서 서서히 생겨나는 전제 조건중 가장 중요한건, 각자의 역할에 최선을 다하는 모습을 서로가 보이고, 이부분을 마음속에서 인정해 줄때, 존중의 마음과 함께, 우리는 같은 배를 탄, ‘원팀’이라는 생각이 자연스럽게 우러난다고 생각한다.

    그러므로, 프로에서의 원팀의 가장 중요한 성립 조건은 각자의 역할에 충실하고 책임을 지고 최선을 다해야한다는것이다. 

    만약, 내가 맡은 업무가 어렵고 힘든일이라고 생각한다면, 도움을 청하는것도 방법이다.

    (아무리 시니어고 경험이 많다고해도, 토발즈, 존카멕이 아닌데, 어렵고 힘든일이 있는건 당연하잖아?!)

    도움을 청하고, 같이 해결하자고 손을 내미는 그 사람 또한,

    이미 다른팀원들을 ‘원팀’,  팀원으로 인정해 주고 믿는다는 반증이기도 하기때문이다.

    하지만, 그렇지 못하다면, 이부분에 대해서는 확실히, 냉철하게 지적을 받아야하고, 이부분에 대해서 개선을 해나가야 한다.

    (왜냐면, 프로기 때문이다. 프로는 프로답지못하다면, 비난을 받아야 한다고 생각한다. 지적이 싫다면, 그냥 자신을 아마추어라고 생각해자)

    부족한 부분에 대한 지적에 대해 개선되는 모습이 보일때, 그 모습에서 다시 ‘존중’이 생기고, ‘원팀’을 다른 팀원들은 생각하게 된다.

    이 부분을 내가 공상만으로 생각을 한건 아니다. 한 경험이 있다.

    이전 다니던 회사에서 금요일 저녁, 기쁜 마음으로 게임도 하고, 유투브도 보고 할생각에, 퇴근을 하려고 준비중이였다.

    그런데 팀원 한명이 쩔쩔매며, 코딩을 하고 있었다.

    너무 당황스러워하는 모습이라, 무슨일이있냐고 하니, 버그가 발생했고, 당장 월요일에 오픈해야하는데, 힘들다는 말이였다.

    그 순간 바로 가방을 자리에 다시 두고, 같이 앉았다.

    그리고 버그 해결을 하기위해 손을 도왔다. 

    시간이 갔고 어느덧 조금만 조금만하는 사이에 새벽 5시가 되었고, 서로 먼저랄것도 없이, 우선 집에가서 씻고,

    점심먹고 오후3시쯤에 다시 와서 하자고 약속하고 퇴근을 하였다.

    그런데, 정말 이솝우화같은 일을 겪었다. (사이좋은 형제??와 더 비슷할까?)

    오후3시에 만나자는 약속을 나는 지킬생각이 없었다.

    우선 피곤한 팀원을 먼저 퇴근시키고 푹쉬다가 3시에 오게하려는 생각이였고,

    나는 잠깐, 집에 가서 씻고, 아침먹고 다시 나올생각이였다.

    그리고 10시쯤에 회사에 왔는데, 조금있다가 그 팀원도 어의없게 출근했다…

    그 황당함이란 참 ㅋㅋ

    서로 이야기해보니 같은 생각이였다. 서로에 대한 배려가 있었다.

    그 경험을 겪고 그 팀원과는 마음속 깊이 서로 존중하고, 이해하는 마음이 생겼다.

    (그리고 이 경험때문에 레빗MQ의 딜레이큐를 정확히 알았다랄까? ㅋㅋ)

    여기서, 내가 황금 금요일 저녁에, 아무 조건없이 같이 앉아서 도와준 가장 큰 이유는, 그 팀원은 평상시에도 자기가 맡은 일에 대해서 엄청난 책임감이 있는 사람이였던것을 나는 알고있었고. 그부분을 존중하고있었기 때문이다.

    결국, 내가 해야할일을 최선을 다하고, 책임을 다하는 모습을 보인다면, 그 모습을 보는 팀원들이, 자연스럽게 존중하고, ‘리스펙’하게 된다.

    이런 사람들이 모인다면, 결국 ‘원팀’이 자연스럽게 되는게 아닐까 한다.

    우리는 동네 골목대장, 대학교 동아리가 아니고, 프로이기 때문이다.

    근데 사실 부질없기도 하더라…

    원팀이던 뭐던…어차피 퇴사하면 잊혀지는건 만고의 순리랄까? ㅋ 

  • [개발생각] Apache Camel에 대해서

    아파치 카멜 처음 잠깐 써본게, 18년 정도 된거같은데… 최근에 각잡고 써보니 쓸만하다!!

    인터넷 찾아보니, 최초 릴리즈가 2007년…ㅎㄷㄷ

    잠깐 사용했을때가, 나온지 1-2년된 따끈따끈한때였구나 ㅋ

    그때도 어느정도 성숙한 오픈소스여서, 꽤 유용했던것으로 기억한다.

    특히 간단한 ETL, BATCH 잡에 사용하기 정말 강력했던 기억이다.

    물론, 스프링배치가 배치쪽은 아직 꽉 잡고있다고는 하지만, 스프링배치는 너무 초기 러닝커브가 있다는 점이 아쉽다.

    최근에 카멜을 다시 쓸일이 있어서, 좀 자세히 알아봤는데, 실시간 이벤트 처리에 관해서는 꽤 괜찮은 솔류션으로 보인다.

    우선 병렬처리에 대한 접근이 쉽다.

    샤딩을 직접 해서 대상을 만들거나, 파티션으로 데이터를 읽거나 하는 방법을 쓰지않아도 (물론 쓰면 더좋다),

    설정 몇개로 병렬처리를 할수있다.

    카멜에서 병렬처리는 크게 3가지로 나뉘는데,

    1) Threads 옵션

       – 실행되는 Step단위로 병렬 처리

    2) Split + ParallelProcessing 옵션

       – 대상 데이터들 각각 단위로 병렬로 처리

    3) Seda 옵션

       – 메모리 큐를 통해, 컨슘을 병렬로 처리.

    위 3개의 옵션으로 병렬처리를 통해, 데이터 처리 퍼포먼스를 크게 올릴수있다.

    특히 3) Seda 옵션은 상당히 흥미롭다.

    Seda 옵션만 잘사용해도 엄청난 퍼포먼스를 낼수있겠다고 추측한다.

    Seda 옵션은 걸면, 옵션이 설정된 스텝은 메모리큐에 처리대상이 쌓이고, 그것을 컨슘하여 처리하도록 처리방식이 바뀐다.

    기존에 만약 아래와 같은 Step3으로 구성된 배치잡이 있다고 생각해보자.

    >>>>>>>>

    Step 1) 카프카 토픽

    Step 2) 데이터 컨슘

    Step 3) 디비 저장

    >>>>>>>>

    여기서 퍼포먼스 병목이 일어나는 경우는 디비 저장이 느려질때이다.

    카프카 컨슈머는 컨슘대상 토픽의 파티션갯수와 1:1로 연결이 되는 구조이기때문에, 퍼포먼스를 올리려면 토픽의 파티션갯수를 늘리는 방법이 가장 최선이다. 하지만 토픽의 파티션갯수는 무한정 늘릴수도없다.

    파티션갯수가 늘어나면 카프카 노드간의 레플리카를 위해 통신해야하는 횟수도 따라서 올라가기때문이다.

    (이부분이 은근히 서버 리소스를 엄청 많이 잡아먹는다)

    게다가 Step 3) 디비 저장이 느려지면, 결국 병목이 더욱 심하게 된다. 

    하지만, Seda가 출동하면 어떻게 될까?? (드.라.군)

    아마 구조는 아래와 같이 만들수있을것이다.

    >>>>>>>>

    Step 1) 카프카 토픽

    Step 2) 데이터 컨슘

    Step 3) Seda 큐

    Step 4) 디비 저장.

    >>>>>>>>

    카프카 토픽에서 컨슘한 데이터를 Seda 큐에 넣는다. 해당 Seda큐는 메모리 큐이고, 해당 메모리 큐에 컨슘을 여러 쓰레드가 나눠서 컨슘을 할수있다. Seda 큐에 컨슈머의 쓰레드갯수를 설정해 줄수있기에,

    카프카 토픽에서 배치 사이즈 30으로 30개의 메세지를 받아서,

    Seda큐에서 컨슈머 쓰레드 갯수를 30개로 설정하면, 30개의 병렬처리가 되는것이다.

    이렇게 되면, 토픽의 파티션갯수를 늘리지 않고도 병렬처리의 갯수를 늘릴수있다.

    물론 디비저장의 쓰레드 풀이나, 성능에 대한 튜닝은 추가로 해야하겠지만, 토픽 처리의 성능을 간단히 늘릴수있게 된다.

    그리고 복잡한 여러개의 Step으로 구성된 배치잡이라면,

    중간중간에 Seda큐를 이용해여 Staging 데이터를 메모리큐로 모았다가 병렬로 처리하도록 분산해주는 단계를 넣어주면,

    각각의 Step들이 비동기 병렬처리로 동작하게 만들수있다.

    배치잡에서 성능을 최대로 끌어올리는 방법으로 고려야 봐야하는 구조라고 생각이 든다.

    물론, 메모리 큐를 사용하기에 메모리 사용량이 늘어날수있기에,

    Throttle, Size등의 설정을 잘해야하는것은 당연히 고민해야하는 기본으로 본다.

    좀더 잘 쓸수있도록 공부해야겠네!! 

  • [개발생각] 오래걸리는 작업에 대한 처리

    오래걸리는 외부 API의 결과를 데이터베이스에 저장하는 기능을 개발해야한다면, 어떻게 구현해야할까?

    내부 API는 30ms~100ms 내외의 응답속도를 보장해야하기도 해서, 큰부담없이 사용할수있겠지만,

    외부에서 제공하는 API들은 기능에 따라서 길게는 수초에서 수십초가 걸리는 것도 있다.

    (스크래핑, 대용량 데이터 응답(빅데이터 조회)등)

    이경우 해당 응답을 데이터베이스에 저장을 해야하는 비즈니스 로직이 존재한다면,

    어떻게 구현을 해야, 개발 잘했다고 소문이날까?!!

    우리는 몇가지를 고려해야한다.

    >>>

    1) 외부API의 장애에 대한 처리가 있어야 한다. 

    – 외부API의 응답속도가 현저히 떨어지거나, 장애로 인해 접속에 문제가 있는경우는 지속적으로 외부API를 호출하지 않도록,

    방어장치가 있어야 한다. 

    – 간단한 방법으로는, 서킷브레이커를 설정하고, connection, read timeout 설정을 하면 대응할수있을것 같다.

    – 서킷브레이커를 사용하여, 장애가 난 경우, 호출을 중지하도록 하고, 이후에 샘플링 호출을 통해,

    실제 장애복구가 되는시점에 다시 호출을 하도록 하면 해결가능하다.

    – connection, read timeout설정을 적절히 하여, 연결, 응답에 많은 시간을 대기하지 않도록 설정하면 좋을것같다.

    >>>

    2) 외부API와 디비 트랜잭션 코드 블럭을 분리해야한다.

    트랜잭션 코드 블록안에서 오래걸리는 외부 API호출 코드가 같이 존재하게 되면,

    외부API의 오랜대기로 인해, 디비 커넥션을 장기간 점유하게 되고, 다수의 이런 케이스가 늘게 되면, 디비 커넥션이 고갈되게 된다. 

    – 디비 저장시 트랜잭션 필요여부를 파악하고, 트랜잭션이 필요없다면, 과감히 트랜잭션을 사용하지않는것이 좋고,

    만약 롤백처리등을 위해서 사용을 해야한다면,

    @Transactional 블록안에 외부API호출 코드를 포함하지 않도록 해야한다.

    @Transactional 코드블록 바깥에서 외부API호출을 해서 결과를 인자로 전달하여, 저장하는 방법을 사용해야 안전하다.

    >>>

    3) 오래걸리는 외부 API호출을 서버에서 해야하는 기능은 별도로 Request Thread고갈을 방지하기위해, 별도 쓰레드 벌크해드 처리를 해야한다.

    – Callable, DefferedResult, WebAsyncTask등의 방법을 통해, 톰캣 요청 쓰레드를 사용하지않고, 별도 쓰레드풀에서 동작하도록 하여, 톰캣 요청 쓰레드 고갈을 방지하도록 해야한다.

    >>>

    4) 버철 쓰레드 사용을 고려해 본다.

    스프링부트 3.1버전 이상, 자바 21부터는

    spring.threads.virtual.enabled=true

    설정을 통해, 스프링부트의 쓰레드를 버철스레드로 사용하도록 설정할수있다.

    ThreadLocal 사용을 많이 하지않는 서비스라고 하면, 설정하는것을 고려해 볼만하다.

    (ThreadLocal을 적극정으로 사용하는 서비스는 메모리 증가의 문제가 발생가능함

    – 대량의 가상스레드별 ThreadLocal이 생성되기때문에)

    외부연동 API의 결과를 데이터베이스에 저장하는 비즈니스 로직의 흐름은 일반적으로 서비스 코드에서 많이 나오는 패턴이다.

    하지만, API의 응답속도에 따라,

    그 코드를 어떻게 구현해야하는지에 대해서는 간과하기 싶다.

    이 부분의 문제는 실제 오픈하고, 트래픽이 몰릴때 발생하기에 선제적으로 고려하지않으면, 그 영향/피해가 상당히 크다.

    항상, 대량 트래픽에 대한 처리에 대해서 간과하지 말자…

  • [개발생각] Kafka 이벤트와 트랜잭션에 대해서

    트랜잭션과 비동기 프로세스의 처리에 대해서, 인지하고 있어야 할것이 있다.

    가끔 카프카 이벤트와 트랜잭션에 대해서 혼돈이 일어날때가 있어서, 적어두고자 한다.

    @Transactional
    
    fun saveUser() {
    
        userRepository.save(User(id = "test"))
    
        kafkaEventPublisher.send(Event("SaveUser"))
    
    }
    
    
    
    @Transactional
    
    @KafkaListener
    
    fun listener(event:String) {
    
        val user = userRepository.findById("test")
    
        user?.let {
    
            println("user is not null")
    
        } ?: println("user is null")
    
    }

    이경우,  대충보면, listener함수에서 당연히 user is not null 이라고 출력이 될것으로 파악할수있다.

    하지만, 결과는 user is null로 출력된다.

    왜나면, saveUser에서 id=test인 user가 커밋되기 전에,

    카프카 이벤트가 발생하고, listener로 이벤트가 들어온 시점에도 아직 saveUser가 커밋이 되지 않은 상태이기 때문에,

    user를 조회해도 user가 없는것이다.

    listener는 별개의 쓰레드로 동작하고, 트랜잭션도 별개이기때문에, user가 커밋되지않은 시점이기에, user는 null로 조회된다.

    이것을 해결하는 방법은 크게는 2가지정도가 있다. (더있나, 좀더 생각을 해봐야지)

    한가지는 트랜잭션아웃박스 패턴처럼, user테이블이 실제 커밋된 시점까지 폴링을 하는 방법이다.

    이건 사실 복잡하고, 폴링에 따른 리소스의 낭비가 심하기에 좋은 방법은 아니라고 생각해서, 사용하지 않는것이 낫다고 생각이 든다.

    (패쓰!!!!)

    (사실 복잡한건..커서 관리가 귀찮고, 분산처리도 해줘야한다. 쿼리에 skip locked 같은것 옵션줘서,

    락프리하게도 만들어야하지만, 락프리기능을 디비에 의존하는 방법이라 좀처럼 맘에 들지는 않는다…)

    나머지 한가지 방법은 TransactionalEventListener를 이용하는법이다.

    카프카 이벤트를 바로 쏘지않고, ApplicationEventPublisher를 이용해 이벤트를 발생시키고,

    TransactionalEventListener 함수에서 한번 받아서 카프카 이벤트를 쏘는 방식이다.

    이때 TransactionalEventListener 함수에서 TransactionPhase.AFTER_COMMIT 옵션을 주어,

    커밋이 완료된 시점에 이벤트가 발생하고, 리스닝할수있게 설정하면,

    실제로 TransactionalEventListener 함수로 이벤트를 받았을때는 이미 saveUser는 커밋이 완료된 상태를 보장하기에,

    이후에 카프카로 이벤트를 발행하고, 리스닝하는 listener함수에서는 user를 조회하면, 값을 조회할수있게 된다.

    이렇게 커밋이후 시점에 이벤트를 발행하도록 TransactionalEventListener을 이용하는 방법을 사용하는게,

    그나마 깔끔한 방법이라고 생각된다.

    (참고로 @Async처리도 비슷한 방법을 사용하면, 트랜잭션 이슈를 해결할수있다 🙂

    트랜잭션과 비동기 처리는 참, 생각할것이 많고, 잠깐만 방심하면, 구멍을 만들어낸다.

    구멍이 만들어진 상태에서는 디버깅이 가장어려운것이 비동기,트랜잭션 처리이기에,

    프로젝트/개발 초기에 이런 부분은 유심히 잘챙겨야 한다.