컨테이너는 거짓말이다 — cgroups와 네임스페이스로 본 커널의 진실

        "컨테이너"라는 환상
  +--------------------------------------+
  |  사실은 그냥 리눅스 프로세스           |
  |                                      |
  |  + 네임스페이스 (격리: 무엇이 보이나)   |
  |    pid, net, mnt, uts, ipc,          |
  |    user, cgroup, (time)              |
  |                                      |
  |  + cgroups (제한: 얼마나 쓸 수 있나)   |
  |    cpu, memory, io, pids ...         |
  |                                      |
  |  + 보안 레이어 (권한: 무엇을 할 수 있나)|
  |    capabilities, seccomp,            |
  |    LSM (SELinux/AppArmor)            |
  |                                      |
  |  + 루트 파일시스템 (overlayfs 이미지)  |
  +--------------------------------------+
            |
            v
     호스트 커널 하나를 모두가 공유
     (VM과의 근본적 차이)

# 1) uts: 가장 간단한 네임스페이스. 호스트네임 격리
sudo unshare --uts bash
hostname container-test   # 호스트의 hostname은 안 바뀜
hostname                  # container-test
exit

# 2) pid: PID 공간 격리. --fork와 --mount-proc이 핵심
sudo unshare --pid --fork --mount-proc bash
echo $$                   # 1  <- 이 셸이 PID 1
ps aux                    # 프로세스가 2~3개만 보임
exit

# 3) net: 빈 네트워크 스택이 생긴다
sudo unshare --net bash
ip link                   # lo 하나만, 그것도 DOWN 상태
exit

# 4) mnt: 마운트 트리 격리
sudo unshare --mount bash
mount -t tmpfs tmpfs /mnt # 호스트에는 안 보이는 마운트
findmnt /mnt
exit

# 5) ipc: 공유메모리 격리
ipcmk -M 1024             # 호스트에서 공유메모리 생성
sudo unshare --ipc bash
ipcs -m                   # 안 보임 (격리됨)
exit

# 6) user: 루트 아닌 사용자가 "네임스페이스 안에서만 root"
unshare --user --map-root-user bash   # sudo 불필요!
id                        # uid=0(root) ... 하지만
cat /proc/self/uid_map    # 0 <내UID> 1 형태의 매핑 확인
exit

# 7) cgroup: cgroup 경로의 시야 격리
sudo unshare --cgroup bash
cat /proc/self/cgroup     # 루트(/)처럼 보임
exit

unshare --user --map-root-user --pid --fork --mount-proc \
        --net --uts --ipc --cgroup bash

   컨테이너 안 시야              호스트의 진실
  +----------------+          +-------------------+
  | uid 0 (root)   |  ----->  | uid 100000 (무권한)|
  | uid 1 (daemon) |  ----->  | uid 100001        |
  | ...            |          | ...               |
  | uid 65535      |  ----->  | uid 165535        |
  +----------------+          +-------------------+

  /etc/subuid, /etc/subgid 가 매핑 가능한 범위를 정의
  newuidmap/newgidmap 헬퍼가 매핑을 기록

# 호스트에서 매핑 범위 확인
cat /etc/subuid    # 예: youngju:100000:65536
cat /etc/subgid

# 실행 중인 프로세스의 매핑 확인
cat /proc/<컨테이너PID 자리에는 실제 숫자>/uid_map

   /sys/fs/cgroup            (루트, cgroup2 마운트)
   |-- cgroup.controllers     사용 가능한 컨트롤러 목록
   |-- cgroup.subtree_control 자식에게 위임할 컨트롤러
   |-- system.slice/          systemd 서비스들
   |-- user.slice/            로그인 세션들
   +-- kubepods.slice/        쿠버네티스 파드들
       +-- kubepods-burstable.slice/
           +-- kubepods-burstable-pod<해시>.slice/
               +-- cri-containerd-<해시>.scope/
                   |-- cpu.max
                   |-- memory.max
                   |-- io.max
                   +-- pids.max

# 새 cgroup 생성과 컨트롤러 활성화
sudo mkdir /sys/fs/cgroup/lab
echo "+cpu +memory +io +pids" | sudo tee /sys/fs/cgroup/cgroup.subtree_control

# cpu: 100ms 주기당 20ms = 0.2 CPU
echo "20000 100000" | sudo tee /sys/fs/cgroup/lab/cpu.max

# memory: 소프트 압박선 192MiB, 하드 한도 256MiB
echo "201326592" | sudo tee /sys/fs/cgroup/lab/memory.high
echo "268435456" | sudo tee /sys/fs/cgroup/lab/memory.max

# pids: 포크밤 방지
echo 128 | sudo tee /sys/fs/cgroup/lab/pids.max

# 현재 셸을 넣고 확인
echo $$ | sudo tee /sys/fs/cgroup/lab/cgroup.procs
cat /sys/fs/cgroup/lab/memory.current   # 현재 사용량
cat /sys/fs/cgroup/lab/cpu.stat         # usage, nr_throttled
cat /sys/fs/cgroup/lab/memory.events    # low/high/max/oom/oom_kill 횟수

# 메모리 압박의 정직한 지표: PSI
cat /sys/fs/cgroup/lab/memory.pressure
# some avg10=12.34 ... 일부 태스크가 메모리 대기에 시간을 씀
# full avg10=3.21  ... 모든 태스크가 동시에 막힘 (심각)

#!/bin/bash
# mini-container.sh — unshare + pivot_root + cgroup 결합
# 사전 준비: 루트FS (예: alpine 미니 루트FS를 풀어둔 디렉터리)
set -euo pipefail

ROOTFS=/opt/rootfs-alpine
CG=/sys/fs/cgroup/minic

# 1) cgroup 준비: 0.5 CPU, 256MiB, 프로세스 64개
mkdir -p "$CG"
echo "50000 100000" > "$CG/cpu.max"
echo "268435456"    > "$CG/memory.max"
echo 64             > "$CG/pids.max"

# 2) 네임스페이스 만들고 그 안에서 셋업 스크립트 실행
exec unshare --pid --fork --mount --uts --ipc --net bash -c '
  set -euo pipefail
  ROOTFS=/opt/rootfs-alpine

  # 2-1) 자신을 cgroup에 등록
  echo $$ > /sys/fs/cgroup/minic/cgroup.procs

  # 2-2) 호스트네임
  hostname minic

  # 2-3) 마운트 전파 차단 (호스트 오염 방지)
  mount --make-rprivate /

  # 2-4) pivot_root 준비: new_root는 마운트 포인트여야 함
  mount --bind "$ROOTFS" "$ROOTFS"
  cd "$ROOTFS"
  mkdir -p old_root

  # 2-5) 루트 교체. chroot와 달리 탈출이 어렵다
  pivot_root . old_root

  # 2-6) 새 루트 기준 필수 가상 파일시스템
  mount -t proc  proc  /proc
  mount -t tmpfs tmpfs /tmp

  # 2-7) 옛 루트 접근 차단
  umount -l /old_root
  rmdir /old_root

  # 2-8) 컨테이너의 init 실행
  exec /bin/sh
'

// minic.go — Go로 만드는 미니 컨테이너 (개념 검증용)
package main

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"syscall"
)

func main() {
	switch os.Args[1] {
	case "run": // 부모: 네임스페이스를 갖고 자기 자신을 재실행
		parent()
	case "child": // 자식: 새 네임스페이스 안에서 셋업
		child()
	default:
		panic("usage: minic run <cmd>")
	}
}

func parent() {
	cmd := exec.Command("/proc/self/exe",
		append([]string{"child"}, os.Args[2:]...)...)
	cmd.SysProcAttr = &syscall.SysProcAttr{
		Cloneflags: syscall.CLONE_NEWPID | syscall.CLONE_NEWNS |
			syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC |
			syscall.CLONE_NEWNET,
	}
	cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
	if err := cmd.Run(); err != nil {
		fmt.Println("error:", err)
		os.Exit(1)
	}
}

func child() {
	rootfs := "/opt/rootfs-alpine"

	// cgroup 등록 (v2 파일 인터페이스 그대로)
	cg := "/sys/fs/cgroup/minic"
	os.MkdirAll(cg, 0755)
	os.WriteFile(filepath.Join(cg, "memory.max"),
		[]byte("268435456"), 0644)
	os.WriteFile(filepath.Join(cg, "pids.max"), []byte("64"), 0644)
	os.WriteFile(filepath.Join(cg, "cgroup.procs"),
		[]byte(fmt.Sprint(os.Getpid())), 0644)

	syscall.Sethostname([]byte("minic"))

	// 마운트 전파 차단 + pivot_root
	syscall.Mount("", "/", "", syscall.MS_REC|syscall.MS_PRIVATE, "")
	syscall.Mount(rootfs, rootfs, "", syscall.MS_BIND, "")
	os.MkdirAll(rootfs+"/old_root", 0700)
	syscall.PivotRoot(rootfs, rootfs+"/old_root")
	os.Chdir("/")
	syscall.Mount("proc", "/proc", "proc", 0, "")
	syscall.Unmount("/old_root", syscall.MNT_DETACH)
	os.Remove("/old_root")

	// 사용자가 준 명령 실행
	cmd := exec.Command(os.Args[2], os.Args[3:]...)
	cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
	cmd.Run()
}

go build -o minic minic.go
sudo ./minic run /bin/sh
# 안에서: hostname -> minic, ps aux -> PID 1부터, ip link -> lo만

   컨테이너가 보는 파일시스템 (merged)
  +------------------------------------+
  |  /bin/sh   /etc/app.conf   /tmp/x  |
  +------------------------------------+
      ^ 합성된 단일 뷰
      |
  upperdir (쓰기 가능, 컨테이너 레이어)     <- 변경분만 기록
  +------------------------------------+
  |  /etc/app.conf (수정본)  /tmp/x     |
  +------------------------------------+
  lowerdir (읽기 전용, 이미지 레이어들)     <- 여러 개 중첩 가능
  +------------------------------------+
  |  layer3: 앱 바이너리                |
  |  layer2: 런타임/라이브러리           |
  |  layer1: 베이스 OS                  |
  +------------------------------------+

  - 읽기: 위에서부터 탐색, 가장 위의 파일이 이김
  - 쓰기: lowerdir 파일 수정 시 upperdir로 복사 후 수정 (copy-up)
  - 삭제: upperdir에 whiteout 마커 생성 (실제로는 안 지워짐)

# overlayfs 직접 실습
mkdir -p /tmp/ov/lower /tmp/ov/upper /tmp/ov/work /tmp/ov/merged
echo "from-image" > /tmp/ov/lower/base.txt
sudo mount -t overlay overlay \
  -o lowerdir=/tmp/ov/lower,upperdir=/tmp/ov/upper,workdir=/tmp/ov/work \
  /tmp/ov/merged

echo "modified" > /tmp/ov/merged/base.txt   # copy-up 발생
cat /tmp/ov/lower/base.txt                  # from-image (원본 보존)
cat /tmp/ov/upper/base.txt                  # modified (변경분)

# 현재 프로세스의 캡 확인
capsh --print
grep Cap /proc/self/status   # CapEff가 유효 캡 비트마스크
capsh --decode=00000000a80425fb   # 비트마스크 해독

# 파일에 캡 부여 (setuid root의 대안)
sudo setcap cap_net_bind_service=+ep ./myserver  # 80포트 바인드만 허용

# 쿠버네티스: 전부 버리고 필요한 것만 추가하는 것이 모범
securityContext:
  capabilities:
    drop: ["ALL"]
    add: ["NET_BIND_SERVICE"]
  allowPrivilegeEscalation: false

{
  "defaultAction": "SCMP_ACT_ERRNO",
  "architectures": ["SCMP_ARCH_X86_64"],
  "syscalls": [
    {
      "names": ["read", "write", "openat", "close", "fstat",
                 "mmap", "brk", "exit_group", "futex", "epoll_wait"],
      "action": "SCMP_ACT_ALLOW"
    }
  ]
}

# 프로세스의 seccomp 상태: 0 없음, 1 strict, 2 filter
grep Seccomp /proc/self/status

# 쿠버네티스에서 런타임 기본 프로파일 적용
# securityContext.seccompProfile.type: RuntimeDefault

  kubelet
    | CRI (gRPC)
    v
  containerd          이미지 풀/저장, 스냅샷(overlayfs), 컨테이너 라이프사이클
    | OCI 스펙 (config.json)
    v
  runc                이 글에서 다룬 모든 것의 실행자:
                      네임스페이스 생성, cgroup 설정, pivot_root,
                      capabilities 적용, seccomp 적재, 프로세스 exec
                      -- 실행 후에는 사라짐 (데몬 아님)

# 실행 중인 컨테이너의 OCI 설정 구경
sudo cat /run/containerd/io.containerd.runtime.v2.task/k8s.io/*/config.json \
  | jq '.linux.namespaces, .process.capabilities.effective' | head -30

stat -fc %T /sys/fs/cgroup    # cgroup2fs 면 v2

# 1) lsns: 호스트의 모든 네임스페이스 나열
lsns                       # 타입별 네임스페이스와 대표 PID
lsns -t net                # net 네임스페이스만

# 2) nsenter: 특정 프로세스의 네임스페이스로 진입
PID=$(pgrep -f my-app | head -1)
nsenter -t "$PID" -n ss -tlnp      # 그 컨테이너의 net ns에서 소켓 보기
nsenter -t "$PID" -m -p ps aux     # mnt+pid ns에서 프로세스 보기
nsenter -t "$PID" -a bash          # 전부 진입 (사실상 exec)
# 디버깅 도구가 없는 distroless 컨테이너도 nsenter로 조사 가능
# (바이너리는 호스트 것을 쓰면서 시야만 컨테이너로)

# 3) /proc에서 네임스페이스 ID 직접 비교
ls -l /proc/$$/ns/         # 각 ns의 inode 번호
ls -l /proc/"$PID"/ns/     # 같은 inode = 같은 네임스페이스

# 4) cgroup 경로 추적: 프로세스 -> cgroup -> 한도/사용량
cat /proc/"$PID"/cgroup    # cgroup 경로 확인
CG=/sys/fs/cgroup$(cut -d: -f3 /proc/"$PID"/cgroup)
cat "$CG/memory.current" "$CG/memory.max" "$CG/memory.events"
cat "$CG/cpu.stat" | grep -E "usage|throttled"
cat "$CG/memory.pressure" "$CG/cpu.pressure"   # PSI

# 5) OOM Kill 사후 분석
dmesg -T | grep -i -A5 "killed process"
journalctl -k | grep -i oom