Zum Inhalt springen

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

Teil 6: Caddy und das erste Deployment

Bring das Gästebuch online: hinter Caddy, der sich das HTTPS-Zertifikat selbst holt, und mit Geheimnissen, die auf dem Server bleiben. Dann aktualisier es auf die übliche Art und zähl die Besucher, die einen Fehler sehen.

Quest-Ziele

  • Verstehen, was ein Reverse Proxy tut und warum die App hinter einem steht
  • Den Server-Stack in einer Compose-Datei beschreiben: Caddy, die App und die Datenbank
  • Passwörter in einer Datei halten, die es nur auf dem Server gibt
  • Das Gästebuch auf dem Server starten und über HTTPS erreichen
  • Die Lücke messen, die ein gewöhnliches Update hinterlässt

Der Server ist bereit, und das Image ist in seiner Reichweite. In diesem Teil geht das Gästebuch online, unter seinem eigenen Namen und mit dem Schloss in der Adresszeile. Am Ende aktualisierst du es so, wie die meisten kleinen Websites aktualisiert werden, und siehst zu, was das mit den Leuten macht, die gerade zu Besuch sind.

Ein Türsteher für die App

Das Gästebuch lauscht auf Port 3000 und spricht einfaches HTTP. Das Internet erwartet die Ports 80 und 443 und verschlüsseltes HTTPS. Dazwischen steht ein Reverse Proxy: das eine Programm, das auf den öffentlichen Ports des Servers lauscht, jede Anfrage annimmt und an die App dahinter weiterreicht. Besucher sprechen immer nur mit dem Proxy.

Die Serie nimmt dafür Caddy, vor allem aus einem Grund: Er holt sich das Zertifikat, das HTTPS braucht, selbst und erneuert es, bevor es abläuft. Und weil alle Besucher durch diese eine Tür kommen, ist er auch die Stelle, an der Teil 7 sie von der alten Version zur neuen schicken wird.

Die Dateien des Servers

Der Server braucht zwei kleine Dateien. Sie gehören zum Projekt, also schreibst du sie auf deinem Rechner, in einem neuen Ordner deploy, und kopierst sie hinüber. Zuerst deploy/compose.yml, die alles beschreibt, was auf dem Server läuft:

deploy/compose.yml
name: guestbook

services:
  caddy:
    image: caddy:2-alpine
    restart: unless-stopped
    ports:
      - '80:80'
      - '443:443'
      - '443:443/udp'
    environment:
      DOMAIN: ${DOMAIN}
    volumes:
      - ./caddy:/etc/caddy
      - caddy-data:/data
      - caddy-config:/config

  web:
    image: ${IMAGE}:production
    restart: unless-stopped
    environment:
      DATABASE_URL: postgres://guestbook:${POSTGRES_PASSWORD}@db:5432/guestbook
    depends_on:
      db:
        condition: service_healthy

  db:
    image: postgres:18-alpine
    restart: unless-stopped
    environment:
      POSTGRES_USER: guestbook
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: guestbook
    volumes:
      - db-data:/var/lib/postgresql
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U guestbook']
      interval: 5s
      timeout: 3s
      retries: 10

volumes:
  caddy-data:
  caddy-config:
  db-data:

Sie sieht aus wie die Datei aus Teil 3, mit ein paar Unterschieden, auf die es ankommt:

  • name: guestbook legt den Namen fest, den Compose vor jeden Container setzt, egal wie der Ordner heißt.

  • caddy ist der einzige Service mit ports: 80, 443 und noch einmal 443 für HTTP/3. Sein Caddyfile kommt aus dem Ordner caddy neben der Compose-Datei. Das Zertifikat liegt im Volume caddy-data und überlebt so einen neuen Container.

  • web hat kein build. Es läuft mit ${IMAGE}:production, dem Image aus der Registry. Es veröffentlicht auch keinen Port: Nur Caddy erreicht es, in dem Netzwerk, das Compose für die drei anlegt.

  • db bekommt sein Passwort von außen, genau wie der Name des Images und die Domain. Überall, wo in der Datei ${…} steht, setzt Compose einen Wert aus einer Datei namens .env ein, die du gleich auf dem Server anlegst.

  • restart: unless-stopped startet jeden Container nach einem Absturz oder einem Neustart des Servers wieder.

Die zweite Datei sagt Caddy, was er tun soll. Leg deploy/caddy/Caddyfile an:

deploy/caddy/Caddyfile
{$DOMAIN} {
	encode
	reverse_proxy web:3000
}

Vier Zeilen. Die erste ist die Adresse, auf die die Seite antwortet: Caddy setzt dort den Wert von DOMAIN ein, den ihm die Compose-Datei mitgibt. Ein echter Domainname an dieser Stelle ist alles, was Caddy braucht, um HTTPS einzuschalten. encode komprimiert die Antworten, damit Seiten schneller reisen. reverse_proxy web:3000 reicht jede Anfrage an den Service web auf Port 3000 weiter.

Committe den Ordner und push ihn:

~/projects/guestbook
$ git add deploy$ git commit --message "The server's files"$ git push

Der Push startet die Pipeline, wie jeder Push. Der Ordner deploy steht seit Teil 3 in .dockerignore, der Inhalt des Images ist also derselbe, aber es ist ein neues Image, benannt nach diesem Commit. Warte, bis die Pipeline grün ist. Leg dann den Ordner auf dem Server an und kopier die Dateien dorthin:

~/projects/guestbook
$ ssh deploy@guestbook.example.com mkdir guestbook$ scp -r deploy/* deploy@guestbook.example.com:guestbook/

Geheimnisse bleiben auf dem Server

Die Datenbank braucht ein Passwort, und ein Passwort gehört nicht in ein Repository. Es kommt in die Datei .env, die es nur auf dem Server gibt. Melde dich auf dem Server an, geh mit cd guestbook in den Ordner, lass ihn ein Passwort erfinden und öffne die neue Datei:

deploy@guestbook: ~/guestbook
$ openssl rand -hex 244411f6852782e50c793ad861a0207c304963fb527deec513$ nano .env

Die Datei bekommt drei Zeilen. Nimm deine eigene Domain, deinen eigenen Namen in der Adresse des Images und das Passwort, das du gerade erzeugt hast, nicht das hier gezeigte:

Ich arbeite mit

GitHub

.env
DOMAIN=guestbook.example.com
IMAGE=ghcr.io/your-name/guestbook
POSTGRES_PASSWORD=4411f6852782e50c793ad861a0207c304963fb527deec513

GitLab

.env
DOMAIN=guestbook.example.com
IMAGE=registry.gitlab.com/your-name/guestbook
POSTGRES_PASSWORD=4411f6852782e50c793ad861a0207c304963fb527deec513

In nano speichern Strg+O und Enter die Datei, und Strg+X schließt den Editor. Compose liest eine Datei mit diesem Namen aus dem Ordner, in dem es gestartet wird, ohne dass man es ihm sagt.

Der erste Start

Weiter auf dem Server, in ~/guestbook. Zuerst bekommt die Datenbank ihre Tabelle, aus den Migrationen des Images, wie du es in Teil 3 ausprobiert hast. Dann startet alles:

deploy@guestbook: ~/guestbook
$ docker compose run --rm web node src/migrate.jsApplied 001-create-entries.sqlDatabase is up to date$ docker compose up --detach$ docker compose ps --format 'table {{.Name}}\t{{.Status}}'NAME                STATUSguestbook-caddy-1   Up 5 secondsguestbook-db-1      Up 21 seconds (healthy)guestbook-web-1     Up 5 seconds (healthy)

Der erste Befehl holt zuerst die Images, bevor er irgendetwas anderes tut. Das dauert einen Moment und ist hier weggelassen. Er startet auch die Datenbank und wartet, bis sie gesund ist, weil web von ihr abhängt. Nach dem zweiten Befehl laufen drei Container, und (healthy) neben web ist der Health Check des Images bei der Arbeit. Frag das Gästebuch von deinem eigenen Rechner aus, wie es ihm geht:

~/projects/guestbook
$ curl https://guestbook.example.com/health{"status":"ok","version":"4f2a9c1"}

Schau auf die Adresse: https. In den paar Sekunden seit dem Start hat Caddy bei Let's Encrypt, einer kostenlosen Zertifizierungsstelle, ein Zertifikat angefragt, hat bewiesen, dass die Domain zu diesem Server führt, und hat HTTPS eingeschaltet. Nichts davon hast du eingestellt. Es hat geklappt, weil der Name auf den Server zeigt und die Ports 80 und 443 offen sind, beides aus Teil 5. Die Version in der Antwort ist der Anfang der Commit-ID, aus der das Image gebaut wurde, deine ist also eine andere. Öffne die Adresse jetzt im Browser:

Das Gästebuch unter seiner eigenen Adresse, über HTTPS. Die Fußzeile zeigt, welcher Commit läuft.

Dein Gästebuch ist online. Trag dich ein.

Ein Update auf die einfache Art

Früher oder später änderst du etwas, und die neue Version muss auf den Server. Die meisten kleinen Websites machen das mit zwei Befehlen: das neue Image holen, die Container neu starten. Das funktioniert. Hier siehst du, was es kostet.

Um es zu sehen, brauchst du jemanden, der die Seite ohne Pause besucht. Speicher auf deinem Rechner dieses kleine Skript als knock.sh im Projektordner:

knock.sh
#!/bin/sh
# Knocks on the site ten times a second: a dot for every answer, the status code for every miss.
while true; do
  code=$(curl --silent --output /dev/null --max-time 2 --write-out '%{http_code}' "$1")
  if [ "$code" = 200 ]; then printf .; else printf ' %s ' "$code"; fi
  sleep 0.1
done

Es fragt zehnmal pro Sekunde nach der Seite und gibt für jede Antwort, die in Ordnung ist, einen Punkt aus. Für jede andere Antwort gibt es den Statuscode aus. Es ist ein Werkzeug für dich. Mit einem der nächsten Commits landet es im Repository, was nicht schadet.

Jetzt eine Änderung, die man sieht. Mach in src/page.js aus <h1>Guestbook</h1> ein <h1>Robin's Guestbook</h1>, gern mit deinem eigenen Namen:

~/projects/guestbook
$ git commit --all --message "Say whose guestbook it is"$ git push

Warte, bis die Pipeline grün ist: Dann liegt das neue Image in der Registry, und der Server weiß noch nichts davon. Das Update selbst sind diese zwei Befehle auf dem Server. Führ sie noch nicht aus:

deploy@guestbook: ~/guestbook
$ docker compose pull web$ docker compose up --detach

Starte zuerst das Klopfen auf deinem Rechner und lass es laufen. Führ dann die zwei Befehle auf dem Server aus und beobachte die Punkte. So sahen sie im Test für diese Serie aus:

~/projects/guestbook
$ chmod +x knock.sh$ ./knock.sh https://guestbook.example.com/........................................ 502  502  502  502  502  502  502  502 ..........................................................................

Achtmal hintereinander war die Antwort 502, etwa eine Sekunde lang. Strg+C beendet das Klopfen. Auf der Seite steht jetzt „Robin's Guestbook“, und die Fußzeile zeigt den neuen Commit, das Update hat also geklappt. Aber in dieser Sekunde bekam jeder Besucher eine Fehlerseite statt des Gästebuchs.

Was passiert ist: Compose hat ein neues Image für web gesehen, den alten Container gestoppt und dann den neuen gestartet. Dazwischen gab es gar kein Gästebuch. Caddy hatte niemanden, an den er die Anfragen weiterreichen konnte, und antwortete mit 502, was heißt: „Der Server hinter mir antwortet nicht“.

Eine Sekunde klingt harmlos. Aber es ist eine Sekunde bei jedem Update, sie wird länger mit jeder App, die länger zum Starten braucht als diese kleine, und wer in dem Moment gerade ein Formular abgeschickt hat, hat es verloren. Unter einem Lasttest mit etwa 1.450 Anfragen pro Sekunde sind beim selben Update 80 von etwa 36.000 Anfragen fehlgeschlagen.

Was du jetzt hast

Das Gästebuch läuft auf deinem Server, hinter Caddy, über HTTPS, und sein Passwort steht nicht im Repository. Und du hast die Lücke gemessen, um die es in dieser Serie geht. Im nächsten Teil schließt du sie: Der neue Container startet neben dem alten, beweist, dass er gesund ist, und erst dann ziehen die Besucher um.

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.