Zum Inhalt springen
Trainingslager IT-Trainingslager

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.yaml legt sich über compose.yaml: keine Ports nach außen, dafür ein Dienst tests, der im Netz frontend gegen api und web prüft.
  • up --wait ist das Gate „Stack gesund”, run --rm tests der Testlauf. Der Exit-Code des Tests wird zum Exit-Code der Pipeline.
  • Jeder Lauf bekommt mit -p einen eigenen Projektnamen. So teilen sich zwei Pipelines einen Docker-Daemon, ohne sich zu sehen.
  • Aufgeräumt wird immer, auch bei Rot: trap mit down -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/healthz

Erwartet (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' ' '; echo

Erwartet:

✔ 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-*.log

Erwartet:

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)"
done

Erwartet (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 Untagged

Erwartet:

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.log

Erwartet (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 EXIT lä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-run lädt und prüft das komplette Modell (Schema, Interpolation, !reset), ohne etwas anzulegen. Ein Tippfehler wie imagee: endet mit services.tests.imagee false schema und Exit 1 (live geprüft).
  • Die Tests laufen gegen genau die Images, die der Schritt davor gebaut hat – ci-62179-api:dev, nicht irgendein latest.

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.yml

Erwartet:

# 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.yml

Erwartet:

# 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 ./tests und die file:-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 --wait

Erwartet (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.log

Erwartet:

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 -l

Erwartet:

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"
done

Erwartet:

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 down

Fortschritt 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 down sie löscht (docker compose logs --no-color > stack.log im trap), und als Artefakt hochladen (GitLab: artifacts: when: always).
  • Secrets kommen aus dem Secret-Store der Plattform, maskiert und nur für geschützte Branches. config ohne -q und set -x gehören nicht in ein CI-Log.
  • Ein Timeout pro Job (timeout-minutes, timeout) und --wait-timeout bei up verhindern Läufe, die stundenlang einen Runner blockieren (Drill 4).