11.4. Resource limits и память Python

Утечка            Фрагментация          Кэш / рост нагрузки
──────            ────────────          ───────────────────
  │      ╱          │    ╱‾‾‾‾            │   ╱‾╲   ╱‾╲
  │    ╱            │  ╱                  │  ╱   ╲_╱   ╲
  │  ╱              │╱                    │ ╱
  └────────         └────────             └────────
рост линейный,     рост до плато,        рост коррелирует
не останавливается затем стабильно       с нагрузкой, падает

по CPU:     workers_cpu = 2 × cpu_limit + 1
по памяти:  workers_mem = (memory_limit × 0.7) / rss_per_worker
итог:       workers = max(1, min(workers_cpu, workers_mem))

узел: 16 GiB
сервисы: 10 × (limit 2 GiB) = 20 GiB лимитов

throttled_ratio = nr_throttled / nr_periods

mkdir -p /tmp/limits && cd /tmp/limits

cat > app.py <<'PY'
"""Приложение с предсказуемым профилем памяти."""
import gc
import json
import os
import sys
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path

MODE = os.environ.get("MODE", "normal")   # normal | leak | fragment
_leaked: list[bytes] = []
_requests = 0


def cgroup(name: str) -> str:
    p = Path("/sys/fs/cgroup") / name
    try:
        return p.read_text().strip()
    except OSError:
        return "н/д"


def mem_stat(field: str) -> int:
    for line in cgroup("memory.stat").splitlines():
        parts = line.split()
        if len(parts) == 2 and parts[0] == field:
            return int(parts[1])
    return 0


def rss_bytes() -> int:
    with open("/proc/self/statm") as f:
        return int(f.read().split()[1]) * 4096


class H(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def do_GET(self):
        global _requests
        if self.path == "/metrics":
            self._json({
                "rss": rss_bytes(),
                "memory_current": int(cgroup("memory.current") or 0),
                "memory_max": cgroup("memory.max"),
                "memory_peak": int(cgroup("memory.peak") or 0),
                "anon": mem_stat("anon"),
                "file": mem_stat("file"),
                "oom_kill": int([l.split()[1] for l in cgroup("memory.events").splitlines()
                                 if l.startswith("oom_kill ")] or [0])[0]
                if "oom_kill" in cgroup("memory.events") else 0,
                "requests": _requests,
            })
            return

        _requests += 1
        # Каждый запрос выделяет память; в режиме leak часть удерживается
        chunk = bytes(256 * 1024)
        if MODE == "leak":
            _leaked.append(chunk[:8192])
        elif MODE == "fragment" and _requests % 3 == 0:
            _leaked.append(chunk[:512])
        self._json({"ok": True, "requests": _requests})

    def _json(self, payload):
        body = json.dumps(payload).encode()
        self.send_response(200)
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def log_message(self, *a):
        pass


if __name__ == "__main__":
    print(f"запущен, MODE={MODE}, pid={os.getpid()}", flush=True)
    ThreadingHTTPServer(("0.0.0.0", 8000), H).serve_forever()
PY

cat > measure.sh <<'SH'
#!/usr/bin/env bash
# Шаги 1-3: запуск без лимита, нагрузка, снятие пика.
set -uo pipefail
MODE="${1:-normal}"
REQUESTS="${2:-400}"

docker rm -f measure > /dev/null 2>&1
docker run -d --name measure -p 127.0.0.1:8800:8000 \
    -e MODE="$MODE" -v "$PWD/app.py:/app.py:ro" \
    python:3.13-slim python -u /app.py > /dev/null
for _ in $(seq 40); do
    curl -s -m 2 -o /dev/null http://127.0.0.1:8800/metrics 2>/dev/null && break
    sleep 0.5
done

m() { curl -s -m 3 http://127.0.0.1:8800/metrics | python3 -c "import json,sys; print(json.load(sys.stdin)['$1'])"; }

printf '  режим: %s\n' "$MODE"
printf '  %-8s %-10s %-10s %-10s\n' "запросов" "RSS МиБ" "anon МиБ" "file МиБ"
for step in 0 $(seq 1 4); do
    if [ "$step" -gt 0 ]; then
        for _ in $(seq $((REQUESTS / 4))); do
            curl -s -m 2 -o /dev/null http://127.0.0.1:8800/ 2>/dev/null
        done
    fi
    printf '  %-8s %-10.0f %-10.0f %-10.0f\n' \
        "$(m requests)" \
        "$(awk -v v="$(m rss)" 'BEGIN{print v/1048576}')" \
        "$(awk -v v="$(m anon)" 'BEGIN{print v/1048576}')" \
        "$(awk -v v="$(m file)" 'BEGIN{print v/1048576}')"
done

peak="$(m memory_peak)"
printf '  ПИК (memory.peak): %.0f МиБ\n' "$(awk -v v="$peak" 'BEGIN{print v/1048576}')"
printf '  лимит = пик × 1.5 = %.0f МиБ\n' "$(awk -v v="$peak" 'BEGIN{print v/1048576*1.5}')"
docker rm -f measure > /dev/null 2>&1
SH
chmod +x measure.sh

echo "═══ измерение без лимита ═══"
./measure.sh normal 400

═══ измерение без лимита ═══
  режим: normal
  запросов RSS МиБ    anon МиБ   file МиБ  
  0        16         12         3         
  100      21         17         3         
  200      21         17         3         
  300      22         17         3         
  400      22         17         3         
  ПИК (memory.peak): 24 МиБ
  лимит = пик × 1.5 = 36 МиБ

cd /tmp/limits
for mode in normal fragment leak; do
    ./measure.sh "$mode" 400
    echo
done

  режим: normal
  запросов RSS МиБ    anon МиБ   file МиБ  
  0        16         12         3         
  100      21         17         3         
  200      21         17         3         
  300      22         17         3         
  400      22         17         3         
  ПИК (memory.peak): 24 МиБ
  лимит = пик × 1.5 = 36 МиБ

  режим: fragment
  запросов RSS МиБ    anon МиБ   file МиБ  
  0        16         12         3         
  100      23         19         3         
  200      25         20         3         
  300      25         21         3         
  400      26         21         3         
  ПИК (memory.peak): 27 МиБ
  лимит = пик × 1.5 = 41 МиБ

  режим: leak
  запросов RSS МиБ    anon МиБ   file МиБ  
  0        16         12         3         
  100      19         15         3         
  200      23         19         3         
  300      26         22         3         
  400      30         26         3         
  ПИК (memory.peak): 31 МиБ
  лимит = пик × 1.5 = 47 МиБ

cd /tmp/limits
cat > verify.sh <<'SH'
#!/usr/bin/env bash
# Шаги 5-6: проверка под установленным лимитом.
set -uo pipefail
LIMIT="${1:-36m}"
MODE="${2:-normal}"
REQUESTS="${3:-600}"

docker rm -f verify > /dev/null 2>&1
docker run -d --name verify -p 127.0.0.1:8801:8000 \
    --memory "$LIMIT" --memory-swap "$LIMIT" \
    -e MODE="$MODE" -v "$PWD/app.py:/app.py:ro" \
    python:3.13-slim python -u /app.py > /dev/null 2>&1

for _ in $(seq 40); do
    curl -s -m 2 -o /dev/null http://127.0.0.1:8801/metrics 2>/dev/null && break
    sleep 0.5
done

for _ in $(seq "$REQUESTS"); do
    curl -s -m 2 -o /dev/null http://127.0.0.1:8801/ 2>/dev/null || true
done
sleep 1

status="$(docker inspect verify --format '{{.State.Status}}' 2>/dev/null || echo 'нет')"
if [ "$status" = "running" ]; then
    cur="$(docker exec verify sh -c 'cat /sys/fs/cgroup/memory.current')"
    max="$(docker exec verify sh -c 'cat /sys/fs/cgroup/memory.max')"
    oom="$(docker exec verify sh -c 'awk "/oom_kill /{print \$2}" /sys/fs/cgroup/memory.events')"
    printf '  лимит %-6s режим %-9s → статус=%s, использовано %.0f%%, oom_kill=%s\n' \
        "$LIMIT" "$MODE" "$status" \
        "$(awk -v c="$cur" -v m="$max" 'BEGIN{print c*100/m}')" "$oom"
else
    printf '  лимит %-6s режим %-9s → статус=%s, код=%s, OOMKilled=%s\n' \
        "$LIMIT" "$MODE" "$status" \
        "$(docker inspect verify --format '{{.State.ExitCode}}')" \
        "$(docker inspect verify --format '{{.State.OOMKilled}}')"
fi
docker rm -f verify > /dev/null 2>&1
SH
chmod +x verify.sh

echo "═══ подтверждение лимита ═══"
./verify.sh 48m normal 600
./verify.sh 48m leak 600
./verify.sh 24m normal 600

═══ подтверждение лимита ═══
  лимит 48m   режим normal    → статус=running, использовано 47%, oom_kill=0
  лимит 48m   режим leak      → статус=running, использовано 78%, oom_kill=0
  лимит 24m   режим normal    → статус=exited, код=137, OOMKilled=true

cd /tmp/limits
cat > workers.py <<'PY'
"""Расчёт числа worker-процессов по CPU и памяти одновременно."""
from __future__ import annotations

import math
import os
from pathlib import Path


def cpu_limit() -> float:
    """Доступные CPU: минимум из квоты cgroup и маски affinity."""
    affinity = float(len(os.sched_getaffinity(0)))
    try:
        raw = Path("/sys/fs/cgroup/cpu.max").read_text().split()
    except OSError:
        return affinity
    if len(raw) != 2 or raw[0] == "max":
        return affinity
    return min(affinity, int(raw[0]) / int(raw[1]))


def memory_limit() -> int | None:
    try:
        raw = Path("/sys/fs/cgroup/memory.max").read_text().strip()
    except OSError:
        return None
    return None if raw == "max" else int(raw)


def compute(rss_per_worker_mb: float, reserve: float = 0.3,
            max_workers: int = 16) -> dict[str, object]:
    cpus = cpu_limit()
    by_cpu = max(1, math.floor(2 * cpus + 1))

    mem = memory_limit()
    if mem is None:
        by_mem = max_workers
        mem_note = "лимит памяти не задан"
    else:
        usable = mem * (1 - reserve)
        by_mem = max(1, int(usable / (rss_per_worker_mb * 1024 ** 2)))
        mem_note = f"{mem / 1048576:.0f} МиБ, из них {usable / 1048576:.0f} доступно"

    workers = max(1, min(by_cpu, by_mem, max_workers))
    binding = "CPU" if by_cpu <= by_mem else "память"
    return {
        "cpus": cpus, "by_cpu": by_cpu, "by_mem": by_mem,
        "workers": workers, "binding": binding, "mem_note": mem_note,
    }


if __name__ == "__main__":
    rss = float(os.environ.get("RSS_PER_WORKER_MB", "60"))
    r = compute(rss)
    print(f"  CPU доступно:      {r['cpus']:.2f}")
    print(f"  память:            {r['mem_note']}")
    print(f"  RSS на worker:     {rss:.0f} МиБ")
    print(f"  по CPU:            {r['by_cpu']}")
    print(f"  по памяти:         {r['by_mem']}")
    print(f"  ИТОГ:              {r['workers']} (ограничивает {r['binding']})")
PY

echo "═══ 2 CPU, 256 МиБ — ограничивает память ═══"
docker run --rm --cpus 2 --memory 256m --memory-swap 256m \
    -v "$PWD/workers.py:/w.py:ro" python:3.13-slim python /w.py

echo "═══ 0.5 CPU, 2 ГиБ — ограничивает CPU ═══"
docker run --rm --cpus 0.5 --memory 2g --memory-swap 2g \
    -v "$PWD/workers.py:/w.py:ro" python:3.13-slim python /w.py

echo "═══ 4 CPU, 2 ГиБ, тяжёлые worker'ы (200 МиБ) ═══"
docker run --rm --cpus 4 --memory 2g --memory-swap 2g \
    -e RSS_PER_WORKER_MB=200 \
    -v "$PWD/workers.py:/w.py:ro" python:3.13-slim python /w.py

echo "═══ без лимитов — формула Gunicorn как есть ═══"
docker run --rm -v "$PWD/workers.py:/w.py:ro" python:3.13-slim python /w.py

═══ 2 CPU, 256 МиБ — ограничивает память ═══
  CPU доступно:      2.00
  память:            256 МиБ, из них 179 доступно
  RSS на worker:     60 МиБ
  по CPU:            5
  по памяти:         2
  ИТОГ:              2 (ограничивает память)
═══ 0.5 CPU, 2 ГиБ — ограничивает CPU ═══
  CPU доступно:      0.50
  память:            2048 МиБ, из них 1434 доступно
  RSS на worker:     60 МиБ
  по CPU:            2
  по памяти:         23
  ИТОГ:              2 (ограничивает CPU)
═══ 4 CPU, 2 ГиБ, тяжёлые worker'ы (200 МиБ) ═══
  CPU доступно:      4.00
  память:            2048 МиБ, из них 1434 доступно
  RSS на worker:     200 МиБ
  по CPU:            9
  по памяти:         7
  ИТОГ:              7 (ограничивает память)
═══ без лимитов — формула Gunicorn как есть ═══
  CPU доступно:      8.00
  память:            лимит памяти не задан
  RSS на worker:     60 МиБ
  по CPU:            17
  по памяти:         16
  ИТОГ:              16 (ограничивает память)

cd /tmp/limits
echo "═══ что попадает в cgroup ═══"
docker run --rm --memory 512m --memory-reservation 256m --memory-swap 512m \
    python:3.13-slim sh -c '
    printf "  memory.max  (limit):       %s\n" "$(cat /sys/fs/cgroup/memory.max)"
    printf "  memory.low  (reservation): %s\n" "$(cat /sys/fs/cgroup/memory.low)"
    printf "  memory.high:               %s\n" "$(cat /sys/fs/cgroup/memory.high)"
    '

echo "═══ то же через Compose ═══"
cat > compose.res.yaml <<'EOF'
name: res
services:
  app:
    image: python:3.13-slim
    command: ["sleep", "60"]
    deploy:
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M
EOF
docker compose -f compose.res.yaml up -d > /dev/null 2>&1
sleep 2
docker compose -f compose.res.yaml exec -T app sh -c '
    printf "  memory.max: %s\n" "$(cat /sys/fs/cgroup/memory.max)"
    printf "  memory.low: %s\n" "$(cat /sys/fs/cgroup/memory.low)"
    '
docker compose -f compose.res.yaml down > /dev/null 2>&1

═══ что попадает в cgroup ═══
  memory.max  (limit):       536870912
  memory.low  (reservation): 268435456
  memory.high:               max
═══ то же через Compose ═══
  memory.max: 536870912
  memory.low: 268435456

cd /tmp/limits
cat > watch.sh <<'SH'
#!/usr/bin/env bash
# Наблюдение за приближением к лимиту.
set -uo pipefail
docker rm -f watched > /dev/null 2>&1
docker run -d --name watched -p 127.0.0.1:8802:8000 \
    --memory 40m --memory-swap 40m \
    -e MODE=leak -v "$PWD/app.py:/app.py:ro" \
    python:3.13-slim python -u /app.py > /dev/null 2>&1
for _ in $(seq 40); do
    curl -s -m 2 -o /dev/null http://127.0.0.1:8802/metrics 2>/dev/null && break
    sleep 0.5
done

printf '  %-10s %-10s %-8s %-10s %s\n' "запросов" "исп. МиБ" "% лимита" "oom_kill" "оценка"
for round in $(seq 1 8); do
    for _ in $(seq 120); do
        curl -s -m 2 -o /dev/null http://127.0.0.1:8802/ 2>/dev/null || true
    done
    if ! docker inspect watched --format '{{.State.Running}}' 2>/dev/null | grep -q true; then
        printf '  %-10s ОСТАНОВЛЕН: код=%s OOMKilled=%s\n' "$((round * 120))" \
            "$(docker inspect watched --format '{{.State.ExitCode}}')" \
            "$(docker inspect watched --format '{{.State.OOMKilled}}')"
        break
    fi
    cur="$(docker exec watched cat /sys/fs/cgroup/memory.current 2>/dev/null || echo 0)"
    max="$(docker exec watched cat /sys/fs/cgroup/memory.max 2>/dev/null || echo 1)"
    oom="$(docker exec watched sh -c 'awk "/oom_kill /{print \$2}" /sys/fs/cgroup/memory.events' 2>/dev/null || echo '?')"
    pct="$(awk -v c="$cur" -v m="$max" 'BEGIN{printf "%.0f", c*100/m}')"
    verdict="норма"
    [ "$pct" -ge 80 ] && verdict="ВНИМАНИЕ: запаса почти нет"
    [ "$pct" -ge 95 ] && verdict="КРИТИЧНО: OOM близко"
    printf '  %-10s %-10.0f %-8s %-10s %s\n' \
        "$((round * 120))" "$(awk -v c="$cur" 'BEGIN{print c/1048576}')" "${pct}%" "$oom" "$verdict"
done
docker rm -f watched > /dev/null 2>&1
SH
chmod +x watch.sh

echo "═══ приближение к лимиту 40 МиБ при утечке ═══"
./watch.sh

═══ приближение к лимиту 40 МиБ при утечке ═══
  запросов   исп. МиБ   % лимита oom_kill   оценка
  120        22         55%      0          норма
  240        26         65%      0          норма
  360        30         75%      0          норма
  480        33         82%      0          ВНИМАНИЕ: запаса почти нет
  600        36         90%      0          ВНИМАНИЕ: запаса почти нет
  720        38         95%      0          КРИТИЧНО: OOM близко
  840        ОСТАНОВЛЕН: код=137 OOMKilled=true

cd /tmp/limits
cat > cpuload.py <<'PY'
"""CPU-bound нагрузка с отчётом о throttling."""
import time
from pathlib import Path


def cpu_stat() -> dict[str, int]:
    text = Path("/sys/fs/cgroup/cpu.stat").read_text()
    return {k: int(v) for k, v in (l.split() for l in text.splitlines() if len(l.split()) == 2)}


before = cpu_stat()
start = time.monotonic()
total = 0
for i in range(8_000_000):
    total += i * i % 7
elapsed = time.monotonic() - start
after = cpu_stat()

periods = after.get("nr_periods", 0) - before.get("nr_periods", 0)
throttled = after.get("nr_throttled", 0) - before.get("nr_throttled", 0)
usec = after.get("throttled_usec", 0) - before.get("throttled_usec", 0)
ratio = (throttled / periods * 100) if periods else 0.0

verdict = "норма"
if ratio >= 25:
    verdict = "лимит занижен вдвое и более"
elif ratio >= 10:
    verdict = "существенно: увеличить лимит"
elif ratio >= 1:
    verdict = "заметно на p99"

print(f"  время:      {elapsed:6.2f} c")
print(f"  периодов:   {periods}")
print(f"  throttled:  {throttled} ({ratio:.0f} %)")
print(f"  простой:    {usec / 1_000_000:.2f} c")
print(f"  оценка:     {verdict}")
PY

for cpus in 4 1 0.3; do
    echo "═══ --cpus $cpus ═══"
    docker run --rm --cpus "$cpus" -v "$PWD/cpuload.py:/c.py:ro" \
        python:3.13-slim python /c.py
done

═══ --cpus 4 ═══
  время:        1.62 c
  периодов:   17
  throttled:  0 (0 %)
  простой:    0.00 c
  оценка:     норма
═══ --cpus 1 ═══
  время:        1.71 c
  периодов:   18
  throttled:  2 (11 %)
  простой:    0.05 c
  оценка:     существенно: увеличить лимит
═══ --cpus 0.3 ═══
  время:        5.48 c
  периодов:   55
  throttled:  54 (98 %)
  простой:    3.79 c
  оценка:     лимит занижен вдвое и более

cd /tmp && rm -rf /tmp/limits

docker run --rm --cpus 0.5 --memory 128m --memory-swap 128m python:3.13-slim sh -c '
    echo "memory.max: $(cat /sys/fs/cgroup/memory.max)"
    echo "memory.low: $(cat /sys/fs/cgroup/memory.low)"
    echo "cpu.max:    $(cat /sys/fs/cgroup/cpu.max)"
    awk "/^anon |^file /" /sys/fs/cgroup/memory.stat
'