Zum Inhalt springen

Deployments ohne Ausfall für Node-Apps mit Docker Compose · Teil 7 von 11 der Serie

Teil 7: Container tauschen ohne Lücke

Schreib das Deploy-Skript, das die Lücke schließt: Es startet den neuen Container neben dem alten, wartet, bis er gesund ist, schickt die Besucher hinüber und lässt erst dann den alten gehen.

Quest-Ziele

  • Verstehen, warum es die Lücke schließt, den neuen Container vor dem Stoppen des alten zu starten
  • Caddy den Container beim Namen nennen, der die Besucher bekommt, und Caddy ohne Unterbrechung neu laden
  • Ein Deploy-Skript aus sechs Schritten schreiben und wissen, was jede Zeile tut
  • Es ausführen, während Anfragen eintreffen, und sehen, dass keine verloren geht
  • Die eine Regel kennen, mit der das Ganze ab jetzt funktioniert

Im letzten Teil hat ein Update etwa eine Sekunde lang Fehlerseiten gekostet. Der Grund war die Reihenfolge: Compose hat zuerst den alten Container gestoppt und danach den neuen gestartet, und dazwischen war niemand da, der antwortet.

Also dreh die Reihenfolge um. Starte den neuen Container neben dem alten, lass ihn beweisen, dass er funktioniert, schick die Besucher zu ihm, und bitte erst dann den alten, fertig zu werden und zu gehen.

Die Weiche ist gestellt: Der Strom der Besucher fließt zum neuen Container, und der alte verabschiedet seinen letzten Gast.
Die Weiche ist gestellt: Der Strom der Besucher fließt zum neuen Container, und der alte verabschiedet seinen letzten Gast.

Mehr baut dieser Teil nicht: ein Skript von etwa sechzig Zeilen, das diese sechs Dinge tut, jedes Mal, wenn eine neue Version wartet:

  1. Das Image namens production holen und prüfen, ob es ein neues ist.

  2. Die Datenbank auf den neuesten Stand bringen.

  3. Einen Container aus dem neuen Image neben dem alten starten.

  4. Warten, bis der neue Container meldet, dass er gesund ist.

  5. Die Besucher zum neuen Container schicken.

  6. Den alten Container seine offenen Anfragen beenden lassen und ihn dann entfernen.

Für die Schritte 4 und 6 hat die App in Teil 2 ihre zwei Fähigkeiten gelernt: Der Health Check beantwortet „Bist du bereit?“, und das saubere Beenden ist das „Mach fertig und geh“.

Caddy den Namen sagen

Bisher hat Caddy jede Anfrage an web weitergereicht, welcher Container das auch gerade war. Für einen Moment wird es zwei davon geben, und nur einer soll Besucher bekommen. Deshalb nennt ab jetzt eine kleine Datei diesen einen Container beim Namen. Ändere auf deinem Rechner deploy/caddy/Caddyfile:

deploy/caddy/Caddyfile
{$DOMAIN} {
	encode
	import upstream.caddy
}

import setzt an dieser Stelle den Inhalt einer anderen Datei ein. Diese Datei, upstream.caddy, enthält eine einzige Zeile: wohin die Anfragen gehen. Das Skript schreibt sie bei jedem Deployment neu, deshalb liegt sie nur auf dem Server, wie die .env, und nicht in deinem Repository. Im Moment läuft deine App im Container guestbook-web-1, die erste Fassung der Datei ist also:

caddy/upstream.caddy
reverse_proxy guestbook-web-1:3000

Jetzt auf dem Server, im Ordner ~/guestbook: Leg diese Datei an, mach dort dieselbe Änderung am Caddyfile, und sag Caddy, dass er seine Einstellungen neu lesen soll:

deploy@guestbook: ~/guestbook
$ echo "reverse_proxy guestbook-web-1:3000" > caddy/upstream.caddy$ nano caddy/Caddyfile$ docker compose exec caddy caddy reload --config /etc/caddy/Caddyfile

Ein Reload ist kein Neustart. Caddy läuft weiter, beantwortet die offenen Anfragen noch mit den alten Einstellungen und verwendet die neuen für alles, was danach kommt. Deine Seite war die ganze Zeit erreichbar, und sie zeigt immer noch dasselbe: Die Datei nennt denselben Container, den web vorher gemeint hat.

Das Deploy-Skript

Zurück auf deinem Rechner: Leg deploy/deploy.sh an:

deploy/deploy.sh
#!/bin/sh
# Brings the newest image online without a gap: the new container starts beside the old
# one, has to prove it is healthy, gets the visitors, and only then the old one leaves.
set -eu
cd "$(dirname "$0")"
# Compose reports every step it takes. The log should hold only what matters.
export COMPOSE_PROGRESS=quiet

say() { echo "$(date +%H:%M:%S) $*"; }

# 1. Fetch the image the registry calls "production" and compare it with what is running.
docker compose pull --quiet web
image=$(grep "^IMAGE=" .env | cut -d = -f 2-):production
wanted=$(docker image inspect --format '{{.Id}}' "$image")
old=$(docker compose ps --quiet web)
running=""
if [ -n "$old" ]; then running=$(docker inspect --format '{{.Image}}' "$old"); fi

if [ "$wanted" = "$running" ]; then
  say "Nothing new"
  exit 0
fi

# 2. Bring the database up to date, with the new image's migrations.
say "New image found, updating the database"
docker compose run --rm -T web node src/migrate.js

# 3. Start a container from the new image beside the old one.
say "Starting the new container"
count=$(echo $old | wc -w)
docker compose up --detach --no-deps --no-recreate --scale web=$((count + 1)) web
new=$(docker compose ps --quiet web | grep --invert-match --fixed-strings "${old:-none}")

# 4. Wait until it reports healthy, for a minute at most.
status=starting
for attempt in $(seq 1 30); do
  status=$(docker inspect --format '{{.State.Health.Status}}' "$new")
  if [ "$status" = healthy ]; then break; fi
  sleep 2
done

if [ "$status" != healthy ]; then
  say "The new container did not get healthy, the old version keeps running. Its last words:"
  docker logs --tail 20 "$new"
  docker rm --force "$new" > /dev/null
  exit 1
fi

# 5. Send the visitors to the new container.
name=$(docker inspect --format '{{.Name}}' "$new" | cut -c 2-)
echo "reverse_proxy $name:3000" > caddy/upstream.caddy
docker compose up --detach caddy
docker compose exec -T caddy caddy reload --config /etc/caddy/Caddyfile
say "Visitors now reach $name"

# 6. Let the old container finish its open requests, then remove it.
if [ -n "$old" ]; then
  docker stop "$old" > /dev/null
  docker rm "$old" > /dev/null
fi
docker image prune --force > /dev/null

say "Version $(docker exec "$new" printenv APP_VERSION | cut -c 1-7) is live"

Das sind viele Zeilen auf einmal, aber jede ist ein Befehl, den du auch selbst tippen könntest.

Das Skript, Schritt für Schritt

Die ersten Zeilen. set -eu macht das Skript vorsichtig: Es hört beim ersten Befehl auf, der fehlschlägt, statt einfach weiterzumachen, und es behandelt eine falsch geschriebene Variable als Fehler. Die cd-Zeile wechselt in den Ordner, in dem das Skript liegt, damit es funktioniert, egal von wo es gestartet wird. COMPOSE_PROGRESS=quiet hält Compose davon ab, jeden kleinen Schritt zu melden, und say ist ein winziger Helfer, der eine Zeile mit der Uhrzeit davor ausgibt.

1. Holen und vergleichen. docker compose pull fragt die Registry nach dem Image namens production und lädt es herunter, falls es noch nicht auf dem Server liegt. Die nächste Zeile liest den Namen des Images aus der .env: grep findet die Zeile, die mit IMAGE= beginnt, cut behält, was nach dem Gleichheitszeichen steht. Jedes Image hat eine ID, einen Fingerabdruck seines Inhalts. wanted ist die ID des Images, das die Registry production nennt, und running die ID des Images, aus dem der laufende Container gestartet wurde. Sind beide gleich, gibt es nichts zu tun: Das Skript sagt Nothing new und endet. Das wird der häufigste Fall sein.

2. Die Datenbank. docker compose run startet einen Container aus dem neuen Image für eine einzige Aufgabe: das Migrationsskript aus Teil 1. --rm entfernt diesen Container, wenn er fertig ist, und -T sagt, dass niemand an einem Terminal sitzt. Schlägt eine Migration fehl, beendet set -e das Skript an dieser Stelle, bevor sich für deine Besucher irgendetwas geändert hat.

3. Der neue Container. Das ist das Herzstück. --scale web=…, normalerweise 2, verlangt von Compose zwei Container des Service web statt einem, und --no-recreate sagt ihm, dass es den vorhandenen genau so lassen soll, wie er ist. Compose fügt also einen Container hinzu, und weil production jetzt das neue Image meint, läuft in diesem Container die neue Version. --no-deps lässt die Datenbank in Ruhe. Das Skript zählt, statt einfach 2 zu schreiben, damit es auch beim allerersten Lauf funktioniert, wenn es noch keinen alten Container gibt. Die letzte Zeile des Schritts findet den Neuling: Sie listet die Container von web auf und streicht den alten von der Liste.

4. Auf „healthy“ warten. Der neue Container läuft, aber noch besucht ihn niemand: Caddy schickt weiterhin alle zum alten. Alle zwei Sekunden fragt das Skript Docker nach dem Zustand des Containers, den Docker vom HEALTHCHECK in deinem Dockerfile kennt. Er wechselt von starting zu healthy, sobald /health mit 200 antwortet. Ist das nach dreißig Versuchen, einer Minute, nicht passiert, gibt das Skript auf: Es gibt die letzten Logzeilen des Containers aus, entfernt ihn und endet mit einem Fehler. Der alte Container wurde nie angerührt, deine Besucher merken also nichts von einer Version, die nicht funktioniert.

5. Die Besucher umleiten. Das Skript fragt Docker nach dem Namen des neuen Containers, etwa guestbook-web-2 (das cut entfernt einen Schrägstrich, den Docker davorsetzt), schreibt ihn in caddy/upstream.caddy und lädt Caddy neu, wie du es eben von Hand getan hast. Die Zeile vor dem Reload stellt sicher, dass Caddy überhaupt läuft, und tut nichts, wenn er das schon tut. Von diesem Moment an geht jede neue Anfrage an die neue Version.

6. Den alten verabschieden. docker stop schickt dem alten Container das Signal SIGTERM. Für diesen Moment wurde der Code zum Beenden in Teil 2 geschrieben: Die alte App nimmt keine neuen Anfragen mehr an, beantwortet die, an denen sie noch arbeitet, schließt ihre Datenbankverbindungen und endet. Dann wird der Container entfernt. docker image prune löscht Images, auf die kein Name mehr zeigt, etwa das, das production vorher gemeint hat, damit die Festplatte nicht vollläuft. Die letzte Zeile fragt den neuen Container, welche Version er ist, und gibt sie aus.

Ausführen

Kopier das Skript auf den Server und erlaube, dass es ausgeführt wird:

~/projects/guestbook
$ scp deploy/deploy.sh deploy@guestbook.example.com:guestbook/$ ssh deploy@guestbook.example.com chmod +x guestbook/deploy.sh

Jetzt gib ihm etwas zu deployen. Ändere in src/page.js den Text des Buttons von Sign the guestbook zu Sign it und pushe. git add . nimmt die neuen Dateien in deploy/ mit, damit auch das Skript in deinem Repository liegt:

~/projects/guestbook
$ git add .$ git commit --message "A shorter button"$ git push

Warte, bis die Pipeline das Image gebaut hat. Starte dann in einem Terminal auf deinem Rechner das Anklopfen aus dem letzten Teil und lass es laufen:

~/projects/guestbook
$ ./knock.sh https://guestbook.example.com/.............................................................................................................................................

Während es klopft, führ auf dem Server in ~/guestbook das Skript aus:

deploy@guestbook: ~/guestbook
$ ./deploy.sh10:06:10 New image found, updating the databaseDatabase is up to date10:06:12 Starting the new container{"level":"info","ts":1794906374.6582832,"msg":"using config from file","file":"/etc/caddy/Caddyfile"}{"level":"info","ts":1794906374.6588163,"msg":"adapted config to JSON","adapter":"caddyfile"}10:06:14 Visitors now reach guestbook-web-210:06:14 Version c41f0a9 is live$ ./deploy.sh10:06:15 Nothing new

Vier Sekunden von „new image found“ bis „is live“, und im anderen Terminal nichts als Punkte. Kein einziger 502. Lade die Seite im Browser neu: Der Button ist kürzer, und in der Fußzeile steht c41f0a9.

Die beiden Zeilen in geschweiften Klammern sind Caddy, der bestätigt, dass er seine neuen Einstellungen gelesen hat. Der zweite Lauf des Skripts zeigt den Normalfall: Das Image hat sich nicht geändert, also sagt es Nothing new und ist nach einer Sekunde fertig.

Sieh dir an, was auf dem Server jetzt läuft:

deploy@guestbook: ~/guestbook
$ docker compose ps --format 'table {{.Name}}\t{{.Status}}'NAME                STATUSguestbook-caddy-1   Up 4 minutesguestbook-db-1      Up 4 minutes (healthy)guestbook-web-2     Up 3 seconds (healthy)$ cat caddy/upstream.caddyreverse_proxy guestbook-web-2:3000

Der Container heißt guestbook-web-2, der erste ist weg, und die Datei nennt den neuen. Mit jedem Deployment zählt die Nummer weiter.

Wie sicher ist das?

Zehnmal Anklopfen pro Sekunde ist ein kleiner Test. Für diese Serie lief das Skript auch unter einem Lasttest mit mehr als tausend Anfragen pro Sekunde, verbunden so, wie Browser es tun, mit HTTP/2 über HTTPS. Drei Deployments hintereinander haben 0 von etwa 48.000 Anfragen verloren, und darunter waren auch die, die sich ins Gästebuch eingetragen haben, während die Container getauscht wurden. Das einfache Update aus dem letzten Teil hat unter vergleichbarer Last 80 von etwa 36.000 verloren.

Was du jetzt hast

Ein Befehl auf dem Server bringt eine neue Version online, und kein Besucher sieht dabei eine Fehlerseite. Eine Version, die nicht gesund wird, begegnet gar keinem Besucher.

Noch musst du dich aber einloggen und diesen Befehl tippen. Im nächsten Teil lernt der Server, selbst nach neuen Versionen zu schauen, einmal pro Minute, und die Pipeline ist komplett: Du pushst, und kurz darauf ist die neue Version live.

Kommentare

Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.

Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.