Node.js mit Docker verwenden: Schritt-für-Schritt-Anleitung

Mit Node.js und Docker können Sie schnelle, skalierbare Anwendungen erstellen und sie in sicheren, ressourcenschonenden Containern bereitstellen.

Diese Kombination bietet erhebliche Vorteile, darunter Portabilität – sodass Ihre App überall auf dieselbe Weise ausgeführt wird – sowie Konsistenz zwischen Entwicklungs- und Produktionsumgebungen.

Wenn Sie Ihre App containerisieren, nutzen Sie Ressourcen effizienter und vereinfachen gleichzeitig den Bereitstellungsprozess.

Im Folgenden zeigen wir Ihnen Schritt für Schritt, wie Sie eine Node.js-Anwendung von Grund auf in Docker einrichten. Sie erfahren außerdem, wie Sie ein bestehendes Projekt containerisieren, Ihre containerisierte Anwendung testen und Best Practices für ein produktionsreifes Setup anwenden.

Voraussetzungen für die Verwendung von Node.js mit Docker

Bevor Sie beginnen, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind:

• Virtueller privater Server (VPS). Sie können dieser Anleitung zwar auf Ihrem eigenen Rechner folgen, für den Produktivbetrieb Ihrer App benötigen Sie jedoch einen VPS. Der KVM-2-Tarif von Hostinger ist ein hervorragender Einstieg für kleine bis mittelgroße Projekte und bietet 2 vCPU-Kerne, 8 GB RAM und 100 GB NVMe-Speicher für €7.99/Monat.
• Docker wird auf Ihrem System ausgeführt. Hostinger-Kunden können Docker mit nur wenigen Klicks auf ihrem VPS installieren, indem sie unsere vorkonfigurierte Vorlage verwenden.
• Node.js ist installiert und konfiguriert. Falls Sie dies noch nicht getan haben, folgen Sie unserer Anleitung zur Installation von Node.js und NPM auf Ihrem Ubuntu-Server.
• Grundlegende Kenntnisse von Docker-Befehlen. Vertrautheit mit Befehlen wie docker build und docker run ist hilfreich, da Sie diese im Terminal häufig ausführen werden.

Einrichten einer Node.js-App in Docker

Um einen einfachen Node.js-Docker-Container zu erstellen, gehen Sie wie folgt vor. Zunächst wählen Sie ein Basis-Image aus und zum Schluss führen Sie Ihre erste containerisierte App aus.

1. Das richtige Node.js-Docker-Image auswählen

Wählen Sie zunächst ein Basis-Image für Ihren Container aus. Das offizielle Node.js-Docker-Image stellt mehrere vorgefertigte Optionen bereit, die für unterschiedliche Anforderungen optimiert sind.

Zu den wichtigsten Typen gehören:

• Vollständige Bilder. Größere Images, die viele Tools und Bibliotheken enthalten und sich daher gut für Entwicklung und Debugging eignen. Beispiel: node:24.
• Schlanke Images. Leichter als vollständige Images und enthält nur die wesentlichen Komponenten, die zum Ausführen von Node.js benötigt werden. Beispiel: node:24-slim.
• Alpine Bilder. Äußerst schlanke Images auf Basis von Alpine Linux. Durch ihre geringe Größe verringern sie die Angriffsfläche und sind damit das beste Docker-Image für Node.js in Produktionsumgebungen. Beispiel: node:24-alpine.

Für produktive Umgebungen empfehlen wir, Alpine-Images zu verwenden, damit Ihre Container klein, schnell und sicher bleiben.

2. Eine einfache Node.js-Anwendung erstellen

Erstellen Sie als Nächstes eine einfache Node.js-App. Öffnen Sie Ihr Terminal und stellen Sie per SSH eine Verbindung zu Ihrem VPS her:

ssh root@your_vps_ip

Hostinger-VPS-Nutzer finden die IP-Adresse ihres Servers in hPanel → VPS → Manage → Overview → VPS details.

Nachdem Sie sich angemeldet haben, erstellen Sie ein neues Projektverzeichnis und wechseln Sie in dieses Verzeichnis:

mkdir node-docker-app && cd node-docker-app

Initialisieren Sie das Projekt mit npm. Dabei wird eine Datei namens package.json erzeugt, mit der Sie die Metadaten und Abhängigkeiten Ihrer App verwalten.

npm init -y

Erstellen Sie nun mit einem Texteditor wie nano eine Datei mit dem Namen app.js:

nano app.js

Fügen Sie den folgenden Code in die Datei ein. Dieses Skript richtet einen einfachen HTTP-Server ein, der mit „Hello, Docker!“ antwortet:

const http = require("http");

const port = 3000;

const server = http.createServer((req, res) => {
  res.writeHead(200, { "Content-Type": "text/plain" });
  res.end("Hello, Docker!");
});

server.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

Speichern Sie die Datei und beenden Sie nano, indem Sie Strg + X → Y → Eingabetaste drücken.

3. Ein einfaches Dockerfile schreiben

Eine Dockerfile ist eine Textdatei mit Schritt-für-Schritt-Anweisungen zum Erstellen eines Docker-Images. Erstellen Sie im Hauptverzeichnis Ihres Projekts eine Datei mit dem Namen Dockerfile ohne Erweiterung:

nano Dockerfile

Fügen Sie den folgenden Inhalt hinzu. Dies ist ein einfaches Beispiel für eine Node.js-Dockerfile:

# Alpine-basiertes Node.js-Image verwenden
FROM node:24-alpine

# Arbeitsverzeichnis im Container festlegen
WORKDIR /app

# package.json und package-lock.json kopieren
COPY package*.json ./

# Anwendungsabhängigkeiten installieren
RUN npm install

# Restlichen Anwendungsquellcode kopieren
COPY . .

# Port 3000 für externe Zugriffe freigeben
EXPOSE 3000

# Befehl zum Starten der Anwendung
CMD ["node", "app.js"]

Speichern Sie die Datei und schließen Sie sie, wenn Sie fertig sind.

4. Erstellen des Images

Nachdem Sie die Dockerfile erstellt haben, bauen Sie Ihr Docker-Image, indem Sie in dem Projektverzeichnis diesen Befehl ausführen:

docker build -t node-docker-app .

Der Schalter -t versieht das Image mit dem Namen node-docker-app. Wenn der Build erfolgreich abgeschlossen ist, zeigt Docker eine Bestätigungsnachricht an.

5. Den Container ausführen

Sobald das Image erstellt ist, führen Sie Node.js in einem Docker-Container mit diesem Befehl aus:

docker run -d -p 3000:3000 node-docker-app

Der Parameter -p 3000:3000 ordnet Port 3000 auf Ihrem Server Port 3000 im Container zu, während der Parameter -d den Container im Detached-Modus (also im Hintergrund) ausführt.

Öffnen Sie Ihren Browser und gehen Sie zu http://your_vps_ip:3000, um zu überprüfen, ob es funktioniert. Sie sollten die Meldung „Hello, Docker!“ sehen.

Nachdem Sie nun eine einfache Anwendung erstellt und ausgeführt haben, sehen wir uns an, wie Sie eine komplexere Node.js-App dockerisieren.

Eine bestehende Node.js-Anwendung containerisieren

Um ein bestehendes Node.js-Projekt zu containerisieren, bereiten Sie Ihre App vor, erstellen Sie eine Ignore-Datei, um das Image schlank zu halten, und schreiben Sie ein optimiertes Dockerfile.

1. Die Anwendung für Docker vorbereiten

Bevor Sie beginnen, stellen Sie sicher, dass Ihr bestehendes Projekt für die Containerisierung bereit ist.

• Überprüfen Sie die Datei package.json. Stellen Sie sicher, dass alle Abhängigkeiten korrekt aufgeführt sind und ein Startskript zum Starten der App enthalten ist.
• Abhängigkeiten sperren. Führen Sie npm install aus, um die Datei package-lock.json zu erstellen oder zu aktualisieren. Dies garantiert in allen Umgebungen konsistente Versionen der Abhängigkeiten.
• Testen Sie lokal. Führen Sie auf Ihrem Rechner den Befehl npm start aus, um zu überprüfen, ob alles wie erwartet funktioniert, bevor Sie fortfahren.

2. Erstellen einer .dockerignore-Datei

Eine .dockerignore -Datei verhindert, dass bestimmte Dateien und Verzeichnisse in Ihr Docker-Image kopiert werden. Dadurch bleibt das Bild klein und geschützt.

Erstellen Sie im Projektstammverzeichnis mit nano eine Datei mit dem Namen .dockerignore und fügen Sie den folgenden Inhalt ein:

node_modules
npm-debug.log
.env
.DS_Store
logs/
tmp/
dist/
coverage/

Diese Datei schließt Folgendes aus:

• node_modules. Der Container installiert die Abhängigkeiten, sodass Sie den lokalen Ordner nicht benötigen.
• npm-debug.log, logs/, tmp/. Protokolle und temporäre Dateien, die in der Produktion nicht benötigt werden.env. Enthält vertrauliche Schlüssel und darf niemals in ein Bild eingefügt werden.
• dist/, coverage/. Build-Artefakte und Testberichte, die nicht benötigt werden, um die App auszuführen.

3. Ein produktionsreifes Dockerfile schreiben

Eine produktionsreife Dockerfile optimiert Ihre Anwendung in Bezug auf Sicherheit und Leistung. Es verwendet ein minimales Basis-Image, installiert nur Produktionsabhängigkeiten und setzt die richtigen Umgebungsvariablen.

Hier ein Beispiel:

# Leichtgewichtiges Node.js-Basis-Image verwenden
FROM node:24-alpine

# Arbeitsverzeichnis festlegen
WORKDIR /usr/src/app

# Paketdateien kopieren und nur Produktionsabhängigkeiten installieren
COPY package*.json ./
RUN npm ci --omit=dev

# Anwendungsdateien kopieren
COPY . .

# Umgebungsvariablen für die Produktionsumgebung festlegen
ENV NODE_ENV=production

# Anwendungsport freigeben
EXPOSE 3000

# Befehl zum Starten der Anwendung
CMD ["node", "app.js"]

Jede Anweisung in der Dockerfile hat einen bestimmten Zweck:

4. Optimierung mit mehrstufigen Builds

Für Apps, die einen Build-Schritt benötigen, etwa das Transpilieren von TypeScript oder das Bündeln mit Webpack, eignet sich ein mehrstufiges Dockerfile für Node.js am besten.

Bei dieser Technik wird die Build-Umgebung von der späteren Laufzeitumgebung getrennt, was zu einem deutlich kleineren Produktions-Image führt.

Ein Multi-Stage-Build verwendet mehrere FROM -Anweisungen. Die erste Phase erstellt die App und ihre Assets, und die zweite Phase kopiert nur die benötigten Build-Dateien in ein sauberes Image.

Im Folgenden sehen Sie ein Beispiel für ein mehrstufiges Dockerfile:

# Phase 1: Anwendung erstellen
FROM node:24-alpine AS builder
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Phase 2: Produktions-Image erstellen
FROM node:24-alpine
WORKDIR /usr/src/app

# Erstellte Dateien und Produktionsabhängigkeiten kopieren
COPY --from=builder /usr/src/app/dist ./dist
COPY package*.json ./
RUN npm ci --omit=dev

# Umgebungsvariablen festlegen
ENV NODE_ENV=production

# Anwendungsport freigeben
EXPOSE 3000

# Anwendung starten
CMD ["node", "dist/app.js"]

Mit diesem Ansatz entsteht ein finales Image, das nur das enthält, was zum Ausführen der App erforderlich ist – und dadurch kleiner, schneller und sicherer ist.

Nachdem Sie Ihre optimierte Dockerfile erstellt haben, bauen und starten Sie das Image mit denselben Befehlen docker build und docker run wie zuvor. Jetzt sind Sie bereit, Ihren Container zu testen.

Testen Ihres Node.js-Docker-Containers

Sobald Ihre Node.js-App in einem Container ausgeführt wird, müssen Sie sie testen, um sicherzustellen, dass sie sich in einer produktionsähnlichen Umgebung wie erwartet verhält.

Beginnen Sie, indem Sie eine Anfrage mit curl oder einem Webbrowser stellen. Führen Sie in Ihrem Terminal Folgendes aus:

curl http://your_vps_ip:3000

Dieser Befehl sollte die Meldung „Hello, Docker!“ zurückgeben.

Überprüfen Sie anschließend die Container-Logs, um das Verhalten zu überwachen und Probleme zu diagnostizieren:

docker logs container_id_or_name

Wenn Sie die Container-ID nicht kennen, listen Sie die aktiven Container mit folgendem Befehl auf:

docker ps

Für interaktives Debugging öffnen Sie eine Shell im laufenden Container mit docker exec:

docker exec -it container_id_or_name sh

Damit können Sie das Dateisystem des Containers erkunden und Probleme direkt beheben.

Wenn bei der Ausführung von Docker-Befehlen Berechtigungsprobleme auftreten, folgen Sie unserer Anleitung dazu, wie Sie den Fehler Docker permission denied beheben.

Fügen Sie abschließend eine Statusprüfung hinzu. Dabei handelt es sich um einen leichtgewichtigen Endpoint (zum Beispiel /health), der den Status Ihrer App meldet. Konfigurieren Sie Docker so, dass dieser Endpunkt in regelmäßigen Abständen angepingt wird, um zu bestätigen, dass der Container ordnungsgemäß läuft, und dass er automatisch neu gestartet wird, falls er ausfällt.

Nachdem Ihr Container vollständig getestet ist, können Sie nun Best Practices anwenden, um ihn effizient und produktionsbereit zu halten.

Was sind bewährte Vorgehensweisen für die Verwendung von Node.js mit Docker?

Wenn Sie bewährte Methoden befolgen, erstellen Sie sichere, effiziente und gut wartbare Docker-Images für Ihre Node.js-Apps. Hier sind einige wichtige Tipps, die Sie anwenden sollten:

• Verwenden Sie schlanke Basis-Images. Verwenden Sie in der Produktion Alpine- oder Slim-Images statt vollständiger Images. Kleinere Images werden schneller erstellt und bieten eine geringere Angriffsfläche.
• Nur Produktionsabhängigkeiten installieren. Verwenden Sie in Ihrer Dockerfile den Befehl npm ci –omit=dev. So vermeiden Sie die Installation von Entwicklungsabhängigkeiten wie Testbibliotheken, die im endgültigen Image nicht benötigt werden und dazu beitragen, es klein zu halten.
• Setzen Sie NODE_ENV=production. Diese Umgebungsvariable signalisiert Bibliotheken wie Express, Optimierungen zu aktivieren, etwa das Caching von View-Templates und die Verringerung des Debug-Overheads.
• Bilder klein halten. Verwenden Sie Multi-Stage-Builds, um Build-Werkzeuge von der Laufzeitumgebung zu trennen. Fügen Sie eine Datei .dockerignore hinzu, um Protokolle, lokale Module und andere unnötige Dateien aus dem Build-Kontext auszuschließen.
• Aktualisieren Sie Basis-Images regelmäßig. Ziehen Sie regelmäßig das neueste Basis-Image und erstellen Sie Ihr App-Image neu, damit Sicherheitsupdates und Leistungsverbesserungen enthalten sind.
• Als Nicht-Root-Benutzer ausführen. Für mehr Sicherheit sollten Sie Ihre App im Container nicht mit Root-Rechten ausführen. Erstellen Sie stattdessen in Ihrer Dockerfile einen eigenen Benutzer und wechseln Sie zu diesem, bevor Sie die Anwendung ausführen.
• Skalieren Sie Ihre App. Verwenden Sie Orchestrierungs-Tools wie Docker Swarm, um Container für hohe Verfügbarkeit über mehrere Server zu verteilen, oder Docker stack, um Multi-Container-Anwendungen in der Produktion bereitzustellen.

Wichtige Erkenntnisse zur Verwendung von Node.js mit Docker

Durch die Kombination von Node.js mit Docker entsteht ein leistungsfähiger Workflow für die Entwicklung und Bereitstellung von Anwendungen, die konsistent, portabel und effizient sind.

Sie haben ein Projekt eingerichtet, ein optimiertes Dockerfile mit Multi-Stage-Builds geschrieben und Best Practices angewendet, um einen produktionsreifen Container zu erstellen.

Der nächste Schritt besteht darin, weiter zu experimentieren. Docker Compose integrieren, um Multi-Container-Anwendungen zu verwalten, oder eine Pipeline für Continuous Integration und Deployment (CI/CD) einrichten, um Ihre Builds zu automatisieren.

Sie können außerdem Umgebungsvariablen und geheime Dateien verwenden, um vertrauliche Daten zu verwalten, einen Reverse-Proxy wie NGINX hinzufügen, um HTTPS zu aktivieren, oder Ihr Image zu Docker Hub pushen, um es überall freizugeben und bereitzustellen.

Alle Tutorial-Inhalte auf dieser Website unterliegen Hostingers strengen redaktionellen Standards und Normen.

Erstellt von

Faradilla Ayunindya

Faradilla, auch bekannt als Ninda, ist Content Marketing Specialist bei Hostinger mit über fünf Jahren Erfahrung und einem zehnjährigen Hintergrund als Linguistin. Sie möchte Technologie für alle zugänglich machen, indem sie komplexe Anleitungen in klare und leicht verständliche Schritt-für-Schritt-Guides verwandelt. In ihrer Freizeit interessiert sie sich für Biowissenschaften oder schaut gerne lustige Tiervideos. Vernetzen Sie sich mit ihr auf LinkedIn.

Mehr von Faradilla Ayunindya