Skalierbare Next.js-Architekturen: Von Monolith zu Micro-Frontends

Feature-Ordner, Monorepo, Multi-Zones: Wie große Next.js-Projekte mit mehreren Teams beherrschbar bleiben
Aktualisiert:
Abstract
- #Next.js
- #Enterprise-Architektur
- #Webentwicklung
- #Best Practices
- #Micro-Frontends
- #Monorepo
- #Multi-Zones
- #Softwarearchitektur
Wann reicht ein gut geschnittener Monolith, und wann lohnt es sich, eine Next.js-Anwendung aufzuteilen?
Am Anfang ist ein Next.js-Projekt übersichtlich: ein Team, ein Repository, ein Ordner app. Drei Jahre später arbeiten vier Teams an Shop, Kundenkonto, Ratgeber und Checkout, der Build dauert eine Viertelstunde, und jede Änderung an der Navigation braucht Abstimmung über drei Abteilungen hinweg. Spätestens dann fällt das Stichwort Micro-Frontends.
Der Reflex ist verständlich, aber oft verfrüht. Die meisten Probleme großer Next.js-Anwendungen entstehen nicht dadurch, dass alles in einer Anwendung liegt, sondern dadurch, dass der Code darin keine klaren Grenzen hat. Dieser Überblick geht den Weg in der Reihenfolge, in der er sich für die meisten Teams lohnt: erst den Monolithen sauber schneiden, dann ein Monorepo für gemeinsame Bausteine, und erst wenn Teams wirklich unabhängig ausliefern müssen, die Anwendung in mehrere Zonen aufteilen.
Der modulare Monolith als Ausgangspunkt
Ein Monolith ist eine Anwendung, die als Ganzes gebaut und ausgeliefert wird. Das ist kein Makel. Ein einzelner Build bedeutet eine Version, ein Deployment, eine Stelle für Fehlerberichte und keine Abstimmungsprobleme zwischen Teilanwendungen. Modular wird der Monolith, wenn sein Code nach fachlichen Bereichen geordnet ist und diese Bereiche nur über definierte Schnittstellen miteinander sprechen.
Der App Router hilft dabei mit zwei Konventionen. Routengruppen sind Ordner in runden Klammern wie (shop), die Seiten zusammenfassen, ohne die URL zu verändern. Private Ordner beginnen mit einem Unterstrich wie _components und werden vom Router ignoriert. So lassen sich Komponenten, Hilfsfunktionen und Datenzugriff direkt neben die Seiten legen, zu denen sie gehören. Eine Struktur für einen mittelgroßen Webshop könnte so aussehen:
src/
app/
(shop)/
produkte/
[slug]/
page.tsx
warenkorb/
page.tsx
layout.tsx
(konto)/
konto/
bestellungen/
page.tsx
layout.tsx
layout.tsx
features/
katalog/
components/
data/
index.ts
warenkorb/
components/
actions.ts
index.ts
konto/
...
shared/
ui/
lib/
Die Seiten im Ordner app bleiben dünn: Sie lesen Parameter, rufen eine Funktion aus dem passenden Feature auf und setzen das Ergebnis zusammen. Die eigentliche Logik steckt in features. Jedes Feature exportiert über seine Datei index.ts nur das, was andere verwenden dürfen. Der Katalog darf die Preisbox des Warenkorbs einbinden, aber nicht in dessen interne Datenbankabfragen greifen.
Solche Regeln halten nur, wenn ein Werkzeug sie prüft. Bewährt haben sich ESLint-Regeln, die Importe über Feature-Grenzen hinweg nur über die öffentliche Schnittstelle erlauben, etwa mit no-restricted-imports oder einem Plugin für Modulgrenzen. Ergänzend legt eine Datei CODEOWNERS im Repository fest, welches Team Änderungen an welchem Ordner freigeben muss. Damit sind Teamgrenzen im Code sichtbar, lange bevor die Anwendung aufgeteilt wird.
Atomic Design, das Komponenten in Atome, Moleküle und Organismen einteilt, bleibt für eine Komponentenbibliothek nützlich. Als Struktur für eine ganze Anwendung taugt es weniger, weil es nach Größe der Bausteine sortiert und nicht nach fachlicher Zuständigkeit. Wie sich Komponenten, Zustand und Rendering in großen React-Anwendungen grundsätzlich organisieren lassen, beschreibt der Beitrag über moderne Architektur mit React und Next.js.
Monorepo: gemeinsame Bausteine ohne Kopien
Der nächste Schritt wird nötig, wenn neben der Website weitere Anwendungen entstehen: ein Händlerportal, eine interne Verwaltung, vielleicht eine zweite Marke. Alle brauchen dieselben Buttons, dieselbe Typografie und denselben API-Client. Kopieren führt nach wenigen Monaten zu drei leicht unterschiedlichen Versionen.
Ein Monorepo ist ein einzelnes Repository, das mehrere Anwendungen und Pakete enthält. Paketmanager wie pnpm, npm oder Yarn verknüpfen die Pakete über sogenannte Workspaces lokal miteinander, Build-Werkzeuge wie Turborepo oder Nx bauen nur, was sich geändert hat, und speichern Zwischenergebnisse in einem Cache. Mit pnpm genügt eine kleine Konfigurationsdatei im Wurzelverzeichnis:
# pnpm-workspace.yaml
packages:
- 'apps/*'
- 'packages/*'
Darunter liegen etwa apps/web, apps/haendlerportal sowie packages/ui, packages/api-client und packages/eslint-config. Eine Anwendung bindet ein internes Paket wie ein normales npm-Paket ein. Liefert das Paket TypeScript-Quellcode statt fertig übersetztem JavaScript, übersetzt Next.js es beim App Router selbst mit, sofern es als Workspace-Paket eingebunden ist. Die Option transpilePackages braucht es nur noch für Pakete aus node_modules, die TypeScript- oder JSX-Quellcode ausliefern, und für Pages-Router-Anwendungen, die mit webpack bauen:
// apps/web/next.config.ts
import type { NextConfig } from 'next';
const nextConfig: NextConfig = {
// Veröffentlichtes Paket, das TypeScript-Quellcode ausliefert
transpilePackages: ['@acme/design-tokens'],
};
export default nextConfig;
Ein Monorepo ändert nichts daran, dass jede Anwendung für sich gebaut und ausgeliefert wird. Es löst das Problem gemeinsamer Bausteine, nicht das Problem gemeinsamer Releases. Wer nur eine einzige Next.js-Anwendung hat, braucht in der Regel kein Monorepo.
Multi-Zones: eine Domain, mehrere Next.js-Anwendungen
Wenn Teams tatsächlich unabhängig voneinander ausliefern sollen, bietet Next.js mit Multi-Zones einen eingebauten Weg. Eine Zone ist eine eigenständige Next.js-Anwendung, die einen bestimmten Pfadbereich bedient. Für Nutzer wirkt alles wie eine Website unter einer Domain. Technisch leitet eine Hauptanwendung bestimmte Pfade per Rewrite an andere Anwendungen weiter.
Angenommen, der Ratgeber unter /ratgeber soll von einem Redaktionsteam getrennt betrieben werden. Die Hauptanwendung bekommt dafür Rewrites:
// apps/web/next.config.ts
import type { NextConfig } from 'next';
const ratgeberUrl = process.env.RATGEBER_URL ?? 'http://localhost:3001';
const nextConfig: NextConfig = {
async rewrites() {
return [
{ source: '/ratgeber', destination: `${ratgeberUrl}/ratgeber` },
{ source: '/ratgeber/:path+', destination: `${ratgeberUrl}/ratgeber/:path+` },
{
source: '/ratgeber-static/:path+',
destination: `${ratgeberUrl}/ratgeber-static/:path+`,
},
];
},
};
export default nextConfig;
Die Ratgeber-Anwendung legt ihre Seiten unter app/ratgeber ab und bekommt ein eigenes Präfix für ihre JavaScript- und CSS-Dateien, damit sich die Dateien beider Anwendungen nicht in die Quere kommen:
// apps/ratgeber/next.config.ts
import type { NextConfig } from 'next';
const nextConfig: NextConfig = {
assetPrefix: '/ratgeber-static',
};
export default nextConfig;
Der Preis ist überschaubar, aber spürbar. Ein Wechsel zwischen Zonen ist eine vollständige Navigation, der Browser lädt die Seite neu. Links von der Hauptanwendung in den Ratgeber sollten deshalb als normales a-Element gesetzt werden, nicht mit der Komponente Link, die eine Navigation innerhalb einer Anwendung erwartet. Gemeinsame Elemente wie Kopfzeile und Fußzeile kommen aus einem geteilten Paket im Monorepo, und Cookies für Login und Warenkorb müssen so gesetzt sein, dass alle Zonen sie lesen können.
Multi-Zones passen gut, wenn sich eine Website entlang von Pfaden schneiden lässt: Shop, Ratgeber, Karriere, Kundenkonto. Sie passen schlecht, wenn mehrere Teams Teile derselben Seite liefern, etwa eine Produktseite, auf der Empfehlungen, Bewertungen und Preisbox von drei Teams stammen.
Micro-Frontends innerhalb einer Seite
Für diesen zweiten Fall gibt es Micro-Frontends im engeren Sinn: Teilanwendungen, die zur Laufzeit in eine gemeinsame Seite geladen werden. Die bekannteste Technik dafür ist Module Federation, die ursprünglich mit webpack 5 eingeführt wurde. Für Next.js ist sie heute eine schwierige Wahl. Das Plugin für Next.js stammt nicht vom Next.js-Team, unterstützt nach Angaben der Maintainer den App Router nicht und wird nur noch eingeschränkt gepflegt. Hinzu kommt, dass Next.js 16 standardmäßig mit Turbopack statt webpack baut.
Realistische Alternativen sind schlichter. Teams können Komponenten als versionierte Pakete veröffentlichen, die die Hauptanwendung beim Build einbindet. Das koppelt die Releases, hält aber die Zuständigkeit klar. Oder ein Teil der Seite kommt als eigenständiges Fragment, etwa als Web Component oder per serverseitigem Einbinden von HTML. Beides ist machbar, kostet aber Ladezeit, doppelte Abhängigkeiten und Abstimmung über gemeinsame Designregeln.
Grundsätzliche Fragen zu Schnitt, Kommunikation und Organisation von Micro-Frontends behandeln die Beiträge Micro Frontends als zukunftsfähige Architektur und Frontend-Architektur mit Micro Frontends. Dieser Beitrag beschränkt sich auf das, was in Next.js konkret anders ist.
Datenabruf und Authentifizierung über Grenzen hinweg
Zwei Querschnittsthemen werden mit wachsender Größe schwieriger. Beim Datenabruf gilt die Regel: Jedes Feature besitzt seine Datenzugriffe, andere Features rufen sie über Funktionen auf, nicht über eigene Datenbankabfragen. Server Components machen das einfach, weil sie Daten direkt auf dem Server laden können. Welche Abrufmethoden und Caching-Optionen es gibt, erklärt der Beitrag zu Datenabruf in Next.js.
Bei der Authentifizierung muss in einer Multi-Zone-Architektur jede Zone die Sitzung selbst prüfen. Ein Rewrite der Hauptanwendung ist kein Schutz. Wie sich Sitzungen, Proxy und Datenzugriff in Next.js zusammen absichern lassen, steht im Beitrag zu Authentifizierung und State Management in Next.js.
Deployment und Skalierung im Betrieb
Für den Betrieb außerhalb von Vercel ist die Option output: 'standalone' in der Next.js-Konfiguration der übliche Weg. Next.js erzeugt dann einen Ordner mit einem minimalen Node.js-Server und nur den Abhängigkeiten, die die Anwendung tatsächlich braucht. Der passt gut in ein schlankes Docker-Image und lässt sich in Kubernetes oder einer Container-Plattform horizontal skalieren, also auf mehrere gleichartige Instanzen verteilen.
Dabei gibt es drei typische Stolperstellen:
- Gemeinsamer Cache: Laufen mehrere Instanzen, hat standardmäßig jede ihren eigenen Cache für gerenderte Seiten und Daten. Damit eine Aktualisierung überall ankommt, braucht es einen gemeinsamen Cache-Speicher, etwa über einen eigenen Cache-Handler mit Redis.
- Server Actions: Next.js verschlüsselt Variablen, die eine Server Action aus ihrer Umgebung mitnimmt und über den Browser zurückschickt. Alle Instanzen derselben Anwendung müssen denselben Schlüssel verwenden, sonst schlagen Aufrufe fehl, sobald ein Load Balancer die Anfrage an eine andere Instanz schickt. Dafür gibt es die Umgebungsvariable
NEXT_SERVER_ACTIONS_ENCRYPTION_KEY, die beim Build gesetzt wird. - Versionsmix beim Rollout: Während eines Deployments laufen kurz alte und neue Versionen nebeneinander. Ist über die Option
deploymentIdeine Deployment-Kennung gesetzt, erkennt Next.js diesen Versionsmix und lädt die Seite vollständig neu, statt Dateien einer anderen Version nachzuladen.
Bei Multi-Zones vervielfachen sich diese Punkte, denn jede Zone ist ein eigenes Deployment mit eigener Pipeline, eigener Überwachung und eigenen Abhängigkeiten. Das ist der eigentliche Preis der Unabhängigkeit.
Was das für Ihr Team bedeutet
Für die meisten Unternehmen ist ein gut geschnittener Monolith mit Feature-Ordnern, geprüften Importgrenzen und klaren Zuständigkeiten die richtige Architektur, oft über viele Jahre. Ein Monorepo lohnt sich, sobald mehrere Anwendungen dieselben Bausteine teilen. Multi-Zones sind sinnvoll, wenn Teams entlang klarer Pfade getrennt ausliefern müssen und den zusätzlichen Betriebsaufwand tragen können.
Überschätzt werden Micro-Frontends innerhalb einer Seite. Sie lösen ein organisatorisches Problem mit technischem Aufwand, und in Next.js fehlt dafür derzeit eine offiziell unterstützte Lösung. Wer darüber nachdenkt, sollte zuerst prüfen, ob die Reibung wirklich aus der Technik kommt oder aus unklaren Zuständigkeiten. Letzteres lässt sich mit CODEOWNERS und Modulgrenzen deutlich günstiger beheben.
Wenn Sie den Schnitt einer bestehenden Anwendung bewerten oder eine Aufteilung planen, unterstützen wir mit Beratung und Seminaren zur Frontend-Architektur, auch zu Monorepos und Micro-Frontends.
Häufige Fragen zu großen Next.js-Architekturen
Ab welcher Größe sollte man eine Next.js-Anwendung aufteilen?
Eine feste Grenze gibt es nicht. Deutliche Signale sind Teams, die regelmäßig auf Releases anderer Teams warten, Builds, die trotz Caching zu lange dauern, und Bereiche mit völlig unterschiedlichen Anforderungen an Release-Takt oder Betrieb. Die Zahl der Seiten allein ist kein Grund.
Sind Multi-Zones dasselbe wie Micro-Frontends?
Sie sind eine Form davon, aber eine grobe. Jede Zone liefert ganze Seiten unter eigenen Pfaden aus. Micro-Frontends im engeren Sinn setzen dagegen eine einzelne Seite aus Teilen verschiedener Teams zusammen.
Brauchen Multi-Zones ein Monorepo?
Nein, die Zonen können in getrennten Repositories liegen. Ein Monorepo erleichtert aber gemeinsame Pakete für Layout, Design und API-Client, und es macht Änderungen über mehrere Zonen hinweg in einem einzigen Pull Request möglich.
Lässt sich ein Monolith später noch aufteilen?
Ja, und gerade dann leichter, wenn er von Anfang an nach Features geordnet ist. Ein Feature mit klarer Schnittstelle und eigenem Pfadbereich lässt sich vergleichsweise gut in eine eigene Zone verschieben. Ein Monolith ohne innere Grenzen muss dagegen erst entflochten werden.