refactor: 문서 사람처럼 작성하기

This commit is contained in:
donghyeon-ka
2026-09-22 16:24:58 +09:00
parent 1549e62b5e
commit f3bed70991
158 changed files with 4381 additions and 832 deletions
@@ -31,7 +31,7 @@ PostgreSQL 을 정상 종료시키고 refresh 와 새 로그인과 관리 API
- **readiness 가 깨진 노드를 시야에서 먼저 치운다**
Ready 파드가 0개가 되고 `ready` 주소가 빈 목록이 되는 경로를 다룬다.
- **세션 캐시와 persistent session store의 경계를 손으로 가른다**
A-0 재검증에서 정상 2노드의 교차 refresh는 반대편 DB 세션 SQL 없이도 성공했다. 여기서는 DB 자체를 내려 **캐시만으로 처리할 수 없는 쓰기 경로가 무엇인지** 확인한다.
A-0의 2026-09-22 격리 재검증에서는 정상 2노드의 교차 refresh도 반대편 노드가 persistent session store를 `SELECT`·`UPDATE`했다. 여기서는 DB 자체를 내려 **로컬 cache entry가 있어도 완료할 수 없는 경로가 무엇인지** 확인한다.
- **PostgreSQL 을 진짜로 크래시시키고 잃은 로그인을 센다**
같은 데이터베이스를 SIGKILL 로 죽이는 편이다. 정상 종료가 아무것도 잃지 않는다는 이 편의 결과가 그쪽의 대조군이 된다.
@@ -75,11 +75,11 @@ A-1 과의 대비가 이 실험의 값이다.
| # | 경로 | 무엇을 보는가 |
|---|---|---|
| ① | **캐시를 가진 노드**에서 refresh | 캐시가 DB 를 대신할 수 있는가 |
| ② | 캐시가 없는 노드에서 refresh | 완전한 DB 의존 |
| ② | **K1에서 만든 세션을 K0에서** refresh | K0 로컬 캐시에 없는 세션의 DB 의존 |
| ③ | 새 로그인 | 쓰기 경로 |
| ④ | 이미 발급된 토큰으로 관리 API 조회 | 서명만으로 되는 경로가 있는가 |
| ④ | 이미 발급된 access token으로 관리 API 조회 | 토큰 발급 뒤의 세션 조회도 DB에 의존하는가 |
절차를 끝까지 밟으면 캐시에 세션을 가진 노드도 refresh 가 `500` 인 것, JWKS 와 `.well-known` 만 `200` 으로 살아 있는 것, Ready 파드가 0개이고 `ready` 주소가 빈 목록인 것, 정문이 `503` 을 주는 것, 헬스 네 항목 중 `database connections` 만 DOWN 인 본문, `up = 1` 인 채로 전면 장애가 나 있는 것, 15초 만에 재시작 0회로 스스로 돌아오는 것을 자기 화면에서 보게 된다.
절차를 끝까지 밟으면 캐시에 세션을 가진 노드도 refresh 가 `500` 인 것, JWKS 와 `.well-known` 만 `200` 으로 살아 있는 것, Ready 파드가 0개이고 `ready` 주소가 빈 목록인 것, 정문이 `503` 을 주는 것, 헬스 네 항목 중 `database connections` 만 DOWN 인 본문, `up = 1` 인 채로 전면 장애가 나 있는 것, DB 복구 뒤 Keycloak 재시작 0회로 스스로 돌아오는 것을 자기 화면에서 보게 된다.
## 전제와 되돌리기
@@ -184,32 +184,31 @@ kubectl -n keycloak-lab exec a2-probe -- sh -c 'echo "K0=$K0 K1=$K1 PW길이=${#
kubectl -n keycloak-lab exec -it a2-probe -- sh
```
### 5. 양쪽 노드에 세션을 하나씩 만든다
### 5. 양쪽 노드에 세션을 하나씩 만들고 토큰을 보관한다
**무엇을 보는가** — ① 과 ② 를 구분하려면 캐시를 가진 노드와 없는 노드가 있어야 한다. A-0 에서 확인한 성질을 그대로 쓴다 — 각 노드는 자기가 로그인시킨 세션만 캐시한다.
**무엇을 보는가** — ①과 ②를 제대로 구분하려면 먼저 **K0이 만든 세션 하나, K1이 만든 세션 하나**만 있어야 한다. 그리고 DB를 내린 뒤 같은 세션을 다시 시험해야 하므로 refresh token을 여기서 변수에 담아 둔다.
```sh label="[탐침 파드] 두 노드에 각각 로그인하고 sid 를 뽑는다"
```sh label="[탐침 파드] K0·K1에 한 번씩만 로그인한다"
TOK=/realms/master/protocol/openid-connect/token
for H in "$K0" "$K1"; do
echo -n "$H : "
curl -s -X POST "http://$H:8080$TOK" \
-d grant_type=password -d client_id=admin-cli \
-d username=admin -d "password=$PW" \
| sed -n 's/.*"access_token":"\([^"]*\)".*/\1/p' \
| cut -d. -f2 | tr '_-' '/+' | base64 -d 2>/dev/null \
| sed -n 's/.*"sid":"\([^"]*\)".*/\1/p'
done
R0=$(curl -s -X POST "http://$K0:8080$TOK" \
-d grant_type=password -d client_id=admin-cli \
-d username=admin -d "password=$PW")
AT=$(echo "$R0" | sed -n 's/.*"access_token":"\([^"]*\)".*/\1/p')
RT0=$(echo "$R0" | sed -n 's/.*"refresh_token":"\([^"]*\)".*/\1/p')
R1=$(curl -s -X POST "http://$K1:8080$TOK" \
-d grant_type=password -d client_id=admin-cli \
-d username=admin -d "password=$PW")
RT1=$(echo "$R1" | sed -n 's/.*"refresh_token":"\([^"]*\)".*/\1/p')
echo "K0 access=${#AT} refresh=${#RT0}"
echo "K1 refresh=${#RT1}"
```
**어디를 보나** — 실측은 이렇다(observed, `02-setup-sessions.txt`).
세 길이가 모두 `0`보다 커야 한다. 토큰 문자열 자체는 화면에 찍지 않는다. `RT0`은 K0이 만든 세션, `RT1`은 K1이 만든 세션이다. 이 구분이 뒤의 ①·② 비교축이다.
```text
=== [준비] 양쪽 노드에 세션을 하나씩 만든다 ===
keycloak-0 에서 로그인 sid=EAXV5HcG2J1BZ3vnwONf64AQ 토큰길이=613
keycloak-1 에서 로그인 sid=McyTj5lj3n_JqApCXeuAHExc 토큰길이=613
```
**이 값이 뜻하는 것** — 빈 줄이 나오면 로그인이 실패했거나 base64 패딩 때문에 sid 를 못 뽑은 것이므로 응답 전체를 한 번 그대로 본다.
2026-09-22 수정 재검증에서는 두 세션을 만든 직후 K0·K1의 `sessions` 고유 엔트리가 각각 `1`, PostgreSQL online session이 `2`였다.
### 6. 세션이 각자 노드에만 캐시됐는가
@@ -221,62 +220,87 @@ for POD in keycloak-0 keycloak-1; do
kubectl -n keycloak-lab get --raw \
"/api/v1/namespaces/keycloak-lab/pods/$POD:9000/proxy/metrics" \
| grep '^vendor_statistics_approximate_entries_unique' \
| grep -E 'cache="(sessions|clientSessions)"'
| grep 'cache="sessions"'
done
```
```bash label="[lab host] PostgreSQL에 저장된 online session 수를 센다"
```bash label="[lab host] PostgreSQL의 online session 수를 센다"
kubectl -n keycloak-lab exec deploy/postgres -- psql -U keycloak -d keycloak \
-c "select offline_flag, count(*) from offline_user_session group by offline_flag order by offline_flag"
-c "select count(*) from offline_user_session where offline_flag='0'"
```
2026-09-22 재검증에서는 A-2 직전 online session이 `2`건이었다. 이 숫자를 복구 뒤와 비교한다.
**어디를 보나** — 이 시점에는 `K0=1`, `K1=1`, `DB=2`가 기준이다. K0과 K1 중 한쪽이 `0`이면 두 로그인 중 하나가 실패한 것이므로 여기서 멈춘다.
### 7. ④ 에 쓸 클라이언트 id 를 미리 뽑는다
### 7. ④에 쓸 클라이언트 id를 미리 뽑는다
**무엇을 보는가** — DB 가 죽은 뒤에는 이 조회 자체가 실패하므로 지금 뽑아 둔다.
**무엇을 보는가** — DB가 죽은 뒤에는 이 조회 자체가 실패하므로 지금 뽑아 둔다. 새로 로그인하지 않고 5번에서 이미 받은 `AT`를 그대로 쓴다. 그래야 준비 단계에서 세션 수가 불필요하게 늘지 않는다.
```sh label="[탐침 파드] ① 응답을 한 번 그대로 본다"
AT=$(curl -s -X POST "http://$K0:8080$TOK" \
-d grant_type=password -d client_id=admin-cli \
-d username=admin -d "password=$PW" \
| sed -n 's/.*"access_token":"\([^"]*\)".*/\1/p')
```sh label="[탐침 파드] admin-cli 내부 id를 찾는다"
curl -s -H "Authorization: Bearer $AT" \
"http://$K0:8080/admin/realms/master/clients?clientId=admin-cli"
```
잘라내는 줄은 미검증이다(unknown).
```sh label="[탐침 파드] ② 첫 번째 id 만 잘라낸다"
CID=$(curl -s -H "Authorization: Bearer $AT" \
"http://$K0:8080/admin/realms/master/clients?clientId=admin-cli" \
| tr ',' '\n' | grep -m1 '"id"' | cut -d'"' -f4)
echo "CID=$CID"
```
`CID`가 빈 문자열이면 다음 단계로 가지 않는다. 이 파싱은 A-0에서 사용한 것과 같은 방식이다.
### 8. 네 경로를 정상 상태에서 한 번 돌린다
```sh label="[탐침 파드] 토큰 둘을 받고 네 경로를 차례로 친다"
R0=$(curl -s -X POST "http://$K0:8080$TOK" \
-d grant_type=password -d client_id=admin-cli -d username=admin -d "password=$PW")
RT0=$(echo "$R0" | sed -n 's/.*"refresh_token":"\([^"]*\)".*/\1/p')
R1=$(curl -s -X POST "http://$K1:8080$TOK" \
-d grant_type=password -d client_id=admin-cli -d username=admin -d "password=$PW")
RT1=$(echo "$R1" | sed -n 's/.*"refresh_token":"\([^"]*\)".*/\1/p')
여기서 ①과 ②가 다르다는 점이 중요하다.
curl -s -o /dev/null -w '① %{http_code}\n' --max-time 10 -X POST "http://$K0:8080$TOK" \
-d grant_type=refresh_token -d client_id=admin-cli -d "refresh_token=$RT0"
curl -s -o /dev/null -w '② %{http_code}\n' --max-time 10 -X POST "http://$K1:8080$TOK" \
-d grant_type=refresh_token -d client_id=admin-cli -d "refresh_token=$RT1"
```text
① RT0은 K0이 만든 세션 → K0 로컬 캐시에 있다 → K0에서 refresh
② RT1은 K1이 만든 세션 → K0 로컬 캐시에 없다 → K0에서 refresh
```
refresh token은 사용 뒤 새 값으로 회전할 수 있다. 그래서 상태코드만 보고 버리지 않고 **응답 본문에서 새 refresh token을 다시 변수에 저장한다.** 이 작업을 빼면 DB 정지 뒤 옛 토큰을 재사용하게 되어 `500`의 원인을 DB 장애와 토큰 재사용 중에서 구분할 수 없다.
```sh label="[탐침 파드] ① K0이 만든 세션을 K0에서 refresh"
R=$(curl -s -w '\n%{http_code}' --max-time 10 -X POST "http://$K0:8080$TOK" \
-d grant_type=refresh_token -d client_id=admin-cli -d "refresh_token=$RT0")
CODE=$(echo "$R" | tail -1)
BODY=$(echo "$R" | sed '$d')
RT0=$(echo "$BODY" | sed -n 's/.*"refresh_token":"\([^"]*\)".*/\1/p')
AT=$(echo "$BODY" | sed -n 's/.*"access_token":"\([^"]*\)".*/\1/p')
echo "① $CODE"
```
```sh label="[탐침 파드] ② K1이 만든 세션을 K0에서 refresh"
R=$(curl -s -w '\n%{http_code}' --max-time 10 -X POST "http://$K0:8080$TOK" \
-d grant_type=refresh_token -d client_id=admin-cli -d "refresh_token=$RT1")
CODE=$(echo "$R" | tail -1)
BODY=$(echo "$R" | sed '$d')
RT1=$(echo "$BODY" | sed -n 's/.*"refresh_token":"\([^"]*\)".*/\1/p')
echo "② $CODE"
```
②가 끝난 직후에도 K0의 `sessions` 고유 엔트리가 1인지 관찰용 터미널에서 확인한다. 2026-09-22 수정 재검증에서는 ②가 `200`인데도 `K0=1`, `K1=1` 그대로였다. 즉 ②는 실제로 **K0 로컬 cache entry가 없는 세션**을 처리한 대조군이다.
```sh label="[탐침 파드] ③ 새 로그인 · ④ 이미 받은 access token으로 관리 API"
curl -s -o /dev/null -w '③ %{http_code}\n' --max-time 10 -X POST "http://$K0:8080$TOK" \
-d grant_type=password -d client_id=admin-cli -d username=admin -d "password=$PW"
curl -s -o /dev/null -w '④ %{http_code}\n' --max-time 10 -H "Authorization: Bearer $AT" \
-d grant_type=password -d client_id=admin-cli \
-d username=admin -d "password=$PW"
curl -s -o /dev/null -w '④ %{http_code}\n' --max-time 10 \
-H "Authorization: Bearer $AT" \
"http://$K0:8080/admin/realms/master/clients/$CID/user-sessions?max=100"
```
**어디를 보나** — 정상 상태에서는 네 줄이 전부 `200` 이다.
**어디를 보나** — 정상 상태에서는 `① 200`, `② 200`, `③ 200`, `④ 200`이다.
**이 값이 뜻하는 것** — `-o /dev/null` 을 빼면 안 된다. 빼면 본문과 상태코드가 한 줄에 섞여 나오고, 원래 실행이 정확히 그것을 당했다.
③은 성공하면 세션을 하나 더 만든다. 따라서 주입 직전 DB row 수는 처음의 `2`가 아니라 `3`이다. 고정 숫자를 외우지 말고 실제 값을 변수처럼 기록한다.
```bash label="[lab host] 주입 직전 DB 세션 수를 기록한다"
DB_BEFORE=$(kubectl -n keycloak-lab exec deploy/postgres -- \
psql -U keycloak -d keycloak -Atc \
"select count(*) from offline_user_session where offline_flag='0'")
echo "DB_BEFORE=$DB_BEFORE"
```
2026-09-22 수정 재검증은 `DB_BEFORE=3`이었다. 복구 뒤에는 이 값과 다시 비교한다.
상태가 필요 없는 경로도 미리 재 둔다.
@@ -393,12 +417,12 @@ kubectl -n keycloak-lab exec -it a2-probe -- sh
**여기서 시계를 본다.** 7번에서 `AT` 를 받은 지 60초가 지났으면 ④ 는 `401` 을 준다. 그 `401` 은 DB 때문이 아니라 토큰이 만료돼서 나온 것이라, 이 실험이 재려는 값이 아니다. 60초를 넘겼으면 ④ 는 이 회차에서 못 잰다 — DB 가 없는 동안에는 새 토큰을 받을 수 없다(③ 이 이미 `500` 이다). 복구 절까지 가서 ④ 만 다시 쳐도 안 된다 — 그때는 DB 가 살아 있어 `200` 이 나오므로 이 표가 묻는 값이 아니다. ④ 가 필요하면 복구한 뒤 토큰을 새로 받고 주입부터 다시 돈다. ①·②·③ 은 `AT` 를 쓰지 않으므로 그대로 쓴다.
주입 전 8번에서 친 것과 글자까지 같은 블록이다.
①·②는 8번에서 갱신해 둔 **최신 `RT0`·`RT1`**을 그대로 쓴다. ②의 대상은 K1이 아니라 K0다.
```sh label="[탐침 파드] 네 경로를 다시 친다"
curl -s -o /dev/null -w '① %{http_code}\n' --max-time 10 -X POST "http://$K0:8080$TOK" \
-d grant_type=refresh_token -d client_id=admin-cli -d "refresh_token=$RT0"
curl -s -o /dev/null -w '② %{http_code}\n' --max-time 10 -X POST "http://$K1:8080$TOK" \
curl -s -o /dev/null -w '② %{http_code}\n' --max-time 10 -X POST "http://$K0:8080$TOK" \
-d grant_type=refresh_token -d client_id=admin-cli -d "refresh_token=$RT1"
curl -s -o /dev/null -w '③ %{http_code}\n' --max-time 10 -X POST "http://$K0:8080$TOK" \
-d grant_type=password -d client_id=admin-cli -d username=admin -d "password=$PW"
@@ -410,11 +434,13 @@ curl -s -o /dev/null -w '④ %{http_code}\n' --max-time 10 -H "Authorization: Be
```text
① 캐시를 가진 노드(keycloak-0)에서 refresh HTTP 500
② 캐시가 없는 노드(keycloak-1)에서 refresh HTTP 500
② K1 세션을 cache 없는 K0에서 refresh HTTP 500
③ 새 로그인 HTTP 500
④ 관리 API (세션 조회 필요) HTTP 500
```
2026-09-22 수정 재검증에서도 네 경로가 모두 `500`이었다. 이 회차는 ②를 실제 cross-node/no-local-cache 경로로 바로잡고 다시 실행한 결과다. 원본은 `final/evidence/raw/2026-09-22-test-server-revalidation/a2-07-corrected-control-refreshes.txt`, `a2-08-corrected-control-four-paths.txt`, `a2-09-corrected-outage-and-recovery.txt`에 남겼다.
본문도 한 번 그대로 본다.
```sh label="[탐침 파드] 500 의 본문을 본다"
@@ -448,7 +474,7 @@ HTTP 000000{"error":"HTTP 401 Unauthorized"}401
`curl -w '%{http_code}'` 를 쓰면서 `-o /dev/null` 을 빼면 본문이 표준출력으로 같이 나오고, 거기에 `--retry` 까지 걸려 있어 실패한 시도의 `000` 이 앞에 쌓인다. 위 표의 ④ `500` 은 아래 「서명 검증만 필요한 두 경로와 ④」 블록에서 DB 가 아직 내려가 있는 동안 다시 잰 값이다. 첫 측정은 쓰지 않았다 — 오염된 측정은 버리고 다시 잰다.
①의 `500`이 이 실험의 핵심이다. 세션이 메모리 캐시에 있어도 refresh는 DB가 없으면 완료되지 않았다. **여기서 필요한 결론은 특정 SQL 문장을 단정하는 것이 아니라, refresh 처리에 persistent session store 쓰기 경로가 포함된다는 것**이다. A-0의 2026-09-22 정상 클러스터 재검증에서는 반대편 refresh에 별도 세션 SELECT가 없었으므로, 오래된 `UPDATE OFFLINE_USER_SESSION ...` 한 줄을 모든 refresh의 고정 경로처럼 설명하지 않는다.
①과 ②가 **둘 다 `500`**이라는 것이 이 실험의 핵심이다. 로컬 cache entry가 있는 세션도, 없는 세션도 DB가 없으면 refresh를 완료하지 못했다. **여기서 필요한 결론은 refresh 처리에 persistent session store의 read/write 경로가 포함된다는 것**이다. A-0의 2026-09-22 격리 재검증에서도 반대편 refresh가 `OFFLINE_USER_SESSION`·`OFFLINE_CLIENT_SESSION`을 `SELECT`하고 `UPDATE`하는 것을 직접 확인했다. 다만 SQL 문장 수나 순서를 모든 refresh의 고정 계약처럼 일반화하지 않고, 이 실험에서는 DB 의존성 자체를 판정한다.
상태가 필요 없는 경로는 살아남는다. ④ 도 여기서 한 번 더 친다 — 표에 적은 ④ `500` 이 이 블록이 낸 값이다. 셋을 한 블록에 두면 세 경로의 답이 한 화면에 나란히 나온다.
@@ -662,18 +688,20 @@ deployment "postgres" successfully rolled out
**목적** — 정상 종료가 데이터를 잃지 않았다는 것을 숫자로 확인하고 실험 도구를 치운다.
```bash label="[lab host] ① 세션 수를 다시 센다"
kubectl -n keycloak-lab exec deploy/postgres -- psql -U keycloak -d keycloak \
-c "select offline_flag, count(*) from offline_user_session group by offline_flag"
```bash label="[lab host] ① 주입 전후 세션 수를 한 줄로 비교한다"
DB_AFTER=$(kubectl -n keycloak-lab exec deploy/postgres -- \
psql -U keycloak -d keycloak -Atc \
"select count(*) from offline_user_session where offline_flag='0'")
echo "DB_BEFORE=$DB_BEFORE DB_AFTER=$DB_AFTER"
```
```bash label="[lab host] ② 탐침 파드를 직접 지운다"
kubectl -n keycloak-lab delete pod a2-probe --ignore-not-found
```
**예상 결과** — 2026-09-22 재검증은 주입 전 `2`, 복구 후 `2`였다. 정상 종료 구간에서 새 로그인은 `500`으로 실패했으므로 이번 회차에는 세션 수가 늘 이유도 없었다.
**예상 결과** — 복구 뒤 세션 수가 앞에서 기록한 `DB_BEFORE`와 같아야 한다. 2026-09-22 수정 재검증에서는 `DB_BEFORE=3`, `DB_AFTER=3`이었다. DB가 내려간 동안 ③ 새 로그인은 `500`으로 실패했으므로 장애 구간에서 새 세션이 추가되지 않았다.
**왜 필요한가** — 주입 전후 동일한 `2`건이 남아 정상 종료 자체가 저장된 세션 행을 잃지 않았음을 확인했다. 탐침 파드는 `sleep 7200` 이 끝나면 `Completed` 로 남고 자동으로 사라지지 않는다. 다음 실험에서 `a2-probe` 이름이 이미 있다고 거절당하는 까닭이 거기 있다.
**왜 필요한가** — `DB_AFTER == DB_BEFORE`가 정상 종료 자체가 저장된 세션 행을 잃지 않았음을 확인한다. 특정 숫자 `2`를 기준으로 삼지 않는다. 준비·대조군 단계에서 만드는 세션 수가 바뀌면 숫자도 바뀌기 때문이다. 탐침 파드는 `sleep 7200` 이 끝나면 `Completed` 로 남고 자동으로 사라지지 않는다. 다음 실험에서 `a2-probe` 이름이 이미 있다고 거절당하는 까닭이 거기 있다.
**문제가 생기면** — 세션 수가 주입 전보다 적으면 이 실험 밖에서 누가 지운 것이다. A-3 의 정리 단계가 돌았는지 본다.
@@ -685,7 +713,7 @@ kubectl -n keycloak-lab delete pod a2-probe --ignore-not-found
| 헬스 | `exec a2-probe -- curl -s "http://$K0:9000/health/ready"` | 전체 `UP` |
| 클러스터 | `vendor_cluster_size` | 양쪽 `2` |
| 탐침 파드 | `kubectl -n keycloak-lab get pod a2-probe` | 지웠으면 `NotFound` |
| 밖 | `curl -s -o /dev/null -w '%{http_code}\n' https://auth.hyeonworks.com/realms/master` | `200` |
| edge 경로 | `curl -skS --resolve auth.hyeonworks.com:443:192.168.122.10 -o /dev/null -w '%{http_code}\n' https://auth.hyeonworks.com/realms/master` | `200` |
표는 위에서 아래로 한 번에 치지 않는다. 막혔을 때 해당하는 줄만 짚는다. 헬스 줄의 `$K0` 는 관찰 절에서 관찰용 터미널에 잡아 둔 값이라 그 터미널을 닫았으면 그 두 줄부터 다시 친다. 헬스 줄 자체는 탐침 파드가 남아 있을 때만 되므로 ② 로 지웠으면 건너뛴다.
@@ -711,12 +739,12 @@ kubectl -n keycloak-lab delete pod a2-probe --ignore-not-found
2026-09-22 현재 lab에서 A-2를 다시 실행했다. 증거는 `final/evidence/raw/2026-09-22-test-server-revalidation/a2-*.txt`에 있다.
- (observed, 2026-09-22) 주입 전 Keycloak 두 파드 Ready, cluster size `2/2`, online session `2`, 정문 `200`.
- (observed, 2026-09-22) PostgreSQL을 `replicas=0`으로 내린 직후 두 파드의 기존 refresh가 모두 `500`, 새 login `500`, admin session API `500`, JWKS와 `.well-known`은 `200`.
- (observed, 2026-09-22) 수정 재검증에서 준비 직후에는 K0·K1 `sessions=1/1`, online session `2`. 대조군의 ③ 새 로그인까지 끝낸 **주입 직전**에는 `K0=2`, `K1=1`, `DB_BEFORE=3`, cluster size `2/2`, edge `200`이었다.
- (observed, 2026-09-22) PostgreSQL을 `replicas=0`으로 내리자 ① K0 로컬 세션 refresh `500`, ② K1에서 만든 세션을 K0에서 refresh `500`, ③ 새 login `500`, ④ admin session API `500`이었다. 첫 회차에서 JWKS와 `.well-known`은 계속 `200`이었다.
- (observed, 2026-09-22) 두 Keycloak은 restart count 증가 없이 `Ready=false`, EndpointSlice `false,false`, edge와 외부 응답은 `503`.
- (observed, 2026-09-22) 직접 Pod IP의 `/health/ready`를 보면 전체 `DOWN`, `database connections async health check`만 `DOWN`, cluster health와 initialized는 `UP`.
- (observed, 2026-09-22) `kube_pod_status_ready` Prometheus query는 여전히 빈 배열이다.
- (observed, 2026-09-22) PostgreSQL은 13:56:21 KST에 Ready가 됐고 13:56:37 확인 시 두 Keycloak은 재시작 없이 Ready, edge/외부 `200`, online session은 주입 전과 같은 `2`, cluster size `2/2`.
- (observed, 2026-09-22) 수정 재검증 복구 뒤 `DB_AFTER=3`으로 `DB_BEFORE=3`과 같았고, 두 Keycloak은 restart count `0`인 채 Ready, edge `200`으로 돌아왔다. 첫 회차에서도 PostgreSQL Ready 뒤 Keycloak이 재시작 없이 Service에 재진입했다.
- (command finding) 현재 Keycloak 26.7.0 이미지에는 `curl`, `wget`뿐 아니라 `awk`도 없다. 컨테이너 내부 명령은 일반적인 userland를 가정하지 않는다.
아래 2026-09-04/17 숫자는 과거 실행 기록이다. 날짜가 다른 값은 현재 불변값처럼 섞지 않는다.
@@ -285,7 +285,7 @@ kubectl -n keycloak-lab get pods -o wide
0건이다. 파드 안에서 `( ... ) &` 로 띄운 루프가 `exec` 세션이 끝날 때 같이 죽었고 측정 자체가 없었다. 그래서 편집기로 파일을 연다.
```bash label="[lab host] ① 편집기로 루프 파일을 연다"
vim /tmp/a3-login-loop.sh
nano /tmp/a3-login-loop.sh
```
```sh label="/tmp/a3-login-loop.sh — 이 내용을 적는다"
@@ -329,17 +329,16 @@ printf "%s" '{"sid":"ABC"}' | sed -n 's/.*"sid":"\([^"]*\)".*/\1/p' | od -c
`/tmp/sids` 에는 클라이언트가 `200` 과 토큰을 실제로 받은 것만 쌓인다. `AT` 가 비면 아무것도 안 적으므로 이 파일이 「서버가 COMMIT 했다고 응답한 것」의 목록이고, 그게 이 실험의 시험군이다.
```bash label="[lab host] ② 파일을 파드 안으로 밀어 넣고 줄 수를 센다"
kubectl -n keycloak-lab exec -i a3-probe -- sh -c 'cat > /tmp/a3-login-loop.sh' \
< /tmp/a3-login-loop.sh
```bash label="[lab host] ② 파일을 파드 안으로 복사하고 줄 수를 센다"
kubectl -n keycloak-lab cp /tmp/a3-login-loop.sh a3-probe:/tmp/a3-login-loop.sh
kubectl -n keycloak-lab exec a3-probe -- wc -l /tmp/a3-login-loop.sh
```
**예상 결과** — 줄 수가 `19 /tmp/a3-login-loop.sh` 로 나오면 들어갔다. 원래 실행의 파일은 `17` 줄이었고, 위에서 sid 를 변수로 받는 두 줄로 바꾸면서 늘었다.
**왜 필요한가** — `kubectl cp` 도 되지만 컨테이너에 `tar` 가 있어야 한다. 이 실험대의 `curlimages/curl:8.11.1` 에 `tar` 가 있는지는 재지 않았다(unknown). 그래서 가이드는 `cat >` 로 밀어 넣는 쪽이 어디서나 통한다고 적고 그쪽을 골랐다.
**왜 필요한가** — 긴 셸 내용을 원격 `sh -c` 한 줄에 다시 욱여넣지 않기 위해 파일로 분리한다. `kubectl cp` 는 컨테이너 안의 `tar` 를 사용한다. 2026-09-22 현재 이 실험의 `curlimages/curl:8.11.1` 에 `/bin/tar` 가 있는 것을 직접 확인했으므로, 독자가 읽기 쉬운 `kubectl cp` 를 기본 절차로 쓴다.
**문제가 생기면** — 줄 수가 0 이면 로컬 파일이 비었거나 경로가 틀린 것이므로 `wc -l /tmp/a3-login-loop.sh` 를 로컬에서 먼저 친다.
**문제가 생기면** — 줄 수가 0 이면 로컬 파일이 비었거나 경로가 틀린 것이므로 `wc -l /tmp/a3-login-loop.sh` 를 로컬에서 먼저 친다. 2026-09-22 현재 lab host에는 `nano`가 있고 `vim`은 없어서, 편집기 예시는 실제 설치된 `nano`로 맞췄다.
### 2. 터미널 하나를 루프에 통째로 쓴다
@@ -431,7 +430,7 @@ kubectl -n keycloak-lab exec deploy/postgres -- kill -9 <PID>
이 두 줄 형태는 이 실험대에서 치지 않았다(unknown). **실제로 친 것은 이름으로 고르는 쪽이다** — 백엔드가 여럿이면 이쪽이 한 번에 전부 끊는다.
```bash label="[터미널 ②] 이 실험대가 실제로 친 형태 (observed)"
kubectl exec deploy/postgres -- pkill -9 -f 'postgres: keycloak'
kubectl -n keycloak-lab exec deploy/postgres -- pkill -9 -f 'postgres: keycloak'
```
이 실험대는 한 줄에 원격 셸과 명령 치환을 겹쳐서 쳤다(observed).
@@ -475,11 +474,13 @@ kubectl -n keycloak-lab exec deploy/postgres -- \
### 1. 시도 ① 의 검증 — 죽인 적이 없다
```bash label="[lab host] 새 파드를 기다리고 기동 로그를 본다"
kubectl -n keycloak-lab rollout status deployment/postgres --timeout=180s
```bash label="[lab host] 새 PostgreSQL 파드가 실제 Ready 가 될 때까지 기다리고 기동 로그를 본다"
kubectl -n keycloak-lab wait --for=condition=Ready pod -l app=postgres --timeout=180s
kubectl -n keycloak-lab logs deploy/postgres | grep -E 'not properly shut down|redo|ready to accept'
```
2026-09-22 재검증에서는 `kubectl rollout status deployment/postgres` 가 새 파드가 아직 `ContainerCreating` 인데도 성공을 반환했다. 강제 삭제 직후에는 Deployment 세대가 바뀐 것이 아니므로 이 명령을 Ready 대기로 쓰지 않는다. 파드 조건을 직접 기다리는 `kubectl wait` 가 이 단계의 의도와 맞다.
실측은 이렇다(observed, `02-design-check.txt`).
```text
@@ -817,10 +818,14 @@ rm -f /tmp/client-sids.txt /tmp/db-sids.txt /tmp/a.txt /tmp/b.txt /tmp/a3-login-
## 무엇이 관측이고 무엇이 아닌가
2026-09-22 현재 lab에서도 세 주입을 다시 확인했다. `--grace-period=0 --force` 뒤 새 PostgreSQL에는 crash-recovery marker가 없었고, 컨테이너 안의 `kill -9 1` 뒤에도 같은 Pod/UID, restart `0`, Ready 상태가 유지됐다. 반면 Keycloak backend PID 하나를 SIGKILL하자 PostgreSQL이 다른 backend를 종료하고 redo/crash recovery를 수행했다. 이번 회차에서도 ACK 받은 세션 `504`개 중 DB에는 `500`개만 남아 `4`개가 유실됐다.
이 절차의 숫자는 `2026-09-04 11:58–12:05 KST` 에 돈 한 번의 실행에서 나왔다(observed).
- (observed) `offline_user_session` 의 시각 컬럼이 `integer`, 로그인 트랜잭션에도 붙은 `SET LOCAL synchronous_commit TO OFF`, WAL 설정 네 줄(`wal_writer_delay 200 ms default` 포함), 시도 ①·②·③ 의 시각 `12:00:26.511`·`12:03:21.441`·`12:04:22.063`, crash recovery 로그 여섯 줄, `153 / 149 / 4`, 유실 sid 네 개, 초당 14건, `DELETE 375`, 비밀번호 길이 `19`.
- (unknown) `LC_ALL=C sort` 와 `comm -23` 세 줄, 루프를 앞으로 두고 돌리는 형태(원래 실행은 호스트에서 배경 `exec` 로 했다), `kubectl exec ... kill -9 40` 으로 PID 를 옮겨 적는 형태, 노드에서 호스트 PID 를 죽이는 (b) 갈래, `curlimages/curl:8.11.1` 에 `tar` 가 있는지.
- (observed, 2026-09-22) 재검증에서는 backend PID 하나를 골라 `kubectl ... exec deploy/postgres -- kill -9 <PID>` 형태로 SIGKILL 했고 실제 crash recovery가 돌았다. 성공 응답 SID `504`, 복구 후 DB SID `500`, `LC_ALL=C sort` + `comm -23` 으로 유실 `4`건을 다시 확인했다. 증거는 `final/evidence/raw/2026-09-22-test-server-revalidation/a3-05-load-console.txt`, `a3-06-backend-kill.txt`, `a3-07-client-sids.sorted.txt`, `a3-08-db-sids.sorted.txt`, `a3-09-lost-sids.txt`다.
- (observed, 2026-09-22) 로그인 루프를 foreground `kubectl exec` 세션으로 유지하는 방식이 실제로 동작했고, `curlimages/curl:8.11.1` 에 `/bin/tar` 가 있어 `kubectl cp` 를 사용할 수 있다.
- (unknown) 게스트 노드에서 컨테이너의 host PID 를 찾아 직접 죽이는 (b) 갈래는 이번 재검증에서도 실행하지 않았다.
- 이 실험이 두 번 틀렸다가 고친 것 — 「`--force` 로 죽였다」와 「`kill -9 1` 로 죽였다」가 둘 다 유실 0건이라는 깨끗한 결과를 냈다. 주입 성공 신호를 미리 정해 두지 않았다면 결론은 「Keycloak 은 DB 크래시에도 데이터를 잃지 않는다」가 됐을 것이다.
- 추정이었다가 나중에 잰 값 — `wal_writer_delay` 200ms. 원래 문서는 결과를 먼저 쓰고 그 값과 맞는다고 주장했는데 그때는 조회한 적이 없었고, 로그인 속도도 초당 19건으로 잘못 적었다가 14건으로 정정했다.
@@ -73,10 +73,10 @@ k3s 의 `kubectl` 은 `~/.kube/config` 가 없으면 `/etc/rancher/k3s/k3s.yaml`
| 네임스페이스 | `keycloak-lab` · 관측 스택은 `observability` |
| 대상 | StatefulSet `keycloak` 파드 둘 · Deployment `postgres` 하나 |
| 탐침 파드 | `kc-probe` — `curlimages/curl:8.11.1`, `--rm -it`, `--restart=Never` |
| 주 계기 | `vendor_statistics_approximate_entries_unique` 와 PostgreSQL 문장 로그 |
| 스크레이프 간격 | 15초. 지표를 다시 묻기 전에 30초 기다린다 |
| 주 계기 | 각 파드의 `/metrics`에서 읽는 `vendor_statistics_approximate_entries_unique`와 PostgreSQL 문장 로그 |
| 지표 읽기 | 현재값은 `kubectl get --raw`로 직접 읽는다. Prometheus의 15초 scrape를 기다리지 않는다 |
| 걸리는 시간 | 전 구간 약 40분 |
| 도구 | `jq` 가 이 실험대에 없다. Prometheus 출력은 `tr` 과 `grep` 으로 자른다 |
| 도구 | `jq` 없이도 된다. text metrics는 `grep`으로 필요한 캐시만 고른다 |
## 이 실험이 가르는 것
@@ -637,7 +637,7 @@ kubectl -n keycloak-lab exec deploy/postgres -- psql -U keycloak -d keycloak \
-c "select pg_reload_conf()"
```
`pg_reload_conf` 가 `t` 를 돌려준다. `%h` 가 클라이언트 주소를 로그 줄 앞에 남기는데, 이것이 없으면 어느 파드가 보낸 질의인지 구별할 수 없어 이 시험의 판정이 성립하지 않는다.
`pg_reload_conf` 가 `t` 를 돌려준다. `%h` 가 클라이언트 주소를 로그 줄 앞에 남기는데, 이것이 없으면 어느 파드가 보낸 질의인지 구별할 수 없어 이 시험의 판정이 성립하지 않는다. `ALTER SYSTEM`은 한 `-c "...; ..."` 문자열에 합치지 않는다. 2026-09-22 재검증에서 그렇게 합쳤더니 `ALTER SYSTEM cannot run inside a transaction block`으로 실패했다. 위처럼 `-c`를 명령마다 나누면 각 문장이 독립적으로 실행된다.
```bash label="[lab host] ② 두 설정이 실제로 적용됐는지 읽는다"
kubectl -n keycloak-lab exec deploy/postgres -- psql -U keycloak -d keycloak \
@@ -670,14 +670,18 @@ curl -s -o /dev/null -w '%{http_code}\n' -X POST "http://$K1:8080$TOK" \
-d grant_type=refresh_token -d client_id=admin-cli -d "refresh_token=$RT"
```
2026-09-22 재검증에서는 요청 자체는 성공했지만, **예전 문서와 SQL 경로가 달랐다.**
2026-09-22에는 중간 재검증 한 번에서 `keycloak-1`의 세션 SQL이 보이지 않았다. 하지만 그 구간은 다른 작업과 겹쳐 파드 IP가 바뀌었고, 캐시 출발값도 고정하지 못한 상태였다. 이 결과는 판정에서 제외했다.
캐시와 DB 세션을 0으로 만들고 두 Keycloak 파드를 다시 띄운 뒤 같은 절차를 짧은 구간으로 다시 묶어 측정했다. 출발값은 양쪽 `sessions=0`, `hits=0`, `misses=0`, `stores=0`이었다. 그 상태에서 `keycloak-0`에 로그인하고 `keycloak-1`에서 같은 refresh token을 사용했다.
```text
SID=0jdhDrcu6VUaGIFCjWzNXDs2
refresh_on_keycloak_1=200
keycloak-0 = 10.42.1.32
keycloak-1 = 10.42.0.29
SID=iRziuATDE0qiNEG1yU7K7XT4
REFRESH_ON_K1=200
```
먼저 현재 파드 IP를 다시 잡는다.
먼저 현재 파드 IP를 다시 잡는다. 로그의 `%h`와 맞춰 어느 파드가 SQL을 보냈는지 구분하기 위해서다.
```bash label="[lab host] PostgreSQL 로그를 파드 IP와 sid로 나눠 볼 준비"
K0=$(kubectl -n keycloak-lab get pod keycloak-0 -o jsonpath='{.status.podIP}')
@@ -685,60 +689,54 @@ K1=$(kubectl -n keycloak-lab get pod keycloak-1 -o jsonpath='{.status.podIP}')
echo "$K0 $K1"
```
그다음 refresh를 받은 `keycloak-1`의 세션 SQL을 찾는다.
refresh를 받은 `keycloak-1`이 세션 테이블을 실제로 읽고 썼는지 찾는다.
```bash label="[lab host] 반대편 노드의 세션 테이블 SQL만 찾는다"
```bash label="[lab host] 반대편 노드의 세션 SQL만 찾는다"
kubectl -n keycloak-lab logs deploy/postgres --since=2m \
| grep "$K1" \
| grep -E 'OFFLINE_USER_SESSION|OFFLINE_CLIENT_SESSION'
| grep -E 'OFFLINE_USER_SESSION|OFFLINE_CLIENT_SESSION|synchronous_commit'
```
2026-09-22 재검증에서는 **출력이 없었다.** 같은 시간대 `keycloak-1` 주소에는 `JGROUPS_PING`의 `DELETE/INSERT/SELECT`만 있었고, 방금 만든 sid가 들어간 `OFFLINE_*_SESSION` 질의는 없었다.
격리 재검증에서는 다음 흐름이 그대로 나왔다.
sid 자체로 한 번 더 확인한다.
```text
keycloak-1 refresh
SELECT OFFLINE_USER_SESSION
SELECT ... VERSION ... FOR NO KEY UPDATE ... SKIP LOCKED
SELECT OFFLINE_CLIENT_SESSION
SELECT ... VERSION ... FOR NO KEY UPDATE ... SKIP LOCKED
UPDATE OFFLINE_CLIENT_SESSION
UPDATE OFFLINE_USER_SESSION
SET LOCAL synchronous_commit TO OFF
```
같은 sid로 한 번 더 확인한다.
```bash label="[lab host] 이번 로그인 sid가 어느 DB 연결에서 보였는지 찾는다"
kubectl -n keycloak-lab logs deploy/postgres --since=2m \
| grep '{{SID}}'
```
현재 실측에서는 sid 관련 SQL이 모두 `keycloak-0` 주소에서 나왔다. 로그인 시 `OFFLINE_USER_SESSION`·`OFFLINE_CLIENT_SESSION`을 조회하고 새 행을 넣었으며, 마지막에는 `SET LOCAL synchronous_commit TO OFF` 뒤 `COMMIT`했다. 반면 `keycloak-1` refresh는 `200`인데 그 sid의 DB SQL은 만들지 않았다.
로그인 시에는 `keycloak-0` 주소가 같은 sid를 만들었고, 약 0.7초 뒤 `keycloak-1` 주소가 그 sid를 `SELECT`하고 `UPDATE`했다. 따라서 이 실험대에서 교차 노드 refresh는 **반대편 노드가 persistent user session을 PostgreSQL에서 다시 읽고 갱신하는 경로**로 확인됐다.
캐시 지표도 함께 보면 해석이 더 분명하다.
```text
keycloak-0 login
SELECT OFFLINE_USER_SESSION
SELECT OFFLINE_CLIENT_SESSION
INSERT OFFLINE_USER_SESSION
INSERT OFFLINE_CLIENT_SESSION
SET LOCAL synchronous_commit TO OFF
COMMIT
keycloak-1 refresh
HTTP 200
sid 관련 OFFLINE_*_SESSION SQL 없음
entries hits misses stores
시작 K0 0 0 0 0
시작 K1 0 0 0 0
refresh 뒤 K0 1 0 1 1
refresh 뒤 K1 0 1 0 1
```
따라서 현재 환경에서 확인된 경로는 다음처럼 읽는 것이 맞다.
`keycloak-1`의 `hits`와 `stores` 계수기는 움직였지만 `approximate_entries_unique`는 계속 `0`이었다. 따라서 `hits`나 `stores` 하나만 보고 “그 세션이 K1 로컬 캐시에 상주한다”고 읽으면 안 된다. **세션 거처는 엔트리 수로 보고, 실제 read/write 경로는 SQL 로그로 확인한다.**
```text
keycloak-1 이 요청을 받음
↓
자기 로컬 sessions 엔트리는 없음
↓
Infinispan/JGroups 분산 캐시를 통해 owner 엔트리를 사용 가능
↓
이번 refresh에서는 PostgreSQL 세션 행을 직접 읽지 않음
```
현재 재검증 결과는 2026-09-04의 기존 관측과 같은 방향이다. 반대편 노드는 세션을 DB에서 읽고 갱신하며, 그 세션을 자기 `sessions` 엔트리로 계속 보유하지 않았다. 최신 격리 재검증 전체 로그는 `final/evidence/raw/2026-09-22-test-server-revalidation/a0-18-isolated-sql-path.txt`에 있다.
중요한 점은 **"로컬 캐시에 없다"와 "DB에서 읽는다" 사이에 등호를 놓으면 안 된다는 것**이다. PostgreSQL은 persistent user session의 저장소지만, 살아 있는 2노드 클러스터에서 모든 교차 노드 요청이 DB를 다시 읽는 것은 아니다. DB fallback이나 재적재 경로는 캐시 miss, 노드 상실, 재시작 같은 조건을 따로 주입해 확인해야 한다.
- `final/evidence/raw/2026-09-22-test-server-revalidation/a0-17-isolated-0d-reset.txt`
- `final/evidence/raw/2026-09-22-test-server-revalidation/a0-18-isolated-0d-measurement.txt`
2026-09-04의 옛 실험 기록에는 반대편 노드가 `OFFLINE_*_SESSION`을 SELECT/UPDATE한 흔적이 있었다. 그 값은 당시 관측으로 남기되 **현재 Keycloak 26.7.0 실험대의 불변 동작으로 일반화하지 않는다.** 이번 재검증 증거는 다음 파일에 있다.
- `final/evidence/raw/2026-09-22-test-server-revalidation/a0-11-sql-refresh-request.txt`
- `final/evidence/raw/2026-09-22-test-server-revalidation/a0-12-sql-read-write-path.txt`
- `final/evidence/raw/2026-09-22-test-server-revalidation/a0-14-sql-pid-drilldown.txt`
전역 `synchronous_commit`은 여전히 `on`이었고, `keycloak-0`이 로그인 세션을 저장하는 트랜잭션에서만 `SET LOCAL synchronous_commit TO OFF`가 관측됐다. `SET LOCAL`은 해당 트랜잭션이 끝나면 되돌아간다. A-3에서 DB crash 직전 쓰기 손실을 볼 때는 **실제로 어떤 요청이 이 구문을 실행했는지 SQL 로그로 같이 묶어** 해석한다.
전역 `synchronous_commit`은 `on`이었고, 세션 쓰기 트랜잭션 안에서만 `SET LOCAL synchronous_commit TO OFF`가 관측됐다. `SET LOCAL`은 해당 트랜잭션이 끝나면 되돌아간다. A-3에서 DB crash 직전 쓰기 손실을 볼 때는 실제 요청과 이 구문을 같은 SQL 로그로 묶어 해석한다.
여기까지가 탐침 파드에서 칠 것의 마지막이다. 파드 셸을 붙잡고 있던 터미널에서 나온다. 나가지 않으면 `--rm` 이 파드를 안 지우고 원상복구 확인표의 `kc-probe` 줄이 `NotFound` 가 아니게 된다.
@@ -846,7 +844,7 @@ kubectl -n keycloak-lab delete pod kc-probe --ignore-not-found
- (observed, 2026-09-22) 양쪽 `vendor_cluster_size=2.0`, 교차 노드 refresh `200`, 같은 sid 유지, 반대편 logout `204`, 그 뒤 원래 노드 refresh `400 invalid_grant`.
- (observed, 2026-09-22) 로컬 cache ownership은 `2/0 → 2/5 → 7/5`, DB online row는 `2 → 7 → 12`였다.
- (changed, 2026-09-22) 반대편 refresh가 성공했지만 그 파드 주소에서 해당 sid의 `OFFLINE_USER_SESSION`/`OFFLINE_CLIENT_SESSION` SQL은 나오지 않았다. 옛 기록의 "반대편은 매번 DB를 읽는다"는 설명은 현재 동작으로 일반화하지 않는다.
- (observed, 2026-09-22) 캐시와 DB를 0으로 만든 격리 재검증에서 반대편 refresh는 `200`이었고, 같은 sid가 PostgreSQL 로그에서 `keycloak-0` 6줄과 `keycloak-1` 6줄로 확인됐다. 따라서 이 실험대에서는 반대편 노드가 persistent session을 PostgreSQL에서 다시 읽고 갱신한다. 증거는 `a0-18-isolated-sql-path.txt`다.
- (observed, 2026-09-22) 로그인한 owner 쪽에서는 `OFFLINE_*_SESSION` SELECT/INSERT와 `SET LOCAL synchronous_commit TO OFF`가 확인됐다.
- (observed, 2026-09-22) 정리 후 DB 세션 0, 두 파드 캐시 0, cluster size 2, `log_statement=none`, 외부 realm HTTP 200으로 돌아왔다. 증거는 `a0-15-cleanup.txt`다.
@@ -65,7 +65,7 @@ NetworkPolicy 로 8080 과 9000 만 열어 JGroups 트랜스포트인 TCP 7800
## 이 실험이 가르는 것
A-0 재검증에서는 `owners=1`인 분산 캐시와 PostgreSQL persistent session store가 함께 동작했다. 정상 2노드 상태의 교차 refresh는 반대편 노드에서 세션 SQL 없이도 성공했으므로, "로컬 캐시에 없으면 DB에서 읽는다"는 단순 모델은 버렸다. A-1은 7800을 끊었을 때 **원격 owner 접근과 캐시 무효화가 어떻게 달라지는지**를 직접 본다.
A-0의 2026-09-22 격리 재검증에서는 `owners=1`인 분산 캐시와 PostgreSQL persistent session store가 함께 동작했다. `keycloak-0`에서 만든 세션을 `keycloak-1`에서 refresh하자 `keycloak-1`이 `OFFLINE_USER_SESSION`과 `OFFLINE_CLIENT_SESSION`을 직접 `SELECT`·`UPDATE`했고, 그 뒤에도 `keycloak-1`의 `sessions` 고유 엔트리는 `0`이었다. 따라서 A-1에서 7800을 끊고 보는 핵심은 "원격 owner에서 세션을 읽을 수 있나"가 아니라 **DB 기반 세션 처리는 계속되더라도 JGroups가 맡던 클러스터 상태·무효화 신호가 끊기면 무엇이 달라지는가**다.
끊을 때 두 가지를 갈라야 한다.
@@ -83,6 +83,7 @@ A-0 재검증에서는 `owners=1`인 분산 캐시와 PostgreSQL persistent sess
- `05-keycloak` · `06-observability` 가 끝나 있다.
- 두 Keycloak 파드가 서로 다른 노드에 있어야 한다. 단일 노드에서는 이 고장을 만들 수 없다.
- `kc-lab-2` 에 `ssh` 로 붙을 수 있어야 한다. **conntrack 은 두 노드 모두에서** 봐야 한다.
- 이 실험을 하는 동안 다른 세션이나 자동화가 같은 `keycloak-lab`의 NetworkPolicy·Keycloak 파드를 건드리지 않아야 한다. 2026-09-22 재검증에서 다른 작업이 `a1-block-jgroups-transport`를 중간에 지워 분단이 약 90초 뒤 저절로 풀린 것처럼 보였다. 관찰 중에는 `kubectl -n keycloak-lab get networkpolicy a1-block-jgroups-transport`가 계속 존재하는지도 전제 조건으로 본다.
**이건 상태를 부수는 실험이다.** Keycloak 클러스터를 실제로 분단시키고 파드를 재시작한다. **실험대에서만 한다.** 중간에 그만두려면 아래 한 줄이면 된다.
@@ -488,6 +489,8 @@ exit
폴더 README 는 게스트 셸이 필요한 것을 `nft`·`tc`·`systemctl` 처럼 노드 자체를 건드리는 명령뿐이라고 적는데, `conntrack` 이 그 경우다.
이 절을 하나의 `bash -s` 스크립트로 자동화한다면 내부 `ssh kc-lab-1 ...` / `ssh kc-lab-2 ...`에는 `-n`을 붙인다. 바깥 스크립트 자체를 stdin으로 실행하는 중 nested `ssh`가 같은 stdin을 읽으면 남은 스크립트를 소비해 명령이 오류 없이 중간에서 끝날 수 있다. 2026-09-22 재검증에서 실제로 이 현상을 확인했고 `ssh -n`으로 다시 실행했다. 사람이 문서대로 셸을 하나씩 이동하며 칠 때는 이 문제가 없다.
실측은 이렇다(observed, `05-conntrack-problem.txt`).
```text
@@ -501,49 +504,43 @@ exit
`2>/dev/null` 은 `conntrack` 이 stderr 로 찍는 「N flow entries have been shown」 요약을 지우려는 것이고, **처음에는 반드시 빼고 친다** — 위에서 본 `command not found` 가 거기로 나가기 때문이다. 상태 열을 읽는다 — `ESTABLISHED` 는 양방향 통신이 성립해 규칙 평가를 건너뛰고, `[ASSURED]` 는 표가 꽉 차도 안 지워지는 오래된 연결이며, `SYN_SENT [UNREPLIED]` 가 정책이 동작하고 있다는 것을 보여 준다. `dport=57800` 도 ESTABLISHED 로 살아 있다. NetworkPolicy 는 이미 붙어 있는 연결을 떼어내지 못하므로, 보안 사고 대응으로 「지금 당장 이 통신을 끊어라」에 NetworkPolicy 를 걸면 새 연결만 막히고 진행 중인 연결은 계속된다. 같은 7800 을 한 방향만 끊는 A-5 가 NetworkPolicy 대신 `iptables` 의 raw PREROUTING 으로 간 까닭도 여기서 나왔다 — 그 체인은 conntrack 조회보다 먼저 평가된다.
### 5. conntrack 항목을 튜플 그대로 지운다
### 5. conntrack 항목을 JGroups 포트로 지운다
**목적** — 규칙 평가를 건너뛰게 만들던 기존 연결 기록을 표에서 없앤다.
**목적** — NetworkPolicy 적용 전에 만들어져 있던 7800·57800 연결의 conntrack 상태를 없애 다음 패킷이 정책을 만나게 한다.
네 값은 바로 위 4단계의 `conntrack -L` 출력에서 읽는다. 한 줄에 `src=` `dst=` `sport=` `dport=` 가 두 벌 나오는데 **앞의 한 벌이 원 방향, 뒤의 한 벌이 응답 방향**이고 두 벌을 각각 한 번씩 지운다. 포트는 ephemeral 이라 재시작할 때마다 바뀐다.
처음 문서에서는 `conntrack -L`의 `src`·`dst`·`sport`·`dport`를 손으로 옮겨 적어 튜플 하나씩 지우게 했다. 재현은 되지만 ephemeral port가 매번 달라 독자가 복사해야 할 값이 많고 오타도 나기 쉽다. 2026-09-22 현재 전용 lab에서는 **목적 포트만 지정해도 해당 conntrack entry 전체가 삭제되는 것**을 확인했다.
```bash label="[kc-lab-1] -L 출력의 네 값을 그대로 옮겨 한 항목씩 지운다"
sudo conntrack -D -p tcp -s <src> -d <dst> --sport <sp> --dport <dp>
`kc-lab-1`에서 두 포트를 지운다.
```bash label="[kc-lab-1] JGroups transport와 FD_SOCK2 conntrack을 지운다"
sudo conntrack -D -p tcp --dport 7800
sudo conntrack -D -p tcp --dport 57800
```
이 실험대에서는 7800 두 방향과 57800 한 방향, 이렇게 세 번 쳤다(observed). 그대로 옮겨 치면 자기 실험대에는 없는 튜플이라 0건이 나온다.
같은 두 줄을 `kc-lab-2`에서도 친다.
```text
sudo conntrack -D -p tcp -s 10.42.0.35 -d 10.42.1.43 --sport 40023 --dport 7800
sudo conntrack -D -p tcp -s 10.42.1.43 -d 10.42.0.35 --sport 7800 --dport 40023
sudo conntrack -D -p tcp -s 10.42.0.35 -d 10.42.1.43 --sport 50477 --dport 57800
```bash label="[kc-lab-2] 반대편 노드에서도 같은 두 포트를 지운다"
sudo conntrack -D -p tcp --dport 7800
sudo conntrack -D -p tcp --dport 57800
```
`kc-lab-2` 에서도 같은 일을 한다. 서버 쪽 노드에는 튜플이 뒤집혀 기록되어 있으므로, 그쪽에 붙어 그쪽 `-L` 출력을 보고 옮긴다.
**어디를 보나** — `N flow entries have been deleted`에서 `N`이 1 이상인지 본다. 2026-09-22 재검증에서는 `kc-lab-1`의 7800에서 2건(기존 JGroups 연결과 직전 포트 탐침), 57800에서 1건이 지워졌고 `kc-lab-2`에서는 각각 1건씩 지워졌다. 그 뒤 두 노드의 7800·57800 conntrack 목록은 비었다.
```bash label="[lab host] ① 반대편 노드에 붙는다"
ssh kc-lab-2
```bash label="[각 게스트] 남은 JGroups conntrack이 없는지 확인한다"
sudo conntrack -L 2>/dev/null | grep -E 'dport=(7800|57800)|sport=(7800|57800)'
```
```bash label="[kc-lab-2] ② 이 노드의 표를 다시 보고 네 값을 읽는다"
sudo conntrack -L 2>/dev/null | grep 7800
```
출력이 없으면 현재 표에는 해당 흐름이 없다는 뜻이다. 새 `SYN_SENT [UNREPLIED]`가 다시 생길 수 있는데, 그것은 정책 아래에서 재연결을 시도했지만 응답받지 못했다는 증거다.
```bash label="[kc-lab-2] ③ 읽은 값으로 지운다"
sudo conntrack -D -p tcp -s <src> -d <dst> --sport <sp> --dport <dp>
```
**왜 `--sport`까지 두 번 지우지 않는가** — conntrack 한 항목에는 원 방향과 응답 방향이 함께 들어 있다. `--dport 7800`으로 원 방향 항목을 지우면 같은 entry의 응답 방향도 같이 사라진다. 2026-09-22에는 이어서 `--sport 7800`을 쳤을 때 `0 flow entries have been deleted`가 나왔다.
```bash label="[kc-lab-2] ④ 나온다"
exit
```
:::warning
**예상 결과** — 삭제 건수가 나온다.
이 축약형은 **JGroups 전용 포트 7800·57800을 다른 워크로드가 쓰지 않는 전용 lab**을 전제로 한다. 공유 노드에서 특정 연결 하나만 지워야 한다면 `conntrack -L`에서 네 값을 읽어 `-s <src> -d <dst> --sport <sp> --dport <dp>`로 좁혀 지우는 편이 안전하다.
**왜 필요한가** — 위 소켓 출력이 보여 준 대로 ESTABLISHED 인 연결은 규칙 평가 앞에서 통과한다. 그 기록을 지워야 다음 패킷이 정책을 만난다.
:::
**문제가 생기면** — `0 flow entries have been deleted` 면 튜플이 틀린 것이고, `--dport 7800` 만 주면 0건이 나온다. 원래 실행에서 실제로 그렇게 나왔다.
여기에 정직하게 적어 둘 것이 있다(observed). 원래 실행에서 conntrack 을 지운 뒤에도 `vendor_cluster_size` 는 계속 2 였다. 해설 문서는 처음에 「conntrack 삭제 → 3분 뒤 분단」이라고 썼다가 증거를 다시 보고 정정했고, 실제 하락은 파드가 재시작된 4초 뒤에 일어났다. 이 단계만으로 분단이 만들어지는지는 이 실험이 판정하지 못했다.
삭제 직후에도 `vendor_cluster_size`가 바로 1로 바뀐다고 가정하지 않는다. 2026-09-22 재검증에서도 두 conntrack 표를 비운 직후에는 두 파드가 모두 `2.0`이었다. 이 단계는 **기존 연결 우회 가능성을 제거했다**는 것까지만 확인하고, 분단 자체는 다음 단계에서 새 파드를 띄워 확정한다.
### 6. 정책이 걸린 채로 파드를 지워 분단을 확정한다
@@ -576,9 +573,13 @@ keycloak-0 false 10.42.1.67 2026-09-04T02:44:23Z
## 관찰
```bash label="[lab host] 두 노드가 아는 멤버 수"
kubectl -n observability exec deploy/prometheus -- \
wget -qO- 'localhost:9090/api/v1/query?query=vendor_cluster_size'
```bash label="[lab host] 두 노드가 아는 현재 멤버 수"
for POD in keycloak-0 keycloak-1; do
printf '%s ' "$POD"
kubectl -n keycloak-lab get --raw \
"/api/v1/namespaces/keycloak-lab/pods/$POD:9000/proxy/metrics" \
| grep '^vendor_cluster_size'
done
```
실측은 이렇다(observed).
@@ -779,7 +780,7 @@ exit
[4] keycloak-0 에서 재갱신 시도 HTTP 200 ← 400 이어야 했다
```
[2]에서 반대편 refresh `200`은 **분단 상태에서도 PostgreSQL에 남은 persistent session을 이용해 세션을 재적재할 수 있음**을 보여 준다. A-0 정상 클러스터에서는 같은 교차 refresh가 DB 세션 SQL 없이 성공했으므로, "세션은 항상 DB로 읽힌다"고 일반화하지 않는다. [4]에서는 로그아웃 무효화가 분단을 건너지 못해 대조군 `400 invalid_grant`와 달리 `200`이 나왔다.
[2]의 반대편 refresh `200`은 **JGroups가 끊겨도 shared PostgreSQL persistent session store를 이용한 refresh 자체는 계속될 수 있음**을 보여 준다. A-0의 2026-09-22 격리 재검증에서도 정상 클러스터의 교차 refresh가 `OFFLINE_USER_SESSION`·`OFFLINE_CLIENT_SESSION`을 `SELECT`·`UPDATE`했다. A-1에서 달라진 것은 DB read/write 가능 여부가 아니라 **로그아웃 뒤 다른 노드의 로컬 캐시를 지우는 무효화 신호가 7800 분단을 건너지 못했다는 점**이다. 그래서 [4]가 대조군 `400 invalid_grant`와 달리 `200`이 된다.
[4] 의 200 이 로그아웃이 아예 안 됐다는 뜻인지 확인한다. sid 는 [1] 에서 JWT payload 를 풀어 화면에 찍고 적어 둔 그 값이다. 로그인할 때마다 새로 생기므로 자기 실행의 값을 넣는다.
@@ -821,7 +822,7 @@ done
keycloak-0 은 자기 캐시로 200 을 준다 ◀────────────┘
```
캐시의 stale 엔트리는 매 요청마다 DB와 대조되지 않았다. 이번 분단에서는 K1이 persistent session을 이용해 refresh를 처리하고 DB 행을 삭제했지만, K0의 기존 cache entry 무효화는 7800 분단을 건너지 못했다. 따라서 **정상 클러스터의 원격 owner 경로와 분단 뒤 DB 재적재/fallback 경로를 같은 것으로 설명하지 않는다.** 실제 사용자도 로그아웃이 안 되는지는 따로 답이 있다 — 아니다. 파드 주소로 직접 쳤기 때문이고, 실제 사용자는 nginx → Traefik → Service 를 거치는데 NotReady 인 `keycloak-0` 은 거기서 빠져 있다.
캐시의 stale 엔트리는 매 요청마다 DB와 대조되지 않았다. A-0 정상 상태와 A-1 분단 상태 모두 교차 refresh에서 persistent session store의 read/write가 관측됐지만, **A-1에서만 JGroups 무효화가 끊겨 DB 행 삭제 뒤에도 K0의 기존 cache entry가 남았다.** 실제 사용자도 로그아웃이 안 되는지는 따로 답이 있다 — 아니다. 이 시험은 파드 주소로 직접 쳤고, 실제 사용자 경로인 edge nginx → Traefik → Service 에서는 NotReady 인 `keycloak-0` 이 EndpointSlice에서 제외된다. 2026-09-22 재검증 원본은 `final/evidence/raw/2026-09-22-test-server-revalidation/a1-08-split-behavior.txt`와 `a1-09-service-impact.txt`에 남겼다.
## 복구와 원상복구 확인표
@@ -856,24 +857,30 @@ networkpolicy.networking.k8s.io "a1-block-jgroups-transport" deleted from keyclo
+90초 keycloak-0=2 keycloak-1=2 ← 재형성
```
**왜 필요한가** — 재형성은 즉시가 아니다. 2026-09-04에는 약 90초가 걸렸지만, 2026-09-22에는 정책 해제 후 약 30초에 cluster size `2/2`와 coordinator 1개가 먼저 회복됐고, `keycloak-0` readiness는 그 뒤 약 15초 더 지나 `true`로 돌아왔다. **cluster merge와 Service endpoint 복귀를 같은 시각으로 가정하지 않는다.**
**왜 필요한가** — 재형성은 즉시가 아니다. 2026-09-04에는 약 90초가 걸렸다. 2026-09-22 재검증에서도 정책 해제 직후에는 `1/1 + coordinator 2개`가 유지됐고, 약 38초 뒤 cluster size `2/2`와 coordinator 1개가 먼저 회복됐다. `keycloak-0` readiness는 그 뒤 약 15초 더 지나 `true`가 됐다. **cluster merge와 Service endpoint 복귀를 같은 시각으로 가정하지 않는다.**
**문제가 생기면** — 2~3분이 지나도 1 이면 MERGE3 주기 밖이거나 정책이 안 지워진 것이므로 `get networkpolicy` 부터 본다.
2026-09-22 원자 재검증에서는 정책 존재를 매 poll마다 확인하며 진행했다. 9번째 5초 poll에서 `cluster_size=1/1`, coordinator 2개로 분단을 확정했고, 정책 제거 뒤 13번째 5초 poll에서 `cluster_size=2/2`, coordinator 1개, 양쪽 Ready로 복구됐다. 전체 증거는 `final/evidence/raw/2026-09-22-test-server-revalidation/a1-07-atomic-revalidation-v2.txt`다.
### 2. 누가 붙였는지 카운터로 확인한다
**목적** — 재형성이 저절로 일어난 것인지 확인한다.
```bash label="[lab host] 병합 이벤트 계수기를 다시 읽는다"
kubectl -n observability exec deploy/prometheus -- \
wget -qO- 'localhost:9090/api/v1/query?query=vendor_jgroups_merge3_get_num_merge_events'
```bash label="[lab host] 각 파드에서 병합 이벤트 계수기를 직접 읽는다"
for POD in keycloak-0 keycloak-1; do
echo "[$POD]"
kubectl -n keycloak-lab get --raw \
"/api/v1/namespaces/keycloak-lab/pods/$POD:9000/proxy/metrics" \
| grep '^vendor_jgroups_merge3_get_num_merge_events'
done
```
**예상 결과** — 실측은 `merge_events keycloak-0 = 1`, `merge_events keycloak-1 = 1` 이다(observed). 주입 전에 `0.0` 이던 값이 1 이다.
**예상 결과** — 두 값이 반드시 같이 오를 필요는 없다. 2026-09-22 이번 재검증에서는 정책 해제 전 `0/0`이었고, 복구 뒤 `keycloak-0=0`, `keycloak-1=1`이었다. K1에서 merge event가 발생했고 동시에 cluster size가 `2/2`, `JGROUPS_PING` coordinator가 하나로 돌아왔다.
**왜 필요한가** — MERGE3 는 split brain 을 감지해 갈라진 뷰를 병합하는 JGroups 프로토콜이고, `0 → 1` 로 오른 카운터가 그 프로토콜이 실제로 일했다고 말한다.
**왜 필요한가** — MERGE3 는 split brain 을 감지해 갈라진 뷰를 병합하는 JGroups 프로토콜이다. 이 카운터는 **어느 노드가 merge event를 처리했는지** 보조 증거로 쓰고, 양쪽 카운터가 같은 값이어야 한다는 조건으로 쓰지 않는다.
**문제가 생기면** — 값이 그대로 0 이면 재형성이 다른 경로로 일어났거나 아직 안 일어난 것이므로 `vendor_cluster_size` 를 다시 본다.
**문제가 생기면** — 두 값이 모두 0이어도 카운터 하나만으로 복구 실패라고 단정하지 않는다. `vendor_cluster_size=2/2`, coordinator 1개, 양쪽 Ready를 먼저 확인하고 로그의 `ISPN000093` merge view까지 본다.
코디네이터도 하나로 돌아온다. 실측은 이렇다(observed).
@@ -893,7 +900,7 @@ kubectl -n observability exec deploy/prometheus -- \
| 디스커버리 | `psql -c "select name, ip, coord from jgroups_ping order by name"` | `coord = t` 가 **하나** |
| 지표 | `vendor_cluster_size` | 양쪽 `2` |
| 임시 파드 | `kubectl -n keycloak-lab get pod kc-probe` | `NotFound` (없어야 정상) |
| 밖 | `curl -s -o /dev/null -w '%{http_code}\n' https://auth.hyeonworks.com/realms/master` | `200` |
| edge 경로 | `curl -skS --resolve auth.hyeonworks.com:443:192.168.122.10 -o /dev/null -w '%{http_code}\n' https://auth.hyeonworks.com/realms/master` | `200` |
conntrack 은 지운 채로 두면 된다. 표는 새 패킷이 오면 다시 채워진다.
@@ -902,7 +909,7 @@ conntrack 은 지운 채로 두면 된다. 표는 새 패킷이 오면 다시
| 증상 | 원인 | 확인 |
|---|---|---|
| 정책을 걸었는데 지표가 안 변한다 | conntrack 의 ESTABLISHED 가 먼저 통과시킨다 | `sudo conntrack -L 2>/dev/null \| grep 7800` |
| `conntrack -D` 가 `0 flow entries` | 튜플이 틀렸다. `--dport` 만으로는 0건 | `-L` 출력의 src/dst/sport/dport 를 **그대로** 옮긴다 |
| `conntrack -D --dport 7800` 이 `0 flow entries` | 이미 지웠거나 해당 흐름이 아직 없다 | 먼저 `conntrack -L`로 7800·57800 흐름이 실제로 있는지 확인한다 |
| conntrack 을 지웠는데도 계속 2 | **이 실험은 그것만으로 분단되는지 판정 못 했다** | 정책이 걸린 채 파드를 재시작한다 |
| 파드가 `0/1`로 빠진다 | 9000 접근 실패 또는 Keycloak readiness DOWN | `describe pod`와 `/health/ready`; **readiness 실패 자체는 컨테이너를 재시작하지 않는다** |
| `kubectl exec keycloak-0 -- curl` 이 `exit 127` | **Keycloak 이미지에 curl 도 wget 도 없다** | 임시 curl 파드를 띄우거나 Prometheus 에 묻는다 |