Bereitstellung von JavaScript (Node.js) auf Kubernetes: Schritt-für-Schritt-Anleitung

Einleitung: Warum Kubernetes für Node.js?

Moderne Webanwendungen auf JavaScript (Node.js) erfordern hohe Verfügbarkeit, Skalierbarkeit und Ausfallsicherheit. Wenn Ihre Anwendung über einen einzelnen Server hinauswächst, wird die manuelle Verwaltung zum Albtraum. Hier kommt Kubernetes (K8s) ins Spiel – ein Container-Orchestrierungssystem, das die Bereitstellung, Skalierung und Verwaltung von Anwendungen automatisiert.

In dieser Anleitung gehen wir den gesamten Weg: von einer einfachen Node.js-Anwendung bis zu ihrem Betrieb in einer produktionsähnlichen Umgebung auf Kubernetes. Sie erfahren, wie Sie Code in ein Docker-Image verpacken, die erforderlichen K8s-Ressourcen (Pod, Deployment, Service) erstellen und den externen Zugriff konfigurieren.

1. Vorbereitung der Node.js-Anwendung

Zunächst erstellen wir eine einfache Express-Anwendung. Sie wird auf HTTP-Anfragen antworten und den Hostnamen des Containers ausgeben (nützlich zur Überprüfung des Lastausgleichs).

1.1. Datei app.js

const express = require('express');const os = require('os');

const app = express();const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {  res.json({    message: 'Hello from Node.js on Kubernetes!',    hostname: os.hostname(),    timestamp: new Date().toISOString()  });});

app.listen(PORT, () => {  console.log(`Server running on port ${PORT}`);});

1.2. Datei package.json

{  "name": "k8s-node-app",  "version": "1.0.0",  "dependencies": {    "express": "^4.18.2"  },  "scripts": {    "start": "node app.js"  }}

2. Containerisierung: Docker-Image

Kubernetes arbeitet mit Containern. Wir erstellen ein minimales Dockerfile für unsere Node.js-Anwendung. Wir verwenden das offizielle Node.js-Image und einen mehrstufigen Build zur Größenoptimierung.

2.1. Dockerfile

FROM node:18-alpine AS builderWORKDIR /appCOPY package*.json ./RUN npm ci --only=production

FROM node:18-alpineWORKDIR /appCOPY --from=builder /app/node_modules ./node_modulesCOPY . .EXPOSE 3000CMD ["node", "app.js"]

Erstellen Sie das Image und senden Sie es an Docker Hub oder eine andere Registry:

docker build -t your-dockerhub/k8s-node-app:v1 .docker push your-dockerhub/k8s-node-app:v1

3. Deployment auf Kubernetes

Kommen wir nun zum Wesentlichen – der Erstellung von Kubernetes-Ressourcen. Wir verwenden ein Deployment (zur Verwaltung der Pods) und einen Service (für den Netzwerkzugriff).

3.1. Erstellen des Deployments

Ein Deployment stellt sicher, dass die gewünschte Anzahl von Pods mit Ihrer Anwendung stets läuft. Erstellen Sie die Datei deployment.yaml:

apiVersion: apps/v1kind: Deploymentmetadata:  name: node-app-deployment  labels:    app: node-appspec:  replicas: 3  selector:    matchLabels:      app: node-app  template:    metadata:      labels:        app: node-app    spec:      containers:      - name: node-app        image: your-dockerhub/k8s-node-app:v1        ports:        - containerPort: 3000        env:        - name: PORT          value: "3000"        resources:          requests:            memory: "64Mi"            cpu: "100m"          limits:            memory: "128Mi"            cpu: "200m"

3.2. Erstellen des Services

Ein Service bietet eine stabile IP-Adresse und einen DNS-Namen für den Zugriff auf die Pods. Erstellen Sie service.yaml:

apiVersion: v1kind: Servicemetadata:  name: node-app-servicespec:  selector:    app: node-app  ports:    - protocol: TCP      port: 80      targetPort: 3000  type: ClusterIP

3.3. Starten im Cluster

Führen Sie die Befehle aus (stellen Sie sicher, dass kubectl konfiguriert ist und Sie Zugriff auf einen Cluster haben):

kubectl apply -f deployment.yamlkubectl apply -f service.yaml