0Pricing
React Academy · Lekcja

Module Federation z Webpack 5

Konfigurowanie aplikacji hosta i zdalnej aplikacji za pomocą Webpack Module Federation w celu współdzielenia komponentów w czasie działania.

Module Federation z Webpack 5 to bezpłatna lekcja React Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej React Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs React Academy zawiera 4 lekcji w sumie.

Przegląd Module Federation

Webpack 5 Module Federation pozwala współdzielić moduły JavaScript między aplikacjami bundlowanymi niezależnie, w czasie działania — jedna aplikacja udostępnia komponenty, a druga korzysta z nich bez etapu budowania.

Role: host i remote

remote udostępnia moduły. host korzysta z modułów jednej lub większej liczby aplikacji remote. Aplikacja może jednocześnie pełnić rolę hosta i remote.

Konfiguracja remote

W pliku webpack.config.js aplikacji remote należy użyć ModuleFederationPlugin, aby udostępnić komponenty.

// Remote: apps/products/webpack.config.js
const { ModuleFederationPlugin } = require('webpack').container;

module.exports = {
  plugins: [
    new ModuleFederationPlugin({
      name: 'products',              // remote name
      filename: 'remoteEntry.js',    // entry file
      exposes: {
        './ProductCard': './src/components/ProductCard', // exposed module
        './CartButton': './src/components/CartButton',
      },
      shared: ['react', 'react-dom'], // share deps to avoid duplication
    }),
  ],
};

Konfiguracja hosta

W konfiguracji webpacka aplikacji host należy zadeklarować, z których aplikacji remote korzystać i skąd je ładować.

// Host: apps/shell/webpack.config.js
new ModuleFederationPlugin({
  name: 'shell',
  remotes: {
    products: 'products@http://localhost:3001/remoteEntry.js',
    cart: 'cart@http://localhost:3002/remoteEntry.js',
  },
  shared: ['react', 'react-dom'],
})

Korzystanie ze zdalnego modułu

Zdalne moduły należy importować, używając nazwy remote jako prefiksu ścieżki. W celu leniwego ładowania należy opakować je w React.lazy i Suspense.

import React, { lazy, Suspense } from 'react';

const ProductCard = lazy(() => import('products/ProductCard'));

function App() {
  return (
    <Suspense fallback={<div>Loading...</div>}>
      <ProductCard productId="123" />
    </Suspense>
  );
}

Współdzielenie zależności

Współdzielone pakiety należy oznaczyć za pomocą singleton: true, aby między wszystkimi mikrofrontendami była ładowana tylko jedna kopia Reacta.

shared: {
  react: { singleton: true, requiredVersion: '^18.0.0' },
  'react-dom': { singleton: true, requiredVersion: '^18.0.0' },
  '@company/design-system': { singleton: true },
},

Dynamiczne aplikacje remote

Aplikacje remote należy ładować dynamicznie w czasie działania z konfiguracji (np. z endpointu manifestu), zamiast wpisywać ich adresy na stałe w konfiguracji webpacka.

async function loadRemote(scope, module) {
  await __webpack_init_sharing__('default');
  const container = window[scope];
  await container.init(__webpack_share_scopes__.default);
  const factory = await container.get(module);
  return factory();
}

const ProductCard = React.lazy(() => loadRemote('products', './ProductCard'));

TypeScript z Module Federation

Należy użyć wtyczki @module-federation/typescript do generowania deklaracji typów dla udostępnianych modułów, aby aplikacje host miały pełne podpowiedzi w edytorze.

Granice błędów dla awarii aplikacji remote

Komponenty remote należy opakować w granice błędów. Jeśli aplikacja remote nie załaduje się, host przejdzie w tryb ograniczonej funkcjonalności zamiast ulec awarii.

<ErrorBoundary fallback={<div>Product unavailable</div>}>
  <Suspense fallback={<Skeleton />}>
    <ProductCard productId={id} />
  </Suspense>
</ErrorBoundary>

Module Federation w Vite

Wtyczka @originjs/vite-plugin-federation udostępnia Module Federation w projektach opartych na Vite, oferując podobny interfejs API.

// vite.config.ts (remote)
import federation from '@originjs/vite-plugin-federation';

export default defineConfig({
  plugins: [
    federation({
      name: 'products',
      filename: 'remoteEntry.js',
      exposes: { './ProductCard': './src/ProductCard' },
      shared: ['react'],
    }),
  ],
});

Szybki test

Co powoduje ustawienie singleton: true dla współdzielonego pakietu w Module Federation?

Podsumowanie

Module Federation używa ModuleFederationPlugin w aplikacjach remote (do udostępniania) i host (do korzystania). Zdalne moduły należy importować za pomocą lazy(), współdzielić react jako singleton, aby uniknąć duplikowania, oraz opakowywać aplikacje remote w granice błędów, by zapewnić kontrolowane działanie w przypadku awarii.

Często zadawane pytania

Czy lekcja „Module Federation z Webpack 5” jest bezpłatna?

Tak — pełny tekst „Module Federation z Webpack 5” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu React Academy, przejdź na CoddyKit PRO. Kurs React Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Module Federation z Webpack 5”?

Konfigurowanie aplikacji hosta i zdalnej aplikacji za pomocą Webpack Module Federation w celu współdzielenia komponentów w czasie działania. Ćwiczysz React Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć React Academy?

Nie wymagamy żadnego doświadczenia. React Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Module Federation z Webpack 5”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji React Academy?

Tak. Każda lekcja React Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Koncepcje mikrofrontendów i kompromisy
  2. Module Federation z Webpack 5
  3. Współdzielony stan i routing między MFE
  4. Niezależne wdrażanie i potoki CI dla MFE
← Powrót do React Academy