5.6. BuildKit

# syntax=docker/dockerfile:1

RUN --mount=type=cache,target=/root/.cache/pip \
    pip install -r requirements.txt

RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
    --mount=type=cache,target=/var/lib/apt/lists,sharing=locked \
    rm -f /etc/apt/apt.conf.d/docker-clean \
 && apt-get update \
 && apt-get install -y --no-install-recommends curl

RUN --mount=type=secret,id=pypi_token \
    pip install --index-url "https://$(cat /run/secrets/pypi_token)@pypi.example.com/simple" -r requirements.txt

docker build --secret id=pypi_token,src=./token.txt -t app .

RUN --mount=type=secret,id=token,env=API_TOKEN \
    curl -H "Authorization: Bearer $API_TOKEN" https://api.example.com/data

export API_TOKEN=xxx
docker build --secret id=token,env=API_TOKEN -t app .

RUN --mount=type=bind,source=requirements.txt,target=/tmp/requirements.txt \
    pip install -r /tmp/requirements.txt

RUN --mount=type=bind,from=builder,source=/artifacts,target=/artifacts \
    cp /artifacts/app /usr/local/bin/

RUN --mount=type=ssh \
    git clone git@github.com:company/private-lib.git /src

docker build --ssh default -t app .

docker buildx create --name multi --driver docker-container --use

RUN --mount=type=cache,id=pip-cache,target=/root/.cache/pip pip install ...

mkdir -p /tmp/buildkit/app && cd /tmp/buildkit

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

echo "print('приложение')" > app/main.py

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

docker build --help | grep -q 'buildx' && echo "BuildKit активен" || echo "legacy builder"
docker buildx version

BuildKit активен
github.com/docker/buildx v0.34.1 ...

cat > Dockerfile.nocache <<'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

cat > Dockerfile.cachemount <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim
WORKDIR /app
COPY requirements.txt .
RUN --mount=type=cache,target=/root/.cache/pip \
    pip install -r requirements.txt
COPY app/ ./app/
CMD ["python", "app/main.py"]
EOF

echo "=== первая сборка обоих вариантов ==="
docker build -q -f Dockerfile.nocache    -t bk:nocache    . > /dev/null
docker build -q -f Dockerfile.cachemount -t bk:cachemount . > /dev/null
echo "готово"

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

echo "=== пересборка после добавления пакета ==="
echo -n "без cache mount: "
s="$(date +%s.%N)"
docker build -q -f Dockerfile.nocache -t bk:nocache . > /dev/null
e="$(date +%s.%N)"
awk -v a="$s" -v b="$e" 'BEGIN{printf "%.2f c\n", b-a}'

echo -n "с cache mount:   "
s="$(date +%s.%N)"
docker build -q -f Dockerfile.cachemount -t bk:cachemount . > /dev/null
e="$(date +%s.%N)"
awk -v a="$s" -v b="$e" 'BEGIN{printf "%.2f c\n", b-a}'

=== пересборка после добавления пакета ===
без cache mount: 24.83 c
с cache mount:   6.12 c

docker run --rm bk:cachemount ls /root/.cache/pip 2>&1 | head -1
docker images --format '{{.Repository}}:{{.Tag}} {{.Size}}' | grep bk:

ls: cannot access '/root/.cache/pip': No such file or directory
bk:cachemount 412MB
bk:nocache 412MB

cat > Dockerfile.apt <<'EOF'
# syntax=docker/dockerfile:1
FROM debian:trixie-slim

RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
    --mount=type=cache,target=/var/lib/apt/lists,sharing=locked \
    rm -f /etc/apt/apt.conf.d/docker-clean \
 && apt-get update \
 && apt-get install -y --no-install-recommends curl ca-certificates

CMD ["curl", "--version"]
EOF

echo "=== первая сборка ==="
s="$(date +%s.%N)"; docker build -q -f Dockerfile.apt -t bk:apt1 . > /dev/null; e="$(date +%s.%N)"
awk -v a="$s" -v b="$e" 'BEGIN{printf "%.2f c\n", b-a}'

echo "=== вторая сборка с другим пакетом (кэш пакетов переиспользуется) ==="
sed -i 's/curl ca-certificates/curl ca-certificates jq/' Dockerfile.apt
s="$(date +%s.%N)"; docker build -q -f Dockerfile.apt -t bk:apt2 . > /dev/null; e="$(date +%s.%N)"
awk -v a="$s" -v b="$e" 'BEGIN{printf "%.2f c\n", b-a}'

docker run --rm bk:apt2 curl --version | head -1

=== первая сборка ===
14.28 c
=== вторая сборка с другим пакетом (кэш пакетов переиспользуется) ===
5.41 c
14.28 c
curl 8.15.0 ...

echo -n 'ghp_SuperSecretToken123456789' > token.txt

cat > Dockerfile.argsecret <<'EOF'
FROM alpine:3.21
ARG API_TOKEN
RUN echo "использую токен длиной ${#API_TOKEN}" > /result.txt
CMD ["cat", "/result.txt"]
EOF

docker build -q -f Dockerfile.argsecret \
    --build-arg API_TOKEN="$(cat token.txt)" -t bk:argsecret . > /dev/null

echo "--- поиск токена в истории образа ---"
docker history --no-trunc bk:argsecret | grep -o 'API_TOKEN=[^ ]*' | head -1

--- поиск токена в истории образа ---
API_TOKEN=ghp_SuperSecretToken123456789

cat > Dockerfile.secret <<'EOF'
# syntax=docker/dockerfile:1
FROM alpine:3.21
RUN --mount=type=secret,id=api_token,required=true \
    echo "использую токен длиной $(wc -c < /run/secrets/api_token)" > /result.txt
CMD ["cat", "/result.txt"]
EOF

docker build -q -f Dockerfile.secret \
    --secret id=api_token,src=token.txt -t bk:secret . > /dev/null

docker run --rm bk:secret

echo "--- поиск токена в истории ---"
docker history --no-trunc bk:secret | grep -c 'SuperSecret' || echo "0 — не найден"

echo "--- поиск в слоях образа ---"
docker save bk:secret -o /tmp/bk-secret.tar
mkdir -p /tmp/bk-extract && tar -xf /tmp/bk-secret.tar -C /tmp/bk-extract
found=0
for b in /tmp/bk-extract/blobs/sha256/*; do
    if tar -tf "$b" 2>/dev/null | grep -q 'run/secrets'; then found=1; fi
done
[ "$found" -eq 0 ] && echo "0 — в слоях отсутствует"
rm -rf /tmp/bk-secret.tar /tmp/bk-extract

использую токен длиной 29
--- поиск токена в истории ---
0 — не найден
--- поиск в слоях образа ---
0 — в слоях отсутствует

docker build -q -f Dockerfile.secret -t bk:secret . 2>&1 | tail -2

ERROR: failed to build: secret api_token: not found

cat > Dockerfile.secretenv <<'EOF'
# syntax=docker/dockerfile:1
FROM alpine:3.21
RUN --mount=type=secret,id=api_token,env=API_TOKEN,required=true \
    echo "длина токена из переменной: ${#API_TOKEN}" > /result.txt
CMD ["cat", "/result.txt"]
EOF

export API_TOKEN='ghp_FromEnvironment12345'
docker build -q -f Dockerfile.secretenv \
    --secret id=api_token,env=API_TOKEN -t bk:secretenv . > /dev/null
docker run --rm bk:secretenv

docker history --no-trunc bk:secretenv | grep -c 'FromEnvironment' || echo "в истории отсутствует"
unset API_TOKEN

длина токена из переменной: 24
в истории отсутствует

cat > Dockerfile.bind <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim
WORKDIR /app

# requirements.txt нужен только на время установки — не копируем его в слой
RUN --mount=type=cache,target=/root/.cache/pip \
    --mount=type=bind,source=requirements.txt,target=/tmp/requirements.txt \
    pip install -r /tmp/requirements.txt

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

docker build -q -f Dockerfile.bind -t bk:bind . > /dev/null

echo "--- есть ли requirements.txt в образе? ---"
docker run --rm bk:bind sh -c 'ls /app/requirements.txt 2>&1 || echo "отсутствует — не копировался"'

echo "--- работает ли приложение? ---"
docker run --rm bk:bind python -c "import fastapi; print('зависимости установлены')"

--- есть ли requirements.txt в образе? ---
ls: cannot access '/app/requirements.txt': No such file or directory
отсутствует — не копировался
--- работает ли приложение? ---
зависимости установлены

echo "rich==14.2.0" >> requirements.txt
docker build -f Dockerfile.bind -t bk:bind . 2>&1 | grep -E 'CACHED|RUN --mount' | head -2
docker run --rm bk:bind python -c "import rich; print('новый пакет установлен')" 2>/dev/null \
    || echo "новый пакет НЕ установлен — кэш не инвалидировался"

 => [3/4] RUN --mount=type=cache,target=/root/.cache/pip     --mount=type=bind,source=req...
новый пакет установлен

cat > Dockerfile.parallel <<'EOF'
# syntax=docker/dockerfile:1
FROM alpine:3.21 AS stage-a
RUN sleep 5 && echo "A готова" > /a.txt

FROM alpine:3.21 AS stage-b
RUN sleep 5 && echo "B готова" > /b.txt

FROM alpine:3.21 AS stage-c
RUN sleep 5 && echo "C готова" > /c.txt

FROM alpine:3.21
COPY --from=stage-a /a.txt /
COPY --from=stage-b /b.txt /
COPY --from=stage-c /c.txt /
CMD ["sh", "-c", "cat /a.txt /b.txt /c.txt"]
EOF

echo "три стадии по 5 секунд каждая:"
s="$(date +%s.%N)"
docker build -q --no-cache -f Dockerfile.parallel -t bk:parallel . > /dev/null
e="$(date +%s.%N)"
awk -v a="$s" -v b="$e" 'BEGIN{printf "общее время: %.1f c\n", b-a}'
docker run --rm bk:parallel

три стадии по 5 секунд каждая:
общее время: 7.3 c

cat > Dockerfile.skip <<'EOF'
# syntax=docker/dockerfile:1
FROM alpine:3.21 AS used
RUN echo "нужная стадия" > /used.txt

FROM alpine:3.21 AS unused
RUN sleep 10 && echo "эта стадия не нужна" > /unused.txt

FROM alpine:3.21
COPY --from=used /used.txt /
CMD ["cat", "/used.txt"]
EOF

s="$(date +%s.%N)"
docker build -q --no-cache -f Dockerfile.skip -t bk:skip . > /dev/null
e="$(date +%s.%N)"
awk -v a="$s" -v b="$e" 'BEGIN{printf "время сборки: %.1f c\n", b-a}'
echo "(стадия unused со sleep 10 не выполнялась)"

время сборки: 2.4 c
(стадия unused со sleep 10 не выполнялась)

docker build -q --target unused -f Dockerfile.skip -t bk:unused . > /dev/null && echo "собрана по запросу"

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

docker buildx ls

NAME/NODE     DRIVER/ENDPOINT  STATUS   BUILDKIT  PLATFORMS
default*      docker
 \_ default    \_ default      running  v0.26.1   linux/amd64, linux/386

docker build --cache-to type=registry,ref=localhost:5000/cache -t test . 2>&1 | tail -2

ERROR: Cache export is not supported for the docker driver.
Switch to a different driver, or turn on the containerd image store.

docker buildx create --name multiarch --driver docker-container --bootstrap > /dev/null 2>&1
docker buildx ls | head -5

docker buildx build --builder multiarch -f Dockerfile.bind -t bk:multi --load . > /dev/null 2>&1 \
    && echo "собрано через docker-container driver"

docker buildx rm multiarch > /dev/null 2>&1

cd /tmp
docker rmi -f $(docker images -q --filter 'reference=bk:*') 2>/dev/null || true
docker builder prune -f > /dev/null
rm -rf /tmp/buildkit

FROM python:3.13-slim
WORKDIR /app

ARG PYPI_TOKEN
RUN pip config set global.index-url "https://${PYPI_TOKEN}@pypi.example.com/simple"

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

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

mkdir -p /tmp/vbk && cd /tmp/vbk
echo -n 'secret-value-12345' > s.txt
printf '# syntax=docker/dockerfile:1\nFROM alpine:3.21\nRUN --mount=type=secret,id=s,required=true wc -c < /run/secrets/s > /len.txt\nCMD ["cat","/len.txt"]\n' > Dockerfile
docker build -q --secret id=s,src=s.txt -t vbk:1 . > /dev/null
docker run --rm vbk:1
docker history --no-trunc vbk:1 | grep -c 'secret-value' || echo "секрет не найден в истории"
docker rmi -f vbk:1 > /dev/null; cd /tmp && rm -rf /tmp/vbk