Pokerogue on Joonlog

깃허브 코드로 배포한 Pokerogue 앱에서 구글/디스코드 외부 로그인이 실패하는 이슈

Wed, 22 Oct 2025 09:00:00 +0900

공식 rogueserver 코드의 쿠키 설정 버그로 인해 구글 OAuth 로그인이 작동하지 않는 이슈

환경

Vite 기반 React 프론트엔드와 Go 기반 백엔드 그리고 Mariadb로 구성
K8S + HAProxy를 통한 외부 접근

문제 상황

일반 계정 로그인은 정상 작동
구글/디스코드 계정 연결 시도 시 에러:
1. 일반 로그인 후 설정 메뉴에서 구글 연결 클릭
2. 구글 OAuth 인증 완료
3. 메인 화면으로 리다이렉트되지만 설정이 저장되지 않고 새로고침만 됨
4. 로그아웃 후 구글로 직접 로그인 시도 시 로그인 실패

에러 분석

1. 백엔드 로그 분석

1

kubectl logs -n pokerogue pokerogue-server

1
2
3


2025/10/14 23:02:24 [DEBUG] Google token response status: 200
2025/10/14 23:02:24 [DEBUG] Successfully extracted userId: 102118711772610730702
2025/10/14 23:02:47 /account/info: missing token

구글 OAuth 토큰 교환은 성공 (userId 추출 완료)
DB에 googleId도 정상 저장됨 확인
하지만 세션 토큰이 누락되어 로그인 상태 유지 실패

2. 브라우저 네트워크 탭 분석

1
2
3
4


Request: GET /api/auth/google/callback
Response: 303 See Other
Set-Cookie: pokerogue_sessionId=...; SameSite=Strict; Domain=pokerogue.net
Sec-Fetch-Site: cross-site

문제점 발견:

Domain=pokerogue.net
- 공식 pokerogue URL로 하드코딩 되어 있어 현재 도메인과 불일치
SameSite=Strict
- 구글에서 돌아오는 요청이 cross-site이므로 쿠키가 전송되지 않음

OAuth 리다이렉트 흐름:
- pokerogue.<도메인> → accounts.google.com → pokerogue.<도메인>/callback
  - SameSite=Strict는 같은 사이트 내부 요청에만 쿠키 전송
  - 구글에서 돌아오는 것은 cross-site 요청으로 간주되어 쿠키 차단

해결 방법

api/endpoints.go 파일의 쿠키 설정 수정:

1
2
3
4
5
6
7
8
9


http.SetCookie(w, &http.Cookie{
 Name: "pokerogue_sessionId",
 Value: sessionToken,
 Path: "/",
 Secure: true,
 SameSite: http.SameSiteLaxMode, // Strict → Lax 변경
 Domain: "", // "pokerogue.net" → "" 변경
 Expires: time.Now().Add(time.Hour * 24 * 30 * 3),
})

변경 사항
1. Domain: ""
  - 빈 문자열로 설정하여 현재 도메인 자동 적용
2. SameSite: http.SameSiteLaxMode
  - Strict → Lax
  - Lax는 안전한 cross-site GET 요청(OAuth 콜백 포함)에서 쿠키 전송 허용
  - OAuth 표준에서 권장하는 설정
  - 여전히 CSRF 공격 방어 가능 (위험한 POST 요청은 차단)

결과

일반 로그인 → 구글 계정 연결 → 로그아웃 → 구글 직접 로그인 모두 정상 작동
세션 쿠키가 올바르게 설정되어 로그인 상태 유지
브라우저 네트워크 탭에서 Set-Cookie: ...; SameSite=Lax 확인

참고

OAuth를 사용하는 많은 프로젝트에서 동일한 이슈가 발생했으며, 모두 SameSite=Lax로 해결

Kubernetes에서 Pokerogue 게임 배포하기

Mon, 20 Oct 2025 09:00:00 +0900

매니지드 K8S가 아닌 자체 관리형 K8S에서의 Pokerogue구축 방법

UI 접근을 위한 외부 통신으로 MetalLB+HAproxy+Nginx Controller가 구성 되었다는 전제 하에 구축

CSP 환경이라면 Ingress 설정에서 AWS ALB Controller와 같은 로드밸런서를 사용해 훨씬 간편하게 구축 가능

Pokerogue 공식문서: https://github.com/pagefaultgames/pokerogue https://github.com/pagefaultgames/rogueserver

아키텍쳐

인프라 구조: Pokerogue WEB(Frontend) - Pokerogue Rogueserver(Backend) - MariaDB(DB)
WEB과 API 통신 경로를 분리
- 분리 이유
  - SPA 특성상 Frontend가 / 경로로 모든 요청을 받아야 함
  - Backend는 /api/* 경로를 /*로 rewrite된 상태로 요청을 받아야 함
  - Ingress는 같은 Host(도메인)에 대해 두 개의 서로 다른 규칙 적용 불가
    - 따라서 HAproxy 설정에서 Frontend는 Ingress, Backend는 LoadBalancer타입 Service로 라우팅되도록 구성
- WEB 통신 구조:
  - Client(HTTPS) → HAproxy(SSL Termination) → Nginx Ingress Controller → Ingress → Service(pokerogue-web ClusterIP) → Workload(pokerogue-web)
- API 통신 구조:
  - Client JS(HTTPS/api/account/info) → HAproxy(SSL Termination + 경로 rewrite ⇒ HTTP /account/info) → Service(pokerogue-server LoadBalancer) → Workloads(pokerogue-server) → Service(pokerogue-db ClusterIP) → Workload(MariaDB)
구글 Oauth 로그인 흐름
- Client가 설정에서 Link Google → pokerogue-web에서 /api/auth/google?mode=link 요청 → rogueserver에서 Google OAuth URL 생성 → 브라우저에서 구글 로그인 → 구글에서 도메인/api/auth/google/callback?code=...&state=... 로 라우팅 → HAproxy(rogueserver-service)로 라우팅 → rogueserver에서 /auth/google/callback로 수신한 code로 구글 ID 조회 + 로그인한 사용자 ID 조회 → DB에서 해당 사용자에 구글 ID값 추가 → 도메인으로 리다이렉트
  - 디스코드 OAuth 로그인도 동일한 흐름

Pokerogue 구축

Pokerogue 네임스페이스 생성

1
2


kubectl create ns pokerogue
kubectl label namespace teleport-cluster 'pod-security.kubernetes.io/enforce=baseline'

mariadb-pvc 생성

mariadb-pvc.yaml
- longhorn pv 사용

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


apiVersion: v1
kind: PersistentVolumeClaim
metadata:
 name: pokerogue-db-pvc
 namespace: pokerogue
spec:
 accessModes:
 - ReadWriteOnce
 storageClassName: longhorn
 resources:
 requests:
 storage: 10Gi

mariadb-secret 생성
- DB 인증정보 secret
  - MYSQL_ROOT_PASSWORD
  - MYSQL_DATABASE
  - MYSQL_USER
  - MYSQL_PASSWORD

mariadb 배포

mariadb-deployment.yaml
- mariadb secret 참조
- mysqladmin ping 명령어로 헬스 체크

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82


apiVersion: apps/v1
kind: Deployment
metadata:
 name: pokerogue-db
 namespace: pokerogue
 labels:
 app: pokerogue-db
spec:
 replicas: 1
 selector:
 matchLabels:
 app: pokerogue-db
 template:
 metadata:
 labels:
 app: pokerogue-db
 spec:
 containers:
 - name: mariadb
 image: mariadb:11.2
 ports:
 - containerPort: 3306
 name: mysql
 env:
 - name: MYSQL_ROOT_PASSWORD
 valueFrom:
 secretKeyRef:
 name: pokerogue-db-secret
 key: MYSQL_ROOT_PASSWORD
 - name: MYSQL_DATABASE
 valueFrom:
 secretKeyRef:
 name: pokerogue-db-secret
 key: MYSQL_DATABASE
 - name: MYSQL_USER
 valueFrom:
 secretKeyRef:
 name: pokerogue-db-secret
 key: MYSQL_USER
 - name: MYSQL_PASSWORD
 valueFrom:
 secretKeyRef:
 name: pokerogue-db-secret
 key: MYSQL_PASSWORD
 volumeMounts:
 - name: db-data
 mountPath: /var/lib/mysql
 resources:
 requests:
 memory: "512Mi"
 cpu: "250m"
 limits:
 memory: "1Gi"
 cpu: "500m"
 livenessProbe:
 exec:
 command:
 - /usr/bin/mariadb-admin
 - ping
 - -h
 - localhost
 - -u
 - root
 - -p${MYSQL_ROOT_PASSWORD}
 initialDelaySeconds: 30
 periodSeconds: 10
 readinessProbe:
 exec:
 command:
 - /usr/bin/mariadb-admin
 - ping
 - -h
 - localhost
 - -u
 - root
 - -p${MYSQL_ROOT_PASSWORD}
 initialDelaySeconds: 5
 periodSeconds: 5
 volumes:
 - name: db-data
 persistentVolumeClaim:
 claimName: pokerogue-db-pvc

mariadb-service 생성

mariadb-service.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


apiVersion: v1
kind: Service
metadata:
 name: pokerogue-db
 namespace: pokerogue
spec:
 selector:
 app: pokerogue-db
 ports:
 - protocol: TCP
 port: 3306
 targetPort: 3306
 type: ClusterIP

OAuth-secret 생성
- rogueserver oauth 로그인을 위한 secret
  - GOOGLE_CLIENT_ID
  - GOOGLE_SECRET_ID
  - DISCORD_CLIENT_ID
  - DISCORD_CLIENT_SECRET

rogueserver 배포

rogueserver-deployment.yaml
- initcontainer로 DB가 준비될 때까지 대기
- DB secret 참조
- OAuth secret 참조

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80


apiVersion: apps/v1
kind: Deployment
metadata:
 name: pokerogue-server
 namespace: pokerogue
 labels:
 app: pokerogue-server
spec:
 replicas: 1
 selector:
 matchLabels:
 app: pokerogue-server
 template:
 metadata:
 labels:
 app: pokerogue-server
 spec:
 # DB가 준비될 때까지 대기
 initContainers:
 - name: wait-for-db
 image: busybox:1.36
 command: ['sh', '-c', 'until nc -z pokerogue-db 3306; do echo waiting for db; sleep 2; done;']
 containers:
 - name: rogueserver
 image: <registry명>/rogueserver:latest
 imagePullPolicy: Always
 ports:
 - containerPort: 8001
 name: api
 env:
 - name: debug
 value: "true"
 - name: dbaddr
 value: "pokerogue-db:3306"
 - name: dbuser
 valueFrom:
 secretKeyRef:
 name: pokerogue-db-secret
 key: MYSQL_USER
 - name: dbpass
 valueFrom:
 secretKeyRef:
 name: pokerogue-db-secret
 key: MYSQL_PASSWORD
 - name: dbname
 valueFrom:
 secretKeyRef:
 name: pokerogue-db-secret
 key: MYSQL_DATABASE
 - name: gameurl
 value: "https://pokerogue.<도메인>:48443"
 - name: callbackurl
 value: "https://pokerogue.<도메인>:48443/api"
 - name: googleclientid
 valueFrom:
 secretKeyRef:
 name: pokerogue-oauth-secret
 key: GOOGLE_CLIENT_ID
 - name: googlesecretid
 valueFrom:
 secretKeyRef:
 name: pokerogue-oauth-secret
 key: GOOGLE_SECRET_ID
 - name: discordclientid
 valueFrom:
 secretKeyRef:
 name: pokerogue-oauth-secret
 key: DISCORD_CLIENT_ID
 - name: discordsecretid
 valueFrom:
 secretKeyRef:
 name: pokerogue-oauth-secret
 key: DISCORD_CLIENT_SECRET
 resources:
 requests:
 memory: "512Mi"
 cpu: "250m"
 limits:
 memory: "1Gi"
 cpu: "1000m"

rogueserver-service생성

rogueserver-service.yaml
- type을 LoadBalancer로 만들어서 pokerogue-web용 ingrss에 할당할 IP와 다른 IP를 MetalLB로부터 할당
- /api로의 통신은 haproxy에서 rogueserver Service(LB)로 직접 라우팅

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


apiVersion: v1
kind: Service
metadata:
 name: pokerogue-server
 namespace: pokerogue
spec:
 selector:
 app: pokerogue-server
 ports:
 - protocol: TCP
 port: 8001
 targetPort: 8001
 type: LoadBalancer

web 배포

web-deployment.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


apiVersion: apps/v1
kind: Deployment
metadata:
 name: pokerogue-web
 namespace: pokerogue
 labels:
 app: pokerogue-web
spec:
 replicas: 1
 selector:
 matchLabels:
 app: pokerogue-web
 template:
 metadata:
 labels:
 app: pokerogue-web
 spec:
 containers:
 - name: web
 image: <registry명>/pokerogue-web:latest
 imagePullPolicy: Always
 ports:
 - containerPort: 80
 name: http
 resources:
 requests:
 memory: "512Mi"
 cpu: "500m"
 limits:
 memory: "1Gi"
 cpu: "1000m"

web-service생성

web-service.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


apiVersion: v1
kind: Service
metadata:
 name: pokerogue-web
 namespace: pokerogue
spec:
 selector:
 app: pokerogue-web
 ports:
 - protocol: TCP
 port: 80
 targetPort: 80
 type: ClusterIP

web-ingress 생성

pokerogue-web-ingress.yaml
- Frontend 라우팅만 처리
  - nginx.ingress.kubernetes.io/ssl-redirect
  - nginx.ingress.kubernetes.io/force-ssl-redirect
    - SSL Redirect 비활성화
      - HAproxy에서 SSL Termination 처리하기 때문
      - Ingress는 HTTP 트래픽만 수신
- Host 기반 라우팅
  - pokerogue.<도메인>으로 들어오는 요청만 처리
  - HAproxy가 Host 헤더 기반으로 이 Ingress로 라우팅

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
 name: pokerogue-unified-ingress
 namespace: pokerogue
 annotations:
 nginx.ingress.kubernetes.io/ssl-redirect: "false"
 nginx.ingress.kubernetes.io/force-ssl-redirect: "false"
spec:
 ingressClassName: nginx
 # TLS is handled by HAProxy, not by Ingress
 # This allows HAProxy to terminate SSL and forward HTTP to Ingress
 rules:
 - host: pokerogue.<도메인>
 http:
 paths:
 - path: /
 pathType: Prefix
 backend:
 service:
 name: pokerogue-web
 port:
 number: 80

SSL 인증서 적용

인증서 발급
- /etc/letsencrypt/live/pokerogue.<도메인>/fullchain.pem
- /etc/letsencrypt/live/pokerogue.<도메인>/privkey.pem

1
2
3


certbot certonly --manual --preferred-challenges dns \
 -d pokerogue.<도메인> \
 --key-type ecdsa

haproxy용 인증서 생성

1
2
3


 cat /etc/letsencrypt/live/pokerogue.<도메인>/fullchain.pem \
 /etc/letsencrypt/live/pokerogue.<도메인>/privkey.pem \
 > /etc/haproxy/pokerogue.pem

HAproxy 설정

ingress, service를 조회하여 MetalLB로부터 부여받은 IP 확인

web: 172.27.1.100
backend: 172.27.1.104

1
2
3
4
5
6


# kubectl get ingress -n pokerogue 
NAME CLASS HOSTS ADDRESS PORTS AGE
pokerogue-unified-ingress nginx pokerogue.<도메인> 172.27.1.100 80 6d21h
# kubectl get svc -n pokerogue 
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
pokerogue-server LoadBalancer 10.233.16.211 172.27.1.104 8001:30946/TCP 9d

확인한 IP를 HAproxy 설정에 추가
HTTPS 트래픽 처리
- SSL Termination
  - SSL인증서와 개인키 파일을 결합한 pokerogue.pem파일 사용
- X-Forwarded-Port
  - 구글/디스코드 같은 외부 로그인을 위한 Backend OAuth callback URL 생성 시
- 경로 기반 라우팅
  - /api/* 요청 시 rogueserver-service로 직접 라우팅
  - 나머지 모든 요청은 pokerogue-ingress로 라우팅

API 서버(rogueserver-service)로의 라우팅을 위해 /api/* 요청을 /* 요청으로 재작성하는 설정 적용

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


frontend pokerogue_frontend
 bind *:443 ssl crt /etc/haproxy/pokerogue.pem
 mode http
 option forwardfor

 # Set X-Forwarded headers for HTTPS
 http-request set-header X-Forwarded-Host %[req.hdr(host)]
 http-request set-header X-Forwarded-Proto https
 http-request set-header X-Forwarded-Port 48443

 # Path-based routing: /api -> Backend API, others -> Frontend
 use_backend pokerogue_api_backend if { path_beg /api }
 default_backend metallb_backend_pokerogue

backend metallb_backend_pokerogue
 # Frontend only (no rewrite)
 server pokerogue 172.27.1.100:80

backend pokerogue_api_backend
 # Backend API: direct to LoadBalancer Service (MetalLB managed)
 # Path rewrite: /api/* -> /*
 http-request set-path %[path,regsub(^/api,)]
 server pokerogue-server-lb 172.27.1.104:8001

haproxy 적용

1
2


haproxy -c -f /etc/haproxy/haproxy.cfg
systemctl reload haproxy

접근 성공!

Pokerogue 게임을 Container 이미지로 빌드하기 위한 방법

Sun, 19 Oct 2025 09:00:00 +0900

Pokerogue 이미지 빌드

Pokerogue 게임을 컨테이너 이미지로 빌드하기 위한 방법

개요

Pokerogue 게임을 K8S 환경에서 동작하게 하기 위해서 약간의 소스코드 수정과 Dockerfile 작성이 필요
- 공식 GitHub에는 로컬 기준으로 코드가 작성된 부분이 많음
Pokerogue는 Vite 기반 React 프론트엔드와 Go 기반 백엔드 그리고 Mariadb로 구성

Frontend

공식 GitHub: https://github.com/pagefaultgames/pokerogue
TypeScript로 작성
Vite 번들러를 사용하는 React SPA
Pokerogue의 UI, 정적파일, 로직 및 랜더링 제공
/api/*로 백엔드 API 호출
OAuth 외부 로그인 UI 제공

Frontend 이미지 빌드

Dockerfile

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


ARG NODE_VERSION=22.14
ARG OS=alpine

# Build stage
FROM node:${NODE_VERSION}-${OS} AS build

RUN apk add --no-cache git rsync
WORKDIR /app

RUN corepack enable && corepack prepare pnpm@10.14.0 --activate

COPY . .

# Initialize git submodules
RUN git submodule update --init --recursive

# Install dependencies with cache
RUN --mount=type=cache,target=/root/.pnpm-store \
 pnpm install --frozen-lockfile

# Production build
RUN pnpm run build

# Production stage
FROM nginx:alpine

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

# Copy built files from build stage
COPY --from=build /app/dist /usr/share/nginx/html

EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

공식 GitHub에는 beta 브랜치에만 Dockerfile이 존재
- development mode로 실행되게 작성되어 있어서 Dockerfile은 새로 전부 작성

Build Stage와 Production Stage 분리
- Build Stage
  - Node.js 정적 파일 빌드
  - Git submodule 초기화
  - pnpm dependencies 설치
  - pnpm 빌드로 /app/dist 생성
- Production Stage
  - Nginx Alpine 이미지
  - 빌드된 정적 파일만 복사
  - Node.js 런타임 포함하지 않음
Git Submodule 처리
- Pokerogue는 assets와 locales를 Git submodule로 관리
- 최종 이미지에는 빌드된 dist 포함되므로 빌드에 사용된 .git은 제외됨

Nginx 사용

SPA 라우팅
- https://pokerogue.com/ 이외에 /game, /home 등 제공하지 않는 경로로 접근 시 index.html을 제공하도록 설정
gzip 압축
- JavaScript, CSS 파일들을 gzip으로 압축하여 전송
보안 헤더 적용
정적 파일 캐싱
- 이미지, 폰트, JS, CSS 등을 1년간 브라우저 캐시

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


server {
 listen 80;
 server_name localhost;
 root /usr/share/nginx/html;
 index index.html;

 # SPA routing - all routes go to index.html
 location / {
 try_files $uri $uri/ /index.html;
 }

 gzip on;
 gzip_vary on;
 gzip_min_length 1024;
 gzip_types text/plain text/css text/xml text/javascript application/x-javascript application/xml+rss application/json application/javascript;

 add_header X-Frame-Options "SAMEORIGIN" always;
 add_header X-Content-Type-Options "nosniff" always;
 add_header X-XSS-Protection "1; mode=block" always;

 location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
 expires 1y;
 add_header Cache-Control "public, immutable";
 }
}

.env 파일 관리

환경변수들을 빌드 시점에 포함시켜야함

.dockeringnore 파일에 명시되어 있던 .env 주석처리

1
2
3
4
5
6
7


# .dockerignore
node_modules
*.log
*.md
.gitignore
Dockerfile
#.env 

Vite의 .env 우선순위
- Vite는 다음 순서로 .env 파일 로드
  - 나중에 로드된 파일이 이전 파일의 변수값을 덮어씀
  1. .env - 모든 환경에서 로드
  2. .env.[mode] - 특정 모드 (예: .env.production)
- 따라서 pnpm run build 실행 시 production 모드로 실행되므로 최종적으로 .env.production에 있는 환경변수를 참조하게 됨

.env | .env.production

VITE_SERVER_URL: 실제 게임을 서비스할 도메인으로 변경
VITE_DISCORD_CLIENT_ID: Discord OAuth 로그인을 위한 본인 값 입력
VITE_GOOGLE_CLIENT_ID: Google OAuth 로그인을 위한 본인 값 입력

1
2
3
4
5
6


VITE_BYPASS_LOGIN=0
VITE_BYPASS_TUTORIAL=0
VITE_SERVER_URL=https://pokerogue.<도메인>:<포트>/api
VITE_DISCORD_CLIENT_ID=<discord client id>
VITE_GOOGLE_CLIENT_ID=<google client id>
VITE_I18N_DEBUG=0

이미지 빌드

1
2


docker build -t ksi05298/pokerogue-web:latest .
docker push ksi05298/pokerogue-web:latest

Backend

공식 GitHub: https://github.com/pagefaultgames/rogueserver
Go로 작성
사용자 인증, 게임 데이터 저장, 조회, 세션 관리 등을 수행하는 RESTFUL API 서버
- /account/*, /gamedata/*, /auth/* 엔드포인트 제공
MariaDB와 연동

Backend 이미지 빌드

Dockerfile

Dockerfile은 공식 GitHub에 있는 파일 그대로 사용
- scratch 이미지를 사용해서 정적 바이너리만 포함

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


# SPDX-FileCopyrightText: 2024-2025 Pagefault Games
#
# SPDX-License-Identifier: AGPL-3.0-or-later
ARG GO_VERSION=1.22

FROM docker.io/library/golang:${GO_VERSION} AS builder

WORKDIR /src

COPY ./go.mod /src/
COPY ./go.sum /src/

RUN go mod download && go mod verify

COPY . /src/

RUN CGO_ENABLED=0 \
 go build -tags=devsetup -o rogueserver

RUN chmod +x /src/rogueserver

# ---------------------------------------------

FROM scratch

WORKDIR /app

COPY --from=builder /src/rogueserver .
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/

EXPOSE 8001

ENTRYPOINT ["./rogueserver"]

OAuth 쿠키 설정 수정

공식 rogueserver 코드에서 구글/디스코드 로그인에 필요한 OAuth 쿠키 설정에 문제 있어 수정 필요

api/endpoints.go 파일의 658줄 handleProviderCallback 함수 내부

수정 전

1
2
3
4
5
6
7
8
9


 http.SetCookie(w, &http.Cookie{
 Name: "pokerogue_sessionId",
 Value: sessionToken,
 Path: "/",
 Secure: true,
 SameSite: http.SameSiteStrictMode,
 Domain: "pokerogue.net",
 Expires: time.Now().Add(time.Hour * 24 * 30 * 3), // 3 months
 })

수정 후

1
2
3
4
5
6
7
8
9


 http.SetCookie(w, &http.Cookie{
 Name: "pokerogue_sessionId",
 Value: sessionToken,
 Path: "/",
 Secure: true,
 SameSite: http.SameSiteLaxMode,
 Domain: "",
 Expires: time.Now().Add(time.Hour * 24 * 30 * 3), // 3 months
 })

변경 사항
- SameSite: SameSiteStrictMode → SameSiteLaxMode
  - OAuth callback은 cross-site 요청이 될 수 밖에 없음 (google.com → 내 도메인)
  - Strict로 설정하면 cross-site 쿠키 전송이 차단돼서 CSRF오류가 발생됨
  - Lax로 변경하여 안전한 도메인에서의 GET 요청(oauth callback)에서 쿠키 전송 허용
- Domain: “pokerogue.net” → “”
  - pokerogue 공식 도메인에서 빈 문자열로 변경해서 현재 도메인이 자동 적용되도록 설정

이미지 빌드 및 푸시

1
2


docker build -t ksi05298/rogueserver:latest .
docker push ksi05298/rogueserver:latest

참고

Vite 환경변수 가이드:

https://vitejs.dev/guide/env-and-mode.html

OAuth SameSite Cookie 설정:

https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite