Mikroservices mit JavaScript: Vom ersten Service in 20 Minuten

Mikroservices mit JavaScript: Erste Schritte, die du nicht nach einer Woche aufgibst

Hast du dich jemals gefragt, warum große Projekte wie Netflix, Uber oder Amazon auf Mikroservices umgestiegen sind? Es geht nicht um einen Trend – es ist eine Frage des Überlebens. Wenn dein Monolith 50 GB wiegt und dein Entwicklungsteam aus 100 Leuten besteht, wird jede Code-Änderung zum russischen Roulette.

Aber es gibt auch eine gute Nachricht: Mikroservices mit JavaScript sind keine Raketenwissenschaft. Heute zeige ich dir, wie du in 20 Minuten eine funktionierende Architektur zusammenbaust, die du bei einem Vorstellungsgespräch oder in deinem Pet-Projekt präsentieren kannst.

Was ist ein Mikroservice in einfachen Worten?

Stell dir ein Schweizer Taschenmesser vor. In einer monolithischen Architektur ist es ein großes Messer mit hundert Klingen. Geht eine kaputt, musst du das ganze Messer wegwerfen. Mikroservices sind eine Reihe einzelner Messer, jedes für eine bestimmte Aufgabe. Eines ist kaputt? Wir tauschen nur dieses eine aus.

Ein Mikroservice ist eine kleine, autonome Anwendung, die eine Sache tut, aber diese eine Sache richtig gut macht.

Warum ist JavaScript ideal für Mikroservices?

\n
• Event Loop: Asynchronität von Haus aus – perfekt für I/O-lastige Aufgaben
\n
• NPM: Über 2 Millionen Pakete, eine fertige Ökosystem für alles
\n
• Node.js: Leichtgewichtige Prozesse, schneller Start (50-100ms)
\n
• TypeScript: Typisierung, die in verteilten Systemen Leben rettet
\n
• Einheitliche Sprache: Frontend und Backend in JS – weniger Kontextwechsel
\n

Erste Schritte: Ein praktischer Roadmap

Schritt 1. Must-have: Express + Docker

Vergiss Kubernetes am Anfang. Du brauchst einen Mikroservice mit Node.js, den du mit einem Befehl starten kannst. Fangen wir mit dem Einfachsten an – einem Begrüßungsservice.

Erstelle deinen ersten Mikroservice

// service-greeting/index.js\nconst express = require('express');\nconst app = express();\nconst PORT = process.env.PORT || 3000;\n\napp.get('/api/hello', (req, res) => {\n  res.json({ \n    message: 'Hallo vom Mikroservice!',\n    timestamp: new Date().toISOString(),\n    service: 'greeting'\n  });\n});\n\napp.listen(PORT, () => {\n  console.log(`Greeting service läuft auf Port ${PORT}`);\n});\n

Jetzt packen wir das in Docker:

# Dockerfile\nFROM node:18-alpine\nWORKDIR /app\nCOPY package*.json ./\nRUN npm ci --only=production\nCOPY . .\nEXPOSE 3000\nCMD ["node", "index.js"]\n

Schritt 2. Docker Compose: Orchestrierung für Arme

Lauf nicht gleich zu Kubernetes. Für den Start ist Docker Compose dein bester Freund. Erstellen wir zwei Services und verbinden sie.

# docker-compose.yml\nversion: '3.8'\nservices:\n  greeting:\n    build: ./service-greeting\n    ports:\n      - "3001:3000"\n    environment:\n      - PORT=3000\n\n  users:\n    build: ./service-users\n    ports:\n      - "3002:3000"\n    environment:\n      - PORT=3000\n      - GREETING_SERVICE=http://greeting:3000\n

Schritt 3. Services verbinden: HTTP vs. Message Broker

In der Mikroservice-Architektur mit JavaScript gibt es zwei Kommunikationswege:

\n
• Synchron (HTTP): Einfach, verständlich, erzeugt aber Abhängigkeiten
\n
• Asynchron (RabbitMQ/Kafka): Komplexer, aber zuverlässiger
\n

Beispiel für HTTP-Kommunikation zwischen Services

// service-users/index.js\nconst express = require('express');\nconst axios = require('axios');\nconst app = express();\n\napp.get('/api/user/:id', async (req, res) => {\n  try {\n    // Aufruf eines anderen Mikroservices\n    const greeting = await axios.get(\n      `${process.env.GREETING_SERVICE}/api/hello`\n    );\n    \n    res.json({\n      userId: req.params.id,\n      greeting: greeting.data.message\n    });\n  } catch (error) {\n    res.status(500).json({ error: 'Service nicht verfügbar' });\n  }\n});\n\napp.listen(3000);\n