먼저 제공해주신 URL의 문서 내용을 확인하여 인증/인가 방법들을 파악한 후, 각 방법별로 실습을 설계해보겠습니다. 안녕하세요! 인증/인가 방법들에 대한 실습을 만들어드리겠습니다. 먼저 제공해주신 URL의 문서 내용을 확인하여 어떤 방법들이 소개되어 있는지 파악하고, 각 방법별로 실제 체험할 수 있는 실습을 설계해보겠습니다.

작업 Plan

1단계: URL 내용 추출

• Tavily extract를 사용하여 문서 내용 확인
• 인증/인가 방법들 식별 및 정리

2단계: 인증/인가 방법 분석

• 각 방법의 특징과 사용 사례 파악
• 실습 가능한 항목들 분류

3단계: 실습 설계

• 각 방법별 실제 구현 가능한 실습 시나리오 작성
• 초급/중급/고급 난이도별 구성

4단계: 구현 가이드 작성

• 단계별 실습 진행 방법
• 필요한 도구 및 환경 정리

5단계: 최종 검토

• 실습의 완성도 및 교육적 효과 검증

이 계획으로 진행하면 될까요? 그럼 먼저 URL 내용부터 확인해보겠습니다. 네이버 블로그 문서를 확인했습니다! 쿠버네티스 인증/인가 방법들에 대한 포괄적인 내용이 담겨 있네요. 이제 각 방법별로 실제 체험할 수 있는 실습을 설계해드리겠습니다.

작업 Plan

1단계: 인증 방법별 실습 설계

• X.509 Client Certificates
• Service Account Tokens
• OpenID Connect (OIDC)
• Webhook Token Authentication
• Authenticating Proxy

2단계: 인가 방법별 실습 설계

• RBAC (Role-Based Access Control)
• ABAC (Attribute-Based Access Control)
• Node Authorization
• Webhook Authorization

3단계: 통합 실습 시나리오 구성

• 실무 환경 시뮬레이션
• 보안 테스트 시나리오

사용할 도구:

• Terminal: 쿠버네티스 환경 구성 및 테스트
• 코드 작성: 각 방법별 구현 예제

이 계획으로 진행해도 될까요?

---

쿠버네티스 인증/인가 실습 가이드

🔐 인증(Authentication) 실습

1. X.509 Client Certificates 실습

실습 목표: 클라이언트 인증서를 생성하고 kubectl 설정하기

준비물:

• 쿠버네티스 클러스터 (minikube 또는 kind)
• OpenSSL

실습 단계:

# 1. 개인키 생성
openssl genrsa -out user.key 2048

# 2. 인증서 서명 요청(CSR) 생성
openssl req -new -key user.key -out user.csr -subj "/CN=devuser/O=developers"

# 3. 쿠버네티스 CA로 인증서 서명
sudo openssl x509 -req -in user.csr -CA /etc/kubernetes/pki/ca.crt \
  -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial -out user.crt -days 365

# 4. kubectl 컨텍스트 설정
kubectl config set-credentials devuser \
  --client-certificate=user.crt \
  --client-key=user.key

kubectl config set-context devuser-context \
  --cluster=kubernetes \
  --user=devuser

# 5. 테스트
kubectl --context=devuser-context get pods

확인 포인트:

• 인증서 만료일 확인: openssl x509 -in user.crt -text -noout
• 권한 없음 에러 발생 확인 (아직 RBAC 설정 전)

2. Service Account Tokens 실습

실습 목표: Pod에서 쿠버네티스 API 호출하기

# serviceaccount-demo.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: demo-sa
  namespace: default
---
apiVersion: v1
kind: Pod
metadata:
  name: sa-demo-pod
spec:
  serviceAccountName: demo-sa
  containers:
  - name: demo
    image: curlimages/curl:latest
    command: ['sleep', '3600']

실습 단계:

# 1. ServiceAccount와 Pod 생성
kubectl apply -f serviceaccount-demo.yaml

# 2. Pod 내부에서 API 호출 테스트
kubectl exec -it sa-demo-pod -- sh

# Pod 내부에서 실행
TOKEN=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)
curl -H "Authorization: Bearer $TOKEN" \
  -k https://kubernetes.default.svc/api/v1/namespaces/default/pods

확인 포인트:

• 토큰이 자동으로 마운트되는지 확인
• API 응답에서 권한 부족 에러 확인

3. OpenID Connect (OIDC) 실습

실습 목표: Google OIDC를 이용한 인증 구성

준비 단계:

1. Google Cloud Console에서 OAuth 2.0 클라이언트 ID 생성
2. kube-apiserver에 OIDC 설정 추가

# kube-apiserver 설정에 추가할 플래그들
--oidc-issuer-url=https://accounts.google.com
--oidc-client-id=YOUR_CLIENT_ID.apps.googleusercontent.com
--oidc-username-claim=email
--oidc-groups-claim=groups

kubectl 설정:

# OIDC 사용자 추가
kubectl config set-credentials oidc-user \
  --auth-provider=oidc \
  --auth-provider-arg=idp-issuer-url=https://accounts.google.com \
  --auth-provider-arg=client-id=YOUR_CLIENT_ID \
  --auth-provider-arg=client-secret=YOUR_CLIENT_SECRET

4. Webhook Token Authentication 실습

실습 목표: 커스텀 인증 서버 구현

인증 서버 구현 (Python Flask):

# auth-webhook.py
from flask import Flask, request, jsonify

app = Flask(__name__)

VALID_TOKENS = {
    "secret-token-123": {"username": "alice", "groups": ["developers"]},
    "secret-token-456": {"username": "bob", "groups": ["admins"]}
}

@app.route('/authenticate', methods=['POST'])
def authenticate():
    data = request.json
    token = data.get('spec', {}).get('token')
    
    if token in VALID_TOKENS:
        user_info = VALID_TOKENS[token]
        return jsonify({
            "apiVersion": "authentication.k8s.io/v1beta1",
            "kind": "TokenReview",
            "status": {
                "authenticated": True,
                "user": {
                    "username": user_info["username"],
                    "groups": user_info["groups"]
                }
            }
        })
    else:
        return jsonify({
            "apiVersion": "authentication.k8s.io/v1beta1",
            "kind": "TokenReview",
            "status": {"authenticated": False}
        })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080, ssl_context='adhoc')

kube-apiserver 설정:

# webhook-config.yaml
apiVersion: v1
kind: Config
clusters:
- cluster:
    server: https://your-auth-server:8080/authenticate
  name: webhook
contexts:
- context:
    cluster: webhook
  name: webhook
current-context: webhook

🛡️ 인가(Authorization) 실습

1. RBAC 실습

실습 목표: 세밀한 권한 제어 구현

# rbac-demo.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: default
subjects:
- kind: User
  name: devuser
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

테스트 명령어:

# RBAC 적용
kubectl apply -f rbac-demo.yaml

# 권한 테스트
kubectl --context=devuser-context get pods        # 성공
kubectl --context=devuser-context get secrets     # 실패
kubectl --context=devuser-context delete pod test # 실패

2. ABAC 실습

실습 목표: 조건부 접근 제어 구현

정책 파일 작성:

# abac-policy.json
{"apiVersion": "abac.authorization.kubernetes.io/v1beta1", 
 "kind": "Policy", 
 "spec": {
   "user": "alice", 
   "namespace": "development", 
   "resource": "pods", 
   "apiGroup": "*"
 }}
{"apiVersion": "abac.authorization.kubernetes.io/v1beta1", 
 "kind": "Policy", 
 "spec": {
   "user": "bob", 
   "namespace": "*", 
   "resource": "*", 
   "apiGroup": "*",
   "nonResourcePath": "*"
 }}

3. Webhook Authorization 실습

인가 서버 구현:

# authz-webhook.py
from flask import Flask, request, jsonify
import datetime

app = Flask(__name__)

@app.route('/authorize', methods=['POST'])
def authorize():
    data = request.json
    spec = data.get('spec', {})
    
    user = spec.get('user', {}).get('username')
    resource = spec.get('resourceAttributes', {})
    
    # 시간 기반 접근 제어 예제
    current_hour = datetime.datetime.now().hour
    
    # 업무 시간(9-18시)에만 접근 허용
    if 9 <= current_hour <= 18:
        if user == 'alice' and resource.get('verb') == 'get':
            return jsonify({
                "apiVersion": "authorization.k8s.io/v1beta1",
                "kind": "SubjectAccessReview",
                "status": {"allowed": True, "reason": "업무 시간 내 조회 권한"}
            })
    
    return jsonify({
        "apiVersion": "authorization.k8s.io/v1beta1",
        "kind": "SubjectAccessReview", 
        "status": {"allowed": False, "reason": "접근 거부"}
    })

🧪 통합 실습 시나리오

시나리오 1: 다중 인증 환경 구축

목표: 개발자는 인증서, Pod는 ServiceAccount 사용

# 1. 개발자용 인증서 생성 및 RBAC 설정
# 2. 애플리케이션 Pod용 ServiceAccount 생성
# 3. 각각 다른 권한 부여
# 4. 접근 테스트 및 권한 확인

시나리오 2: 보안 취약점 테스트

목표: 잘못된 설정의 보안 위험 확인

# 1. 과도한 권한 부여 시나리오
kubectl create clusterrolebinding dangerous \
  --clusterrole=cluster-admin --user=testuser

# 2. 권한 남용 테스트
# 3. 최소 권한 원칙 적용
# 4. 개선된 보안 설정 확인

시나리오 3: 실제 운영 환경 시뮬레이션

팀별 권한 분리:

• 개발팀: development 네임스페이스만 접근
• 운영팀: production 네임스페이스 관리
• 보안팀: 모든 네임스페이스 읽기 권한

각 실습을 단계별로 진행하시겠어요? 어떤 실습부터 시작하고 싶으신지 알려주세요!