Kurs JavaScript i React · Moduł 10: Ekosystem i przyszłość React

Micro-frontends z React - architektura skalowalna

6 min czytania ·
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. 1. Do czego służy Module Federation w kontekście micro-frontends?

  2. 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).

  1. PytanieModule Federation w Webpack 5
  2. PytanieKomunikacja między MFE
  3. Ułóż w kolejnościArchitektura micro-frontends
  4. Zadanie z kodemPraktyka: Micro-frontends

Przydatne artykuły