Kurs JavaScript i React · Moduł 10: Ekosystem i przyszłość React
Micro-frontends z React - architektura skalowalna
W tej lekcji4
Flota rośnie: nad jedną aplikacją pracuje pięć zespołów, a każde wdrożenie wymaga zgody wszystkich, bo kod jest jednym monolitem. Poprawka w koszyku czeka na testy katalogu produktów, a konflikt wersji jednej biblioteki blokuje całą załogę. Micro-frontends to wzorzec architektoniczny, który przenosi ideę mikroserwisów na frontend: niezależne zespoły rozwijają, wdrażają i skalują osobne części aplikacji.
Wprowadzenie do Micro-frontends
Czym są Micro-frontends?
Micro-frontends to technika dzielenia monolitycznej aplikacji frontendowej na mniejsze, niezależne aplikacje (MFE), z których każda ma własne repozytorium i proces wdrożenia. Użytkownik widzi jedną stronę, bo aplikacja-powłoka (shell) składa je w całość. Architekturę czytasz od zewnątrz: shell, w nim router, router ładuje zdalne MFE, a każde MFE renderuje własne komponenty wewnętrzne. To jak stacja kosmiczna złożona z modułów różnych agencji, spiętych wspólnym dokiem.
Module Federation (Webpack 5)
Najpopularniejszym sposobem łączenia MFE jest Module Federation, wbudowane w webpack 5 jako require('webpack').container.ModuleFederationPlugin. Pozwala aplikacji ładować w czasie działania moduły wystawione przez inne aplikacje i współdzielić zależności, np. Reacta. Tak wygląda konfiguracja powłoki:
// webpack.config.js - Shell Application
const { ModuleFederationPlugin } = require('webpack').container;
module.exports = {
mode: 'development',
devServer: {
port: 3000,
},
plugins: [
new ModuleFederationPlugin({
name: 'shell',
remotes: {
products: 'products@http://localhost:3001/remoteEntry.js',
cart: 'cart@http://localhost:3002/remoteEntry.js',
user: 'user@http://localhost:3003/remoteEntry.js',
},
shared: {
react: { singleton: true, eager: true },
'react-dom': { singleton: true, eager: true },
'@shared/ui-kit': { singleton: true },
'@shared/utils': { singleton: true },
},
}),
],
};remotes mapuje nazwy na adresy plików remoteEntry.js, które publikuje każde MFE. shared z singleton: true pilnuje, żeby w przeglądarce działała jedna kopia Reacta, bo biblioteki z globalnym stanem źle znoszą duplikaty, a eager: true dołącza je do początkowej paczki. Po dodatki, jak manifest i wtyczki runtime, sięgnij po Module Federation 2.0 z pakietu @module-federation/enhanced.
Implementacja Shell Application
Powłoka ładuje MFE leniwie przez lazy, jak zwykłe komponenty. Ścieżka products/ProductsApp wskazuje moduł z remote o nazwie products:
// src/App.jsx - Shell Application
import React, { Suspense, lazy } from 'react';
import { BrowserRouter, Routes, Route } from 'react-router-dom';
import ErrorBoundary from './components/ErrorBoundary';
import Layout from './components/Layout';
// Leniwe ładowanie micro-frontendów
const ProductsApp = lazy(() => import('products/ProductsApp'));
const CartApp = lazy(() => import('cart/CartApp'));
const UserApp = lazy(() => import('user/UserApp'));
// Lokalne komponenty powłoki
const HomePage = lazy(() => import('./pages/HomePage'));
function App() {
return (
<ErrorBoundary>
<BrowserRouter>
<Layout>
<Suspense fallback={<div>Ładowanie...</div>}>
<Routes>
<Route path="/" element={<HomePage />} />
{/* Micro-frontend produktów */}
<Route
path="/products/*"
element={
<ErrorBoundary fallback={<div>Katalog chwilowo niedostępny</div>}>
<ProductsApp />
</ErrorBoundary>
}
/>
{/* Micro-frontend koszyka */}
<Route
path="/cart/*"
element={
<ErrorBoundary fallback={<div>Koszyk chwilowo niedostępny</div>}>
<CartApp />
</ErrorBoundary>
}
/>
{/* Micro-frontend profilu użytkownika */}
<Route
path="/user/*"
element={
<ErrorBoundary fallback={<div>Profil chwilowo niedostępny</div>}>
<UserApp />
</ErrorBoundary>
}
/>
</Routes>
</Suspense>
</Layout>
</BrowserRouter>
</ErrorBoundary>
);
}
export default App;Każde MFE ma własny ErrorBoundary, więc awaria koszyka nie wyłączy katalogu, a Suspense pokazuje stan ładowania, zanim kod remote dotrze przez sieć. Ścieżki z /* oddają dalsze adresy routerowi wewnątrz MFE.
Komunikacja między Micro-frontends
Architektura sterowana zdarzeniami
Micro-frontendy nie powinny importować siebie nawzajem, bo wtedy znowu powstaje monolit. Najczęściej rozmawiają przez zdarzenia: Event Bus w pamięci i natywne CustomEvent na obiekcie window:
// shared/eventBus.js
class EventBus {
constructor() {
this.events = {};
}
subscribe(eventName, callback) {
if (!this.events[eventName]) {
this.events[eventName] = [];
}
this.events[eventName].push(callback);
// Zwróć funkcję wypisania
return () => {
this.events[eventName] = this.events[eventName].filter(
cb => cb !== callback
);
};
}
emit(eventName, data) {
if (this.events[eventName]) {
this.events[eventName].forEach(callback => callback(data));
}
// Wyślij też CustomEvent, żeby usłyszały go inne MFE
window.dispatchEvent(new CustomEvent(`mfe:${eventName}`, {
detail: data
}));
}
}
export const eventBus = new EventBus();subscribe zwraca funkcję wypisania, więc komponent odłączy się w cleanupie efektu. emit wysyła też CustomEvent z prefiksem mfe:, który usłyszy każde MFE, nawet napisane w innym frameworku.
Współdzielony stan
Niektóre dane, jak zalogowany użytkownik czy koszyk, muszą być wspólne. Store z zustand/vanilla działa bez Reacta, więc może żyć we współdzielonym module:
// shared/stateManager.js
import { createStore } from 'zustand/vanilla';
// Globalny store dostępny dla wszystkich MFE
const globalStore = createStore((set, get) => ({
// Stan użytkownika
user: null,
isAuthenticated: false,
// Stan koszyka
cartItems: [],
cartTotal: 0,
// Akcje
setUser: (user) => set({ user, isAuthenticated: !!user }),
addToCart: (product) => set(state => {
const existingItem = state.cartItems.find(item => item.id === product.id);
let newItems;
if (existingItem) {
newItems = state.cartItems.map(item =>
item.id === product.id
? { ...item, quantity: item.quantity + 1 }
: item
);
} else {
newItems = [...state.cartItems, { ...product, quantity: 1 }];
}
const newTotal = newItems.reduce((sum, item) =>
sum + (item.price * item.quantity), 0
);
return { cartItems: newItems, cartTotal: newTotal };
}),
removeFromCart: (productId) => set(state => {
const newItems = state.cartItems.filter(item => item.id !== productId);
const newTotal = newItems.reduce((sum, item) =>
sum + (item.price * item.quantity), 0
);
return { cartItems: newItems, cartTotal: newTotal };
}),
}));addToCart zwiększa quantity, gdy produkt już leży w koszyku, a cartTotal przelicza się przy każdej zmianie. Wspólny store to jednak zależność między zespołami, więc radzę Ci trzymać w nim tylko naprawdę globalne dane, a resztę przesyłać zdarzeniami.
Testowanie micro-frontendów
Test integracyjny sprawdza, czy powłoka poprawnie ładuje MFE, a zdalny moduł zastępuje mock z jest.mock:
// __tests__/integration/mfe-integration.test.jsx
import { render, screen, waitFor } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import App from '../App';
// Mock zdalnego MFE: modułu nie ma na dysku, dlatego virtual: true
jest.mock('products/ProductsApp', () => {
return function MockProductsApp() {
return <div data-testid="products-mfe">Products MFE Loaded</div>;
};
}, { virtual: true });
describe('MFE Integration', () => {
test('loads products MFE when navigating to /products', async () => {
const user = userEvent.setup();
// App sam renderuje BrowserRouter, więc nie owijamy go drugim routerem
render(<App />);
// Przejdź do produktów
await user.click(screen.getByRole('link', { name: /products/i }));
// Sprawdź, czy MFE się załadował
await waitFor(() => {
expect(screen.getByTestId('products-mfe')).toBeInTheDocument();
});
});
});Test klika link, a waitFor czeka, aż leniwie załadowany mock pojawi się w DOM. Zdalnego modułu nie ma na dysku, dlatego jest.mock dostaje opcję { virtual: true } (zamiast niej możesz dodać wpis w moduleNameMapper). App sam renderuje BrowserRouter, więc test renderuje go bez drugiego routera, bo React Router zgłosiłby błąd zagnieżdżenia.
Kiedy warto?
Micro-frontends oferują potężne możliwości skalowania aplikacji React w dużych organizacjach, ale wymagają przemyślanej architektury i zarządzania złożonością: osobnych pipeline'ów, kontraktów zdarzeń i pilnowania wersji wspólnych zależności. Dla jednego zespołu to zwykle przerost formy, bo dobrze podzielony monolit będzie prostszy. W ćwiczeniu zbudujesz orkiestrację kilku MFE ze współdzielonymi zależnościami i komunikacją przez zdarzenia.
Pamiętaj: micro-frontend to moduł stacji od innej agencji - dokuje do wspólnej powłoki, ale startuje według własnego harmonogramu. W przykładzie poniżej przełącz sekcję w nawigacji albo wyłącz system: komunikator dostanie zdarzenie z Event Busa, a powłoka usłyszy CustomEvent na obiekcie window.
Kod do tej lekcji: App.jsx
import { useCallback, useEffect, useState } from 'react';
// === Micro-frontends - symulacja w jednym pliku ===
// Każdy moduł MF udaje osobną aplikację z własnym stanem. Moduły nie importują
// siebie nawzajem, tylko rozmawiają przez Event Bus, jak w lekcji.
class EventBus {
constructor() {
this.events = {};
}
subscribe(eventName, callback) {
if (!this.events[eventName]) this.events[eventName] = [];
this.events[eventName].push(callback);
// Funkcja wypisania do cleanupu efektu
return () => {
this.events[eventName] = this.events[eventName].filter(cb => cb !== callback);
};
}
emit(eventName, data) {
(this.events[eventName] || []).forEach(callback => callback(data));
// CustomEvent z prefiksem mfe: usłyszy też MF napisany w innym frameworku
window.dispatchEvent(new CustomEvent('mfe:' + eventName, { detail: data }));
}
}
const eventBus = new EventBus();
// Hook do nasłuchiwania zdarzeń z innych modułów
function useEventBus(eventName, handler) {
useEffect(() => eventBus.subscribe(eventName, handler), [eventName, handler]);
}
// MF-1: Nawigacja stacji kosmicznej
function NavigationModule() {
const [activeSection, setActiveSection] = useState('panel');
const sections = [
{ id: 'panel', label: 'Panel główny' },
{ id: 'crew', label: 'Załoga' },
{ id: 'systems', label: 'Systemy' },
{ id: 'cargo', label: 'Ładownia' },
];
const navigate = section => {
setActiveSection(section.id);
eventBus.emit('navigation:change', { label: section.label });
};
return (
<div style={{ ...styles.module, border: '2px solid #00d4ff' }}>
<div style={styles.moduleHeader}>
<h3 style={{ ...styles.moduleTitle, color: '#00d4ff' }}>MF-1: Nawigacja</h3>
<span style={styles.port}>port 3001</span>
</div>
<div style={{ display: 'flex', gap: '6px', flexWrap: 'wrap' }}>
{sections.map(section => (
<button
key={section.id}
onClick={() => navigate(section)}
style={{ ...styles.navButton, ...(activeSection === section.id ? styles.navActive : null) }}
>
{section.label}
</button>
))}
</div>
</div>
);
}
// MF-2: Panel statusu systemów
function SystemStatusModule() {
const [systems, setSystems] = useState([
{ name: 'Napęd warp', online: true, health: 95 },
{ name: 'Tarcze', online: true, health: 88 },
{ name: 'Komunikacja', online: true, health: 100 },
{ name: 'Podtrzymywanie życia', online: true, health: 92 },
]);
const toggleSystem = index => {
const system = systems[index];
const online = !system.online;
// Najpierw nowy stan, potem zdarzenie - updater setState zostaje czysty
setSystems(prev => prev.map((s, i) => (i === index ? { ...s, online } : s)));
eventBus.emit('status:update', { system: system.name, online });
};
return (
<div style={{ ...styles.module, border: '2px solid #00ff88' }}>
<div style={styles.moduleHeader}>
<h3 style={{ ...styles.moduleTitle, color: '#00ff88' }}>MF-2: Status systemów</h3>
<span style={styles.port}>port 3002</span>
</div>
{systems.map((system, i) => (
<button key={system.name} onClick={() => toggleSystem(i)} style={styles.systemRow}>
<span style={{ ...styles.dot, background: system.online ? '#00ff88' : '#ff6b6b' }} />
<span style={{ flex: 1, textAlign: 'left' }}>{system.name}</span>
<span style={{ color: '#778da9' }}>{system.online ? system.health + '%' : 'wyłączony'}</span>
</button>
))}
</div>
);
}
// MF-3: Komunikator załogi - słucha zdarzeń z MF-1 i MF-2
function CrewChatModule() {
const [messages, setMessages] = useState([
{ from: 'Komandor Nova', text: 'Systemy sprawne, gotowi do skoku.', type: 'crew' },
{ from: 'Astro', text: 'Napęd warp naładowany.', type: 'crew' },
]);
const [input, setInput] = useState('');
// Stabilne funkcje (useCallback), żeby nie zapisywać się do szyny przy każdym renderze
const onStatusUpdate = useCallback(data => {
setMessages(prev => [...prev, { from: 'System', text: data.system + (data.online ? ' włączony' : ' wyłączony'), type: 'system' }]);
}, []);
const onNavigationChange = useCallback(data => {
setMessages(prev => [...prev, { from: 'Nawigacja', text: 'Przejście do sekcji: ' + data.label, type: 'system' }]);
}, []);
useEventBus('status:update', onStatusUpdate);
useEventBus('navigation:change', onNavigationChange);
const send = () => {
if (!input.trim()) return;
setMessages(prev => [...prev, { from: 'Ty', text: input, type: 'crew' }]);
setInput('');
};
return (
<div style={{ ...styles.module, border: '2px solid #ffaa00' }}>
<div style={styles.moduleHeader}>
<h3 style={{ ...styles.moduleTitle, color: '#ffaa00' }}>MF-3: Komunikator</h3>
<span style={styles.port}>port 3003</span>
</div>
<div style={styles.chat}>
{messages.map((msg, i) => (
<div key={i} style={{ marginBottom: '4px' }}>
<strong style={{ color: msg.type === 'system' ? '#ff6b6b' : '#00d4ff' }}>{msg.from}: </strong>
<span>{msg.text}</span>
</div>
))}
</div>
<div style={{ display: 'flex', gap: '6px' }}>
<input
value={input}
onChange={e => setInput(e.target.value)}
onKeyDown={e => e.key === 'Enter' && send()}
placeholder="Wiadomość..."
style={styles.input}
/>
<button onClick={send} style={styles.sendButton}>Wyślij</button>
</div>
</div>
);
}
// Shell Application - składa moduły i słucha CustomEvent na window
export default function App() {
const [currentSection, setCurrentSection] = useState('Panel główny');
useEffect(() => {
const onNavigation = event => setCurrentSection(event.detail.label);
window.addEventListener('mfe:navigation:change', onNavigation);
return () => window.removeEventListener('mfe:navigation:change', onNavigation);
}, []);
return (
<div style={styles.page}>
<div style={{ maxWidth: '620px', margin: '0 auto' }}>
<h1 style={styles.title}>Shell Application - Stacja Kosmiczna</h1>
<p style={styles.subtitle}>
Shell (port 3000) ładuje trzy niezależne moduły. Aktywna sekcja według zdarzenia z MF-1: <strong style={{ color: '#00d4ff' }}>{currentSection}</strong>
</p>
<div style={{ display: 'grid', gap: '12px' }}>
<NavigationModule />
<SystemStatusModule />
<CrewChatModule />
</div>
<div style={styles.patterns}>
<h4 style={{ margin: '0 0 8px', color: '#778da9' }}>Kluczowe wzorce micro-frontends:</h4>
<ul style={{ margin: 0, paddingLeft: '20px', lineHeight: 1.8 }}>
<li><strong style={{ color: '#00d4ff' }}>Module Federation</strong> - ładowanie modułów innych aplikacji w czasie działania</li>
<li><strong style={{ color: '#00ff88' }}>Event Bus i CustomEvent</strong> - luźno powiązana komunikacja</li>
<li><strong style={{ color: '#ffaa00' }}>Niezależne wdrożenia</strong> - każdy zespół wdraża swój moduł osobno</li>
<li><strong style={{ color: '#ff6b6b' }}>Własny stan</strong> - wspólny store tylko dla naprawdę globalnych danych</li>
</ul>
</div>
</div>
</div>
);
}
const styles = {
page: { background: '#0d1b2a', minHeight: '100vh', padding: '20px', color: '#e0e1dd', fontFamily: 'system-ui, sans-serif', fontSize: '13px' },
title: { color: '#00d4ff', textAlign: 'center', fontSize: '19px', margin: '0 0 6px' },
subtitle: { color: '#778da9', textAlign: 'center', margin: '0 0 16px' },
module: { background: '#1b2838', padding: '14px', borderRadius: '12px' },
moduleHeader: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '10px' },
moduleTitle: { margin: 0, fontSize: '14px' },
port: { fontSize: '10px', color: '#778da9', border: '1px solid #415a77', padding: '2px 8px', borderRadius: '4px' },
navButton: { padding: '6px 12px', borderRadius: '6px', border: '1px solid #415a77', background: 'transparent', color: '#778da9', cursor: 'pointer' },
navActive: { border: '1px solid #00d4ff', background: 'rgba(0,212,255,0.15)', color: '#00d4ff' },
systemRow: { display: 'flex', alignItems: 'center', gap: '10px', width: '100%', background: '#0d1b2a', color: '#e0e1dd', border: 'none', padding: '8px 12px', borderRadius: '8px', cursor: 'pointer', marginBottom: '6px', fontSize: '13px' },
dot: { width: '8px', height: '8px', borderRadius: '50%', flexShrink: 0 },
chat: { background: '#0d1b2a', padding: '10px', borderRadius: '8px', maxHeight: '140px', overflowY: 'auto', marginBottom: '8px' },
input: { flex: 1, padding: '6px 10px', borderRadius: '6px', border: '1px solid #415a77', background: '#0d1b2a', color: '#e0e1dd' },
sendButton: { padding: '6px 12px', borderRadius: '6px', border: 'none', background: '#ffaa00', color: '#0d1b2a', fontWeight: 'bold', cursor: 'pointer' },
patterns: { marginTop: '16px', background: '#1b2838', padding: '12px', borderRadius: '8px', border: '1px solid #415a77' },
};Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Do czego służy Module Federation w kontekście micro-frontends?
2. Który wzorzec komunikacji jest najczęściej używany między micro-frontends?
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj elementy architektury micro-frontends od zewnętrznego do wewnętrznego:
- Edytor kodu
Połącz dwa niezależne micro-frontendy szyną zdarzeń: katalog części (MFE zespołu Astro) wysyła zdarzenie cargo:add, a ładownia (MFE zespołu Komandor Nova) je odbiera. ___BLANK1___: funkcja zwracana przez on() wypisuje tylko tę jedną subskrypcję (użyj metody off z tym samym event i handler). ___BLANK2___: emit wywołuje każdą zapisaną funkcję z danymi zdarzenia (payload). ___BLANK3___: efekt w CargoHold zwraca funkcję wypisującą subskrypcję, żeby po ukryciu ładowni nie zostawał osierocony słuchacz (i żeby podwójny efekt w StrictMode nie dodawał części dwa razy).