Enterprise에서의 K8S

가장 기본적인 형태

┌─────────────────────────────────────────────────────────────────┐
│                        Git Workflow                             │
│  Developer → Bitbucket → Jenkins → Build → Test → Deploy        │
└─────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                      CI/CD Pipeline                             │
│  ┌─────────┐  ┌──────────┐  ┌─────────┐  ┌─────────────────┐    │
│  │Jenkins  │→ │SonarQube │→ │ Build   │→ │ArgoCD Deployment│    │
│  │Pipeline │  │Security  │  │& Test   │  │                 │    │
│  └─────────┘  └──────────┘  └─────────┘  └─────────────────┘    │
│                                │                   │            │
│                                ▼                   ▼            │
│                        ┌─────────────┐   ┌─────────────────┐    │
│                        │Allure Report│   │Container Registry│   │
│                        └─────────────┘   └─────────────────┘    │
└─────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Multi-Zone K8s Cluster                       │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐  │
│  │  DEV Zone   │  │  IT Zone    │  │     PROD Zone           │  │
│  │             │  │             │  │                         │  │
│  │ - Dev Apps  │  │ - Jenkins   │  │ - Production Apps       │  │
│  │ - Test DB   │  │ - SonarQube │  │ - Production DB         │  │
│  │ - Staging   │  │ - ArgoCD    │  │ - Monitoring            │  │
│  │             │  │ - Monitoring│  │ - Logging               │  │
│  └─────────────┘  └─────────────┘  └─────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Shared Infrastructure                        │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐  │
│  │ELK Stack HA │  │ Kafka HA    │  │   Shared Services       │  │
│  │- Elastic    │  │- 3 Brokers  │  │ - Registry              │  │
│  │- Logstash   │  │- Zookeeper  │  │ - Backup Storage        │  │  
│  │- Kibana     │  │- Schema Reg │  │ - Network Storage       │  │
│  └─────────────┘  └─────────────┘  └─────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘

🚀 단계별 구현 로드맵 (실무급 버전)

Phase 1: K8s 멀티존 클러스터 구축 (2-3주)

# 네임스페이스 기반 Zone 분리
kubectl create namespace dev-zone
kubectl create namespace it-zone  
kubectl create namespace prod-zone

# 각 Zone별 RBAC 구성
# 각 Zone별 리소스 할당량 설정
# 네트워크 정책으로 Zone간 격리

# 실제 회사처럼 구성:
apiVersion: v1
kind: ResourceQuota
metadata:
  name: dev-zone-quota
  namespace: dev-zone
spec:
  hard:
    requests.cpu: "4"
    requests.memory: 8Gi
    limits.cpu: "8" 
    limits.memory: 16Gi
    pods: "10"

Phase 2: Git + Jenkins CI 파이프라인 (3-4주)

# 1) Bitbucket 대신 GitLab self-hosted 구축
# 2) Jenkins 마스터-슬레이브 구성 (it-zone에 배포)
# 3) Jenkins Pipeline as Code

# Jenkinsfile 예시 (실제 회사 스타일):
pipeline {
    agent {
        kubernetes {
            yaml """
apiVersion: v1
kind: Pod
spec:
  containers:
  - name: maven
    image: maven:3.8.1-jdk-11
  - name: docker
    image: docker:dind
    securityContext:
      privileged: true
"""
        }
    }
    stages {
        stage('Checkout') { ... }
        stage('SonarQube Analysis') { ... }
        stage('Build & Test') { ... }
        stage('Security Scan') { ... }
        stage('Build Docker Image') { ... }
        stage('Deploy to ArgoCD') { ... }
    }
    post {
        always {
            publishHTML([
                allowMissing: false,
                alwaysLinkToLastBuild: true,
                keepAll: true,
                reportDir: 'allure-report',
                reportFiles: 'index.html',
                reportName: 'Allure Report'
            ])
        }
    }
}

Phase 3: GitOps + ArgoCD 구성 (2-3주)

# ArgoCD 설치 (it-zone)
# App of Apps 패턴으로 멀티존 관리
# 각 Zone별 별도 ArgoCD Application

# dev-zone-apps.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: dev-zone-apps
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://git.yourcompany.com/k8s-configs
    targetRevision: main
    path: dev-zone
  destination:
    server: https://kubernetes.default.svc
    namespace: dev-zone
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

Phase 4: 품질 관리 도구들 (2-3주)

# SonarQube HA 구성 (it-zone)
# - PostgreSQL HA
# - SonarQube 인스턴스 이중화
# - 품질 게이트 설정

# Allure Report Server
# - 테스트 결과 중앙 집중 관리
# - 히스토리 관리
# - 슬랙/이메일 알림 연동

Phase 5: ELK Stack HA 구성 (3-4주)

# Elasticsearch 클러스터 (최소 3노드)
# - 마스터 노드 3개
# - 데이터 노드 분산
# - 인덱스 샤딩 전략

# Logstash HA 
# - 로드밸런서 뒤에 여러 인스턴스
# - 큐 기반 처리 (Redis/Kafka)

# Kibana 이중화
# - 세션 공유 설정
# - 대시보드 자동 백업

Phase 6: Kafka HA 구성 (2-3주)

# Kafka 클러스터 (3 브로커)
# Zookeeper 앙상블 (3노드)
# Schema Registry
# Kafka Connect
# 모니터링 (Kafka Manager, Burrow)

# 실제 사용 사례:
# - 애플리케이션 로그 스트리밍
# - 마이크로서비스간 이벤트 통신
# - 실시간 데이터 파이프라인

💾 백업 전략 (Enterprise급)

etcd 백업 (3-2-1 전략)

# 3개 복사본, 2개 다른 미디어, 1개 오프사이트
# 매시간 자동 백업
# 매일 검증된 백업 테스트
# 일주일, 한달, 6개월 보존 정책

애플리케이션 데이터 백업

# Velero 클러스터 백업 도구
# PV 스냅샷 자동화
# 크로스 클러스터 복구 테스트

설정 관리 (GitOps)

# 모든 설정을 Git으로 버전 관리
# 환경별 브랜치 전략
# 설정 변경 이력 추적

📊 모니터링 & 알림 (Production Ready)

# Prometheus + Grafana (각 Zone별)
# - 인프라 메트릭
# - 애플리케이션 메트릭  
# - 비즈니스 메트릭

# 알림 체계:
# - Slack 채널별 라우팅
# - 심각도별 에스컬레이션
# - 온콜 로테이션 연동

API Gateway 방식일 경우 (Kong)

┌─────────────────────────────────────────────────────────────────┐
│                    External Traffic Flow                       │
│  Internet → Kong Gateway → Internal Services                   │
└─────────────────────────────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────────────────────────────┐
│                   Kong API Gateway                              │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐  │
│  │   Kong Proxy    │  │  Kong Admin     │  │   Kong Manager  │  │
│  │  (Public API)   │  │     API         │  │    (GUI)        │  │
│  │                 │  │                 │  │                 │  │
│  │ - Rate Limiting │  │ - Plugin Config │  │ - Visual Mgmt   │  │
│  │ - Authentication│  │ - Route Config  │  │ - Analytics     │  │
│  │ - Load Balancing│  │ - Service Config│  │ - Health Checks │  │
│  │ - SSL Terminate │  │                 │  │                 │  │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘  │
└─────────────────────────────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Zone-Based Routing                           │
│                                                                 │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────────────┐  │
│  │  DEV Zone   │    │  IT Zone    │    │     PROD Zone       │  │
│  │             │    │             │    │                     │  │
│  │/api/v1/dev/ │    │/tools/      │    │/api/v1/             │  │
│  │/staging/    │    │/jenkins/    │    │/app/                │  │
│  │             │    │/sonar/      │    │/admin/              │  │
│  │             │    │/argocd/     │    │                     │  │
│  └─────────────┘    └─────────────┘    └─────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘

🚀 Kong 통합 전략 (실무급)

Kong 배포 전략

# Option 1: Kong을 별도 Zone에 배포 (권장)
kubectl create namespace kong-zone

# Option 2: 각 Zone별로 Kong 인스턴스 (대규모)
# - dev-kong (dev-zone)
# - it-kong (it-zone)  
# - prod-kong (prod-zone)

# HA 구성을 위한 Kong 클러스터링
apiVersion: apps/v1
kind: Deployment
metadata:
  name: kong-proxy
  namespace: kong-zone
spec:
  replicas: 3  # HA를 위한 3개 인스턴스
  selector:
    matchLabels:
      app: kong-proxy
  template:
    metadata:
      labels:
        app: kong-proxy
    spec:
      containers:
      - name: kong
        image: kong:3.4
        env:
        - name: KONG_DATABASE
          value: postgres
        - name: KONG_PG_HOST
          value: postgres-kong.kong-zone.svc.cluster.local
        - name: KONG_PROXY_ACCESS_LOG
          value: /dev/stdout
        - name: KONG_ADMIN_ACCESS_LOG
          value: /dev/stdout
        - name: KONG_PROXY_ERROR_LOG
          value: /dev/stderr
        - name: KONG_ADMIN_ERROR_LOG
          value: /dev/stderr
        - name: KONG_ADMIN_LISTEN
          value: 0.0.0.0:8001

Zone별 라우팅 설정

# Kong Ingress Controller 설치
kubectl apply -f https://bit.ly/k4k8s

# DEV Zone 라우팅
apiVersion: configuration.konghq.com/v1
kind: KongIngress
metadata:
  name: dev-zone-routing
  namespace: dev-zone
route:
  methods:
  - GET
  - POST
  paths:
  - /api/v1/dev
  - /staging
upstream:
  algorithm: round-robin
  healthchecks:
    active:
      http_path: /health
      healthy:
        interval: 10

---
# IT Zone 라우팅 (DevOps 도구들)
apiVersion: configuration.konghq.com/v1
kind: KongIngress
metadata:
  name: it-zone-routing
  namespace: it-zone
route:
  paths:
  - /jenkins
  - /sonarqube  
  - /argocd
  - /grafana
  - /kibana

Kong 플러그인 활용 (Production Ready)

# Rate Limiting Plugin
apiVersion: configuration.konghq.com/v1
kind: KongPlugin
metadata:
  name: rate-limiting-dev
  namespace: dev-zone
config:
  minute: 100
  hour: 1000
  policy: local
plugin: rate-limiting

---
# Authentication Plugin (JWT)
apiVersion: configuration.konghq.com/v1
kind: KongPlugin
metadata:
  name: jwt-auth
  namespace: prod-zone
config:
  uri_param_names:
  - token
  cookie_names:
  - jwt
plugin: jwt

---
# CORS Plugin
apiVersion: configuration.konghq.com/v1
kind: KongPlugin
metadata:
  name: cors-policy
config:
  origins:
  - http://localhost:3000
  - https://yourcompany.com
  methods:
  - GET
  - POST
  - PUT
  - DELETE
  headers:
  - Accept
  - Authorization
  - Content-Type
plugin: cors

🔧 Kong + CI/CD 통합

Jenkins Pipeline에서 Kong API 관리

pipeline {
    agent any
    stages {
        stage('Deploy Application') {
            steps {
                // 애플리케이션 배포 후 Kong Route 자동 등록
                script {
                    sh """
                    # Kong Admin API를 통한 서비스 등록
                    curl -X POST http://kong-admin.kong-zone.svc.cluster.local:8001/services \\
                      -d name=${APP_NAME} \\
                      -d url=http://${APP_NAME}.${NAMESPACE}.svc.cluster.local:${PORT}
                    
                    # Route 등록
                    curl -X POST http://kong-admin.kong-zone.svc.cluster.local:8001/services/${APP_NAME}/routes \\
                      -d paths[]=/api/v1/${APP_NAME} \\
                      -d methods[]=GET \\
                      -d methods[]=POST
                    
                    # 플러그인 적용
                    curl -X POST http://kong-admin.kong-zone.svc.cluster.local:8001/services/${APP_NAME}/plugins \\
                      -d name=rate-limiting \\
                      -d config.minute=60
                    """
                }
            }
        }
    }
}

ArgoCD + Kong 설정 관리

# argocd-kong-config.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: kong-configuration
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://git.yourcompany.com/kong-configs
    targetRevision: main
    path: kong-declarative
  destination:
    server: https://kubernetes.default.svc
    namespace: kong-zone
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

📊 Kong 모니터링 & 로깅

Prometheus 메트릭 수집

# Kong Prometheus Plugin
apiVersion: configuration.konghq.com/v1
kind: KongClusterPlugin
metadata:
  name: prometheus
  annotations:
    kubernetes.io/ingress.class: kong
  labels:
    global: "true"
config:
  per_consumer: true
  status_code_metrics: true
  latency_metrics: true
  bandwidth_metrics: true
plugin: prometheus

ELK Stack 로그 수집

# Kong 로그를 Logstash로 전송
apiVersion: v1
kind: ConfigMap
metadata:
  name: kong-logstash-config
data:
  logstash.conf: |
    input {
      http {
        port => 8080
        codec => json
      }
    }
    
    filter {
      if [service] {
        mutate {
          add_field => { "kong_service" => "%{[service][name]}" }
          add_field => { "kong_route" => "%{[route][paths][0]}" }
        }
      }
    }
    
    output {
      elasticsearch {
        hosts => ["elasticsearch.logging.svc.cluster.local:9200"]
        index => "kong-logs-%{+YYYY.MM.dd}"
      }
    }

🔐 보안 & 인증 전략

Zone별 보안 정책

# DEV Zone: 기본 API Key 인증
# IT Zone: LDAP/AD 통합 인증  
# PROD Zone: JWT + mTLS 인증

# Example: PROD Zone JWT 설정
apiVersion: configuration.konghq.com/v1
kind: KongPlugin
metadata:
  name: jwt-prod
  namespace: prod-zone
config:
  secret_is_base64: false
  run_on_preflight: true
  maximum_expiration: 3600
plugin: jwt

📋 Kong 구현 로드맵

Phase 1: Kong 기본 설치 & 설정 (1-2주)

1. Kong + PostgreSQL HA 설치
2. Kong Ingress Controller 설정
3. 기본 라우팅 규칙 구성
4. Kong Manager 설정

Phase 2: Zone별 라우팅 & 플러그인 (2-3주)

1. 각 Zone별 라우팅 규칙
2. 인증/인가 플러그인 적용
3. Rate Limiting & CORS 설정
4. 로깅 & 모니터링 플러그인

Phase 3: CI/CD 통합 (1-2주)

1. Jenkins Pipeline Kong API 연동
2. ArgoCD Kong 설정 관리
3. 자동 서비스 등록/해제
4. Blue/Green 배포 연동