16. avgust 2025Slovenščina

Odklenite moč mikro-frontendov z JavaScript Module Federation v Webpack 5. Naučite se graditi razširljive, vzdrževane in neodvisne spletne aplikacije.

JavaScript Module Federation z Webpack 5: Celovit vodnik po mikro-frontendih

V nenehno razvijajočem se svetu spletnega razvoja je gradnja velikih in kompleksnih aplikacij lahko zastrašujoča naloga. Tradicionalne monolitne arhitekture pogosto vodijo do podaljšanega časa razvoja, ozkih grl pri uvajanju in izzivov pri ohranjanju kakovosti kode. Mikro-frontendi so se pojavili kot močan arhitekturni vzorec za reševanje teh izzivov, ki ekipam omogoča gradnjo in uvajanje neodvisnih delov večje spletne aplikacije. Ena najobetavnejših tehnologij za implementacijo mikro-frontendov je JavaScript Module Federation, predstavljena v Webpack 5.

Kaj so mikro-frontendi?

Mikro-frontendi so arhitekturni slog, kjer je frontend aplikacija razčlenjena na manjše, neodvisne enote, ki jih lahko različne ekipe razvijajo, testirajo in uvajajo avtonomno. Vsak mikro-frontend je odgovoren za določeno poslovno domeno ali funkcionalnost, vsi skupaj pa se sestavijo med izvajanjem in tvorijo celoten uporabniški vmesnik.

Predstavljajte si to kot podjetje: namesto ene ogromne razvojne ekipe imate več manjših ekip, ki se osredotočajo na določena področja. Vsaka ekipa lahko dela neodvisno, kar omogoča hitrejše razvojne cikle in lažje vzdrževanje. Pomislite na veliko e-trgovinsko platformo, kot je Amazon; različne ekipe bi lahko upravljale katalog izdelkov, nakupovalno košarico, postopek zaključka nakupa in upravljanje uporabniških računov. Vse to bi lahko bili neodvisni mikro-frontendi.

Prednosti mikro-frontendov:

Neodvisne namestitve: Ekipe lahko svoje mikro-frontende nameščajo neodvisno, ne da bi to vplivalo na druge dele aplikacije. To zmanjšuje tveganje pri uvajanju in omogoča hitrejše cikle izdaj.
Tehnološko neodvisni: Različni mikro-frontendi so lahko zgrajeni z različnimi tehnologijami ali ogrodji (npr. React, Angular, Vue.js). To ekipam omogoča, da izberejo najboljšo tehnologijo za svoje specifične potrebe in postopoma uvajajo nove tehnologije, ne da bi morali prepisati celotno aplikacijo. Predstavljajte si, da ena ekipa uporablja React za katalog izdelkov, druga Vue.js za marketinške pristajalne strani, tretja pa Angular za postopek zaključka nakupa.
Izboljšana avtonomija ekip: Ekipe imajo popolno lastništvo nad svojimi mikro-frontendi, kar vodi do večje avtonomije, hitrejšega odločanja in izboljšane produktivnosti razvijalcev.
Povečana razširljivost: Mikro-frontendi omogočajo horizontalno razširitev aplikacije z nameščanjem posameznih mikro-frontendov na različne strežnike.
Ponovna uporaba kode: Komponente in knjižnice v skupni rabi se lahko enostavno delijo med mikro-frontendi.
Lažje vzdrževanje: Manjše kodne baze so na splošno lažje za razumevanje, vzdrževanje in odpravljanje napak.

Izzivi mikro-frontendov:

Povečana kompleksnost: Upravljanje več mikro-frontendov lahko poveča kompleksnost celotne arhitekture, zlasti pri komunikaciji, upravljanju stanja in uvajanju.
Dodatna obremenitev zmogljivosti: Nalaganje več mikro-frontendov lahko povzroči dodatno obremenitev zmogljivosti, še posebej, če niso pravilno optimizirani.
Presečne zadeve: Obravnavanje presečnih zadev, kot so avtentikacija, avtorizacija in tematizacija, je lahko v arhitekturi mikro-frontendov izziv.
Operativna obremenitev: Zahteva zrele DevOps prakse in infrastrukturo za upravljanje uvajanja in nadzora več mikro-frontendov.

Kaj je JavaScript Module Federation?

JavaScript Module Federation je funkcija Webpack 5, ki omogoča deljenje kode med ločeno prevedenimi JavaScript aplikacijami med izvajanjem. Omogoča vam, da dele svoje aplikacije izpostavite kot »module«, ki jih lahko porabljajo druge aplikacije, ne da bi jih bilo treba objaviti v osrednjem repozitoriju, kot je npm.

Predstavljajte si Module Federation kot način za ustvarjanje federativnega ekosistema aplikacij, kjer lahko vsaka aplikacija prispeva svojo funkcionalnost in porablja funkcionalnost drugih aplikacij. To odpravlja potrebo po odvisnostih v času gradnje in omogoča resnično neodvisne namestitve.

Na primer, ekipa za oblikovalski sistem lahko izpostavi komponente uporabniškega vmesnika kot module, različne aplikacijske ekipe pa lahko te komponente porabljajo neposredno iz aplikacije oblikovalskega sistema, ne da bi jih morale namestiti kot npm pakete. Ko ekipa za oblikovalski sistem posodobi komponente, se spremembe samodejno odrazijo v vseh aplikacijah, ki jih uporabljajo.

Ključni koncepti v Module Federation:

Host (gostitelj): Glavna aplikacija, ki porablja oddaljene module.
Remote (oddaljen): Aplikacija, ki izpostavlja module za porabo s strani drugih aplikacij.
Shared Modules (moduli v skupni rabi): Moduli, ki se delijo med gostiteljsko in oddaljeno aplikacijo (npr. React, Lodash). Module Federation lahko samodejno upravlja z različicami in deduplikacijo modulov v skupni rabi, da zagotovi, da se naloži samo ena različica vsakega modula.
Exposed Modules (izpostavljeni moduli): Specifični moduli iz oddaljene aplikacije, ki so na voljo za porabo drugim aplikacijam.
RemoteEntry.js: Datoteka, ki jo ustvari Webpack in vsebuje metapodatke o izpostavljenih modulih oddaljene aplikacije. Gostiteljska aplikacija uporablja to datoteko za odkrivanje in nalaganje oddaljenih modulov.

Nastavitev Module Federation z Webpack 5: Praktični vodnik

Poglejmo si praktičen primer nastavitve Module Federation z Webpack 5. Ustvarili bomo dve preprosti aplikaciji: aplikacijo Host (gostitelj) in aplikacijo Remote (oddaljena). Oddaljena aplikacija bo izpostavila komponento, gostiteljska aplikacija pa jo bo porabila.

1. Priprava projekta

Ustvarite dve ločeni mapi za svoji aplikaciji: `host` in `remote`.

```bash mkdir host remote cd host npm init -y npm install webpack webpack-cli webpack-dev-server html-webpack-plugin --save-dev npm install react react-dom cd ../remote npm init -y npm install webpack webpack-cli webpack-dev-server html-webpack-plugin --save-dev npm install react react-dom ```

2. Konfiguracija oddaljene aplikacije (Remote)

V mapi `remote` ustvarite naslednje datoteke:

`src/index.js`: Vstopna točka aplikacije.
`src/RemoteComponent.jsx`: Komponenta, ki bo izpostavljena.
`webpack.config.js`: Konfiguracijska datoteka Webpack.

src/index.js:

```javascript import React from 'react'; import ReactDOM from 'react-dom/client'; import RemoteComponent from './RemoteComponent'; const App = () => (

Oddaljena aplikacija

); const root = ReactDOM.createRoot(document.getElementById('root')); root.render(); ```

src/RemoteComponent.jsx:

```javascript import React from 'react'; const RemoteComponent = () => (

To je oddaljena komponenta!

Izrisano iz oddaljene aplikacije.

); export default RemoteComponent; ```

webpack.config.js:

```javascript const HtmlWebpackPlugin = require('html-webpack-plugin'); const ModuleFederationPlugin = require('webpack/lib/container/ModuleFederationPlugin'); const path = require('path'); module.exports = { entry: './src/index', mode: 'development', devServer: { port: 3001, static: { directory: path.join(__dirname, 'dist'), }, }, output: { publicPath: 'auto', }, module: { rules: [ { test: /\.(js|jsx)$/, exclude: /node_modules/, use: { loader: 'babel-loader', options: { presets: ['@babel/preset-react', '@babel/preset-env'], }, }, }, ], }, plugins: [ new ModuleFederationPlugin({ name: 'remote', filename: 'remoteEntry.js', exposes: { './RemoteComponent': './src/RemoteComponent', }, shared: { react: { singleton: true, eager: true }, 'react-dom': { singleton: true, eager: true }, }, }), new HtmlWebpackPlugin({ template: './public/index.html', }), ], resolve: { extensions: ['.js', '.jsx'], }, }; ```

Ustvarite `public/index.html` z osnovno HTML strukturo. Pomemben je `

3. Konfiguracija gostiteljske aplikacije (Host)

V mapi `host` ustvarite naslednje datoteke:

`src/index.js`: Vstopna točka aplikacije.
`webpack.config.js`: Konfiguracijska datoteka Webpack.

src/index.js:

```javascript import React, { Suspense } from 'react'; import ReactDOM from 'react-dom/client'; const RemoteComponent = React.lazy(() => import('remote/RemoteComponent')); const App = () => (

Gostiteljska aplikacija

Nalaganje oddaljene komponente...

); const root = ReactDOM.createRoot(document.getElementById('root')); root.render(); ```

webpack.config.js:

```javascript const HtmlWebpackPlugin = require('html-webpack-plugin'); const ModuleFederationPlugin = require('webpack/lib/container/ModuleFederationPlugin'); const path = require('path'); module.exports = { entry: './src/index', mode: 'development', devServer: { port: 3000, static: { directory: path.join(__dirname, 'dist'), }, }, output: { publicPath: 'auto', }, module: { rules: [ { test: /\.(js|jsx)$/, exclude: /node_modules/, use: { loader: 'babel-loader', options: { presets: ['@babel/preset-react', '@babel/preset-env'], }, }, }, ], }, plugins: [ new ModuleFederationPlugin({ name: 'host', remotes: { remote: 'remote@http://localhost:3001/remoteEntry.js', }, shared: { react: { singleton: true, eager: true }, 'react-dom': { singleton: true, eager: true }, }, }), new HtmlWebpackPlugin({ template: './public/index.html', }), ], resolve: { extensions: ['.js', '.jsx'], }, }; ```

Ustvarite `public/index.html` z osnovno HTML strukturo (podobno kot pri oddaljeni aplikaciji). Pomemben je `

4. Namestitev Babel

V obeh mapah, `host` in `remote`, namestite odvisnosti za Babel:

```bash npm install --save-dev @babel/core @babel/preset-env @babel/preset-react babel-loader ```

5. Zagon aplikacij

V obeh mapah, `host` in `remote`, dodajte naslednji skript v `package.json`:

```json "scripts": { "start": "webpack serve" } ```

Sedaj zaženite obe aplikaciji:

```bash cd remote npm start cd ../host npm start ```

Odprite brskalnik in pojdite na `http://localhost:3000`. Morali bi videti gostiteljsko aplikacijo z oddaljeno komponento, izrisano znotraj nje.

Pojasnilo ključnih možnosti konfiguracije:

`name`: Edinstveno ime za aplikacijo.
`filename`: Ime datoteke, ki bo vsebovala metapodatke o izpostavljenih modulih (npr. `remoteEntry.js`).
`exposes`: Preslikava imen modulov v poti do datotek, ki določa, kateri moduli naj bodo izpostavljeni.
`remotes`: Preslikava imen oddaljenih aplikacij v URL-je, ki določa, kje najti datoteko remoteEntry.js za vsako oddaljeno aplikacijo.
`shared`: Seznam modulov, ki naj se delijo med gostiteljsko in oddaljenimi aplikacijami. Možnost `singleton: true` zagotavlja, da se naloži samo ena instanca vsakega modula v skupni rabi. Možnost `eager: true` zagotavlja, da se modul v skupni rabi naloži takoj (tj. pred drugimi moduli).

Napredne tehnike Module Federation

Module Federation ponuja veliko naprednih funkcij, ki vam lahko pomagajo zgraditi še bolj sofisticirane arhitekture mikro-frontendov.

Dinamični oddaljeni moduli (Remotes)

Namesto da bi URL-je oddaljenih aplikacij trdo kodirali v konfiguraciji Webpack, jih lahko naložite dinamično med izvajanjem. To vam omogoča enostavno posodabljanje lokacije oddaljenih aplikacij, ne da bi morali ponovno graditi gostiteljsko aplikacijo.

Na primer, URL-je oddaljenih aplikacij lahko shranite v konfiguracijski datoteki ali bazi podatkov in jih dinamično naložite z uporabo JavaScripta.

```javascript // V webpack.config.js remotes: { remote: `promise new Promise(resolve => { const urlParams = new URLSearchParams(window.location.search); const remoteUrl = urlParams.get('remote'); // Predpostavimo, da je remoteUrl nekaj takega kot 'http://localhost:3001/remoteEntry.js' const script = document.createElement('script'); script.src = remoteUrl; script.onload = () => { // ključno pri module federation je, da je oddaljena aplikacija // dostopna preko imena, ki je določeno v njeni konfiguraciji resolve(window.remote); }; document.head.appendChild(script); })`, }, ```

Sedaj lahko gostiteljsko aplikacijo naložite s poizvedbenim parametrom `?remote=http://localhost:3001/remoteEntry.js`

Verzionirani moduli v skupni rabi

Module Federation lahko samodejno upravlja z različicami in deduplikacijo modulov v skupni rabi, da zagotovi nalaganje samo ene združljive različice vsakega modula. To je še posebej pomembno pri delu z velikimi in kompleksnimi aplikacijami, ki imajo veliko odvisnosti.

V konfiguraciji Webpack lahko določite obseg različic za vsak modul v skupni rabi.

```javascript // V webpack.config.js shared: { react: { singleton: true, eager: true, requiredVersion: '^18.0.0' }, 'react-dom': { singleton: true, eager: true, requiredVersion: '^18.0.0' }, }, ```

Nalaganje modulov po meri

Module Federation vam omogoča, da definirate nalagalnike modulov po meri, ki se lahko uporabljajo za nalaganje modulov iz različnih virov ali v različnih formatih. To je lahko uporabno za nalaganje modulov iz CDN-ja ali iz registra modulov po meri.

Deljenje stanja med mikro-frontendi

Eden od izzivov arhitektur mikro-frontendov je deljenje stanja med različnimi mikro-frontendi. Obstaja več pristopov, ki jih lahko uporabite za reševanje tega izziva:

Upravljanje stanja prek URL-ja: Shranite stanje v URL in ga uporabite za komunikacijo med mikro-frontendi. To je preprost in neposreden pristop, vendar lahko postane okoren pri kompleksnem stanju.
Dogodki po meri: Uporabite dogodke po meri za oddajanje sprememb stanja med mikro-frontendi. To omogoča ohlapno povezovanje med mikro-frontendi, vendar je lahko upravljanje naročnin na dogodke težavno.
Knjižnica za upravljanje stanja v skupni rabi: Uporabite knjižnico za upravljanje stanja v skupni rabi, kot sta Redux ali MobX, za upravljanje stanja celotne aplikacije. To zagotavlja centraliziran in dosleden način upravljanja stanja, vendar lahko uvede odvisnost od določene knjižnice za upravljanje stanja.
Posrednik sporočil (Message Broker): Uporabite posrednika sporočil, kot sta RabbitMQ ali Kafka, za lažjo komunikacijo in deljenje stanja med mikro-frontendi. To je bolj kompleksna rešitev, vendar ponuja visoko stopnjo prilagodljivosti in razširljivosti.

Najboljše prakse za implementacijo mikro-frontendov z Module Federation

Tukaj je nekaj najboljših praks, ki jih je treba upoštevati pri implementaciji mikro-frontendov z Module Federation:

Določite jasne meje za vsak mikro-frontend: Vsak mikro-frontend naj bo odgovoren za določeno poslovno domeno ali funkcionalnost in naj ima dobro definirane vmesnike.
Uporabljajte dosleden tehnološki sklad: Čeprav Module Federation omogoča uporabo različnih tehnologij za različne mikro-frontende, je na splošno dobro uporabljati dosleden tehnološki sklad za zmanjšanje kompleksnosti in izboljšanje vzdržljivosti.
Vzpostavite jasne komunikacijske protokole: Določite jasne komunikacijske protokole za medsebojno interakcijo mikro-frontendov.
Avtomatizirajte postopek uvajanja: Avtomatizirajte postopek uvajanja, da zagotovite neodvisno in zanesljivo uvajanje mikro-frontendov. Razmislite o uporabi CI/CD cevovodov in orodij za infrastrukturo kot kodo.
Spremljajte delovanje vaših mikro-frontendov: Spremljajte delovanje vaših mikro-frontendov, da prepoznate in odpravite morebitna ozka grla v zmogljivosti. Uporabite orodja, kot so Google Analytics, New Relic ali Datadog.
Implementirajte robustno obravnavanje napak: Implementirajte robustno obravnavanje napak, da zagotovite odpornost vaše aplikacije na napake.
Sprejmite decentraliziran model upravljanja: Opolnomočite ekipe, da sprejemajo odločitve o svojih mikro-frontendih, hkrati pa ohranjajte splošno doslednost in kakovost.

Primeri uporabe Module Federation v praksi

Čeprav so specifične študije primerov pogosto zaupne, je tukaj nekaj splošnih scenarijev, kjer je Module Federation lahko izjemno koristen:

E-trgovinske platforme: Kot smo že omenili, lahko velike e-trgovinske platforme uporabljajo Module Federation za gradnjo neodvisnih mikro-frontendov za katalog izdelkov, nakupovalno košarico, postopek zaključka nakupa in upravljanje uporabniških računov. To omogoča različnim ekipam, da neodvisno delajo na teh funkcijah in jih uvajajo brez vpliva na druge dele aplikacije. Globalna platforma bi lahko prilagodila funkcije za različne regije prek oddaljenih modulov.
Aplikacije za finančne storitve: Aplikacije za finančne storitve imajo pogosto kompleksne uporabniške vmesnike z veliko različnimi funkcijami. Module Federation se lahko uporablja za gradnjo neodvisnih mikro-frontendov za različne vrste računov, trgovalne platforme in nadzorne plošče za poročanje. Funkcije za skladnost, ki so edinstvene za določene države, se lahko dostavijo prek Module Federation.
Zdravstveni portali: Zdravstveni portali lahko uporabljajo Module Federation za gradnjo neodvisnih mikro-frontendov za upravljanje pacientov, načrtovanje terminov in dostop do zdravstvenih kartotek. Različni moduli za različne zavarovalnice ali regije se lahko dinamično nalagajo.
Sistemi za upravljanje z vsebino (CMS): CMS lahko uporablja Module Federation, da uporabnikom omogoči dodajanje funkcionalnosti po meri na svoje spletne strani z nalaganjem oddaljenih modulov od tretjih razvijalcev. Različne teme, vtičniki in pripomočki se lahko distribuirajo kot neodvisni mikro-frontendi.
Sistemi za upravljanje učenja (LMS): LMS lahko ponuja tečaje, ki so razviti neodvisno in integrirani v enotno platformo prek Module Federation. Posodobitve posameznih tečajev ne zahtevajo ponovnih namestitev celotne platforme.

Zaključek

JavaScript Module Federation v Webpack 5 ponuja močan in prilagodljiv način za gradnjo arhitektur mikro-frontendov. Omogoča deljenje kode med ločeno prevedenimi JavaScript aplikacijami med izvajanjem, kar omogoča neodvisne namestitve, tehnološko raznolikost in izboljšano avtonomijo ekip. Z upoštevanjem najboljših praks, opisanih v tem vodniku, lahko izkoristite Module Federation za gradnjo razširljivih, vzdrževanih in inovativnih spletnih aplikacij.

Prihodnost frontend razvoja se nedvomno nagiba k modularnim in porazdeljenim arhitekturam. Module Federation zagotavlja ključno orodje za gradnjo teh sodobnih sistemov, ki ekipam omogoča ustvarjanje kompleksnih aplikacij z večjo hitrostjo, prilagodljivostjo in odpornostjo. Ko bo tehnologija dozorela, lahko pričakujemo še več inovativnih primerov uporabe in najboljših praks.