Zum Inhalt springen

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

Teil 3: Die App im Container

Pack das Gästebuch in ein Docker-Image, das seinen Zustand selbst prüft, lass es mit Docker Compose neben seiner Datenbank laufen und sieh zu, wie es sich sauber beendet, wenn der Container gestoppt wird.

Quest-Ziele

  • Wissen, was ein Image und ein Container sind
  • Ein Dockerfile für eine Node.js-App schreiben, Zeile für Zeile
  • Docker den Health Check selbst abfragen lassen
  • Die App und ihre Datenbank zusammen mit Docker Compose betreiben
  • Das saubere Beenden in einem Container arbeiten sehen
  • Die Commit-ID als Version ins Image einbauen

Bisher läuft das Gästebuch auf deinem Rechner, weil dein Rechner zufällig das richtige Node.js und die richtigen Pakete hat. Ein Server bräuchte dasselbe, von Hand eingerichtet und für immer im Gleichschritt gehalten. Docker löst das mit zwei Dingen:

  • Ein Image ist ein Paket mit deiner App und allem, was sie braucht: Node.js, die installierten Pakete, dein Code. Es wird einmal gebaut und ändert sich nie.

  • Ein Container ist eine laufende Kopie eines Images. Du kannst aus demselben Image so viele starten, wie du willst, und jeder verhält sich gleich, auf deinem Rechner und auf jedem Server.

Das macht den Rest der Serie erst möglich. Der Server wird deinen Quellcode nie sehen und nie npm install ausführen. Er holt nur fertige Images und startet Container daraus. Und „die neue Version neben der alten“ ist nichts weiter als zwei Container aus zwei Images.

Das Dockerfile

Ein Image wird nach einem Rezept gebaut, das Dockerfile heißt. Leg es im Projektordner an, mit genau diesem Namen:

Dockerfile
FROM node:26-alpine

WORKDIR /app
ENV NODE_ENV=production

# The dependencies first: this layer is reused as long as they do not change.
COPY package.json package-lock.json ./
RUN npm ci --omit=dev

COPY src ./src
COPY migrations ./migrations

# Which commit this image was built from. The pipeline passes it in.
ARG APP_VERSION=dev
ENV APP_VERSION=$APP_VERSION

USER node
EXPOSE 3000

HEALTHCHECK --interval=5s --timeout=3s --start-period=20s --start-interval=1s \
  CMD wget --quiet --spider http://127.0.0.1:3000/health || exit 1

CMD ["node", "src/server.js"]

Von oben nach unten:

  • FROM nennt das Image, von dem aus gebaut wird: eines, das Node.js 26 schon enthält, auf Alpine, einem sehr kleinen Linux.

  • WORKDIR ist der Ordner im Image, in dem alles Weitere passiert. NODE_ENV=production sagt Node.js und seinen Paketen, dass das hier der Ernstfall ist, nicht die Entwicklung.

  • Das erste COPY nimmt nur die beiden Paketdateien, und RUN npm ci --omit=dev installiert genau die Versionen, die in package-lock.json stehen, ohne Pakete, die nur für die Entwicklung gebraucht werden. Warum nicht alles auf einmal kopieren? Docker merkt sich das Ergebnis jeder Zeile und verwendet es wieder, solange sich nichts geändert hat, was hineinging. Dein Code ändert sich mit jedem Commit, die Pakete selten. In dieser Reihenfolge überspringt ein neuer Build das Installieren und dauert Sekunden.

  • Die nächsten beiden COPY-Zeilen fügen deinen Code und die Migrationen hinzu.

  • ARG ist ein Wert, der beim Bauen des Images mitgegeben werden kann, und ENV behält ihn als Umgebungsvariable APP_VERSION. Das ist die Variable, die die Fußzeile der Seite liest. Wird nichts mitgegeben, ist sie dev.

  • USER node lässt die App als normalen Benutzer namens node laufen, den das Basis-Image mitbringt, und nicht als Administrator.

  • EXPOSE ist ein Hinweis für Menschen: Diese App lauscht auf Port 3000. Von selbst öffnet die Zeile nichts.

  • CMD ist der Befehl, den ein Container beim Start ausführt.

Bleibt HEALTHCHECK, die Zeile, von der diese Serie abhängt. Mit ihr fragt Docker selbst die Adresse aus Teil 2 ab. Alle fünf Sekunden führt es den Befehl hinter CMD im Container aus: wget ruft /health ab, und --spider heißt, dass es nur fragt und nichts speichert. Ist die Antwort keine 200, schlägt der Befehl fehl. Nach drei Fehlschlägen in Folge markiert Docker den Container als unhealthy.

Eine App braucht einen Moment zum Starten, und für diesen Moment sind die beiden start-Optionen da. In den ersten zwanzig Sekunden zählt eine fehlgeschlagene Prüfung nicht (--start-period), und Docker fragt jede Sekunde statt alle fünf (--start-interval). Ein Container, der nach einer Sekunde bereit ist, gilt also nach einer Sekunde als gesund. In Teil 7 wartet das Deploy-Skript auf genau dieses Wort, healthy, bevor es Besucher zu einem neuen Container schickt.

Nicht alles in deinem Ordner gehört ins Image. Leg .dockerignore an:

.dockerignore
node_modules
.git
.env
deploy

Was hier steht, sieht sich Docker gar nicht erst an. node_modules bleibt draußen, weil das Image seine eigenen Pakete installiert, .git, weil die Historie zum Laufen der App nicht gebraucht wird, und .env, weil Einstellungen und Passwörter in einem Image, das herumgereicht wird, nichts verloren haben. deploy ist ein Ordner, den du in Teil 6 anlegst, für die Dateien des Servers.

Mit Compose starten

Deine compose.yml beschreibt die Datenbank. Jetzt bekommt sie einen zweiten Service, die App. Ersetz die Datei durch das hier:

compose.yml
services:
  web:
    build: .
    ports:
      - '3000:3000'
    environment:
      DATABASE_URL: postgres://guestbook:guestbook@db:5432/guestbook
    depends_on:
      db:
        condition: service_healthy

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

volumes:
  db-data:

Der Service db ist unverändert. Der Service web ist neu:

  • build: . sagt: Für diesen gibt es kein fertiges Image, bau es aus dem Dockerfile in diesem Ordner.

  • ports macht die App von deinem Rechner aus auf Port 3000 erreichbar.

  • DATABASE_URL ist wieder die Adresse der Datenbank, mit einem Unterschied zu deiner .env: Der Rechner heißt db, nicht localhost. In einem Container ist localhost der Container selbst. Compose verbindet seine Services in einem eigenen Netzwerk, in dem jeder unter seinem Namen erreichbar ist.

  • depends_on mit service_healthy lässt Compose die App erst starten, wenn die Datenbank meldet, dass sie bereit ist. Dafür war der healthcheck der Datenbank da.

Läuft npm run dev noch, beende es mit Strg+C: Es belegt den Port, den der Container haben will. Dann bauen und starten:

~/projects/guestbook
$ docker compose up --detach --build$ docker compose ps --format 'table {{.Name}}\t{{.Image}}\t{{.Status}}'NAME              IMAGE                STATUSguestbook-db-1    postgres:18-alpine   Up 4 minutes (healthy)guestbook-web-1   guestbook-web        Up 8 seconds (healthy)$ curl http://localhost:3000/health{"status":"ok","version":"dev"}

Der erste Build dauert eine Minute, weil Docker das Basis-Image holt und die Pakete installiert. Die Liste zeigt dann beide Container, und neben der App das Wort, auf das es ankommt: (healthy). Dafür hat niemand einen Befehl getippt. Docker hat den Health Check von selbst abgefragt, und die App hat geantwortet. Öffne localhost:3000: Es ist dasselbe Gästebuch mit denselben Einträgen, denn sie liegen im Volume der Datenbank.

Freundlich stoppen

Jetzt die zweite Frage aus Teil 2. Stopp den Container der App und sieh dir an, was er geschrieben hat:

~/projects/guestbook
$ docker compose stop web$ docker compose logs webweb-1  | Guestbook listening on port 3000web-1  | SIGTERM received, finishing open requestsweb-1  | All done, bye

Da sind die beiden Zeilen wieder. Docker hat SIGTERM geschickt, die App ist fertig geworden und von selbst gegangen, weit innerhalb der zehn Sekunden, die Docker ihr lässt. Eine App ohne den Handler würde mitten in dem abgeschnitten, was sie gerade tut.

Im Image steckt mehr als die App selbst: Auch die Migrationen und ihr Skript sind darin. Ein Container lässt sich mit einem anderen Befehl starten als dem aus dem Dockerfile:

~/projects/guestbook
$ docker compose run --rm web node src/migrate.jsDatabase is up to date$ docker compose up --detach

docker compose run startet einen Container aus dem Image des Services für eine einzelne Aufgabe, hier das Migrationsskript, und --rm entfernt ihn danach. Es gab nichts zu tun, weil deine Datenbank auf dem neuesten Stand ist. Genau so wird der Server seine Datenbank vor jedem Deployment aktualisieren: mit dem neuen Image, bevor die neue Version startet. Der zweite Befehl startet die App wieder.

Eine Version im Image

Eines fehlt noch: die Version. Git gibt jedem Commit eine ID, und git rev-parse HEAD gibt die deines letzten Commits aus. Gib sie beim Bauen mit:

~/projects/guestbook
$ docker build --build-arg APP_VERSION=$(git rev-parse HEAD) --tag guestbook-test .$ docker run --rm guestbook-test printenv APP_VERSIONa93d0e4c7b1f5a28e6c3d9b0f4a7e1c5d2b8f603

--build-arg füllt das ARG aus dem Dockerfile, und --tag gibt dem Image einen Namen. Der zweite Befehl startet einen Container, der nur die Variable ausgibt: Die ID steckt im Image. Deine ist natürlich eine andere. Die Pipeline wird genau das mit jedem Commit tun, sodass jedes Image weiß, aus welchem Commit es gebaut wurde, und die Fußzeile der Seite seine ersten sieben Zeichen zeigt. Das Test-Image kannst du mit docker image rm guestbook-test wieder löschen.

Commit

Sichere den Stand:

~/projects/guestbook
$ git add .$ git commit --message "The app in a container"$ git push

Was du jetzt hast

Das Gästebuch als Image: nach einem Rezept gebaut, von Docker alle fünf Sekunden geprüft, gestoppt, ohne eine Anfrage zu verlieren, und mit dem Commit markiert, aus dem es stammt. Bisher baust du es von Hand, auf deinem Rechner. Im nächsten Teil erledigt GitHub oder GitLab das für dich bei jedem Push, und nur, wenn die Tests bestehen.

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.