쿠버네티스를 로컬로 가져오는 기술: Podman이 선사하는 5가지 반전의 혁신

┌─────────────────────────────────────────────────────────────────┐
│                    Docker 아키텍처 (Client-Server)               │
│                                                                  │
│  ┌──────────┐     REST API      ┌──────────────────────────┐    │
│  │ docker   │ ─────────────────▶│       dockerd            │    │
│  │ CLI      │     /var/run/     │   (Docker Daemon)        │    │
│  └──────────┘    docker.sock    │   ┌──────────────────┐   │    │
│                                 │   │   containerd     │   │    │
│  ┌──────────┐     REST API      │   │  ┌────────────┐  │   │    │
│  │ docker   │ ─────────────────▶│   │  │   runc     │  │   │    │
│  │ CLI      │     /var/run/     │   │  └────────────┘  │   │    │
│  └──────────┘    docker.sock    │   └──────────────────┘   │    │
│                                 │                          │    │
│  ┌──────────┐     REST API      │   ┌─────┐ ┌─────┐       │    │
│  │ docker   │ ─────────────────▶│   │ C1  │ │ C2  │ ...   │    │
│  │ CLI      │                   │   └─────┘ └─────┘       │    │
│  └──────────┘                   └──────────────────────────┘    │
│                                          ▲                      │
│                                          │                      │
│                              ★ 단일 장애점(SPOF) ★              │
│                              dockerd가 죽으면                   │
│                              모든 컨테이너 관리 불가            │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                  Podman 아키텍처 (Daemonless Fork-Exec)          │
│                                                                  │
│  ┌──────────┐   fork/exec    ┌───────┐    ┌─────────────────┐   │
│  │ podman   │ ──────────────▶│ conmon │───▶│   Container 1   │   │
│  │ CLI      │                └───────┘    └─────────────────┘   │
│  └──────────┘                                                    │
│       │                                                          │
│       │          fork/exec    ┌───────┐    ┌─────────────────┐   │
│       └─────────────────────▶│ conmon │───▶│   Container 2   │   │
│       │                      └───────┘    └─────────────────┘   │
│       │                                                          │
│       │          fork/exec    ┌───────┐    ┌─────────────────┐   │
│       └─────────────────────▶│ conmon │───▶│   Container 3   │   │
│                              └───────┘    └─────────────────┘   │
│                                                                  │
│  ★ 데몬 없음: 각 컨테이너가 독립 프로세스                       │
│  ★ Podman CLI 종료해도 컨테이너 영향 없음                       │
│  ★ conmon: 경량 컨테이너 모니터 (로그, exit code 관리)           │
│  ★ OCI 런타임(crun/runc) 직접 호출                              │
└─────────────────────────────────────────────────────────────────┘

# /etc/containers/systemd/webapp.container (Quadlet 형식)
[Unit]
Description=Production Web Application
After=network-online.target
Wants=network-online.target

[Container]
Image=registry.example.com/webapp:v2.1.0
PublishPort=8080:8080
Environment=NODE_ENV=production
Environment=DB_HOST=db.internal
Volume=/data/webapp:/app/data:Z
Network=webapp.network
AutoUpdate=registry
HealthCmd=/bin/curl -f http://localhost:8080/health || exit 1
HealthInterval=30s
HealthRetries=3
HealthStartPeriod=10s

[Service]
Restart=always
RestartSec=5
TimeoutStartSec=120
WatchdogSec=60

[Install]
WantedBy=multi-user.target default.target

# ~/.config/containers/systemd/app-network.network
[Network]
Subnet=10.89.1.0/24
Gateway=10.89.1.1

# ~/.config/containers/systemd/postgres.container
[Unit]
Description=PostgreSQL Database

[Container]
Image=docker.io/library/postgres:16-alpine
Volume=pgdata.volume:/var/lib/postgresql/data:Z
Network=app-network.network
Environment=POSTGRES_DB=appdb
Environment=POSTGRES_USER=appuser
Secret=pg-password,type=env,target=POSTGRES_PASSWORD
HealthCmd=pg_isready -U appuser
HealthInterval=10s

[Service]
Restart=always

[Install]
WantedBy=multi-user.target default.target

# ~/.config/containers/systemd/pgdata.volume
[Volume]

# Quadlet 적용
systemctl --user daemon-reload

# 서비스 시작
systemctl --user start postgres.service

# 상태 확인
systemctl --user status postgres.service

# 로그 확인
journalctl --user -u postgres.service -f

┌─────────────────────────────────────────────────────────────────┐
│               User Namespace UID 매핑 다이어그램                 │
│                                                                  │
│  ┌─────────────────────┐      ┌─────────────────────────────┐   │
│  │   컨테이너 내부       │      │        호스트 시스템         │   │
│  │   (User Namespace)   │      │                             │   │
│  │                      │      │                             │   │
│  │   UID 0 (root)  ─────┼──────┼──▶  UID 1000 (youruser)    │   │
│  │   UID 1         ─────┼──────┼──▶  UID 100000             │   │
│  │   UID 2         ─────┼──────┼──▶  UID 100001             │   │
│  │   UID 3         ─────┼──────┼──▶  UID 100002             │   │
│  │   ...                │      │     ...                     │   │
│  │   UID 65535     ─────┼──────┼──▶  UID 165535             │   │
│  │                      │      │                             │   │
│  └─────────────────────┘      └─────────────────────────────┘   │
│                                                                  │
│  ★ 컨테이너의 root가 탈출해도 호스트에서는 UID 1000             │
│  ★ 비특권 사용자 → 시스템 파일 접근 불가                        │
│  ★ 커널 취약점 악용 범위 대폭 축소                              │
└─────────────────────────────────────────────────────────────────┘

# /etc/subuid — 사용자별 하위 UID 범위 할당
youruser:100000:65536

# /etc/subgid — 사용자별 하위 GID 범위 할당
youruser:100000:65536

# 의미: youruser는 UID 100000부터 65536개의 UID를 사용할 수 있음

# 컨테이너를 루트리스 모드로 실행
podman run -d --name test-rootless alpine sleep 3600

# 컨테이너 내부에서 UID 확인
podman exec test-rootless id
# uid=0(root) gid=0(root)  ← 컨테이너 내부에서는 root로 보임

# 호스트에서 실제 UID 확인
podman top test-rootless huser
# HUSER
# 1000     ← 호스트에서는 일반 사용자 (UID 1000)

# keep-id 모드: 호스트 UID를 컨테이너 내부에서도 유지
# → 바인드 마운트된 파일의 소유권 문제 해결
podman run --userns=keep-id -v $HOME/project:/workspace:Z \
  -it node:20-alpine sh

# nomap 모드: 호스트 사용자 UID를 아예 매핑하지 않음
# → 컨테이너가 호스트 사용자 소유 파일에 접근 불가 (world permission 제외)
podman run --userns=nomap alpine cat /proc/self/uid_map

# Podman 기본 Capabilities 확인
podman run --rm alpine grep Cap /proc/1/status
# CapBnd: 00000000a80425fb

# Docker 기본 Capabilities 확인
docker run --rm alpine grep Cap /proc/1/status
# CapBnd: 00000000a80435fb
# → Docker가 더 많은 Capabilities 부여 (NET_RAW 등 추가 포함)

┌─────────────────────────────────────────────────────────────────┐
│              개발/운영 언어 이중성 문제                           │
│                                                                  │
│  개발자 노트북                     프로덕션 클러스터             │
│  ┌───────────────────┐            ┌──────────────────────┐      │
│  │ docker-compose.yml│            │  deployment.yaml     │      │
│  │                   │  ──────▶   │  service.yaml        │      │
│  │ version: "3.8"    │  변환 필요 │  configmap.yaml      │      │
│  │ services:         │            │  ingress.yaml        │      │
│  │   web:            │            │                      │      │
│  │     image: app    │            │  apiVersion: apps/v1 │      │
│  │     ports:        │            │  kind: Deployment    │      │
│  │       - "8080:80" │            │  spec:               │      │
│  └───────────────────┘            │    replicas: 3       │      │
│                                   └──────────────────────┘      │
│                                                                  │
│  ★ 두 가지 문법, 두 가지 도구, 두 배의 학습 비용                │
│  ★ 변환 과정에서 미묘한 차이로 인한 배포 실패                   │
│  ★ "내 노트북에서는 됐는데..." 문제의 새로운 변종              │
└─────────────────────────────────────────────────────────────────┘

# microservices-stack.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  DATABASE_HOST: 'postgres'
  DATABASE_PORT: '5432'
  DATABASE_NAME: 'appdb'
  APP_LOG_LEVEL: 'info'
---
apiVersion: v1
kind: Pod
metadata:
  name: microservices
  labels:
    app: microservices-stack
    environment: development
spec:
  # Init 컨테이너: 데이터베이스 마이그레이션
  initContainers:
    - name: db-migration
      image: docker.io/library/flyway/flyway:10
      command: ['flyway', 'migrate']
      env:
        - name: FLYWAY_URL
          value: 'jdbc:postgresql://localhost:5432/appdb'
        - name: FLYWAY_USER
          value: 'appuser'
        - name: FLYWAY_PASSWORD
          value: 'secret123'
      volumeMounts:
        - name: migration-scripts
          mountPath: /flyway/sql
  containers:
    # 데이터베이스
    - name: postgres
      image: docker.io/library/postgres:16-alpine
      ports:
        - containerPort: 5432
      env:
        - name: POSTGRES_DB
          value: 'appdb'
        - name: POSTGRES_USER
          value: 'appuser'
        - name: POSTGRES_PASSWORD
          value: 'secret123'
      volumeMounts:
        - name: pgdata
          mountPath: /var/lib/postgresql/data
    # API 서버
    - name: api-server
      image: docker.io/library/node:20-alpine
      ports:
        - containerPort: 3000
          hostPort: 3000
      env:
        - name: DATABASE_HOST
          value: 'localhost'
        - name: DATABASE_PORT
          value: '5432'
      command: ['node', 'server.js']
      volumeMounts:
        - name: app-source
          mountPath: /app
    # Redis 캐시
    - name: redis
      image: docker.io/library/redis:7-alpine
      ports:
        - containerPort: 6379
      command: ['redis-server', '--maxmemory', '256mb']
  volumes:
    - name: pgdata
      persistentVolumeClaim:
        claimName: pgdata-pvc
    - name: migration-scripts
      hostPath:
        path: ./migrations
    - name: app-source
      hostPath:
        path: ./src

# YAML 파일로 전체 스택 생성
podman kube play microservices-stack.yaml

# 실행 상태 확인
podman pod ps
# POD ID        NAME            STATUS   CREATED        INFRA ID      # OF CONTAINERS
# a1b2c3d4e5f6  microservices   Running  10 seconds ago 9f8e7d6c5b4a  4

# 개별 컨테이너 확인
podman ps --pod
# CONTAINER ID  IMAGE                            STATUS         POD ID        NAMES
# ...           docker.io/library/postgres:16    Up 10 seconds  a1b2c3d4e5f6  microservices-postgres
# ...           docker.io/library/node:20        Up 8 seconds   a1b2c3d4e5f6  microservices-api-server
# ...           docker.io/library/redis:7        Up 8 seconds   a1b2c3d4e5f6  microservices-redis

# API 서버 로그 확인
podman logs microservices-api-server

# --down 플래그로 전체 스택 한 번에 종료 및 정리
podman kube play --down microservices-stack.yaml

# 확인
podman pod ps
# (비어 있음 — 모든 리소스가 정리됨)

프로젝트 디렉터리 구조:
├── my-stack.yaml          ← image: my-api 참조
├── my-api/                ← 자동 빌드 대상
│   ├── Containerfile
│   └── src/
│       └── server.js
└── my-frontend/           ← image: my-frontend 참조
    ├── Containerfile
    └── dist/
        └── index.html

# --build 플래그로 이미지 자동 빌드 + 실행
podman kube play --build my-stack.yaml

# 이미 빌드된 이미지 교체(강제 빌드)
podman kube play --replace --build my-stack.yaml

# Init 컨테이너 타입 지정 (Podman 어노테이션)
metadata:
  annotations:
    io.podman.annotations.init.container.type/wait-for-db: 'always'
spec:
  initContainers:
    - name: wait-for-db
      image: docker.io/library/busybox:latest
      command:
        ['sh', '-c', 'until nc -z localhost 5432; do echo "Waiting for DB..."; sleep 2; done']

┌─────────────────────────────────────────────────────────────────┐
│                      Podman Pod 아키텍처                         │
│                                                                  │
│  ┌─── Pod ──────────────────────────────────────────────────┐   │
│  │                                                          │   │
│  │  ┌──────────┐                                            │   │
│  │  │  Infra   │  ← pause 컨테이너                          │   │
│  │  │Container │  ← 네트워크 네임스페이스 소유자             │   │
│  │  │ (pause)  │  ← Pod 생명주기의 앵커                     │   │
│  │  └──────────┘                                            │   │
│  │       │                                                  │   │
│  │       │── 공유: Network Namespace                        │   │
│  │       │── 공유: IPC Namespace                            │   │
│  │       │── 공유: UTS Namespace (hostname)                 │   │
│  │       │                                                  │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐               │   │
│  │  │   App    │  │  Sidecar │  │  Logging │               │   │
│  │  │Container │  │ (envoy)  │  │ (fluentd)│               │   │
│  │  │          │  │          │  │          │               │   │
│  │  │ :8080    │  │ :15001   │  │ :24224   │               │   │
│  │  └──────────┘  └──────────┘  └──────────┘               │   │
│  │                                                          │   │
│  │  ★ 모든 컨테이너가 localhost로 서로 통신                 │   │
│  │  ★ Kubernetes Pod와 동일한 네트워크 모델                 │   │
│  └──────────────────────────────────────────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

# 1. Pod 생성 (포트 매핑은 Pod 수준에서 설정)
podman pod create --name my-app \
  --publish 8080:8080 \
  --publish 9090:9090

# 2. 메인 애플리케이션 컨테이너
podman run -d --pod my-app \
  --name app-main \
  my-registry.io/my-app:v1.0

# 3. 사이드카: Envoy 프록시
podman run -d --pod my-app \
  --name app-envoy \
  docker.io/envoyproxy/envoy:v1.31

# 4. 사이드카: 로그 수집기
podman run -d --pod my-app \
  --name app-logger \
  docker.io/fluent/fluentd:v1.17

# 5. 사이드카: 메트릭 수집기
podman run -d --pod my-app \
  --name app-metrics \
  docker.io/prom/node-exporter:v1.8

# Pod 상태 확인
podman pod inspect my-app

# Step 1: 로컬에서 Pod 구성
podman pod create --name webapp --publish 8080:80

podman run -d --pod webapp \
  --name webapp-nginx \
  -v ./html:/usr/share/nginx/html:Z \
  docker.io/library/nginx:alpine

podman run -d --pod webapp \
  --name webapp-redis \
  docker.io/library/redis:7-alpine

# Step 2: Kubernetes YAML 생성
podman kube generate webapp -f webapp-k8s.yaml

# Step 3: 생성된 YAML 확인
cat webapp-k8s.yaml

# webapp-k8s.yaml (podman kube generate가 자동 생성)
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: '2026-03-01T09:00:00Z'
  labels:
    app: webapp
  name: webapp
spec:
  containers:
    - name: webapp-nginx
      image: docker.io/library/nginx:alpine
      ports:
        - containerPort: 80
          hostPort: 8080
          protocol: TCP
      volumeMounts:
        - mountPath: /usr/share/nginx/html
          name: html-host
    - name: webapp-redis
      image: docker.io/library/redis:7-alpine
  volumes:
    - name: html-host
      hostPath:
        path: /home/user/project/html
        type: Directory

# Step 4: 생성된 YAML을 Kubernetes 클러스터에 적용
kubectl apply -f webapp-k8s.yaml

# 또는 동일한 YAML을 다른 Podman 호스트에서 실행
podman kube play webapp-k8s.yaml

# Service 객체도 함께 생성
podman kube generate -s webapp -f webapp-with-service.yaml

# Deployment 타입으로 생성 (replicas 지정 가능)
podman kube generate --type deployment --replicas 3 webapp

# DaemonSet 또는 Job 타입으로도 생성 가능
podman kube generate --type job webapp

┌───────────────────────────────────────────────────────────┐
│            Podman ↔ Kubernetes 양방향 워크플로우           │
│                                                           │
│   로컬 개발                            Kubernetes 클러스터│
│   ┌─────────┐                         ┌─────────────┐    │
│   │ podman  │   podman kube generate  │ kubectl     │    │
│   │ pod     │ ───────────────────────▶│ apply -f    │    │
│   │ create  │                         │             │    │
│   │ + run   │   podman kube play      │ Deployment  │    │
│   │         │ ◀───────────────────────│ export      │    │
│   └─────────┘                         └─────────────┘    │
│                                                           │
│   ★ 동일한 YAML, 동일한 의미론(Semantics)                │
│   ★ 환경 간 전환 시 변환(Translation) 불필요             │
└───────────────────────────────────────────────────────────┘

컨테이너 → TAP 장치 → slirp4netns (사용자 공간 NAT) → 호스트 네트워크

┌─────────────────────────────────────────────────────────────────┐
│            slirp4netns vs Pasta 아키텍처 비교                    │
│                                                                  │
│  ┌─ slirp4netns (레거시) ─────────────────────────────────────┐ │
│  │                                                             │ │
│  │  컨테이너           사용자 공간             호스트          │ │
│  │  ┌───────┐    ┌──────────────────┐    ┌──────────┐         │ │
│  │  │ eth0  │───▶│  slirp4netns     │───▶│ 호스트   │         │ │
│  │  │ (TAP) │    │  ┌────────────┐  │    │ 네트워크 │         │ │
│  │  └───────┘    │  │ User-space │  │    └──────────┘         │ │
│  │               │  │ TCP/IP     │  │                         │ │
│  │               │  │ + NAT      │  │  ← 모든 패킷 NAT 변환  │ │
│  │               │  └────────────┘  │  ← CPU 오버헤드 높음    │ │
│  │               └──────────────────┘                         │ │
│  └─────────────────────────────────────────────────────────────┘ │
│                                                                  │
│  ┌─ Pasta (Podman 5.0+ 기본값) ───────────────────────────────┐ │
│  │                                                             │ │
│  │  컨테이너           커널 공간               호스트          │ │
│  │  ┌───────┐    ┌──────────────────┐    ┌──────────┐         │ │
│  │  │ eth0  │───▶│  L2→L4 소켓 매핑 │───▶│ 호스트   │         │ │
│  │  │ (TAP) │    │  ┌────────────┐  │    │ 네트워크 │         │ │
│  │  └───────┘    │  │ splice(2)  │  │    │ 설정 복사│         │ │
│  │               │  │ sendmmsg() │  │    └──────────┘         │ │
│  │               │  │ recvmmsg() │  │                         │ │
│  │               │  └────────────┘  │  ← NAT 없음            │ │
│  │               └──────────────────┘  ← 직접 소켓 전달       │ │
│  └─────────────────────────────────────────────────────────────┘ │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

# Podman 5.0+ 에서는 Pasta가 기본값
# 명시적으로 지정하려면:
podman run --network=pasta -d nginx

# slirp4netns로 폴백하려면:
podman run --network=slirp4netns -d nginx

# Pasta 포트 포워딩 (특정 포트만 노출)
podman run --network=pasta:-T,8080,-U,5353 -d my-app

# Pasta 네트워킹 상태 확인
podman inspect --format '{{.HostConfig.NetworkMode}}' <container>

# macOS
brew install podman
podman machine init --cpus 4 --memory 8192 --disk-size 60
podman machine start

# RHEL/CentOS/Fedora
sudo dnf install -y podman

# Ubuntu/Debian
sudo apt-get install -y podman

# Windows
winget install RedHat.Podman

# ~/.bashrc 또는 ~/.zshrc
alias docker=podman

# Docker Socket 호환 (Docker API를 사용하는 도구를 위해)
# macOS의 경우:
podman machine stop
podman machine set --rootful
podman machine start

# Linux의 경우 (rootless):
systemctl --user enable --now podman.socket
export DOCKER_HOST=unix://$XDG_RUNTIME_DIR/podman/podman.sock

# 방법 1: podman compose (Podman 5.x 내장 지원)
podman compose up -d

# 방법 2: podman-compose (Python 기반 독립 도구)
pip install podman-compose
podman-compose up -d

# 방법 3: Kubernetes YAML로 전환 (권장)
# docker-compose.yml → Kubernetes YAML 변환 후
podman kube play my-stack.yaml

# GitHub Actions 예시
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install Podman
        run: |
          sudo apt-get update
          sudo apt-get install -y podman

      - name: Build Image
        run: podman build -t my-app:${{ github.sha }} .

      - name: Push to Registry
        run: |
          podman login -u ${{ secrets.REGISTRY_USER }} \
                       -p ${{ secrets.REGISTRY_PASS }} \
                       registry.example.com
          podman push my-app:${{ github.sha }} \
                      registry.example.com/my-app:${{ github.sha }}

┌─────────────────────────────────────────────────────────────────┐
│                   Podman의 5가지 혁신 요약                       │
│                                                                  │
│  ┌─────────────┐   데몬을 뺐다       → 안정성 확보              │
│  │  혁신 1     │   SPOF 제거         → 개별 컨테이너 독립성     │
│  │  Daemonless │   systemd 통합      → OS 네이티브 관리         │
│  └─────────────┘                                                │
│                                                                  │
│  ┌─────────────┐   root를 뺐다       → 공격 표면 최소화         │
│  │  혁신 2     │   User Namespace    → UID 격리                 │
│  │  Rootless   │   최소 Capabilities → 컴플라이언스 충족        │
│  └─────────────┘                                                │
│                                                                  │
│  ┌─────────────┐   번역을 뺐다       → 개발/운영 언어 통일      │
│  │  혁신 3     │   K8s YAML 직접 실행 → 환경 간 일관성          │
│  │  play kube  │   관례 기반 빌드     → 워크플로우 단순화       │
│  └─────────────┘                                                │
│                                                                  │
│  ┌─────────────┐   추상화를 뺐다     → K8s와 동일한 단위        │
│  │  혁신 4     │   네이티브 Pod      → 사이드카 패턴 로컬 구현  │
│  │  Pod 관리   │   generate kube     → 양방향 워크플로우        │
│  └─────────────┘                                                │
│                                                                  │
│  ┌─────────────┐   NAT를 뺐다        → 지연시간 감소            │
│  │  혁신 5     │   L2-L4 소켓 매핑   → 처리량 향상              │
│  │  Pasta      │   splice(2)         → 제로카피 전송            │
│  └─────────────┘                                                │
│                                                                  │
│  ★ 공통 철학: 불필요한 것을 제거하여 본질적 가치를 극대화       │
└─────────────────────────────────────────────────────────────────┘