Tag 13: Compose in CI
Ziel: Derselbe Stack läuft in einer Pipeline: bauen, Unit-Tests, starten, gegen den laufenden Stack testen, Exit-Code durchreichen, spurlos aufräumen – auch parallel. · Dauer: ca. 75 min · Voraussetzung: Tag 12
Briefing
compose.ci.yamllegt sich übercompose.yaml: keine Ports nach außen, dafür ein Diensttests, der im Netzfrontendgegen api und web prüft.up --waitist das Gate „Stack gesund”,run --rm testsder Testlauf. Der Exit-Code des Tests wird zum Exit-Code der Pipeline.- Jeder Lauf bekommt mit
-peinen eigenen Projektnamen. So teilen sich zwei Pipelines einen Docker-Daemon, ohne sich zu sehen. - Aufgeräumt wird immer, auch bei Rot:
trapmitdown -v.
ci/pipeline.sh -p ci-<PID>
├─ Lint up --dry-run
├─ Unit-Tests --profile test build api-test
├─ Stack up -d --build --wait
├─ Tests run --rm tests ──► api:8080, web:3000
└─ trap EXIT down -v --remove-orphans, Images ci-<PID>-* löschen
Drill 1: Ports raus mit !reset
source ~/compose-lab/setup/env.sh
docker compose -p notes down
mkdir -p ~/compose-lab/tag13 && cd ~/compose-lab/tag13
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag12/notes/." .Auf einem CI-Runner laufen oft mehrere Pipelines nebeneinander. Ein
veröffentlichter Port wie 127.0.0.1:8080 kann nur einer
belegen. Die Tests laufen ohnehin im Compose-Netz, also brauchen sie
keine Ports:
cat > compose.ci.yaml <<'EOF'
# compose.ci.yaml – CI, nur per -f zusammen mit compose.yaml (Tag 13)
services:
api:
ports: !reset []
proxy:
ports: !reset []
tests:
image: curlimages/curl:8.23.0
profiles: [ci]
entrypoint: ["/bin/sh", "/tests/integration.sh"]
volumes:
- ./tests:/tests:ro
environment:
API_URL: http://api:8080
WEB_URL: http://web:3000
NOTES_API_KEY_FILE: /run/secrets/api_key
secrets: [api_key]
networks: [frontend]
depends_on:
api:
condition: service_healthy
web:
condition: service_healthy
EOF!reset [] leert die Liste aus compose.yaml,
statt sie zu ergänzen (Tag 7). Das Profil ci hält
tests aus einem normalen up heraus: Ohne
Profil startete up --wait den Test-Container mit, und er
lief bei jedem up einmal nebenher. run startet
einen Dienst mit Profil auch ohne --profile.
COMPOSE_FILE spart dir für den Rest des Tages das
doppelte -f (Tag 7):
export COMPOSE_FILE=compose.yaml:compose.ci.yaml
docker compose up -d --build --wait --quiet-pull --quiet-build
docker compose ps --format 'table {{.Service}}\t{{.Ports}}'
curl -s -o /dev/null -w '%{http_code}\n' localhost:8080/healthzErwartet (gekürzt, IDs und Zeiten weichen bei dir ab):
Image notes-worker:dev Built
Image notes-api:dev Built
Image notes-web:dev Built
Container notes-db-1 Healthy
Container notes-migrate-1 Exited
Container notes-api-1 Healthy
Container notes-web-1 Healthy
Container notes-worker-1 Healthy
Container notes-proxy-1 Healthy
SERVICE PORTS
api 8080/tcp
db 5432/tcp
proxy 80/tcp, 443/tcp, 2019/tcp, 443/udp
web 3000/tcp
worker
000
Keine Zeile 127.0.0.1:…->… mehr: Die Ports sind nur
noch im Compose-Netz offen, curl vom Mac bekommt keine
Verbindung (000). --quiet-pull und
--quiet-build halten das CI-Log kurz; Fehler erscheinen
trotzdem.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Integrationstests als Dienst
Das Testskript läuft im Image curlimages/curl –
POSIX-sh und curl, sonst nichts:
mkdir -p tests
cat > tests/integration.sh <<'EOF'
#!/bin/sh
# integration.sh – Integrationstests gegen den laufenden Stack (Tag 13)
# Läuft im Dienst tests (curlimages/curl). Exit-Code = Zahl der Fehler.
API_URL=${API_URL:-http://api:8080}
WEB_URL=${WEB_URL:-http://web:3000}
KEY=$(cat "${NOTES_API_KEY_FILE:-/run/secrets/api_key}") || exit 1
TEXT="ci-$(date +%s)-$$"
JSON='Content-Type: application/json'
fail=0
ok() { echo "✔ $1"; }
bad() { echo "✘ $1"; fail=$((fail + 1)); }
# status <methode> <url> [curl-optionen…] – gibt nur den HTTP-Status aus
status() {
m=$1 u=$2; shift 2
curl -s -o /dev/null -w '%{http_code}' -X "$m" "$@" "$u"
}
# expect <name> <ist> <soll>
expect() {
if [ "$2" = "$3" ]; then ok "$1"; else bad "$1 (erwartet $3, bekommen $2)"; fi
}
expect "api /healthz" "$(status GET "$API_URL/healthz")" 200
expect "web /healthz" "$(status GET "$WEB_URL/healthz")" 200
expect "POST ohne Key → 401" \
"$(status POST "$API_URL/notes" -H "$JSON" -d '{"text":"x"}')" 401
expect "POST mit Key → 201" "$(status POST "$API_URL/notes" -H "$JSON" \
-H "X-API-Key: $KEY" -d "{\"text\":\"$TEXT\"}")" 201
if curl -s "$API_URL/notes" | grep -q "$TEXT"; then
ok "GET /notes enthält die Notiz"
else
bad "GET /notes enthält die Notiz nicht"
fi
expect "POST über web → 201" \
"$(status POST "$WEB_URL/api/notes" -H "$JSON" -d '{"text":"via web"}')" 201
if curl -s "$API_URL/metrics" | grep -q '^notes_created_total [1-9]'; then
ok "/metrics zählt notes_created_total"
else
bad "/metrics ohne notes_created_total > 0"
fi
echo "Fehler: $fail"
exit "$fail"
EOF
chmod +x tests/integration.sh
shellcheck tests/integration.sh; echo "Exit: $?"
docker compose run --rm tests; echo "Exit: $?"Erwartet (gekürzt):
Exit: 0
Container notes-api-1 Running
Container notes-db-1 Running
Container notes-web-1 Running
Container notes-db-1 Healthy
Container notes-migrate-1 Started
Container notes-migrate-1 Exited
Container notes-api-1 Healthy
Container notes-web-1 Healthy
Container notes-tests-run-ed87b0979ea4 Created
✔ api /healthz
✔ web /healthz
✔ POST ohne Key → 401
✔ POST mit Key → 201
✔ GET /notes enthält die Notiz
✔ POST über web → 201
✔ /metrics zählt notes_created_total
Fehler: 0
Exit: 0
run wartet wie up auf die
depends_on-Bedingungen – und startet dabei auch migrate
noch einmal (idempotent, Tag 5). Der Test-Container heißt
notes-tests-run-… und ist nach dem Lauf dank
--rm weg. Jede Notiz bekommt einen eindeutigen Text, damit
ein Treffer aus einem früheren Lauf nicht als Erfolg zählt.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Rot muss rot sein
Ein Test, der nie scheitert, ist keiner. run -e
überschreibt eine Variable nur für diesen Lauf – hier zeigt der Key auf
eine leere Datei:
docker compose run --rm -e NOTES_API_KEY_FILE=/dev/null tests 2>/dev/null
echo "Exit: $?"
docker compose ps -a --format '{{.Service}}' | sort | tr '\n' ' '; echoErwartet:
✔ api /healthz
✔ web /healthz
✔ POST ohne Key → 401
✘ POST mit Key → 201 (erwartet 201, bekommen 401)
✘ GET /notes enthält die Notiz nicht
✔ POST über web → 201
✔ /metrics zählt notes_created_total
Fehler: 2
Exit: 2
api db migrate proxy web worker
Der Exit-Code des Containers kommt unverändert bei dir an, genau das
braucht die Pipeline. Kein tests-run-… bleibt liegen.
Fortschritt speichern? Kostenlos registrieren
Drill 4: --exit-code-from und die
migrate-Falle
Die Alternative zu up -d plus run: alles im
Vordergrund starten und den Exit-Code des Test-Dienstes übernehmen. Laut
docker compose up --help impliziert
--exit-code-from die Option
--abort-on-container-exit – „Stops all containers if any
container was stopped”. Probier es mit dem ganzen Stack:
docker compose down
docker compose --profile ci up --exit-code-from tests
# nach einer halben Minute ohne Fortschritt: Ctrl-C
echo "Exit: $?"
docker compose --profile ci ps -a --format 'table {{.Service}}\t{{.Status}}'Erwartet (gekürzt):
Attaching to api-1, db-1, migrate-1, proxy-1, tests-1, web-1, worker-1
…
migrate-1 | time=… level=INFO msg="migration complete" table=notes
migrate-1 exited with code 0
Compose Stopping Aborting on container exit...
…
db-1 exited with code 0
Container notes-db-1 Error dependency db failed to start
^C
Exit: 130
SERVICE STATUS
api Created
db Exited (0) About a minute ago
migrate Exited (0) About a minute ago
proxy Created
tests Created
web Created
worker Created
Der Einmal-Job migrate endet planmäßig mit 0 – für
--abort-on-container-exit reicht das, um alles zu stoppen.
Die Tests liefen nie, und Compose hing danach, bis du abgebrochen hast.
In einer CI-Pipeline wäre das ein Job, der bis zum Timeout läuft. Die
Lösung: nur den Test-Dienst nennen. Compose startet seine
Abhängigkeiten, hängt sich aber nur an tests:
docker compose up --exit-code-from tests tests; echo "Exit: $?"
docker compose --profile ci ps -a --format 'table {{.Service}}\t{{.Status}}'Erwartet (gekürzt):
Attaching to tests-1
Container notes-tests-1 Started
tests-1 | ✔ api /healthz
tests-1 | ✔ web /healthz
tests-1 | ✔ POST ohne Key → 401
tests-1 | ✔ POST mit Key → 201
tests-1 | ✔ GET /notes enthält die Notiz
tests-1 | ✔ POST über web → 201
tests-1 | ✔ /metrics zählt notes_created_total
tests-1 | Fehler: 0
tests-1 exited with code 0
Compose Stopping Aborting on container exit...
Container notes-tests-1 Stopped
Exit: 0
SERVICE STATUS
api Up 3 seconds (healthy)
db Up 5 seconds (healthy)
migrate Exited (0) 4 seconds ago
tests Exited (0) Less than a second ago
web Up 2 seconds (healthy)
worker und proxy fehlen – sie sind keine Abhängigkeit von
tests. Für die Pipeline bleibt es deshalb bei
up -d --wait für den ganzen Stack und
run --rm tests. Die Variante
--abort-on-container-failure stoppt nur bei einem Exit
ungleich 0; endet der Test grün, läuft up weiter, bis
jemand abbricht.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Ausgabe für CI-Logs
--progress ist eine globale Option (vor dem Unterbefehl)
und kennt laut --help auto, tty,
plain, json und quiet:
docker compose down >/dev/null 2>&1
for p in plain json quiet; do
docker compose --progress "$p" up -d --wait > "p-$p.log" 2>&1
echo "$p: Exit $? · $(wc -l < "p-$p.log" | tr -d ' ') Zeilen"
docker compose down >/dev/null 2>&1
done
head -3 p-plain.log; head -2 p-json.log; cat p-quiet.log; rm p-*.logErwartet:
plain: Exit 0 · 60 Zeilen
json: Exit 0 · 60 Zeilen
quiet: Exit 0 · 0 Zeilen
Network notes_frontend Creating
Network notes_backend Creating
Network notes_backend Creating
{"id":"Network notes_backend","status":"Working","text":"Creating"}
{"id":"Network notes_frontend","status":"Working","text":"Creating"}
Ohne Terminal schreibt Compose 5.6 manche Zeilen doppelt (hier
notes_backend); in diesem Buch sind die Ausgaben deshalb
entdoppelt. json eignet sich zum Filtern mit
jq, quiet für Schritte, deren Exit-Code
reicht. Farben schaltest du mit der globalen Option
--ansi never bzw. bei up mit
--no-color ab.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Parallele Pipelines mit -p
Zwei Pipelines auf demselben Daemon – das ist auf selbst betriebenen Runnern Alltag:
for p in ci-a ci-b; do docker compose -p "$p" --progress quiet up -d --wait & done
wait; echo "beide oben"
docker compose ls --filter name=ci-
docker network ls --filter name=ci- --format '{{.Name}}' | sort
docker volume ls --filter name=ci- --format '{{.Name}}' | sort
docker image ls --format '{{.Repository}}:{{.Tag}}' | grep '^ci-' | sort
for p in ci-a ci-b; do
echo "$p: $(docker compose -p "$p" run --rm tests 2>/dev/null | tail -1)"
doneErwartet (gekürzt):
beide oben
NAME STATUS CONFIG FILES
ci-a running(5) /Users/du/compose-lab/tag13/compose.yaml,/Users/du/…/compose.ci.yaml
ci-b running(5) /Users/du/compose-lab/tag13/compose.yaml,/Users/du/…/compose.ci.yaml
ci-a_backend
ci-a_frontend
ci-a_monitoring
ci-b_backend
ci-b_frontend
ci-b_monitoring
ci-a_caddy_config
ci-a_caddy_data
ci-a_pgdata
ci-b_caddy_config
ci-b_caddy_data
ci-b_pgdata
ci-a-api:dev
ci-a-web:dev
ci-a-worker:dev
ci-b-api:dev
ci-b-web:dev
ci-b-worker:dev
ci-a: Fehler: 0
ci-b: Fehler: 0
Der Projektname steckt in allem: Containern, Netzen, Volumes – und
dank image: ${COMPOSE_PROJECT_NAME}-api:${TAG:-dev} (Tag 8)
auch in den Images. -p setzt diesen Wert für die
Interpolation, auch wenn Compose den Build an Bake übergibt (live
geprüft). Zwei Datenbanken, zwei Netze, kein Kontakt. Und ohne
compose.ci.yaml?
docker compose -f compose.yaml up -d --wait >/dev/null 2>&1 # notes auf Port 8080
docker compose -p ci-c -f compose.yaml up -d --wait 2>&1 | grep 'port is'Erwartet (gekürzt):
Error response from daemon: failed to set up container networking: driver failed
programming external connectivity on endpoint ci-c-api-1 (…): Bind for 127.0.0.1:8080
failed: port is already allocated
Aufräumen – Volumes und die projekteigenen Images gehören dazu:
for p in ci-a ci-b ci-c; do docker compose -p "$p" --progress quiet down -v; done
docker image ls --format '{{.Repository}}:{{.Tag}}' | grep '^ci-' \
| xargs docker image rm | grep -c UntaggedErwartet:
9
down --rmi all wäre hier falsch: Es entfernte auch
postgres:18.6-alpine und caddy:2.11.7-alpine,
die andere Projekte noch brauchen.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Die Pipeline als Skript
Was eben Handarbeit war, kommt in ein Skript, das lokal und im Runner gleich läuft:
mkdir -p ci
cat > ci/pipeline.sh <<'EOF'
#!/usr/bin/env bash
# pipeline.sh – die CI-Pipeline von notes, lokal wie im Runner (Tag 13)
# Aufruf: ci/pipeline.sh [projektname] Standard: ci-<PID>, eindeutig pro Lauf
set -euo pipefail
cd "$(dirname "$0")/.."
P="${1:-ci-$$}"
dc() { docker compose -p "$P" -f compose.yaml -f compose.ci.yaml "$@"; }
# shellcheck disable=SC2329 # wird per trap aufgerufen
cleanup() {
echo "--- Aufräumen: $P"
dc down -v --remove-orphans >/dev/null 2>&1 || true
docker image ls --format '{{.Repository}}:{{.Tag}}' | { grep "^$P-" || true; } \
| xargs -r docker image rm >/dev/null 2>&1 || true
}
trap cleanup EXIT
# Lab-Secrets, falls sie fehlen (frischer Checkout). Im echten Runner kommen
# die Werte aus dem Secret-Store der CI-Plattform, nie aus dem Repository.
lab_secret() { [ -s "secrets/$1" ] || printf '%s' "$2" > "secrets/$1"; }
mkdir -p secrets
lab_secret api_key.txt lab-api-key-123
lab_secret db_password.txt lab-db-pw-123
lab_secret db_url.txt postgres://notes:lab-db-pw-123@db:5432/notes
lab_secret grafana_admin.txt lab-grafana-pw-123
lab_secret npmrc "$(printf '%s\n' '@notes-lab:registry=https://npm.lab.invalid/' \
'//npm.lab.invalid/:_authToken=lab-npm-token-123')"
echo "--- Lint: $P"
# Modell laden und prüfen: Probelauf, legt nichts an und zieht nichts
if ! out=$(dc --dry-run up -d --no-build --pull never 2>&1); then
echo "$out"; exit 1
fi
echo "--- Unit-Tests"
dc --profile test build --quiet api-test
echo "--- Stack starten"
dc up -d --build --wait --wait-timeout 180 --quiet-pull --quiet-build
echo "--- Integrationstests"
rc=0
dc run --rm --quiet-pull tests || rc=$?
echo "--- Ergebnis: Exit $rc"
exit "$rc"
EOF
chmod +x ci/pipeline.sh
shellcheck ci/pipeline.sh; echo "Exit: $?"
unset COMPOSE_FILE
ci/pipeline.sh > pipeline.log 2>&1; echo "Exit: $?"
grep -E '^---|Built|Healthy|Exited|✔|✘|Fehler' pipeline.logErwartet (gekürzt, die PID weicht ab):
Exit: 0
Exit: 0
--- Lint: ci-62179
--- Unit-Tests
Image ci-62179-api:test Built
--- Stack starten
Image ci-62179-api:dev Built
Image ci-62179-web:dev Built
Image ci-62179-worker:dev Built
Container ci-62179-db-1 Healthy
Container ci-62179-migrate-1 Exited
Container ci-62179-api-1 Healthy
Container ci-62179-web-1 Healthy
Container ci-62179-worker-1 Healthy
Container ci-62179-proxy-1 Healthy
--- Integrationstests
✔ api /healthz
✔ web /healthz
✔ POST ohne Key → 401
✔ POST mit Key → 201
✔ GET /notes enthält die Notiz
✔ POST über web → 201
✔ /metrics zählt notes_created_total
Fehler: 0
--- Ergebnis: Exit 0
--- Aufräumen: ci-62179
Drei Entscheidungen im Skript:
trap cleanup EXITläuft bei Grün, bei Rot und bei einem Abbruch mitten im Skript (set -e). Der Lauf hinterlässt weder Container noch Volumes noch Images.- Der Lint ist ein Probelauf:
--dry-runlädt und prüft das komplette Modell (Schema, Interpolation,!reset), ohne etwas anzulegen. Ein Tippfehler wieimagee:endet mitservices.tests.imagee false schemaund Exit 1 (live geprüft). - Die Tests laufen gegen genau die Images, die der Schritt davor
gebaut hat –
ci-62179-api:dev, nicht irgendeinlatest.
Der übliche Lint in Pipelines ist
docker compose config -q: Er gibt nichts aus und endet bei
einer ungültigen Datei mit Exit 1. Ohne -q druckt
config das aufgelöste Modell – mit allen interpolierten
Werten (Tag 4) – ins CI-Log.
docker compose -f compose.yaml -f compose.ci.yaml config -q; echo "Exit: $?"Bei gültigen Dateien bleibt die Ausgabe bis auf Exit: 0
leer. Bei einem Fehler steht die Meldung auf stderr, und der Exit-Code
ist 1.
Fortschritt speichern? Kostenlos registrieren
Drill 8: GitHub Actions und GitLab CI
Beide Plattformen rufen nur noch das Skript auf. Die Dateien liegen fertig im Begleitcode; sie sind gegen die Dokumentation geschrieben, aber nicht auf echten Runnern gelaufen.
cp "$LAB/code/tag13/notes/ci/github-actions.yml" \
"$LAB/code/tag13/notes/ci/gitlab-ci.yml" ci/
cat ci/github-actions.ymlErwartet:
# ci/github-actions.yml – Beispiel (Tag 13), nicht ausgeführt.
# Im Repository als .github/workflows/ci.yml ablegen.
name: ci
on:
push:
pull_request:
jobs:
integration:
runs-on: ubuntu-latest # Docker und das Compose-Plugin sind vorinstalliert
timeout-minutes: 15 # ein hängendes up darf den Runner nicht blockieren
steps:
- uses: actions/checkout@v7
- name: Secrets aus dem Secret-Store
env:
NOTES_API_KEY: ${{ secrets.NOTES_API_KEY }}
run: |
mkdir -p secrets
printf '%s' "$NOTES_API_KEY" > secrets/api_key.txt
- name: Pipeline
run: ci/pipeline.sh "ci-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}"cat ci/gitlab-ci.ymlErwartet:
# ci/gitlab-ci.yml – Beispiel (Tag 13), nicht ausgeführt.
# Im Repository als .gitlab-ci.yml ablegen. Docker-Executor mit Docker-in-Docker:
# jeder Job hat seinen eigenen Docker-Daemon im Dienst docker.
integration:
image: docker:29.9-cli
services:
- docker:29.9-dind
variables:
DOCKER_TLS_CERTDIR: "/certs"
timeout: 15 minutes
before_script:
- apk add --no-cache bash
- mkdir -p secrets
- printf '%s' "$NOTES_API_KEY" > secrets/api_key.txt
script:
- ci/pipeline.sh "ci-${CI_JOB_ID}"Was du daraus mitnimmst:
| Punkt | GitHub Actions | GitLab CI |
|---|---|---|
| Docker-Daemon | auf dem Runner vorinstalliert | Dienst docker:29.9-dind, einer pro Job |
| Timeout | timeout-minutes |
timeout |
| Projektname | GITHUB_RUN_ID + Versuch |
CI_JOB_ID |
| Secret | secrets.NOTES_API_KEY |
maskierte CI/CD-Variable NOTES_API_KEY |
Achtung: Bei GitLab mit Docker-in-Docker teilen sich Job-Container und dind-Dienst laut Doku kein Root-Dateisystem. Bind-Mounts wie
./testsund diefile:-Secrets funktionieren nur, weil das Projekt im Build-Verzeichnis (/builds/…) liegt, das beide sehen. Ein Pfad außerhalb davon ist im Container leer oder fehlt – dieselbe Falle wie mit Colima und/tmp(Tag 0) und wie morgen auf dem Server (Tag 14).
Das Image docker:29.9-cli ist Alpine ohne bash, deshalb
apk add bash. after_script bräuchte das Skript
nicht: Laut GitLab-Doku läuft es bei einem Timeout ohnehin nicht, der
trap im Skript dagegen bei jedem Ende des Skripts
selbst.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
Der Kontrollpunkt startet den normalen Stack auf Port 8080 und lässt die Pipeline daneben laufen. Erst das CI-Modell:
cd ~/compose-lab/tag13
unset COMPOSE_FILE
docker compose -f compose.yaml -f compose.ci.yaml config -q; echo "Exit: $?"Erwartet:
Exit: 0
Der Entwicklungs-Stack läuft:
docker compose -f compose.yaml up -d --waitErwartet (gekürzt):
Container notes-db-1 Healthy
…
Container notes-proxy-1 Healthy
Container notes-web-1 Healthy
Die Pipeline daneben, mit eigenem Projektnamen:
ci/pipeline.sh ci-kp > ci-kp.log 2>&1; echo "Exit: $?"
grep 'Fehler:' ci-kp.logErwartet:
Exit: 0
Fehler: 0
Von ci-kp bleibt nichts übrig:
docker ps -aq --filter label=com.docker.compose.project=ci-kp | wc -l
docker volume ls -q --filter label=com.docker.compose.project=ci-kp | wc -l
docker image ls -q --filter reference='ci-kp-*' | wc -lErwartet:
0
0
0
Den vollständigen Stand findest du in code/tag13/notes/
(compose.ci.yaml, tests/integration.sh,
ci/).
Challenge
Lass zwei Pipelines gleichzeitig laufen: eine aus tag13,
eine aus einer Kopie, in der ein Konfigurationsfehler steckt – web
bekommt seinen API-Key nicht mehr. Die eine muss grün, die andere rot
enden, und danach darf von keiner etwas übrig sein.
Hinweis: Der Wrapper von web liest
/run/secrets/api_key (Tag 10); ein Tippfehler im Dateinamen
genügt, und die Projektnamen übergibst du pipeline.sh als
Argument.
Lösung
cd ~/compose-lab
rm -rf tag13-rot && cp -R tag13 tag13-rot
sed -i '' 's#secrets/api_key)#secrets/apikey)#' tag13-rot/compose.yaml
grep -n 'apikey' tag13-rot/compose.yaml
tag13/ci/pipeline.sh ci-gruen > gruen.log 2>&1 & g=$!
tag13-rot/ci/pipeline.sh ci-rot > rot.log 2>&1 & r=$!
wait $g; echo "grün: Exit $?"; wait $r; echo "rot: Exit $?"
grep -E '✘|Fehler:|Ergebnis' rot.log
for p in ci-gruen ci-rot; do
f="label=com.docker.compose.project=$p"
echo "$p: $(docker ps -aq --filter "$f" | wc -l | tr -d ' ') Container," \
"$(docker volume ls -q --filter "$f" | wc -l | tr -d ' ') Volumes"
doneErwartet:
107: command: ['NOTES_API_KEY="$$(cat /run/secrets/apikey)" exec node server.js']
grün: Exit 0
rot: Exit 1
✘ POST über web → 201 (erwartet 201, bekommen 401)
Fehler: 1
--- Ergebnis: Exit 1
ci-gruen: 0 Container, 0 Volumes
ci-rot: 0 Container, 0 Volumes
Der Fehler ist tückisch: web startet und ist healthy,
denn /healthz braucht keinen Key. Erst der Integrationstest
findet ihn. Beide Läufe teilten sich Daemon, Basis-Images und
Build-Cache, aber kein Netz und kein Volume. Aufräumen:
rm -rf ~/compose-lab/tag13-rot ~/compose-lab/gruen.log ~/compose-lab/rot.log
cd ~/compose-lab/tag13 && docker compose downFortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Auf geteilten Runnern ist der eindeutige Projektname Pflicht, das
Aufräumen auch. Besser ist ein eigener Daemon pro Job (GitLab-dind,
kurzlebige VMs); dind braucht allerdings
privileged– auf geteilten Kubernetes-Runnern eine Sicherheitsfrage. - Einmal bauen, dann dasselbe Image (per Digest) durch Test, Staging und Produktion schieben. Die Pipeline von heute baut pro Lauf neu – für ein Lab in Ordnung.
- Bei Rot die Logs aller Dienste sichern, bevor
downsie löscht (docker compose logs --no-color > stack.logimtrap), und als Artefakt hochladen (GitLab:artifacts: when: always). - Secrets kommen aus dem Secret-Store der Plattform, maskiert und nur
für geschützte Branches.
configohne-qundset -xgehören nicht in ein CI-Log. - Ein Timeout pro Job (
timeout-minutes,timeout) und--wait-timeoutbeiupverhindern Läufe, die stundenlang einen Runner blockieren (Drill 4).