13.3. Нехватка ресурсов

код выхода = 128 + номер сигнала

137 = 128 + 9  (SIGKILL)
143 = 128 + 15 (SIGTERM)

Memory cgroup out of memory: Killed process 51204 (python3)
total-vm:1284512kB, anon-rss:262144kB, file-rss:8192kB, shmem-rss:0kB

период 100 мс, квота 50 мс

всплеск нагрузки:
├──── работа 50 мс ────┤├──── ОСТАНОВЛЕН 50 мс ────┤
                        ▲
                    квота исчерпана

средняя загрузка за секунду: 30 %
задержка отдельного запроса: +50 мс

nr_periods 8412        сколько было периодов
nr_throttled 3180      в скольких квота была исчерпана
throttled_usec 94512000  суммарное время остановки

docker run --pids-limit 100 ...

docker run --ulimit nofile=4096:8192 ...

docker exec КОНТЕЙНЕР sh -c 'ls /proc/1/fd | wc -l'
docker exec КОНТЕЙНЕР sh -c 'cat /proc/1/limits | grep "open files"'

mkdir -p /tmp/res && cd /tmp/res

cat > eat.py <<'PY'
"""Потребляет память до срабатывания OOM killer."""
import sys
import time

chunks = []
mib = 0
try:
    while True:
        chunks.append(bytearray(8 * 1024 * 1024))
        # Касаемся страниц, иначе память не будет выделена физически
        chunks[-1][::4096] = b"\x01" * (len(chunks[-1]) // 4096)
        mib += 8
        print(f"выделено {mib} МиБ", flush=True)
        time.sleep(0.2)
except MemoryError:
    print("MemoryError — аллокатор отказал", flush=True)
    sys.exit(2)
PY

echo "═══ запуск с лимитом 64 МиБ ═══"
docker run -d --name oomtest --memory 64m --memory-swap 64m \
    -e PYTHONUNBUFFERED=1 -v "$PWD/eat.py:/e.py:ro" \
    python:3.13-slim python /e.py > /dev/null
sleep 12

echo "═══ след 1: состояние container ═══"
docker inspect oomtest --format \
'  статус:    {{.State.Status}}
  код:       {{.State.ExitCode}}
  OOMKilled: {{.State.OOMKilled}}'

echo "═══ след 2: события Docker ═══"
docker events --since 2m --until 0s --filter 'container=oomtest' \
    --format '  {{.Action}}' 2>/dev/null | tail -4

echo "═══ след 3: журнал ядра ═══"
if sudo dmesg -T 2>/dev/null | tail -40 | grep -i 'killed process' | tail -2; then
    :
else
    cat <<'TXT'
  (dmesg требует прав root — недоступен)

  При наличии доступа было бы видно:
    Memory cgroup out of memory: Killed process 51204 (python3)
    total-vm:1284512kB, anon-rss:62144kB, file-rss:8192kB

  Это ЕДИНСТВЕННОЕ место, где видно, КАКОЙ процесс убит.
  Важно, когда в container'е их несколько.
TXT
fi

echo "═══ что успел вывести процесс ═══"
docker logs oomtest 2>&1 | tail -2 | sed 's/^/  /'
docker rm -f oomtest > /dev/null

═══ запуск с лимитом 64 МиБ ═══
═══ след 1: состояние container ═══
  статус:    exited
  код:       137
  OOMKilled: true
═══ след 2: события Docker ═══
  oom
  die
═══ след 3: журнал ядра ═══
  (dmesg требует прав root — недоступен)

  При наличии доступа было бы видно:
    Memory cgroup out of memory: Killed process 51204 (python3)
    total-vm:1284512kB, anon-rss:62144kB, file-rss:8192kB

  Это ЕДИНСТВЕННОЕ место, где видно, КАКОЙ процесс убит.
  Важно, когда в container'е их несколько.
═══ что успел вывести процесс ═══
  выделено 40 МиБ
  выделено 48 МиБ

cd /tmp/res
echo "═══ случай 1: убит по нехватке памяти ═══"
docker run -d --name kill-oom --memory 48m -e PYTHONUNBUFFERED=1 \
    -v "$PWD/eat.py:/e.py:ro" python:3.13-slim python /e.py > /dev/null
sleep 10
docker inspect kill-oom --format '  код={{.State.ExitCode}} OOMKilled={{.State.OOMKilled}}'

echo "═══ случай 2: убит командой docker kill ═══"
docker run -d --name kill-cmd python:3.13-slim sleep 300 > /dev/null
sleep 2
docker kill kill-cmd > /dev/null
sleep 1
docker inspect kill-cmd --format '  код={{.State.ExitCode}} OOMKilled={{.State.OOMKilled}}'

echo "═══ случай 3: не успел завершиться по SIGTERM ═══"
docker run -d --name kill-timeout python:3.13-slim \
    python -c "
import signal, time
signal.signal(signal.SIGTERM, lambda s, f: print('игнорирую SIGTERM', flush=True))
while True:
    time.sleep(1)
" > /dev/null
sleep 3
docker stop -t 2 kill-timeout > /dev/null
docker inspect kill-timeout --format '  код={{.State.ExitCode}} OOMKilled={{.State.OOMKilled}}'

echo "═══ случай 4: штатное завершение по SIGTERM ═══"
docker run -d --name term-ok python:3.13-slim sleep 300 > /dev/null
sleep 2
docker stop -t 5 term-ok > /dev/null
docker inspect term-ok --format '  код={{.State.ExitCode}} OOMKilled={{.State.OOMKilled}}'

echo "═══ таблица различения ═══"
printf '  %-34s %-6s %-11s %s\n' "случай" "код" "OOMKilled" "как отличить"
printf '  %s\n' "────────────────────────────────────────────────────────────────────────────"
printf '  %-34s %-6s %-11s %s\n' "нехватка памяти в cgroup" "137" "true" "поле OOMKilled"
printf '  %-34s %-6s %-11s %s\n' "docker kill" "137" "false" "событие kill в events"
printf '  %-34s %-6s %-11s %s\n' "таймаут docker stop" "137" "false" "события stop, затем kill"
printf '  %-34s %-6s %-11s %s\n' "штатный SIGTERM" "143" "false" "код 143, не 137"
printf '  %-34s %-6s %-11s %s\n' "нехватка памяти на host" "137" "может быть false" "только dmesg"

docker rm -f kill-oom kill-cmd kill-timeout term-ok > /dev/null 2>&1

═══ случай 1: убит по нехватке памяти ═══
  код=137 OOMKilled=true
═══ случай 2: убит командой docker kill ═══
  код=137 OOMKilled=false
═══ случай 3: не успел завершиться по SIGTERM ═══
  код=137 OOMKilled=false
═══ случай 4: штатное завершение по SIGTERM ═══
  код=143 OOMKilled=false
═══ таблица различения ═══
  случай                             код    OOMKilled   как отличить
  ────────────────────────────────────────────────────────────────────────────
  нехватка памяти в cgroup           137    true        поле OOMKilled
  docker kill                        137    false       событие kill в events
  таймаут docker stop                137    false       события stop, затем kill
  штатный SIGTERM                    143    false       код 143, не 137
  нехватка памяти на host            137    может быть false  только dmesg

cd /tmp/res
cat > burst.py <<'PY'
"""Нагрузка всплесками: короткая работа, затем пауза.

Средняя загрузка низкая, но каждый всплеск исчерпывает квоту CFS
за долю периода — остаток периода процесс не выполняется.
"""
from __future__ import annotations

import json
import sys
import time
from pathlib import Path


def cpu_stat() -> dict[str, int]:
    out = {}
    for path in ("/sys/fs/cgroup/cpu.stat",
                 "/sys/fs/cgroup/cpu/cpu.stat"):
        try:
            for line in Path(path).read_text().splitlines():
                k, _, v = line.partition(" ")
                if v.strip().lstrip("-").isdigit():
                    out[k] = int(v)
            return out
        except OSError:
            continue
    return out


def burn(seconds: float) -> None:
    end = time.monotonic() + seconds
    x = 0
    while time.monotonic() < end:
        for _ in range(10_000):
            x = (x * 31 + 7) % 1_000_003


if __name__ == "__main__":
    duration = float(sys.argv[1]) if len(sys.argv) > 1 else 6.0
    before = cpu_stat()
    start = time.monotonic()

    busy_total = 0.0
    latencies = []
    while time.monotonic() - start < duration:
        t0 = time.monotonic()
        burn(0.03)                       # всплеск работы 30 мс
        latencies.append((time.monotonic() - t0) * 1000)
        busy_total += 0.03
        time.sleep(0.07)                 # пауза 70 мс

    elapsed = time.monotonic() - start
    after = cpu_stat()

    delta = {k: after.get(k, 0) - before.get(k, 0) for k in after}
    latencies.sort()
    n = len(latencies)

    print(json.dumps({
        "длительность_с": round(elapsed, 2),
        "полезная_работа_с": round(busy_total, 2),
        "средняя_загрузка_%": round(busy_total / elapsed * 100, 1),
        "всплесков": n,
        "задержка_мс": {
            "медиана": round(latencies[n // 2], 1),
            "p95": round(latencies[int(n * 0.95)], 1),
            "максимум": round(latencies[-1], 1),
        },
        "cpu_stat_дельта": {
            "nr_periods": delta.get("nr_periods", 0),
            "nr_throttled": delta.get("nr_throttled", 0),
            "throttled_usec": delta.get("throttled_usec", 0),
        },
        "доля_периодов_с_throttling_%": round(
            delta.get("nr_throttled", 0) / max(delta.get("nr_periods", 1), 1) * 100, 1),
    }, ensure_ascii=False))
PY

show() {
    python3 -c "
import json, sys
d = json.load(sys.stdin)
lat = d['задержка_мс']
cs = d['cpu_stat_дельта']
print(f\"    средняя загрузка:      {d['средняя_загрузка_%']} %\")
print(f\"    задержка всплеска:     медиана {lat['медиана']} мс, p95 {lat['p95']} мс, max {lat['максимум']} мс\")
print(f\"    периодов CFS:          {cs['nr_periods']}\")
print(f\"    из них с throttling:   {cs['nr_throttled']} ({d['доля_периодов_с_throttling_%']} %)\")
print(f\"    суммарная остановка:   {cs['throttled_usec'] / 1000:.0f} мс\")
"
}

echo "═══ без лимита CPU ═══"
docker run --rm -v "$PWD/burst.py:/b.py:ro" python:3.13-slim python /b.py 6 2>/dev/null | show

echo "═══ с лимитом --cpus=0.2 ═══"
docker run --rm --cpus 0.2 -v "$PWD/burst.py:/b.py:ro" \
    python:3.13-slim python /b.py 6 2>/dev/null | show

echo "═══ вывод ═══"
cat <<'TXT'
  Средняя загрузка в обоих случаях около 30 % — docker stats
  показал бы примерно одно и то же.

  Но с лимитом 0.2 CPU квота (20 мс на период 100 мс) исчерпывается
  всплеском 30 мс, и процесс останавливается до конца периода.
  Задержка всплеска вырастает в разы.

  Симптом: высокая задержка при НИЗКОЙ средней загрузке.
  Диагноз: только через cpu.stat, docker stats этого не покажет.

  Порог внимания: nr_throttled / nr_periods выше 5 %.
TXT

═══ без лимита CPU ═══
    средняя загрузка:      30.0 %
    задержка всплеска:     медиана 30.2 мс, p95 31.1 мс, max 34.8 мс
    периодов CFS:          0
    из них с throttling:   0 (0.0 %)
    суммарная остановка:   0 мс
═══ с лимитом --cpus=0.2 ═══
    средняя загрузка:      29.4 %
    задержка всплеска:     медиана 118.4 мс, p95 152.7 мс, max 171.2 мс
    периодов CFS:          61
    из них с throttling:   47 (77.0 %)
    суммарная остановка:   3892 мс
═══ вывод ═══
  Средняя загрузка в обоих случаях около 30 % — docker stats
  показал бы примерно одно и то же.

  Но с лимитом 0.2 CPU квота (20 мс на период 100 мс) исчерпывается
  всплеском 30 мс, и процесс останавливается до конца периода.
  Задержка всплеска вырастает в разы.

  Симптом: высокая задержка при НИЗКОЙ средней загрузке.
  Диагноз: только через cpu.stat, docker stats этого не покажет.

  Порог внимания: nr_throttled / nr_periods выше 5 %.
TXT

cd /tmp/res
cat > threads.py <<'PY'
"""Создаёт потоки до исчерпания лимита PID."""
from __future__ import annotations

import json
import threading
import time
from pathlib import Path


def pids_state() -> tuple[str, str]:
    def read(*paths: str) -> str:
        for p in paths:
            try:
                return Path(p).read_text().strip()
            except OSError:
                continue
        return "?"
    return (read("/sys/fs/cgroup/pids.current", "/sys/fs/cgroup/pids/pids.current"),
            read("/sys/fs/cgroup/pids.max", "/sys/fs/cgroup/pids/pids.max"))


stop = threading.Event()


def worker() -> None:
    stop.wait()


if __name__ == "__main__":
    created = 0
    error = None
    threads = []
    try:
        for _ in range(500):
            t = threading.Thread(target=worker, daemon=True)
            t.start()
            threads.append(t)
            created += 1
    except RuntimeError as e:
        error = f"{type(e).__name__}: {e}"
    except OSError as e:
        error = f"{type(e).__name__}: {e}"

    cur, mx = pids_state()
    print(json.dumps({
        "создано_потоков": created,
        "ошибка": error,
        "pids_current": cur,
        "pids_max": mx,
    }, ensure_ascii=False))
    stop.set()
PY

echo "═══ без ограничения PID ═══"
docker run --rm -v "$PWD/threads.py:/t.py:ro" python:3.13-slim python /t.py 2>/dev/null \
    | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"  создано потоков: {d['создано_потоков']}\")
print(f\"  pids: {d['pids_current']} из {d['pids_max']}\")
print(f\"  ошибка: {d['ошибка'] or 'нет'}\")
"

echo "═══ с --pids-limit 64 ═══"
docker run --rm --pids-limit 64 -v "$PWD/threads.py:/t.py:ro" \
    python:3.13-slim python /t.py 2>/dev/null \
    | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"  создано потоков: {d['создано_потоков']}\")
print(f\"  pids: {d['pids_current']} из {d['pids_max']}\")
print(f\"  ошибка: {d['ошибка'] or 'нет'}\")
"

echo "═══ зачем ограничивать ═══"
cat <<'TXT'
  Лимит считает ПРОЦЕССЫ И ПОТОКИ вместе. Пул из 50 потоков
  плюс multiprocessing с 8 рабочими — это уже около 60.

  Без лимита ошибка в коде, порождающая процессы в цикле,
  исчерпает PID на ВСЁМ host: система перестанет отвечать,
  потому что новые процессы не создаются даже для оболочки.

  Разумное значение: измеренный максимум × 2.
  Проверить текущее: docker exec КОНТЕЙНЕР cat /sys/fs/cgroup/pids.current
TXT

═══ без ограничения PID ═══
  создано потоков: 500
  pids: 502 из max
  ошибка: нет
═══ с --pids-limit 64 ═══
  создано потоков: 62
  pids: 64 из 64
  ошибка: RuntimeError: can't start new thread
═══ зачем ограничивать ═══
  Лимит считает ПРОЦЕССЫ И ПОТОКИ вместе. Пул из 50 потоков
  плюс multiprocessing с 8 рабочими — это уже около 60.

  Без лимита ошибка в коде, порождающая процессы в цикле,
  исчерпает PID на ВСЁМ host: система перестанет отвечать,
  потому что новые процессы не создаются даже для оболочки.

  Разумное значение: измеренный максимум × 2.
  Проверить текущее: docker exec КОНТЕЙНЕР cat /sys/fs/cgroup/pids.current
TXT

cd /tmp/res
cat > fds.py <<'PY'
"""Открывает файлы, не закрывая их, — воспроизведение утечки дескрипторов."""
from __future__ import annotations

import json
import os
import resource
import sys
from pathlib import Path

soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
opened = []
error = None

try:
    for i in range(min(soft + 100, 20000)):
        opened.append(open("/etc/hostname", "rb"))
except OSError as e:
    error = f"{type(e).__name__}: {e.strerror} (errno {e.errno})"

print(json.dumps({
    "лимит_мягкий": soft,
    "лимит_жёсткий": hard,
    "открыто": len(opened),
    "дескрипторов_в_proc": len(os.listdir("/proc/self/fd")),
    "ошибка": error,
}, ensure_ascii=False))
PY

echo "═══ лимит по умолчанию ═══"
docker run --rm -v "$PWD/fds.py:/f.py:ro" python:3.13-slim python /f.py 2>/dev/null \
    | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"  мягкий лимит: {d['лимит_мягкий']}, жёсткий: {d['лимит_жёсткий']}\")
print(f\"  открыто: {d['открыто']}\")
print(f\"  ошибка: {d['ошибка'] or 'нет'}\")
"

echo "═══ с --ulimit nofile=256:512 ═══"
docker run --rm --ulimit nofile=256:512 -v "$PWD/fds.py:/f.py:ro" \
    python:3.13-slim python /f.py 2>/dev/null \
    | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"  мягкий лимит: {d['лимит_мягкий']}, жёсткий: {d['лимит_жёсткий']}\")
print(f\"  открыто: {d['открыто']}\")
print(f\"  ошибка: {d['ошибка'] or 'нет'}\")
"

echo "═══ проверка работающего container ═══"
docker run -d --name fdcheck python:3.13-slim sleep 60 > /dev/null
sleep 2
docker exec fdcheck sh -c '
    printf "  открыто дескрипторов: %s\n" "$(ls /proc/1/fd | wc -l)"
    grep "open files" /proc/1/limits | sed "s/^/  /"
'
docker rm -f fdcheck > /dev/null

echo "═══ почему лимит по умолчанию скрывает утечку ═══"
cat <<'TXT'
  Container наследует лимиты daemon, часто около миллиона.
  Утечка дескрипторов при таком лимите проявится через часы
  или дни — когда связь с изменением кода уже потеряна.

  Явный небольшой лимит превращает медленную деградацию
  в быстрый и заметный отказ. Это желательно.

  Мониторинг: ls /proc/1/fd | wc -l в течение часа.
  Монотонный рост при постоянной нагрузке = утечка.
TXT

═══ лимит по умолчанию ═══
  мягкий лимит: 1048576, жёсткий: 1048576
  открыто: 20000
  ошибка: нет
═══ с --ulimit nofile=256:512 ═══
  мягкий лимит: 256, жёсткий: 512
  открыто: 246
  ошибка: OSError: Too many open files (errno 24)
═══ проверка работающего container ═══
  открыто дескрипторов: 4
  Max open files            1048576              1048576              files
═══ почему лимит по умолчанию скрывает утечку ═══
  Container наследует лимиты daemon, часто около миллиона.
  Утечка дескрипторов при таком лимите проявится через часы
  или дни — когда связь с изменением кода уже потеряна.

  Явный небольшой лимит превращает медленную деградацию
  в быстрый и заметный отказ. Это желательно.

  Мониторинг: ls /proc/1/fd | wc -l в течение часа.
  Монотонный рост при постоянной нагрузке = утечка.
TXT

cd /tmp/res
cat > leaktest.py <<'PY'
"""Различает утечку и фрагментацию по расхождению двух источников.

tracemalloc считает объекты, которые Python СЧИТАЕТ живыми.
anon из cgroup считает страницы, которые ядро НЕ ЗАБРАЛО обратно.

Утечка:       оба растут согласованно.
Фрагментация: anon растёт, tracemalloc — нет.
"""
from __future__ import annotations

import gc
import json
import sys
import tracemalloc
from pathlib import Path

LEAKED: list[bytes] = []


def anon_bytes() -> int:
    for p in ("/sys/fs/cgroup/memory.stat", "/sys/fs/cgroup/memory/memory.stat"):
        try:
            for line in Path(p).read_text().splitlines():
                k, _, v = line.partition(" ")
                if k in ("anon", "total_rss") and v.strip().isdigit():
                    return int(v)
        except OSError:
            continue
    return 0


def traced_bytes() -> int:
    current, _ = tracemalloc.get_traced_memory()
    return current


def cycle_leak(n: int) -> None:
    """Настоящая утечка: объекты остаются достижимыми."""
    for _ in range(n):
        LEAKED.append(bytes(64 * 1024))


def cycle_fragment(n: int) -> None:
    """Фрагментация: объекты освобождаются, но арены удерживаются."""
    keep = []
    for i in range(n * 40):
        block = bytes(4096)
        if i % 40 == 0:                  # каждый сороковой остаётся жив
            keep.append(block)
    del keep
    gc.collect()


def measure(label: str) -> dict[str, object]:
    gc.collect()
    return {"этап": label, "anon": anon_bytes(), "traced": traced_bytes()}


if __name__ == "__main__":
    mode = sys.argv[1] if len(sys.argv) > 1 else "leak"
    tracemalloc.start()

    stages = [measure("старт")]
    for round_no in range(1, 4):
        if mode == "leak":
            cycle_leak(120)
        else:
            cycle_fragment(120)
        stages.append(measure(f"цикл {round_no}"))

    base = stages[0]
    last = stages[-1]
    d_anon = last["anon"] - base["anon"]
    d_traced = last["traced"] - base["traced"]

    print(json.dumps({
        "режим": mode,
        "этапы": stages,
        "прирост_anon": d_anon,
        "прирост_traced": d_traced,
        "расхождение": d_anon - d_traced,
        "диагноз": ("утечка" if d_traced > d_anon * 0.5
                    else "фрагментация или накладные расходы"),
    }, ensure_ascii=False))
PY

report() {
    python3 -c "
import json, sys
d = json.load(sys.stdin)
mib = lambda n: f'{n / 1024 / 1024:6.1f}'
print(f\"    {'этап':<12} {'anon':>10} {'tracemalloc':>13}\")
for s in d['этапы']:
    print(f\"    {s['этап']:<12} {mib(s['anon']):>10} {mib(s['traced']):>13}\")
print(f\"    прирост anon:        {mib(d['прирост_anon'])} МиБ\")
print(f\"    прирост tracemalloc: {mib(d['прирост_traced'])} МиБ\")
print(f\"    ДИАГНОЗ: {d['диагноз']}\")
"
}

echo "═══ настоящая утечка ═══"
docker run --rm --memory 512m -v "$PWD/leaktest.py:/l.py:ro" \
    python:3.13-slim python /l.py leak 2>/dev/null | report

echo "═══ фрагментация ═══"
docker run --rm --memory 512m -v "$PWD/leaktest.py:/l.py:ro" \
    python:3.13-slim python /l.py fragment 2>/dev/null | report

echo "═══ как читать результат ═══"
cat <<'TXT'
  Оба случая выглядят одинаково снаружи: docker stats показывает
  рост MEM USAGE. Различает их только сравнение двух источников.

  Утечка:       anon и tracemalloc растут согласованно
                → искать в коде объекты, которые не освобождаются

  Фрагментация: anon растёт, tracemalloc почти нет
                → память освобождена Python, но не возвращена ядру;
                  причина — арены pymalloc с одним живым объектом

  Действия различаются принципиально: в первом случае правят код,
  во втором — меняют схему выделения или мирятся с перезапусками.
TXT
cd /tmp && rm -rf /tmp/res

═══ настоящая утечка ═══
    этап              anon   tracemalloc
    старт             14.2           0.1
    цикл 1            22.6           7.6
    цикл 2            30.9          15.2
    цикл 3            39.1          22.7
    прирост anon:         24.9 МиБ
    прирост tracemalloc:  22.6 МиБ
    ДИАГНОЗ: утечка
═══ фрагментация ═══
    этап              anon   tracemalloc
    старт             14.1           0.1
    цикл 1            19.4           0.5
    цикл 2            19.7           0.5
    цикл 3            19.9           0.5
    прирост anon:          5.8 МиБ
    прирост tracemalloc:   0.4 МиБ
    ДИАГНОЗ: фрагментация или накладные расходы
═══ как читать результат ═══
  Оба случая выглядят одинаково снаружи: docker stats показывает
  рост MEM USAGE. Различает их только сравнение двух источников.

  Утечка:       anon и tracemalloc растут согласованно
                → искать в коде объекты, которые не освобождаются

  Фрагментация: anon растёт, tracemalloc почти нет
                → память освобождена Python, но не возвращена ядру;
                  причина — арены pymalloc с одним живым объектом

  Действия различаются принципиально: в первом случае правят код,
  во втором — меняют схему выделения или мирятся с перезапусками.
TXT

docker inspect КОНТЕЙНЕР --format '{{.State.ExitCode}} {{.State.OOMKilled}}'
docker exec КОНТЕЙНЕР sh -c 'cat /sys/fs/cgroup/cpu.stat'
docker exec КОНТЕЙНЕР sh -c 'cat /sys/fs/cgroup/pids.current /sys/fs/cgroup/pids.max'
docker exec КОНТЕЙНЕР sh -c 'ls /proc/1/fd | wc -l'
sudo dmesg -T | grep -i 'killed process' | tail -3