5.5. Build cache

   FROM python:3.13-slim      ключ = хэш(базовый образ)              ✓ CACHED
   WORKDIR /app               ключ = хэш(предыдущий + "WORKDIR /app") ✓ CACHED
   COPY requirements.txt .    ключ = хэш(предыдущий + содержимое)     ✓ CACHED
   RUN pip install ...        ключ = хэш(предыдущий + текст команды)  ✓ CACHED
   COPY . .                   ключ = хэш(предыдущий + содержимое)     ✗ изменился код
   CMD [...]                  ключ = хэш(предыдущий + ...)            ✗ каскад

RUN pip install -r requirements.txt

# ОШИБКА: pip install закэширован навсегда
RUN pip install fastapi==0.141.1

FROM python:3.13-slim
WORKDIR /app
COPY . .                                    ← изменение ЛЮБОГО файла
RUN pip install -r requirements.txt         ← пересобирается всегда
CMD ["python", "app.py"]

FROM python:3.13-slim
WORKDIR /app
COPY requirements.txt .                     ← меняется редко
RUN pip install -r requirements.txt         ← кэшируется
COPY . .                                    ← меняется часто
CMD ["python", "app.py"]

RUN apt-get update \
 && apt-get install -y curl \
 && rm -rf /var/lib/apt/lists/*

docker build --help | grep -q 'buildx' && echo "BuildKit"

docker system df

TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Build Cache     183       0         4.271GB   4.271GB

mkdir -p /tmp/cache-demo/app && cd /tmp/cache-demo

cat > requirements.txt <<'EOF'
fastapi==0.141.1
uvicorn[standard]==0.52.0
pydantic==2.13.4
httpx==0.28.1
EOF

cat > app/main.py <<'PY'
print("версия 1")
PY

cat > .dockerignore <<'EOF'
Dockerfile*
.dockerignore
__pycache__
*.pyc
EOF

cat > Dockerfile.bad <<'EOF'
FROM python:3.13-slim
WORKDIR /app
COPY . .
RUN pip install --no-cache-dir -r requirements.txt
CMD ["python", "app/main.py"]
EOF

echo "--- первая сборка (наполняем кэш) ---"
time docker build -q -f Dockerfile.bad -t cache:bad . > /dev/null

real	0m28.412s

echo 'print("версия 2")' > app/main.py

echo "--- пересборка после изменения кода ---"
time docker build -f Dockerfile.bad -t cache:bad . 2>&1 | grep -E 'CACHED|\[[0-9]/[0-9]\]'

 => CACHED [2/4] WORKDIR /app
 => [3/4] COPY . .
 => [4/4] RUN pip install --no-cache-dir -r requirements.txt

real	0m24.183s

cat > Dockerfile.good <<'EOF'
FROM python:3.13-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app/ ./app/
CMD ["python", "app/main.py"]
EOF

echo "--- первая сборка ---"
time docker build -q -f Dockerfile.good -t cache:good . > /dev/null

echo 'print("версия 3")' > app/main.py

echo "--- пересборка после изменения кода ---"
time docker build -f Dockerfile.good -t cache:good . 2>&1 | grep -E 'CACHED|\[[0-9]/[0-9]\]'

--- первая сборка ---
real	0m27.914s
--- пересборка после изменения кода ---
 => CACHED [2/5] WORKDIR /app
 => CACHED [3/5] COPY requirements.txt .
 => CACHED [4/5] RUN pip install --no-cache-dir -r requirements.txt
 => [5/5] COPY app/ ./app/

real	0m0.612s

echo "python-multipart==0.0.20" >> requirements.txt

docker build -f Dockerfile.good -t cache:good . 2>&1 | grep -E 'CACHED|RUN pip'

 => CACHED [2/5] WORKDIR /app
 => [3/5] COPY requirements.txt .
 => [4/5] RUN pip install --no-cache-dir -r requirements.txt

docker run --rm cache:good python -c "import multipart; print('пакет установлен')"

пакет установлен

mkdir -p /tmp/run-cache && cd /tmp/run-cache

cat > Dockerfile.date <<'EOF'
FROM alpine:3.21
RUN date +%s%N > /build-time.txt
CMD ["cat", "/build-time.txt"]
EOF

docker build -q -f Dockerfile.date -t rc:1 . > /dev/null
FIRST="$(docker run --rm rc:1)"
sleep 2
docker build -q -f Dockerfile.date -t rc:1 . > /dev/null
SECOND="$(docker run --rm rc:1)"

echo "первая сборка:  $FIRST"
echo "вторая сборка:  $SECOND"
[ "$FIRST" = "$SECOND" ] && echo "→ значения совпали: инструкция взята из кэша"

первая сборка:  1785481203847291000
вторая сборка:  1785481203847291000
→ значения совпали: инструкция взята из кэша

RUN apt-get update && apt-get upgrade -y

cat > Dockerfile.bust <<'EOF'
FROM alpine:3.21
RUN echo "стабильная часть" > /stable.txt

ARG CACHE_BUST=0
RUN echo "обновляемая часть, bust=${CACHE_BUST}" > /volatile.txt

CMD ["sh", "-c", "cat /stable.txt /volatile.txt"]
EOF

docker build -q -f Dockerfile.bust -t bust:1 . > /dev/null
docker run --rm bust:1

echo "--- сборка с другим значением ARG ---"
docker build -f Dockerfile.bust --build-arg CACHE_BUST=1 -t bust:1 . 2>&1 \
    | grep -E 'CACHED|RUN echo'
docker run --rm bust:1

стабильная часть
обновляемая часть, bust=0
--- сборка с другим значением ARG ---
 => CACHED [2/3] RUN echo "стабильная часть" > /stable.txt
 => [3/3] RUN echo "обновляемая часть, bust=1" > /volatile.txt
стабильная часть
обновляемая часть, bust=1

docker build --build-arg CACHE_BUST="$(date +%Y-%W)" -t app .

cd /tmp/cache-demo
chmod 644 app/main.py
docker build -q -f Dockerfile.good -t cache:good . > /dev/null

echo "--- меняем ТОЛЬКО права, содержимое то же ---"
chmod 755 app/main.py
docker build -f Dockerfile.good -t cache:good . 2>&1 | grep -E 'CACHED|COPY app'

--- меняем ТОЛЬКО права, содержимое то же ---
 => CACHED [3/5] COPY requirements.txt .
 => CACHED [4/5] RUN pip install --no-cache-dir -r requirements.txt
 => [5/5] COPY app/ ./app/

chmod 644 app/main.py

cd /tmp/cache-demo
echo 'print("версия 4")' > app/main.py

docker build --progress=plain -f Dockerfile.good -t cache:good . 2>&1 \
    | grep -E '^#[0-9]+ (\[|CACHED|DONE)' | head -12

analyze_cache() {
    local dockerfile="$1" tag="$2"
    local out
    out="$(docker build -f "$dockerfile" -t "$tag" . 2>&1)"
    local cached total
    cached="$(grep -c 'CACHED' <<< "$out" || echo 0)"
    total="$(grep -cE '=> (CACHED )?\[[0-9]+/[0-9]+\]' <<< "$out" || echo 0)"
    printf '  кэш: %s из %s инструкций\n' "$cached" "$total"
    echo "  пересобраны:"
    grep -E '=> \[[0-9]+/[0-9]+\]' <<< "$out" | sed 's/^/    /' | head -5
}

echo 'print("версия 5")' > app/main.py
echo "=== Dockerfile.good ==="
analyze_cache Dockerfile.good cache:good

echo 'print("версия 6")' > app/main.py
echo "=== Dockerfile.bad ==="
analyze_cache Dockerfile.bad cache:bad

=== Dockerfile.good ===
  кэш: 3 из 4 инструкций
  пересобраны:
     => [5/5] COPY app/ ./app/
=== Dockerfile.bad ===
  кэш: 1 из 3 инструкций
  пересобраны:
     => [3/4] COPY . .
     => [4/4] RUN pip install --no-cache-dir -r requirements.txt

# полностью без кэша
docker build --no-cache -t cache:fresh -f Dockerfile.good . 2>&1 | grep -c CACHED || echo "0 попаданий"

# обновить базовый образ перед сборкой
docker build --pull -t cache:fresh -f Dockerfile.good . 2>&1 | tail -1

cat > Dockerfile.stages <<'EOF'
FROM python:3.13-slim AS deps
RUN echo "стадия зависимостей" > /deps.txt

FROM python:3.13-slim AS final
COPY --from=deps /deps.txt /deps.txt
RUN echo "финальная стадия" > /final.txt
CMD ["cat", "/deps.txt", "/final.txt"]
EOF

docker build -q -f Dockerfile.stages -t stages:1 . > /dev/null
echo "--- пересборка только стадии final ---"
docker build --no-cache-filter=final -f Dockerfile.stages -t stages:1 . 2>&1 \
    | grep -E 'CACHED|\[final|\[deps' | head -4

--- пересборка только стадии final ---
 => CACHED [deps 2/2] RUN echo "стадия зависимостей" > /deps.txt
 => [final 2/3] COPY --from=deps /deps.txt /deps.txt
 => [final 3/3] RUN echo "финальная стадия" > /final.txt

docker system df --format 'table {{.Type}}\t{{.Size}}\t{{.Reclaimable}}' | grep -E 'TYPE|Build'

TYPE           SIZE      RECLAIMABLE
Build Cache    2.847GB   2.847GB

# записи старше недели
docker builder prune --filter 'until=168h' -f

# ограничить общий размер
docker builder prune --reserved-space 5GB -f

cd /tmp
docker rmi -f cache:bad cache:good cache:fresh rc:1 bust:1 stages:1 2>/dev/null || true
rm -rf /tmp/cache-demo /tmp/run-cache

FROM python:3.13-slim

RUN apt-get update
RUN apt-get install -y --no-install-recommends build-essential curl
RUN rm -rf /var/lib/apt/lists/*

COPY . /app
WORKDIR /app

RUN pip install --no-cache-dir -r requirements.txt
RUN python -m compileall /app

CMD ["python", "/app/app/main.py"]

mkdir -p /tmp/vfy/app && cd /tmp/vfy
echo "fastapi==0.141.1" > requirements.txt
echo "print(1)" > app/main.py
printf 'FROM python:3.13-slim\nWORKDIR /app\nCOPY requirements.txt .\nRUN pip install --no-cache-dir -r requirements.txt\nCOPY app/ ./app/\nCMD ["python","app/main.py"]\n' > Dockerfile

docker build -q -t vfy:1 . > /dev/null
echo "print(2)" > app/main.py
docker build -t vfy:1 . 2>&1 | grep -c CACHED

docker rmi -f vfy:1 > /dev/null; cd /tmp && rm -rf /tmp/vfy