Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 13: Build-Secrets mit BuildKit

Ziel: Tokens, die nur der Build braucht, per RUN --mount=type=secret übergeben und nachweisen, dass sie in keinem Layer und in keiner History landen. · Dauer: ca. 75 min · Voraussetzung: Tag 12

Briefing

  • Ein Build-Secret existiert nur während eines einzigen RUN: als Datei unter /run/secrets/<id> oder, mit env=, als Umgebungsvariable. Danach ist es weg.
  • Übergeben wird es mit docker build --secret id=…,src=<datei> oder ,env=<variable>. Im Dockerfile steht nur die ID, nie der Wert.
  • Der artifact-server spielt heute dein privates Artefakt-Repository: Er liefert eine Datei nur mit Authorization: Bearer lab-artifact-token-123.
  • Achtung Cache: Ein geänderter Secret-Wert baut nichts neu (Drill 6).
 docker build --secret id=artifact_token,env=ARTIFACT_TOKEN
        │   Wert nur im Speicher des Builds
        ▼
 RUN --mount=type=secret,…,env=ARTIFACT_TOKEN ── Bearer ──► notes-artifacts:8081
        │   nach dem RUN: Token weg, heruntergeladene Datei bleibt
        ▼
 Layer: /usr/share/notes/banner.txt   (kein Token, keine Spur in der History)

Drill 1: Das private Artefakt-Repository

source ~/docker-lab/setup/env.sh
mkdir -p ~/docker-lab/tag13 && cd ~/docker-lab/tag13
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag12/notes/." .

Die zweite Kopie legt den Stand vom Ende von Tag 12 darüber – auch wenn du ihn übersprungen hast. Secrets für den Build legst du in einem eigenen Ordner ab, den Git ignoriert. printf '%s' schreibt ohne Zeilenumbruch, sonst hängt am Token ein \n:

mkdir -p secrets
grep -qxF 'secrets/' .gitignore || echo 'secrets/' >> .gitignore
printf '%s' 'lab-artifact-token-123' > secrets/artifact_token.txt
wc -c secrets/artifact_token.txt

Erwartet:

      22 secrets/artifact_token.txt

Jetzt den artifact-server bauen und starten. Er liegt im Begleitcode, ein http.server aus der Python-Standardbibliothek mit eigenem kleinem Dockerfile:

docker build -q -t notes-artifacts:tag13 "$LAB/code/tag13/artifact-server"
docker run -d --name notes-artifacts -p 127.0.0.1:8081:8081 \
  -e ARTIFACT_TOKEN_FILE=/run/token -v "$PWD/secrets/artifact_token.txt:/run/token:ro" \
  notes-artifacts:tag13
curl -s -o /dev/null -w '%{http_code}\n' localhost:8081/tools/notes-banner.txt
curl -s -H 'Authorization: Bearer lab-artifact-token-123' \
  localhost:8081/tools/notes-banner.txt

Erwartet (gekürzt, kann je nach Version abweichen):

sha256:3f0a…
4c1d…
401
notes – privates Artefakt vom artifact-server (Lab, Tag 13)

Ohne Token 401, mit Token die Datei. Genau so verhält sich ein privates npm-, PyPI- oder Artifactory-Repository. Der Server loggt Pfad und Status, nie Header.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Wo liegt das Secret im Build?

Bevor das Token in notes-api wandert, schaust du einem Secret-Mount zu. Das Probe- Dockerfile mountet dasselbe Secret auf drei Arten und prüft danach, was übrig ist:

cat "$LAB/code/tag13/probe/Dockerfile"

Erwartet:

# syntax=docker/dockerfile:1
# probe – zeigt, wie ein Build-Secret im RUN ankommt und wieder verschwindet (Tag 13)
# in Produktion: @sha256:… pinnen, siehe Tag 8
FROM golang:1.27-alpine
# 1) Standard: Datei unter /run/secrets/<id>, root, 0400
RUN --mount=type=secret,id=artifact_token \
    ls -ln /run/secrets
# 2) eigener Pfad, eigene Rechte
RUN --mount=type=secret,id=artifact_token,target=/tmp/token,mode=0440,uid=65532 \
    ls -ln /tmp/token
# 3) nur als Umgebungsvariable (dann ohne Datei)
RUN --mount=type=secret,id=artifact_token,env=ARTIFACT_TOKEN \
    echo "ARTIFACT_TOKEN hat ${#ARTIFACT_TOKEN} Zeichen" \
    && test ! -e /run/secrets/artifact_token && echo "keine Datei unter /run/secrets"
# 4) ohne Mount: nichts mehr da
RUN test ! -s /run/secrets/artifact_token && test ! -s /tmp/token \
    && echo "ohne Mount: kein Secret-Inhalt im Dateisystem"
docker build --no-cache --progress=plain -t notes-probe:tag13 \
  --secret id=artifact_token,src=secrets/artifact_token.txt \
  "$LAB/code/tag13/probe" 2>&1 | grep -E '^#[0-9]+ [0-9.]+ '

Erwartet (gekürzt, kann je nach Version abweichen):

#5 0.112 total 4
#5 0.112 -r--------    1 0        0               22 Oct 29 09:14 artifact_token
#6 0.098 -r--r-----    1 65532    0               22 Oct 29 09:14 /tmp/token
#7 0.087 ARTIFACT_TOKEN hat 22 Zeichen
#7 0.087 keine Datei unter /run/secrets
#8 0.071 ohne Mount: kein Secret-Inhalt im Dateisystem

Die Optionen stammen aus der Dockerfile-Referenz:

Option Standard Wirkung
id Basisname von target Name, unter dem --secret den Wert liefert
target /run/secrets/<id> (wenn auch env fehlt) Pfad der Datei
env – Wert als Umgebungsvariable, ohne oder mit target
required false Build bricht ab, wenn das Secret fehlt
mode, uid, gid 0400, 0, 0 Rechte und Besitzer der Datei

env= gibt es seit Dockerfile-Frontend 1.10. Mit # syntax=docker/dockerfile:1 hast du es. Mit env= allein entsteht keine Datei; willst du beides, setzt du env und target zusammen.

Fortschritt speichern? Kostenlos registrieren

Drill 3: notes-api lädt das Artefakt

notes-api bekommt eine eigene Stage artifacts, die nur das Artefakt holt. Das Token kommt per env= in die Variable ARTIFACT_TOKEN, die nur dieser eine RUN sieht. Die Final-Stage kopiert nur die Datei:

cat > notes-api/Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
# check=error=true
# notes-api – Stand Ende Tag 13
ARG GO_VERSION=1.27

# in Produktion: @sha256:… pinnen, siehe Tag 8
FROM --platform=$BUILDPLATFORM golang:${GO_VERSION}-alpine AS base
WORKDIR /src
COPY go.mod go.sum ./
RUN --mount=type=cache,target=/go/pkg/mod go mod download
COPY . .

FROM base AS test
RUN --mount=type=cache,target=/go/pkg/mod \
    --mount=type=cache,target=/root/.cache/go-build \
    go vet ./... && go test ./...

# Tag 13: privates Artefakt mit Build-Secret laden. Das Token existiert nur
# während dieses RUN als Umgebungsvariable – in keinem Layer, in keiner History.
FROM --platform=$BUILDPLATFORM golang:${GO_VERSION}-alpine AS artifacts
ARG ARTIFACT_URL=http://127.0.0.1:8081
RUN --mount=type=secret,id=artifact_token,env=ARTIFACT_TOKEN,required=true \
    wget -q --header "Authorization: Bearer ${ARTIFACT_TOKEN}" \
      -O /notes-banner.txt "${ARTIFACT_URL}/tools/notes-banner.txt"

FROM base AS build
ARG TARGETOS TARGETARCH VERSION=dev
RUN --mount=type=cache,target=/go/pkg/mod \
    --mount=type=cache,target=/root/.cache/go-build \
    CGO_ENABLED=0 GOOS=$TARGETOS GOARCH=$TARGETARCH \
    go build -trimpath -ldflags="-s -w -X main.version=${VERSION}" \
      -o /out/notes-api .

FROM scratch AS final
ARG VERSION=dev REVISION=unknown CREATED=unknown
LABEL org.opencontainers.image.title="notes-api" \
      org.opencontainers.image.description="Notiz-API aus dem Trainingslager" \
      org.opencontainers.image.source="https://example.com/docker-lab/notes" \
      org.opencontainers.image.version="${VERSION}" \
      org.opencontainers.image.revision="${REVISION}" \
      org.opencontainers.image.created="${CREATED}"
COPY --link --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
COPY --link --from=artifacts /notes-banner.txt /usr/share/notes/banner.txt
COPY --link --from=build --chmod=555 /out/notes-api /notes-api
EXPOSE 8080
USER 65532:65532
HEALTHCHECK --interval=10s --timeout=2s --start-period=5s --start-interval=1s \
  CMD ["/notes-api", "healthcheck"]
STOPSIGNAL SIGTERM
ENTRYPOINT ["/notes-api"]
EOF
hadolint notes-api/Dockerfile && docker build --check notes-api

Erwartet (gekürzt, kann je nach Version abweichen):

Check complete, no warnings found.

Gebaut wird mit dem Token aus einer Umgebungsvariablen. --network=host braucht nur das Lab: Die RUN-Schritte laufen sonst in einem eigenen Netz und erreichen 127.0.0.1:8081 nicht.

export ARTIFACT_TOKEN="$(cat secrets/artifact_token.txt)"
docker build --network=host --secret id=artifact_token,env=ARTIFACT_TOKEN \
  -t notes-api:tag13 notes-api
docker logs notes-artifacts | tail -1

Erwartet (gekürzt, kann je nach Version abweichen):

[+] Building 14.2s (19/19) FINISHED                              docker:colima
 => [artifacts 2/2] RUN --mount=type=secret,id=artifact_token,env=ARTIFACT_T  0.4s
 => [build 1/1] RUN --mount=type=cache,target=/go/pkg/mod --mount=type=cac   9.8s
 => [final 2/3] COPY --link --from=artifacts /notes-banner.txt /usr/share/   0.0s
172.17.0.1 "GET /tools/notes-banner.txt HTTP/1.1" 200 -

Build-Zeiten, Größen und Digests weichen bei dir ab. Die Stage artifacts hängt nicht von base ab, BuildKit baut sie parallel zum Go-Build.

Tipp: Meldet der Build, dass das Entitlement network.host fehlt, ergänze --allow network.host. In CI hat das Artefakt-Repository einen echten Hostnamen, dann entfällt --network=host ganz.

Für --secret gibt es drei Schreibweisen:

Aufruf Quelle
--secret id=artifact_token,src=secrets/artifact_token.txt Datei
--secret id=artifact_token,env=ARTIFACT_TOKEN Umgebungsvariable
--secret id=artifact_token Variable artifact_token, sonst Datei artifact_token

Die Kurzform sucht laut buildx-Referenz zuerst eine Umgebungsvariable mit dem Namen der ID und fällt sonst auf eine Datei gleichen Namens im aktuellen Ordner zurück. Schreib src= oder env= aus, dann gibt es keine Überraschung.

Fortschritt speichern? Kostenlos registrieren

Drill 4: required=true und das falsche Token

Ohne required=true liefe der RUN ohne Secret einfach weiter, wget bekäme einen leeren Header. So bricht der Build sofort und mit klarer Meldung ab:

docker build --network=host --no-cache-filter artifacts \
  -t notes-api:tag13 notes-api 2>&1 | grep -i -m1 error

Erwartet (gekürzt, kann je nach Version abweichen):

ERROR: failed to solve: secret artifact_token: not found

Und mit falschem Token antwortet der Server, wie er soll:

ARTIFACT_TOKEN=lab-falsch-000 docker build --network=host \
  --no-cache-filter artifacts --secret id=artifact_token,env=ARTIFACT_TOKEN \
  -t notes-api:tag13 notes-api 2>&1 | grep -m1 'wget:'

Erwartet (gekürzt, kann je nach Version abweichen):

#12 0.031 wget: server returned error: HTTP/1.0 401 Unauthorized

--no-cache-filter artifacts baut nur diese Stage neu. Warum das hier nötig ist, zeigt Drill 6.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Nachweis – kein Token im Image

Tag 11 hat gezeigt, wo ein Secret hängen bleibt: History, Config, Layer. Die Layer durchsuchst du wie in Tag 11, Drill 8:

rm -rf /tmp/img && mkdir /tmp/img
docker save notes-api:tag13 | tar -x -C /tmp/img
for l in /tmp/img/blobs/sha256/*; do tar -xOf "$l" 2>/dev/null; done \
  | grep -ac lab-artifact-token-123
docker history --no-trunc --format '{{.CreatedBy}}' notes-api:tag13 | head -4

Erwartet (gekürzt, kann je nach Version abweichen):

0
ENTRYPOINT ["/notes-api"]
STOPSIGNAL SIGTERM
HEALTHCHECK &{["CMD" "/notes-api" "healthcheck"] "10s" "2s" "5s" "1s" '\x00'}
USER 65532:65532

Null Treffer in den Layern, und die History zeigt kein Token. Die Stage artifacts taucht in der History gar nicht auf, nur ihr Ergebnis per COPY --from. Das Artefakt selbst ist drin:

docker create --name notes-probe notes-api:tag13 >/dev/null
docker cp notes-probe:/usr/share/notes/banner.txt - | tar -xO
docker rm notes-probe >/dev/null

Erwartet:

notes – privates Artefakt vom artifact-server (Lab, Tag 13)

docker cp mit - liefert ein tar-Archiv, so liest du Dateien aus scratch.

Sicherheit: Ein Secret-Mount schützt nur den Transport. Schreibt der RUN das Token in eine Datei, ein Log oder eine Konfiguration im Image, ist es trotzdem drin. Genau das ist die Challenge heute.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Die Cache-Falle

Rotiere das Token auf dem Server und baue mit dem alten Token neu:

docker rm -f notes-artifacts >/dev/null
printf '%s' 'lab-artifact-token-456' > secrets/artifact_token_neu.txt
docker run -d --name notes-artifacts -p 127.0.0.1:8081:8081 \
  -e ARTIFACT_TOKEN_FILE=/run/token \
  -v "$PWD/secrets/artifact_token_neu.txt:/run/token:ro" notes-artifacts:tag13
docker build --network=host --progress=plain \
  --secret id=artifact_token,env=ARTIFACT_TOKEN -t notes-api:tag13 notes-api \
  2>&1 | grep -A1 'artifacts 2/2'
docker logs notes-artifacts | grep -c GET

Erwartet (gekürzt, kann je nach Version abweichen):

#10 [artifacts 2/2] RUN --mount=type=secret,id=artifact_token,env=ARTIFACT_TOKEN,r…
#10 CACHED
0

Der Build ist grün, obwohl das Token nicht mehr gilt, und der Server hat keine einzige Anfrage gesehen. Die Doku sagt es ausdrücklich: Der Inhalt eines Build-Secrets gehört nicht zum Cache-Schlüssel, ein neuer Wert invalidiert nichts. ID und Mount-Pfad zählen dagegen mit. Neu laden erzwingst du gezielt:

docker build --network=host --no-cache-filter artifacts \
  --secret id=artifact_token,src=secrets/artifact_token_neu.txt \
  -t notes-api:tag13 notes-api >/dev/null
docker logs notes-artifacts | tail -1

Erwartet (gekürzt, kann je nach Version abweichen):

172.17.0.1 "GET /tools/notes-banner.txt HTTP/1.1" 200 -

Ändert sich das Artefakt hinter einem Secret regelmäßig, nimm ein ARG mit einer Version oder Prüfsumme in die Stage auf: Build-Argumente invalidieren den Cache, Secrets nicht. Das Token selbst gehört aber nie in ein ARG (Tag 11).

Fortschritt speichern? Kostenlos registrieren

Drill 7: .npmrc, uv-Index und SSH

Private npm-Registries erwarten ihr Token in der .npmrc. Die gehört weder ins Repository noch per COPY ins Image, sondern als Secret-Mount genau auf den Pfad, an dem npm sie sucht. Eine private Registry hat das Lab nicht; die Lab-.npmrc verweist nur für den Scope @notes-lab auf einen Host, den notes-web nicht braucht, also läuft npm ci gegen die öffentliche Registry weiter:

cat > secrets/npmrc <<'EOF'
@notes-lab:registry=https://npm.lab.invalid/
//npm.lab.invalid/:_authToken=lab-npm-token-123
EOF
cp "$LAB/code/tag13/notes/notes-web/Dockerfile" notes-web/Dockerfile
grep -n -A2 'type=secret' notes-web/Dockerfile

Erwartet:

10:    --mount=type=secret,id=npmrc,target=/root/.npmrc \
11-    npm ci
12-COPY . .
--
20:    --mount=type=secret,id=npmrc,target=/root/.npmrc \
21-    npm ci --omit=dev
22-COPY server.js ./

Ohne required=true ist das Secret optional: Fehlt es, baut notes-web wie an Tag 6.

docker build -q --secret id=npmrc,src=secrets/npmrc -t notes-web:tag13 notes-web
rm -rf /tmp/img && mkdir /tmp/img
docker save notes-web:tag13 | tar -x -C /tmp/img
for l in /tmp/img/blobs/sha256/*; do tar -xOf "$l" 2>/dev/null; done \
  | grep -ac lab-npm-token-123

Erwartet (gekürzt, kann je nach Version abweichen):

sha256:a71e…
0

Dasselbe Muster für Python: uv liest Zugangsdaten eines benannten Index aus UV_INDEX_<NAME>_USERNAME und UV_INDEX_<NAME>_PASSWORD. Für einen Index intern in der pyproject.toml (statisch, nicht im Lab):

RUN --mount=type=cache,target=/root/.cache/uv \
    --mount=type=secret,id=pypi_user,env=UV_INDEX_INTERN_USERNAME \
    --mount=type=secret,id=pypi_token,env=UV_INDEX_INTERN_PASSWORD \
    uv sync --locked --no-dev

Private Git-Repositories holst du über den SSH-Agenten statt mit einem Key im Image. --mount=type=ssh legt nur den Agent-Socket in den RUN (Standard-ID default, Pfad /run/buildkit/ssh_agent.0), der Schlüssel verlässt deinen Rechner nicht (statisch):

RUN apk add --no-cache git openssh-client \
    && mkdir -p -m 0700 /root/.ssh \
    && ssh-keyscan github.com >> /root/.ssh/known_hosts
RUN --mount=type=ssh,required=true \
    git clone [email protected]:example/private-lib.git /src/private-lib
docker build --ssh default -t notes-api:ssh notes-api

Achtung: ssh-keyscan im Build vertraut dem Host beim ersten Kontakt. In Produktion checkst du die bekannten Fingerprints als known_hosts ein.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Build-Secrets mit Compose

Compose reicht Build-Secrets über build.secrets an BuildKit weiter. Die Quelle definiert der Top-Level-Block secrets:, aus einer Datei oder einer Umgebungsvariablen:

cp "$LAB/code/tag13/notes/compose.yaml" compose.yaml
sed -n '/^services:/,/^  notes-worker:/p;/^secrets:/,$p' compose.yaml

Erwartet:

services:
  notes-api:
    build:
      context: notes-api
      network: host            # Lab: artifact-server auf 127.0.0.1:8081
      secrets:
        - artifact_token       # Tag 13: Build-Secret, landet in keinem Layer
    image: notes-api:tag13
    container_name: notes-api
    env_file: .env
    ports:
      - "127.0.0.1:8080:8080"

  notes-worker:
secrets:
  artifact_token:
    environment: ARTIFACT_TOKEN
  npmrc:
    file: ./secrets/npmrc

Compose baut über docker buildx bake, und bake verlangt für network: host ein ausdrückliches --allow network.host, das docker compose build nicht weiterreicht. Deshalb gibt --print die Build-Definition aus, und bake baut sie. Ein Top-Level-Secret allein gibt noch keinem Build Zugriff; jeder Dienst bekommt nur, was unter seinem build.secrets steht. Die ID im Dockerfile ist der Name des Secrets (lange Syntax: target). Der Server läuft noch mit dem neuen Token aus Drill 6:

export ARTIFACT_TOKEN="$(cat secrets/artifact_token_neu.txt)"
docker compose build --print notes-api \
  | docker buildx bake -f - --no-cache --allow network.host
docker compose config | sed -n '/^secrets:/,$p'

Erwartet (gekürzt, kann je nach Version abweichen):

…
#11 [artifacts 2/2] RUN --mount=type=secret,id=artifact_token,env=ARTIFACT_TOKEN,r…
…
#17 naming to docker.io/library/notes-api:tag13 done
…
secrets:
  artifact_token:
    name: notes_artifact_token
    environment: ARTIFACT_TOKEN
  npmrc:
    name: notes_npmrc
    file: /Users/du/docker-lab/tag13/secrets/npmrc

docker compose config zeigt Variablennamen und Pfade, nie den Wert. Vergleich mit Tag 12: Dort stand der API-Key aus env_file im Klartext in derselben Ausgabe.

Aufräumen (entfernt auch notes-artifacts und notes-probe:tag13):

docker ps -a --filter name=^notes- --format '{{.Names}}' | xargs -r docker rm -f
docker image ls --format '{{.Repository}}:{{.Tag}}' \
  | grep -E '^(notes-|localhost:5001/)' | xargs -r docker rmi
docker buildx prune --builder docker-lab --all --force

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Vor dem Prüfen einmal neu bauen, weil das Aufräumen die Images entfernt hat:

cd ~/docker-lab/tag13
docker build -q -t notes-artifacts:tag13 "$LAB/code/tag13/artifact-server" >/dev/null
docker run -d --name notes-artifacts -p 127.0.0.1:8081:8081 \
  -e ARTIFACT_TOKEN_FILE=/run/token \
  -v "$PWD/secrets/artifact_token.txt:/run/token:ro" notes-artifacts:tag13 >/dev/null
export ARTIFACT_TOKEN="$(cat secrets/artifact_token.txt)"
docker build -q --network=host --secret id=artifact_token,env=ARTIFACT_TOKEN \
  -t notes-api:tag13 notes-api >/dev/null
docker build -q --secret id=npmrc,src=secrets/npmrc -t notes-web:tag13 \
  notes-web >/dev/null

notes-api holt das Artefakt per Secret-Mount:

cd ~/docker-lab/tag13
grep -c 'type=secret,id=artifact_token' notes-api/Dockerfile

Erwartet:

1

Kein Token in ARG oder ENV:

grep -Ec '^(ARG|ENV) .*(TOKEN|KEY)' notes-api/Dockerfile notes-web/Dockerfile

Erwartet:

notes-api/Dockerfile:0
notes-web/Dockerfile:0

secrets/ steht in .gitignore:

grep -x 'secrets/' .gitignore

Erwartet:

secrets/

Das Artefakt ist im Image:

docker create --name notes-probe notes-api:tag13 >/dev/null
docker cp notes-probe:/usr/share/notes/banner.txt - | tar -xO
docker rm notes-probe

Erwartet:

notes – privates Artefakt vom artifact-server (Lab, Tag 13)
notes-probe

Kein Token in notes-api und notes-web:

rm -rf /tmp/img && mkdir /tmp/img
docker save notes-api:tag13 | tar -x -C /tmp/img
for l in /tmp/img/blobs/sha256/*; do tar -xOf "$l" 2>/dev/null; done \
  | grep -ac lab-artifact-token-123
rm -rf /tmp/img && mkdir /tmp/img
docker save notes-web:tag13 | tar -x -C /tmp/img
for l in /tmp/img/blobs/sha256/*; do tar -xOf "$l" 2>/dev/null; done \
  | grep -ac lab-npm-token-123

Erwartet:

0
0

Challenge

Unter ~/docker-lab/code/tag13/falle/ liegt ein Dockerfile, das brav --mount=type=secret benutzt und das Token trotzdem ins Image bringt. Bau es als notes-falle:tag13, weise das Leck in den Layern nach und repariere es so, dass kein Treffer bleibt und das Image weiterhin den Banner ausgibt.

Hinweis: Ein rm in einem späteren RUN löscht nur aus dem obersten Layer.

Lösung

Der Server aus dem Kontrollpunkt läuft noch. Erst das Leck:

cd ~/docker-lab/tag13
grep -n RUN "$LAB/code/tag13/falle/Dockerfile"
docker build -q --network=host \
  --secret id=artifact_token,src=secrets/artifact_token.txt \
  -t notes-falle:tag13 "$LAB/code/tag13/falle" >/dev/null
rm -rf /tmp/img && mkdir /tmp/img
docker save notes-falle:tag13 | tar -x -C /tmp/img
for l in /tmp/img/blobs/sha256/*; do tar -xOf "$l" 2>/dev/null; done \
  | grep -ac lab-artifact-token-123

Erwartet:

8:RUN --mount=type=secret,id=artifact_token cp /run/secrets/artifact_token /app/.token
9:RUN TOKEN_FILE=/app/.token python3 fetch.py \
11:RUN rm /app/.token
1

Der Mount war sauber, aber cp hat den Inhalt in einen eigenen Layer geschrieben, und das rm zwei Schritte später versteckt ihn nur. Die Reparatur liest das Secret direkt im einzigen RUN, der es braucht:

# syntax=docker/dockerfile:1
# Lösung der Challenge (Tag 13): Secret nur im RUN, der es braucht, nie kopieren.
# in Produktion: @sha256:… pinnen, siehe Tag 8
FROM python:3.13-slim
WORKDIR /app
COPY fetch.py ./
RUN --mount=type=secret,id=artifact_token,required=true \
    TOKEN_FILE=/run/secrets/artifact_token python3 fetch.py \
      http://127.0.0.1:8081/tools/notes-banner.txt /app/banner.txt
USER 65532:65532
CMD ["cat", "/app/banner.txt"]
docker build -q --network=host -f "$LAB/code/tag13/falle/Dockerfile.fix" \
  --secret id=artifact_token,src=secrets/artifact_token.txt \
  -t notes-falle:tag13 "$LAB/code/tag13/falle" >/dev/null
rm -rf /tmp/img && mkdir /tmp/img
docker save notes-falle:tag13 | tar -x -C /tmp/img
for l in /tmp/img/blobs/sha256/*; do tar -xOf "$l" 2>/dev/null; done \
  | grep -ac lab-artifact-token-123
docker run --rm notes-falle:tag13
rm -rf /tmp/img
docker ps -a --filter name=^notes- --format '{{.Names}}' | xargs -r docker rm -f
docker image ls --format '{{.Repository}}:{{.Tag}}' \
  | grep -E '^(notes-|localhost:5001/)' | xargs -r docker rmi
docker buildx prune --builder docker-lab --all --force

Erwartet (gekürzt, Namen, IDs und Größen weichen ab):

0
notes – privates Artefakt vom artifact-server (Lab, Tag 13)
notes-artifacts
Untagged: notes-falle:tag13
Deleted: sha256:…
…
Total:  …

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • In CI kommt das Token aus dem Secret-Store der Pipeline (GitLab CI/CD-Variablen als „masked”, GitHub Actions secrets) und geht per --secret id=…,env=… in den Build, nie als --build-arg. docker/build-push-action hat dafür einen eigenen secrets-Eingang.
  • Kurzlebige Tokens (Job-Token, OIDC-Austausch) statt langlebiger Service-Accounts. Dann ist die Cache-Falle aus Drill 6 auch ein Feature: Ein abgelaufenes Token stört einen gecachten Build nicht.
  • Remote-Builder und geteilter Registry-Cache (Tag 4) enthalten keine Secret-Werte, aber die Ergebnisse der RUNs. Was ein RUN mit dem Token herunterlädt, ist für jeden lesbar, der den Cache lesen darf.
  • Für Go-Module aus privaten Repositories: GOPRIVATE plus GIT_AUTH_TOKEN oder --mount=type=ssh. Das Konzept dahinter, Secrets zentral ausstellen und rotieren, vertieft „OpenBao-Secrets zum Anfassen”.
  • Secret-Scans (Tag 11) laufen trotzdem auf jedem Image. Sie fangen genau den Fehler aus der Challenge.