17.3. Namespaces: углублённо

mkdir -p /tmp/nslab && cd /tmp/nslab

cat > nsinspect.py <<'PY'
"""Разбор namespaces процесса и сравнение с host."""
from __future__ import annotations

import json
import os
import subprocess
import sys
from pathlib import Path

TYPES = ("mnt", "uts", "ipc", "pid", "net", "user", "cgroup", "time")

DESCRIPTIONS = {
    "mnt": "точки монтирования",
    "uts": "имя хоста и домена",
    "ipc": "очереди, семафоры, разделяемая память",
    "pid": "пространство идентификаторов процессов",
    "net": "интерфейсы, маршруты, порты",
    "user": "отображение UID и GID, capabilities",
    "cgroup": "корень иерархии cgroups",
    "time": "смещение монотонных часов",
}


def ns_link(pid: str | int, kind: str) -> str | None:
    try:
        return os.readlink(Path(f"/proc/{pid}/ns/{kind}"))
    except OSError:
        return None


def container_pid(name: str) -> int:
    out = subprocess.run(
        ["docker", "inspect", name, "--format", "{{.State.Pid}}"],
        capture_output=True, text=True).stdout.strip()
    return int(out) if out.isdigit() else 0


def compare(name: str) -> dict[str, object]:
    pid = container_pid(name)
    rows = []
    isolated = shared = unknown = 0
    for kind in TYPES:
        host = ns_link("self", kind)
        cont = ns_link(pid, kind)
        if host is None or cont is None:
            state = "неизвестно"
            unknown += 1
        elif host == cont:
            state = "общий"
            shared += 1
        else:
            state = "изолирован"
            isolated += 1
        rows.append({"тип": kind, "host": host, "container": cont,
                     "состояние": state})
    return {"pid": pid, "строки": rows, "изолировано": isolated,
            "общих": shared, "неизвестно": unknown}


def main(name: str) -> int:
    result = compare(name)
    print(f"  PID container'а: {result['pid']}\n")
    print(f"  {'тип':<8} {'состояние':<12} {'что изолирует':<40} inode")
    print("  " + "─" * 86)
    for row in result["строки"]:
        cont = row["container"] or "—"
        inode = cont.split("[")[-1].rstrip("]") if "[" in cont else cont
        print(f"  {row['тип']:<8} {row['состояние']:<12} "
              f"{DESCRIPTIONS[row['тип']]:<40} {inode}")

    print()
    print(f"  изолировано: {result['изолировано']}, "
          f"общих с host: {result['общих']}, "
          f"неизвестно: {result['неизвестно']}")

    not_created = [r["тип"] for r in result["строки"] if r["состояние"] == "общий"]
    if not_created:
        print(f"  НЕ созданы: {', '.join(not_created)}")
        if "user" in not_created:
            print("    user → UID внутри и снаружи совпадают ([урок 12.3])")
        if "time" in not_created:
            print("    time → uptime container'а совпадает с host")

    print()
    print(json.dumps({
        "изолировано": result["изолировано"],
        "общих": result["общих"],
        "не_созданы": not_created,
    }, ensure_ascii=False))
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv[1] if len(sys.argv) > 1 else "nslab-demo"))
PY

cat > manual-env.sh <<'SH'
#!/usr/bin/env bash
# Изолированное окружение без Docker.
set -uo pipefail

ROOTFS="${1:-./rootfs}"

if [ ! -d "$ROOTFS" ] || [ -z "$(ls -A "$ROOTFS" 2>/dev/null)" ]; then
    mkdir -p "$ROOTFS"
    cid="$(docker create alpine:3.21 true)"
    docker export "$cid" | tar -x -C "$ROOTFS" 2>/dev/null
    docker rm "$cid" > /dev/null
fi

unshare --user --map-root-user --pid --fork --mount --uts --ipc \
    sh -c '
    hostname manual-env 2>/dev/null || true
    printf "%s\n" "hostname=$(hostname)"
    printf "%s\n" "pid=$$"
    printf "%s\n" "uid=$(id -u)"
    printf "%s\n" "uid_map=$(tr -s " " < /proc/self/uid_map | tr -d "\n")"
    for kind in mnt uts ipc pid net user cgroup; do
        printf "%s\n" "ns_${kind}=$(readlink /proc/self/ns/$kind 2>/dev/null || echo none)"
    done
' 2>/dev/null
SH
chmod +x manual-env.sh

fail=0
ok()  { printf '  ✓ %s\n' "$1"; }
bad() { printf '  ✗ %s\n' "$1"; fail=1; }

printf '\n═══ Подготовка ═══\n'
docker rm -f nslab-demo nslab-shared > /dev/null 2>&1
docker run -d --name nslab-demo alpine:3.21 sleep 300 > /dev/null
sleep 2
printf '    container запущен\n'

printf '\n═══ Требование 1: какие namespaces создаёт Docker ═══\n'
python3 nsinspect.py nslab-demo > ns.log 2>&1
sed -n '1,/^  {/p' ns.log | head -18
summary="$(tail -1 ns.log)"
isolated="$(echo "$summary" | python3 -c "import json,sys; print(json.load(sys.stdin)['изолировано'])")"
not_created="$(echo "$summary" | python3 -c "
import json,sys; print(','.join(json.load(sys.stdin)['не_созданы']))")"
printf '  изолировано: %s, не созданы: %s\n' "$isolated" "$not_created"
[ "${isolated:-0}" -ge 5 ] \
    && ok "Docker создаёт шесть namespaces; user общий с хостом" \
    || bad "изолировано: $isolated"

printf '\n═══ Требование 2: карта UID ═══\n'
uid_map="$(docker exec nslab-demo cat /proc/self/uid_map | tr -s ' ')"
printf '    uid_map: %s\n' "$uid_map"
python3 - <<'PY'
import subprocess

raw = subprocess.run(["docker", "exec", "nslab-demo", "cat", "/proc/self/uid_map"],
                     capture_output=True, text=True).stdout.split()
if len(raw) >= 3:
    inside, outside, count = map(int, raw[:3])
    print(f"    UID {inside} внутри → UID {outside} снаружи, диапазон {count}")
    if inside == outside == 0 and count > 2 ** 31:
        print("    Полное тождество: отображения НЕТ.")
PY

mkdir -p shared
docker run --rm -v "$PWD/shared:/data" alpine:3.21 \
    sh -c 'touch /data/probe; echo "    внутри uid=$(id -u)"' 2>/dev/null
owner="$(ls -ln shared/probe | awk '{print $3}')"
printf '    снаружи владелец uid=%s\n' "$owner"
rm -rf shared
[ "$owner" = "0" ] \
    && ok "файл от root внутри принадлежит root снаружи — отображения нет" \
    || bad "владелец: $owner"

printf '\n═══ Требование 3: clone, unshare, setns ═══\n'
python3 - <<'PY'
CALLS = [
    ("clone(CLONE_NEW*)", "создаёт НОВЫЙ процесс сразу в новых namespaces",
     "runc при запуске container'а",
     "новый процесс становится PID 1 в новом PID namespace"),
    ("unshare(CLONE_NEW*)", "переводит ТЕКУЩИЙ процесс в новые namespaces",
     "утилита unshare",
     "для PID: текущий процесс ОСТАЁТСЯ в старом namespace"),
    ("setns(fd, type)", "помещает текущий процесс в СУЩЕСТВУЮЩИЙ namespace",
     "nsenter, docker exec",
     "для PID: переходят потомки, а не сам процесс"),
]
print(f"    {'вызов':<22} {'что делает':<48} кто применяет")
print("    " + "─" * 96)
for call, what, who, _ in CALLS:
    print(f"    {call:<22} {what:<48} {who}")
print()
print("    Особенность PID namespace:")
for call, _, _, note in CALLS:
    print(f"      {call:<22} {note}")
print()
print("    Отсюда: unshare --pid БЕЗ --fork даёт процесс, который сам")
print("    остаётся снаружи, а ps показывает не то, что ожидается.")
print("    Правильно: unshare --pid --fork --mount-proc")
PY
ok "различие трёх вызовов объяснено через поведение PID namespace"

printf '\n═══ Требование 4: окружение вручную ═══\n'
if ./manual-env.sh ./rootfs > manual.log 2>&1 && [ -s manual.log ]; then
    python3 - <<'PY'
from pathlib import Path

data = {}
for line in Path("manual.log").read_text().splitlines():
    if "=" in line:
        k, _, v = line.partition("=")
        data[k] = v

print(f"    hostname внутри: {data.get('hostname', '—')}")
print(f"    PID внутри:      {data.get('pid', '—')}")
print(f"    uid внутри:      {data.get('uid', '—')}")
print(f"    uid_map:         {data.get('uid_map', '—')}")
print()
print("    namespaces созданного окружения:")
import os
for kind in ("mnt", "uts", "ipc", "pid", "net", "user", "cgroup"):
    inner = data.get(f"ns_{kind}", "—")
    try:
        outer = os.readlink(f"/proc/self/ns/{kind}")
    except OSError:
        outer = "—"
    state = "общий с host" if inner == outer else "изолирован"
    print(f"      {kind:<8} {state}")
PY
    manual_ok=1
else
    echo "    создание namespaces НЕ УДАЛОСЬ"
    echo "    (может быть запрещено: sysctl kernel.unprivileged_userns_clone)"
    manual_ok=0
fi

printf '\n    Чего НЕТ в ручном окружении по сравнению с Docker:\n'
python3 - <<'PY'
MISSING = [
    ("cgroups", "ограничения памяти, CPU и PID не настроены"),
    ("pivot_root", "корень не подменён; видна файловая система host"),
    ("seccomp", "фильтр системных вызовов не применён"),
    ("сеть", "интерфейсы, адреса и маршруты не настроены"),
    ("capabilities", "набор не сокращён"),
    ("образы и слои", "нет управления содержимым файловой системы"),
]
for name, note in MISSING:
    print(f"      {name:<16} {note}")
print()
print("    Docker — оркестровка этих механизмов, а не отдельная технология.")
print("    Всё, что он делает, делается системными вызовами ядра.")
PY
[ "${manual_ok:-0}" -eq 1 ] \
    && ok "окружение создано вручную; перечислено, чего в нём нет" \
    || ok "создание namespaces недоступно — отмечено; перечень приведён"

printf '\n═══ Требование 5: --network container: даёт ТОТ ЖЕ namespace ═══\n'
docker run -d --name nslab-shared --network "container:nslab-demo" \
    alpine:3.21 sleep 60 > /dev/null
sleep 2
pid1="$(docker inspect nslab-demo --format '{{.State.Pid}}')"
pid2="$(docker inspect nslab-shared --format '{{.State.Pid}}')"
net1="$(readlink "/proc/$pid1/ns/net" 2>/dev/null || echo '?')"
net2="$(readlink "/proc/$pid2/ns/net" 2>/dev/null || echo '?')"
mnt1="$(readlink "/proc/$pid1/ns/mnt" 2>/dev/null || echo '?')"
mnt2="$(readlink "/proc/$pid2/ns/mnt" 2>/dev/null || echo '?')"
printf '    %-12s %-24s %-24s совпадает\n' "тип" "nslab-demo" "nslab-shared"
printf '    %s\n' "──────────────────────────────────────────────────────────────────────"
printf '    %-12s %-24s %-24s %s\n' "net" "$net1" "$net2" \
    "$([ "$net1" = "$net2" ] && echo ДА || echo нет)"
printf '    %-12s %-24s %-24s %s\n' "mnt" "$mnt1" "$mnt2" \
    "$([ "$mnt1" = "$mnt2" ] && echo ДА || echo нет)"
printf '\n    Сетевой namespace ОБЩИЙ, файловая система — своя.\n'
printf '    Это и делает sidecar рабочим приёмом ([урок 13.5]).\n'
[ "$net1" = "$net2" ] && [ "$mnt1" != "$mnt2" ] \
    && ok "тот же сетевой namespace, разные mount namespace" \
    || bad "net: $net1 / $net2, mnt: $mnt1 / $mnt2"

printf '\n═══ Требование 6: что не выполнялось ═══\n'
python3 - <<'PY'
import shutil
import subprocess
from pathlib import Path

def has_sudo() -> bool:
    return subprocess.run(["sudo", "-n", "true"], capture_output=True).returncode == 0

def userns_allowed() -> bool:
    return subprocess.run(
        ["unshare", "--user", "--map-root-user", "true"],
        capture_output=True).returncode == 0

CHECKS = [
    ("nsenter -t PID -n с утилитой host", shutil.which("nsenter") and has_sudo(),
     "нужен nsenter и права root"),
    ("nsenter -t PID -m -n (отказ в distroless)", shutil.which("nsenter") and has_sudo(),
     "то же"),
    ("создание namespaces непривилегированным", userns_allowed(),
     "может быть запрещено настройкой ядра"),
    ("pivot_root в ручном окружении", has_sudo(),
     "требует CAP_SYS_ADMIN"),
]
print(f"    {'проверка':<42} {'выполнена':<12} причина")
print("    " + "─" * 92)
not_run = 0
for name, done, why in CHECKS:
    if not done:
        not_run += 1
    print(f"    {name:<42} {'да' if done else 'НЕТ':<12} {'' if done else why}")
print(f"\n    не выполнено: {not_run} из {len(CHECKS)}")
PY
ok "невыполненные проверки перечислены с причиной"

printf '\n═══ ИТОГ ═══\n'
[ "$fail" -eq 0 ] && echo "  все требования выполнены" || echo "  ЕСТЬ ПРОВАЛЫ"

docker rm -f nslab-demo nslab-shared > /dev/null 2>&1
cd /tmp && rm -rf /tmp/nslab
exit "$fail"

═══ Подготовка ═══
    container запущен

═══ Требование 1: какие namespaces создаёт Docker ═══
  PID container'а: 53412

  тип      состояние    что изолирует                            inode
  ──────────────────────────────────────────────────────────────────────────────────────
  mnt      изолирован   точки монтирования                       4026532567
  uts      изолирован   имя хоста и домена                       4026532568
  ipc      изолирован   очереди, семафоры, разделяемая память    4026532569
  pid      изолирован   пространство идентификаторов процессов   4026532571
  net      изолирован   интерфейсы, маршруты, порты              4026532574
  user     общий        отображение UID и GID, capabilities      4026531837
  cgroup   изолирован   корень иерархии cgroups                  4026532570
  time     общий        смещение монотонных часов                4026531834

  изолировано: 6, общих с host: 2, неизвестно: 0
  НЕ созданы: user, time
    user → UID внутри и снаружи совпадают ([урок 12.3])
    time → uptime container'а совпадает с host

  изолировано: 6, не созданы: user,time
  ✓ Docker создаёт шесть namespaces; user общий с хостом

═══ Требование 2: карта UID ═══
    uid_map:  0 0 4294967295
    UID 0 внутри → UID 0 снаружи, диапазон 4294967295
    Полное тождество: отображения НЕТ.
    внутри uid=0
    снаружи владелец uid=0
  ✓ файл от root внутри принадлежит root снаружи — отображения нет

═══ Требование 3: clone, unshare, setns ═══
    вызов                  что делает                                       кто применяет
    ────────────────────────────────────────────────────────────────────────────────────────────────
    clone(CLONE_NEW*)      создаёт НОВЫЙ процесс сразу в новых namespaces   runc при запуске container'а
    unshare(CLONE_NEW*)    переводит ТЕКУЩИЙ процесс в новые namespaces     утилита unshare
    setns(fd, type)        помещает текущий процесс в СУЩЕСТВУЮЩИЙ namespace nsenter, docker exec

    Особенность PID namespace:
      clone(CLONE_NEW*)      новый процесс становится PID 1 в новом PID namespace
      unshare(CLONE_NEW*)    для PID: текущий процесс ОСТАЁТСЯ в старом namespace
      setns(fd, type)        для PID: переходят потомки, а не сам процесс

    Отсюда: unshare --pid БЕЗ --fork даёт процесс, который сам
    остаётся снаружи, а ps показывает не то, что ожидается.
    Правильно: unshare --pid --fork --mount-proc
  ✓ различие трёх вызовов объяснено через поведение PID namespace

═══ Требование 4: окружение вручную ═══
    hostname внутри: manual-env
    PID внутри:      1
    uid внутри:      0
    uid_map:         0 1000 1

    namespaces созданного окружения:
      mnt      изолирован
      uts      изолирован
      ipc      изолирован
      pid      изолирован
      net      общий с host
      user     изолирован
      cgroup   общий с host

    Чего НЕТ в ручном окружении по сравнению с Docker:
      cgroups          ограничения памяти, CPU и PID не настроены
      pivot_root       корень не подменён; видна файловая система host
      seccomp          фильтр системных вызовов не применён
      сеть             интерфейсы, адреса и маршруты не настроены
      capabilities     набор не сокращён
      образы и слои    нет управления содержимым файловой системы

    Docker — оркестровка этих механизмов, а не отдельная технология.
    Всё, что он делает, делается системными вызовами ядра.
  ✓ окружение создано вручную; перечислено, чего в нём нет

═══ Требование 5: --network container: даёт ТОТ ЖЕ namespace ═══
    тип          nslab-demo               nslab-shared             совпадает
    ──────────────────────────────────────────────────────────────────────
    net          net:[4026532574]         net:[4026532574]         ДА
    mnt          mnt:[4026532567]         mnt:[4026532601]         нет

    Сетевой namespace ОБЩИЙ, файловая система — своя.
    Это и делает sidecar рабочим приёмом ([урок 13.5]).
  ✓ тот же сетевой namespace, разные mount namespace

═══ Требование 6: что не выполнялось ═══
    проверка                                   выполнена    причина
    ────────────────────────────────────────────────────────────────────────────────────────────
    nsenter -t PID -n с утилитой host          НЕТ          нужен nsenter и права root
    nsenter -t PID -m -n (отказ в distroless)  НЕТ          то же
    создание namespaces непривилегированным    да           
    pivot_root в ручном окружении              НЕТ          требует CAP_SYS_ADMIN

    не выполнено: 3 из 4
  ✓ невыполненные проверки перечислены с причиной

═══ ИТОГ ═══
  все требования выполнены