DH Developement

[GO] Graceful Shutdown

dongburiii — Fri, 25 Apr 2025 15:35:50 +0900

Graceful Shutdown

취소 가능한 컨텍스트 생성
- 컨텍스트와 취소 함수가 리턴됨
- 종료 시그널 감지 시 취소 함수 실행

ctx, cancel := context.WithCancel(context.Background()) defer cancel()

신호 감지

ctrl + c -> 운영체제에서 취소 신호(interrupt 신호)를 프로세스로 넘겨줌
signal.Notify는 신호를 감지하면 받아서 sigChan 이라는 채널로 넘겨줌

sigChan := make(chan os.Signal, 1) 
signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

신호 감지 고루틴

신호가 들어올때까지 sig := <- sigChan은 기다림
- Buffered Channel 로 생각하면 될듯
취소 신호(interrupt 신호)를 감지하면 signal.Notify로 sigchan 채널에 취소 신호를 넘김
sigChan 채널의 값을 sig 변수에 채널을 담고, 해당 블록은 해제됨
로그를 찍은 후 컨텍스트 취소 메서드를 실행

go func() { 
    sig := <-sigChan 
    log.Printf("Received signal %s, shutting down...", sig) 
    cancel() 
}()

컨텍스트 완료 대기

컨텍스트 취소 함수 (cancel())가 실행되기 전까지 대기 (블록)
신호 감지 고루틴을 통해 취소 함수가 실행되면 대기중인 context의 채널이 닫힘
- 이렇게 되면 해당 context를 사용중인 모든 함수들에 취소 신호가 전파됨
컨텍스트가 취소되면 ctx.Done() 이 실행됨

<-ctx.Done()

완성본

전체 코드와 흐름은 아래와 같다.
취소 신호를 받아 컨텍스가 취소되기 전까지 실행할 함수를 넣어주면 된다.
- 실행할 함수에도 취소 가능한 context(ctx) 를 넘겨줘서, Graceful 하게 고루틴을 종료시킬 수 있음


func main() {
    // 취소 가능한 context 생성
    ctx, cancel := context.WithCancel(context.Background())

    defer cancel() // 종료 취소 보장

    // 신호 채널 생성
    sigChan := make(chan os.Signal, 1)

    // 취소 신호 감지 시 채널에 넘겨주는 용도
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    go func() {
        sig := <-sigChan // 신호가 들어올 때 까지 대기. 신호가 들어오면 해제됨
        log.Printf("Received signal %s, shutting down...", sig)
        cancel() // context 취소 함수 실행
    }()

    // 실행할 함수
    lib.Download(ctx, url, fileName)

    <-ctx.Done()

    // 종료 로그 등, 종료
}

[GO] 채널

dongburiii — Mon, 7 Apr 2025 09:58:38 +0900

Channel

채널은 고루틴 간의 데이터 파이프라인이다.
종류는 Unbuffered channel과 buffered channel로 구분된다.
- Unbuffered Channel: 동기적
  - 수신 채널쪽에서 송신될 때 까지 채널이 묶는다. 즉 Block을 시키고 대기한다.
  - 수신 채널이 준비되지 않다면 deadlock 에러가 발생한다.
- Buffered Channel: 비동기적
  - 수신 채널이 데이터를 받을 준비가 되지 않더라도 지정된 버퍼만큼 데이터를 보내고 다음 작업을 수행한다.
main() 함수는 가장 메인으로 생성되는 Goroutine이다.

채널 예시1

수신자는 goroutine으로부터 데이터가 채널을 통해 들어올 때 까지 대기한다.

func main() {
    channel := make(chan int) // 정수 타입을 받는 채널 생성

    go func() {
        channel <- 123 // 채널에 123을 보냄
    }()

    var i int

    // goroutine에서 데이터를 전송할 때까지 계속 대기
    i = <- channel // 채널의 123을 수신한다.
}

채널 예시2

수신자와 송신자가 서로 기다리기 때문에, Goroutine 이 끝날 때 까지 기다리게 할 수 있음

func main() {
    done := make(chan bool)

    go func() {
        for i := 0; i < 10; i +=1 {
            fmt.Println(i)
        }

        done <- true
    }()

    <- done // 위 익명함수 Goroutine이 종료될 때까지 대기
}

Channel Buffering

Unbuffered Channel

하나의 수신자가 데이터를 받을 때까지 송신자의 채널에 묶임
즉 위에서 보여준 예시가 Unbuffered Channel 임
만약 수신자가 준비되지 않았다면 에러 발생
- Deadlock

func main() {
    channel := make(chan int)
    channel <- 1 // 수신 Goroutine이 없으므로 DEADLOCK
    fmt.Println(<- channel) // 별도의 Goroutine이 없으므로 DEADLOCK
}

Buffered Channel

버퍼 채널을 만들어서 사용하면 수신자가 없어도 데이터를 보낼 수 있음

func main() {
    channel := make(chan int, 2) // 두개의 버퍼 채널 생성

    channel <- 10 // 수신자가 없더라도 보낼 수 있음

    fmt.Println(<- channel)

}

송수신 역할 분리

채널은 기본적으로 송신과 수신 역할 전부 다 할 수 있다.
그러나 특정 역할만 수행하게 정해줄 수 있다.

func main() {
    channel := make(chan string, 1) // Buffered Channel
    sendChannel(channel) // 전송
    receiveFromChannel(channel) // 수신
}

// 채널에 데이터 입력하는 역할만 수행
func sendToChannel(ch chan <- string ){
    ch <- "data"
    // data := <- ch 에러 발생
}

// 채널의 데이터를 수신하는 역할만 수행
func receiveFromChannel(ch <- chan string) {
    data := <- ch
    fmt.Println(data) // "data" 반환
}

채널 닫기

채널을 닫은 이후 더 이상 해당 채널로 데이터 전송은 불가하다
그러나 남은 데이터가 있다면 수신은 가능하다.
channel의 리턴값은 두개이다
- 채널 내의 데이터 값과 수신 성공 여부

func main() {
    channel := make(chan int, 2)

    channel <- 1 // 채널에 데이터 전송
    channel <- 3 // 채널에 데이터 전송

    close(channel) // 채널 종료

    fmt.Println(<-channel) // 남은 데이터가 채널에 있다면 수신
    fmt.Println(<-channel) // 남은 데이터가 채널에 있다면 수신

    if _, success := <- channel; !success { // 채널에 남아있는 데이터가 없다면 false
        fmt.Println("데이터 없음")
    }

}

[GOLANG] 고루틴(GoRoutine)

dongburiii — Fri, 4 Apr 2025 16:53:32 +0900

Goroutine

Go 런타임이 관리하는 가상(논리) 쓰레드
- go 키워드로 고루틴 실행 가능
비동기적으로 함수 루틴을 수행하며, 동시 동작 수행에 사용됨
OS 스레드보다 훨씬 가볍고, 생성할 때 비용이 적음
- OS 스레드는 1mb의 메모리 스택, goroutine은 kb 단위 (동적 증가 가능)
기본적으로 CPU 1개를 시분할하여 사용

다중 처리

Go는 기본적으로 CPU 개를 사용한다
다중 병렬 처리를 위해 CPU를 여러개 사용하기 위해선 GOMAXPROCS로 증가시킬 수 있다.

runtime.GOMAXPROCS(4) // CPU 4개 사용

익명함수 (go func)

익명 함수 go func() {}() 으로 비동기 실행 가능

func main() {  
  var wait sync.WaitGroup // Go 루틴 대기열 두개 생성  
  wait.Add(2)


  go func (parameter string) {
      defer wait.Done()
      //
  } ("parameterValue")

  wait.Wait() // Go 루틴 끝날 때 까지 대기
 }

Graceful Shutdown

Go 언어에서 여러 고루틴을 운영할 때 Graceful Shutdown 로직이 필요한 이유는, Go 애플리케이션이 종료 신호를 받았을 때 하위 고루틴들이 메인 고루틴보다 먼저 종료될 가능성이 있기 때문
쉽게 말하면, 작업 지시서이다

Context

동시성을 관리
여러 goroutine에 값을 전달
취소 신호 전파
분산 시스템 / 서비스 간의 상호 작용에서 아용

context.Background

모든 context 의 기본이 되는 빈 context 를 반환
대부분의 context 는 이를 기반으로 생성

context.TODO()

아직 구현되지 않은 부분을 나타내는 context 를 반환

[패키지] 오픈소스 패키지 발행

dongburiii — Mon, 31 Mar 2025 08:22:01 +0900

계기

Go 로 사이드 프로젝트 개발을 하다, 동적 쿼리가 필요한 경우도 많았고 동일한 유틸/함수들을 다양한 프로젝트에서 동일하게 사용해야 하는 경우가 너무나 많았다.
문득 내가 모든 프로젝트들에 사용하는, 내가 만든 함수들을 패키지화 시키고 간편하게 사용하면 어떨까 생각하게 되었다.
- 그렇게 '동적 쿼리 유틸'과 'DB 연결 및 쿼리' 유틸들을 오픈소스 패키지화 하기로 결정하였다.

버전 릴리즈

우선 깃허브에 퍼블릭 레포를 파고 패키지 소스코드를 푸시 하였다.
패키지를 임포트 해 사용할 것이기 때문에, 메인 함수의 패키지명은 사용할 패키지 명으로 설정해야 한다.

package gqbd

// ... 코드

테스트 코드들로 각 함수및 유틸들이 원하는 리턴값을 가져오는지 검증을 진행하였다.
- 여담이지만 <>_test.go 파일들을 테스트 코드로 인식한다.
- t *testing.T 타입을 인자로 넘겨주면 테스트 진행할 함수로 인식된다.
완료된 후 버전을 릴리즈했다. 최초 베타 테스트이므로 v0.1.0 으로 잡았다.

git tag v0.1.0
git push origin v0.1.0

위처럼 레포에 v0.1.0으로 푸시를 했다면, 이제 Go 쪽에 해당 패키지와 버전을 알려주면 배포가 완료된다.

GOPROXY=proxy.golang.org go list -m github.com/<repo_owner>/<repo_name>@<version>

이렇게 하면 GoDoc에서 내가 배포한 레포를 확인할 수 있다.
- 다만 배포했다고 GoDoc이 빠르게 반영되는건 아니라는 함정.
- 그리고 레포의 README.md 파일은 GODOC의 메인 설명 페이지로 나온다는 것.

결과

아래는 내가 배포한 두가지 패키지들이다. 지속적으로 유지보수하면서 버전업 시킬 예정이다.
GQBD : Go-Query-Builder
GDCT : Go-Database-ConnecT

[미디어] HLS

dongburiii — Fri, 28 Mar 2025 18:25:54 +0900

HLS

HLS: HTTP Live Streaming
- 콘텐츠를 작은 세그먼트로 나누어서 .m3u8 파일과 .ts 세그먼트 파일로 구성함
- 즉 비디오를 2-10초 정도의 작은 .ts(Transport Stream)으로 나누게 됨
- m3u8 파일이 모든 세그먼트와 재생 정보를 관리하는 익덱스 파일
- 적응형 비트레이트: 네트워크 상태에 따라 다양한 화질 선택 가능
m3u8 형식 혹은 .ts 파일이 hls 스트리밍에 사용되는 파일 형식

예시

manifest.m3u8 (메인 인덱스 파일)
|- quality_high.m3u8 (고화질 인덱스)
|  |- segment0_high.ts
|  |- segment1_high.ts
|  |- ...
|- quality_medium.m3u8 (중간 화질 인덱스)
|  |- segment0_medium.ts
|  |- ...
|- quality_low.m3u8 (저화질 인덱스)
   |- segment0_low.ts
   |- ...

FFMPEG 이용한 m3u8 파일 변환

여러개의 .ts 파일과 .m3u8 파일이 생김
- m3u8 파일이 각 ts 파일에 대한 인덱스 역할을 함

ffmpeg -i <video_file>.mp4 -profile:v baseline -level 3.0 -start_number 0 -hls_time 10 -hls_list_size 0 -f hls <output_file>.m3u8

HTTP Streaming vs HLS

주요 차이점

적응성
- HLS: 네트워크 상태에 따라 화질을 자동으로 조정
- HTTP 스트리밍: 단일 화질만 제공, 적응형 기능 없음
지연 시간
- HLS: 일반적으로 10-30초 지연 발생
- HTTP 스트리밍: 버퍼링 시간만큼의 지연
대역폭 효율
- HLS: 현재 네트워크 상태에 맞는 최적의 화질 제공
- HTTP 스트리밍: 고정 화질로 네트워크 상태가 좋지 않으면 버퍼링 발생
서버 부하
- HLS: 여러 화질의 세그먼트를 미리 생성해야 함
- HTTP 스트리밍: 단일 파일만 제공하므로 서버 부하 낮음
구현 복잡성
- HLS: 인코딩, 세그먼트화, 인덱스 파일 관리 등 복잡한 과정 필요
- HTTP 스트리밍: 단순히 파일을 제공하는 것만으로 가능
확장성
- HLS: CDN과 연계하여 우수한 확장성 제공
- HTTP 스트리밍: CDN 활용 가능하나 적응형 기능 부재
호환성
- HLS: iOS, Safari에서 네이티브 지원, 다른 브라우저는 추가 라이브러리 필요
- HTTP 스트리밍: 대부분의 브라우저에서 네이티브 지원

간단한 비유

HLS는 도서관에서 책의 각 장을 필요할 때마다 가져오는 것과 같음
일반 HTTP 스트리밍은 책 전체를 한 번에 빌려오는 것과 같음

[AUTH] 검증 방법 변경 - Http Only Cookie

dongburiii — Fri, 31 Jan 2025 09:41:56 +0900

계기

이전에 만들었던 프로젝트들을 리팩토링 중, 검증 방법이 헤더의 Authorization 으로 토큰 검증을 하게 해 뒀던 걸 발견했다.
뭐 잘못된 방법은 아니지만, 쿠키를 활용해서 검증하는 방법으로 변경하였다.

개요

로그인 요청을 받았을 때, 이메일/패스워드 정보를 검증 후 유저 정보를 Redis 서버에서 체크한다.
- Redis 서버에 해당 정보가 조회될 경우, 새로운 환경에서 로그인 요청을 한 것으로 판단한다.
  - 이전 로그인은 종료시키기 위해, 해당 정보를 삭제한다.
- 조회된 정보가 없다면 이전 로그인은 만료된 것이므로 무시한다.
이후 새로운 accessToken과 refreshToken을 생성한다.
- refreshToken을 상위 키로, 하위 키로는 유저 id 로 삼아 로그인 정보를 세팅한다.
  - 키: refresh:{refreshToken}:{userId}
해당 키들을 응답 쿠키에 각각 도메인, 만료시간, 토큰, secure, httpOnly 를 세팅한다.
- accessToken의 만료 시간은 한시간, refreshToken의 만료 시간은 일주일로 세팅한다.
이후 로그인 및 유저 정보가 필요한 요청은 미들웨어에서 토큰 검증 및 데이터 추출하여 사용한다.
만료시간이 끝난 경우, 토큰 갱신 요청을 날려서 새로운 access token을 발급 받는다.

코드 구현

백엔드는 golang, 프론트는 nextjs app router를 사용하였다.

백엔드

주요 로직은 주석처리, 토큰 세팅 및 쿠키 세팅하는 로직만 유지

// 컨트롤러가 아닌, 비즈니스 로직을 담은 서비스
func LoginService(request LoginRequest, response http.ResponseWriter, request *http.Request) {    
    /* 
        DB 에서 유저 정보 조회 및 패스워드 매칭
    */

    // Access Token 생성
    token, tokenErr := auth.CreateAccessToken(userData.UserId, uuid.String(), userData.Email, fmt.Sprintf("%d", userData.UserStatus), fmt.Sprintf("%d", userData.IsAdmin), time.Hour)

    if tokenErr != nil {
        log.Printf("[LOGIN] Create Token Error: %v", tokenErr)

        return LoginResponse{
            Status:  http.StatusInternalServerError,
            Code:    "ULG09",
            Message: "Create JWT Error",
        }
    }

    // Refresh Token 생성
    refreshToken, refreshTokenErr := auth.CreateRefreshToken("",, time.Hour*24*7)

    if refreshTokenErr != nil {
        log.Printf("[LOGIN] Create Refresh Token Error: %v", refreshTokenErr)

        return LoginResponse{
            Status:  http.StatusInternalServerError,
            Code:    "ULG09",
            Message: "Create JWT Error",
        }
    }

    // Redis 서버에서 유저 정보 조회 - 이전 로그인 만료 여부 체크
    userDataFromRedis, getRedisErr := GetRefreshUserInfoFromRedis(refreshToken, userData.UserId)

    if getRedisErr != nil {
        return LoginResponse{
            Status:  http.StatusNotFound,
            Code:    "ULG08",
            Message: "Get User Data from redis Error",
        }
    }

    // 유저 정보가 조회되었을 시
    if (userDataFromRedis != LoginUserInfo{}) {
        // 조회된 Redis 정보 삭제
        delerr := DeleteAlreadySetToken(refreshToken, userData.UserId)

        if delerr != nil {
            return LoginResponse{
                Status:  http.StatusInternalServerError,
                Code:    "ULG08",
                Message: "Delete Already Set Data from redis Error",
            }
        }
    }

    // Redis 서버에 새로운 로그인 정보 세팅
    setErr := SetRefreshToken(refreshToken, userData.Email, fmt.Sprintf("%d", userData.UserStatus), userData.UserId, userData.UserName, fmt.Sprintf("%d", userData.IsAdmin))

    if setErr != nil {
        return LoginResponse{
            Status:  http.StatusInternalServerError,
            Code:    "ULG10",
            Message: "Set JWT Error",
        }
    }

    accessTokenCookie := http.Cookie{
        Name:     "accessToken",
        Value:    token,
        Path:     "/",
        Secure:   true,
        HttpOnly: true,
        SameSite: http.SameSiteNoneMode,
    }

    refreshTokenCookie := http.Cookie{
        Name:     "refreshToken",
        Value:    refreshToken,
        Path:     "/",
        Secure:   true,
        HttpOnly: true,
        SameSite: http.SameSiteNoneMode,
    }

    http.SetCookie(response, &accessTokenCookie)
    http.SetCookie(response, &refreshTokenCookie)

    return LoginResponse{
        Status:       http.StatusOK,
        Code:         "0000",
        AccessToken:  token,
        RefreshToken: refreshToken,
        Message:      "Login Success",
    }

프론트

App Router의 Server Side Component를 이용해서 쿠키 및 토큰을 관리한다.
- 로그인 응답으로 토큰을 받고 서버 사이드 쿠키에 세팅한다.

export async function POST(request: NextRequest) {
  // const cookieStore = cookies();

  // 로그인 데이터 확인 - 요청 조건 검증
  const loginSchema = z.object({
    email: z.string().email(),
    password: z.string().min(6).max(16),
  });

  try {
    const _loginData = await request.json();
    const loginData = await loginSchema.parseAsync(_loginData);

    const loginResponse = await login({ ...loginData });

    if (!loginResponse.ok) {
      return NextResponse.json({ message: 'unauthorized' }, { status: 401 });
    }
});

    const response = <LoginResponse>(await loginResponse.json());

    if (response.status !== 200) {
      return NextResponse.json({ message: 'Login Failed' }, { status: 302 });
    }

    // 브라우저에 리턴할 쿠키 설정
    const ONE_HOUR = 60 * 60 * 1000;
    const ONE_WEEK = 60 * 60 * 1000 * 24 * 7;

    const res = NextResponse.json({ message: 'Login Success' }, { status: 200 });

    // 쿠키 설정
    res.cookies.set('accessToken', response.accessToken, {
      secure: true, // 프로덕션 환경에서는 true로 설정
      httpOnly: true,
      domain: process.env.NEXT_PUBLIC_COOKIE_DOMAIN,
      expires: new Date(Date.now() + ONE_HOUR),
    });

    res.cookies.set('refreshToken', response.refreshToken, {
      secure: true,
      httpOnly: true,
      domain: process.env.NEXT_PUBLIC_COOKIE_DOMAIN,
      expires: new Date(Date.now() + ONE_WEEK),
    });

    return res;
  } catch (error) {
    console.log(error);
    return NextResponse.json({ message: 'server error' }, { status: 500 });
  }
}

서버 사이드 컴포넌트. 받은 쿠키들을 이용해 이후 요청을 한다.
- 만료시 토큰 리프레시를 한다.


export async function POST(request: NextRequest) {
    try {
        let tokenCookie = request.cookies.get("accessToken");
        let refreshToken = request.cookies.get("refreshToken");

        let cookie: string;
        let refreshCookie: string;

        if (!tokenCookie) {
            /** 
                refresh token 갱신 요청 로직
            */

            const ONE_HOUR = 60 * 60 * 1000;
            const ONE_WEEK = 60 * 60 * 1000 * 24 * 7;

            cookieStore.set('accessToken', response.accessToken, {
                secure: true,
                httpOnly: true,
                path:"/",
              //   domain: process.env.NEXT_PUBLIC_COOKIE_DOMAIN,
                expires: new Date(Date.now() + ONE_HOUR),
              });

              cookieStore.set('refreshToken', response.refreshToken, {
                secure: true,
                httpOnly: true,
                path:"/",
              //   domain: process.env.NEXT_PUBLIC_COOKIE_DOMAIN,
                expires: new Date(Date.now() + ONE_WEEK),
              });


            cookie = response.accessToken;
            refreshCookie = response.refreshToken;
        } else {
            cookie = tokenCookie.value;
            refreshCookie = refreshToken.value;

            // 기술통계 요청 데이터 확인
            const exampleScheme = z.object({
                // 요청 검증 필드
            });

            const _exampleData = await request.json();
            const exampleData = await exampleScheme.parseAsync(_exampleData);

            const exampleResponse = await example({ ...exampleData }, cookie, refreshCookie);

            if (!exampleResponse.ok) {
                return NextResponse.json({ message: 'unauthorized' }, { status: 401 });
            }

            const dataResponse = <ExampleResponse>await exampleResponse.json();

            const response = NextResponse.json(dataResponse);

            return response;
        }
    } catch (error) {
        console.log(error);
        return NextResponse.json({ message: 'server error' }, { status: 500 });

    }
}

Middleware를 적용하여, 쿠키가 없을 시 로그인 페이지로 자동 리디렉션 시킨다.

import { NextFetchEvent, NextMiddleware, NextRequest, NextResponse } from "next/server";

// 인증 없이 방문 불가 페이지
const PROTECTED_ROUTE: string[] = [
  // 페이지 리스트들
];

export type MiddlewareFactory = (middleware: NextMiddleware) => NextMiddleware;

export const authMiddleware: MiddlewareFactory = (next: NextMiddleware) => {
  return async (request: NextRequest, event: NextFetchEvent) => {
    // URL 에서 언어 값 분리
    const [ , , ...segments ] = request.nextUrl.pathname.split('/');

    const cookies = request.cookies.get("accessToken");

    // 체크사항
    // 1. 로그인 유무
    // 2. 인증 없이 방문 불가 페이지
    const isProtecteRoute = PROTECTED_ROUTE.includes(request.nextUrl.pathname);

    if (!cookies && isProtecteRoute) {
      return NextResponse.redirect(new URL('/login', request.url));
    }

    if (cookies && isProtecteRoute) {
      if (cookies.value === "") {
        return NextResponse.redirect(new URL('/login', request.url));
      }
    }
    // 인증 성공, 통과
    return next(request, event);
  };
};

[NEXTJS] 사이드 컴포넌트 쿠키 처리

dongburiii — Wed, 22 Jan 2025 09:22:32 +0900

Nextjs App Router 서버 사이드 요청

Nextjs의 App Router를 통해 서버사이드에서 요청 날리게끔 구성되어 있다.
요청에 쿠키를 담아 서버쪽에서 검증 받는 흐름이지만, 쿠키가 계속 안 들어왔다.
- credentials: "include" 인데도 들어오지 않는 것에 의문을 가졌다.
결론은 서버 사이드에서의 요청일 경우 직접 쿠키를 담아줘야 한다는 것이다.

쿠키 양식

"Cookie": "accessToken=tokendata; refreshToken=refreshToken"

변경된 코드

헤더에 직접 입력
API 라우트에서 쿠키를 뽑아와 인자로 던짐

클라이언트 사이드 요청 함수

react query를 이용해 요청 및 관리
이 때는 쿠키를 담을 수 없다.
- 클라이언트 사이드에서는 쿠키를 가져올 수 없음. 브라우저 범위이기 때문

export interface ReferenceListResponse {
    status: number;
    code: string;
    message: string;
    result: ReferenceListItem[];
    totalCount: number;
}

export interface ReferenceListItem {
    referenceSeq: string;
    referenceName?: string;
    referenceUrl: string;
    referenceMemo?: string;
    referenceCategory: string;
    createdAt: string;
}

export const referenceListRequest = async (props: ReferenceListRequest) => {

    const response = await jsFetch<ReferenceListResponse>(`/api/reference/list`, {
        method: 'post',
        cache: 'no-store',
        body: JSON.stringify(props),
        headers: {
            'content-type': 'application/json',

        },        
    });

    return response;

};

서버 사이드 요청 함수

export interface ReferenceListRequest {
    category: string;
    page: number;
    pageSize: number;
}


export const referenceList = async (request: ReferenceListRequest, accessToken: string, refreshToken: string) => {

    const response = await fetch(
    `${ process.env.NEXT_PUBLIC_BASE_API }/reference/list`, {
        method: 'post',
        cache: 'no-store',
        body: JSON.stringify({ category: request.category, page: request.page, pageSize: request.pageSize }),
        headers: {
            'content-type': 'application/json',
            "Cookie": `accessToken=${ accessToken }; refreshToken=${ refreshToken }`
        },
        credentials: 'include', // 쿠키를 포함해서 요청 전송
        next: { tags: [ 'search-word' ] },
    });

    return response;
};

[AUTH] Cookie를 이용한 검증

dongburiii — Tue, 21 Jan 2025 10:21:17 +0900

개요

로그인 시 발급되는 access token을 쿠키에 세팅
미들웨어에서 쿠키의 access token 을 검증

Cookie 세팅

생성된 토큰을 쿠키에 세팅한다

func Login(res http.ResponseWriter, req *http.Request) {

    /*
        로그인 로직
    */

    accessTokenCookie := http.Cookie{
        Name: "accessToken",
        Value: accessToken,
        Path: "/",
        Secure: true, // HTTPS 만
        HttpOnly: true, // 브라우저에서 쿠키 조작 불가하게 세팅
        SameSite: http.SameSiteNoneMode,
    }

    refreshTokenCookie := http.Cookie{
        Name: "refreshToken",
        Value: refreshToken,
        Path: "/",
        Secure: true, // HTTPS 만
        HttpOnly: true, // 브라우저에서 쿠키 조작 불가하게 세팅
        SameSite: http.SameSiteNoneMode,
    }

    http.SetCookie(res, &accessTokenCookie)
    http.SetCookie(res, &refreshTokenCookie)

    /*
        응답 보내기
    */
}

검증 미들웨어

쿠키에서 토큰을 추출해서 컨텍스트에 담는다
담은 컨텍스트의 정보를 컨트롤러에서 사용한다.

// 사용자 정의 키 타입을 사용하여 컨텍스트 충돌 방지

type contextKey string

const (
    // JWT 서명에 사용할 비밀 키 (환경 변수로 관리하는 것이 좋습니다)

    // jwtSecret = configs.GlobalConfig.JwtKey // 실제 배포 시 환경 변수로 관리

    // 컨텍스트에 사용자 정보를 저장할 키
    userContextKey = contextKey("user")
)

// 사용자 정보 구조체

type User struct {
    UserId string
    UserEmail string
    UserStatus string
}

var excludeRouteList = []string{
    "/", "/api", 
    "/user/signup", "/user/login",
}

// AuthMiddleware는 accessToken 쿠키를 추출하고 JWT를 검증하는 미들웨어입니다.
func AuthMiddleware(next http.Handler) http.Handler {

    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

        // 제외할 경로는 바로 다음 핸들러로 넘김
        for _, route := range excludeRouteList {
            if r.URL.Path == route {
                log.Printf("Found Match Route: %s", route)
                next.ServeHTTP(w, r)
                return
            }
        }

        // accessToken 쿠키 추출
        cookie, err := r.Cookie("accessToken")

        log.Printf("Cookie: %s", cookie)

        if err != nil {
            log.Printf("Get Cookie Error :%v", err)  

            if err == http.ErrNoCookie {
                response.Response(w, response.CommonResponseWithMessage{
                    Status: http.StatusUnauthorized,
                    Code: "AUTH001",
                    Message: "No access token provided",    
                })

                return
            }

            // 다른 쿠키 에러 처리

            response.Response(w, response.CommonResponseWithMessage{
                Status: http.StatusUnauthorized,
                Code: "AUTH002",
                Message: "Invalid cookie format",
            })

            return
        }

        accessToken := cookie.Value

        userId, userEmail, userStatus, validateErr := auth.ValidateJwtTokenFromString(accessToken)


        if validateErr != nil {
            log.Printf("ValidateErr Cookie Error :%v", validateErr)

            // 토큰 만료에 대한 응답
            if strings.Contains(validateErr.Error(), "token expired") {
                response.Response(w, response.CommonResponseWithMessage{
                    Status: http.StatusUnauthorized,
                    Code: "AUTH003",
                    Message: "Token expired",
                })

                return
            }

            // 일반적인 JWT 검증 실패 응답
            response.Response(w, response.CommonResponseWithMessage{
                Status: http.StatusUnauthorized,
                Code: "AUTH004",
                Message: "Invalid token",
            })

            return        
        }

        // 사용자 정보를 구조체로 생성

        user := User{
            UserId: userId,
            UserEmail: userEmail,
            UserStatus: userStatus,
        }

        // 사용자 정보를 컨텍스트에 추가
        ctx := context.WithValue(r.Context(), userContextKey, user)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}



// 사용자 정보를 핸들러 및 컨트롤러에서 가져오는 헬퍼 함수
func GetUserFromContext(ctx context.Context) (User, bool) {
    user, ok := ctx.Value(userContextKey).(User)
    return user, ok
}

컨트롤러에서 추출된 정보들 사용


func SampleController(res http.ResponseWriter, req *http.Request) {
    user, ok := middlewares.GetUserFromContext(req.Context())

    if !ok {    
        dto.SetErrorResponse(res, 401, "01", "JWT Verifying Error", nil)

        return
    }
    /*
        이후 로직
    */

    dto.SetResponse(res, 200, "01")
}

[CORS] CORS 설정 - 라이브러리 이용

dongburiii — Mon, 20 Jan 2025 09:42:58 +0900

기존

기존에는 직접 CORS 체크 미들웨어를 작성해 사용했다.

func CorsMiddlewares(next http.Handler) http.Handler {
    return http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {

        origin := req.Header.Get("Origin")

        if origin == "" {
            origin = "unknown"
        }

        for _, o := range originList {
            if o == origin {    
                log.Printf("Allowed Origin: %s", origin)
                res.Header().Set("Access-Control-Allow-Origin", origin)
                res.Header().Set("Access-Control-Max-Age", "86400")
                res.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS")
                res.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
                res.Header().Set("Access-Control-Allow-Credentials", "true")
                break
            }
        }

        // Handle preflight request
        if req.Method == http.MethodOptions {
            res.WriteHeader(http.StatusOK)
            return
        }

        next.ServeHTTP(res, req)
    })
}

변경

그러나 조금 더 심플하고 편하게 설정할 수 있는 패키지가 있어 가져와 사용했다.

get -u github.com/rs/cors

이후 세팅은 이렇게 된다.

func CorsHanlder() *cors.Cors {
    corHandler := cors.New(cors.Options{
        AllowedOrigins: originList,
        AllowedMethods: []string{http.MethodGet, http.MethodPost, http.MethodOptions},
        AllowedHeaders: []string{"Origin", "Accept", "Content-Type", "Authorization"},
        AllowCredentials: true,
        MaxAge: 86400,        
        Debug: false,
    })

    return corHandler
}

미들웨어 등록하기

현재 표준 라이브러리인 net/http 에서 gorilla/mux 로 변경한 상태이다.

func OpenServer() *http.Server {
    router := mux.NewRouter()

    routers.DefaultRouter(router)

    routers.UploadImageController(router)

    routers.AdminUserRouter(router)

    routers.AdminPostRouter(router)

    routers.UserRouter(router)

    routers.PostRouter(router)

    router.Use(middlewares.AuthMiddleware)

    // CORS 핸들러
    handler := middlewares.CorsHanlder().Handler(router)

    // 기존 방식  
    // handler := middlewares.CorsMiddlewares(router)

    serving := &http.Server{
        Handler: handler,
        Addr: configs.GlobalConfig.AppHost,
        WriteTimeout: 30 * time.Second,
        ReadTimeout: 30 * time.Second,
    }

    return serving
}

[TLS] TLS 핸드세이크?

dongburiii — Tue, 14 Jan 2025 09:42:45 +0900

TLS 핸드세이크

클라이언트 - 서버가 교환하는 일련의 데이터그램 == 메시지
사용되는 키 교환 알고리즘의 종류 및 양측에서 지원하는 암호 모음에 따라 달라짐
- 1.3 버전 이전에는 RSA 키 교환 알고리즘을 사용했지만, 안전하지 않음

TLS 핸드세이크 작동 방식

비대칭 암호화(공개 키 - 개인 키) 사용

TLS 핸드세이크
- 클라이언트 헬로 메시지
  - 클라이언트가 서버로 Hello 메시지 전송하여 핸드세이크 개시
  - 이 때 TLS 버전, 지원 암호 제품군, 클라이언트 무작위 바이트 문자열 포함
- 서버 헬로 메시지
  - 클라이언트 헬로 메시지에 대한 응답으로 서버의 SSL 인증서, 서버에서 선택한 암호 제품군, 그리고 서버에서 생성한 무작위 문자열 바이트 포함한 메시지 전송
- 인증
  - 클라이언트가 서버의 SSL 인증서를 인증서 발행 기관을 통해 검증
  - 인증서에 명시된 서버인지, 상호작용중인 서버가 실제 해당 도메인의 소유자인지 확인
- 예비 마스터 암호
  - 클라이언트가 무작위 바이트 문자열 하나 더 전송
  - 공개키로 암호화 되며, 서버 개인 키로만 해독 가능
  - 공개키는 서버의 SSL 인증서를 통해 클라이언트에 전달됨
- 개인키 사용
  - 서버가 예비 마스터 암호를 해독함
- 세션 키 생성
  - 클라이언트와 서버 모두 클라이언트 무작위, 서버 무작위, 예비 마스터 암호 이용해 세션 키 생성
  - 모두 동일한 결과가 나와야 함
- 클라이언트 준비 완료
  - 클라이언트가 세션 키로 암호화된 완료 메시지 전송
- 서버 준비 완료
  - 서버가 세션 키로 암호화된 완료 메시지 전송
- 안전한 대칭 암호화 성공
  - 핸드세이크 완료, 세션키를 통한 통신이 진행
데이터가 암호화되고 인증되면, 메시지 인증 코드(MAC: Message Authorization Code)와 함께 서명됨