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, mitenv=, 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-serverspielt heute dein privates Artefakt-Repository: Er liefert eine Datei nur mitAuthorization: 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.txtErwartet:
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.txtErwartet (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-apiErwartet (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 -1Erwartet (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.hostfehlt, ergänze--allow network.host. In CI hat das Artefakt-Repository einen echten Hostnamen, dann entfällt--network=hostganz.
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 errorErwartet (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 -4Erwartet (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/nullErwartet:
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
RUNdas 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 GETErwartet (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 -1Erwartet (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/DockerfileErwartet:
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-123Erwartet (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-devPrivate 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-libdocker build --ssh default -t notes-api:ssh notes-apiAchtung:
ssh-keyscanim Build vertraut dem Host beim ersten Kontakt. In Produktion checkst du die bekannten Fingerprints alsknown_hostsein.
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.yamlErwartet:
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/npmrcCompose 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 --forceFortschritt 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/nullnotes-api holt das Artefakt per Secret-Mount:
cd ~/docker-lab/tag13
grep -c 'type=secret,id=artifact_token' notes-api/DockerfileErwartet:
1
Kein Token in ARG oder ENV:
grep -Ec '^(ARG|ENV) .*(TOKEN|KEY)' notes-api/Dockerfile notes-web/DockerfileErwartet:
notes-api/Dockerfile:0
notes-web/Dockerfile:0
secrets/ steht in .gitignore:
grep -x 'secrets/' .gitignoreErwartet:
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-probeErwartet:
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-123Erwartet:
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-123Erwartet:
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 --forceErwartet (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-actionhat dafür einen eigenensecrets-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 einRUNmit dem Token herunterlädt, ist für jeden lesbar, der den Cache lesen darf. - Für Go-Module aus privaten Repositories:
GOPRIVATEplusGIT_AUTH_TOKENoder--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.