Inhaltsverzeechnes[Verstoppen][Show]
- Aféierung fir Mikro Front-End Architektur
Virdeeler vum Micro Frontend +- Déi
- Entwécklung a séier autonom Équipen
- Méi kleng Codebase vun Individuelle Mikro Frontends féieren zu méi proppere Code
- Verbessert App Stabilitéit Wéinst enger loose Kupplung
- Individuell Features testen ass méi einfach gemaach
- Reduzéiert Bundle Gréisst féiert zu méi séier Säit Lueden
- Technologie Onofhängegkeet
- Konklusioun
D'Iddi vu Mikroservicer huet viru kuerzem vill Opmierksamkeet gewonnen, a vill Firme benotze se fir grouss, monolithesch Backends ze läschen.
Dee selwechte Wee mam Frontend ze goen ass nach ëmmer eng Erausfuerderung fir vill Geschäfter, och wann dës verdeelt Manéier fir d'Serversäit vu Webapps ze bauen méi oder manner zouverlässeg ass wat d'Recherche an d'Ausféierung ugeet.
Wéinst senger enker Ofhängegkeet mécht de Client-Säit Monolith typesch et schwéier nei Features z'integréieren, nei Technologien ze adoptéieren an eenzel Komponenten ze skaléieren.
Dës an aner Erausfuerderunge hunn Frontend Entwéckler opgefuerdert fir Mikroservicer ze benotzen.
Als Resultat gouf eng fuschneie architektonesch Strategie bekannt als Mikro Frontend entwéckelt fir d'Front-End Schicht vu Websäiten a Web-baséiert Uwendungen ze kreéieren.
De Begrëff gouf fir d'éischt am Joer 2016 benotzt, an zënterhier huet et vill Opmierksamkeet fir e gudden Zweck gemaach.
Dësen Artikel gëtt en allgemengt Verständnis vu wat Mikrofrontends sinn an d'Themen déi se adresséieren. et funktionéiert, souwéi Virdeeler an Nodeeler.
Aféierung fir Mikro Front-End Architektur
Eng zäitgenëssesch Method fir Front-End Entwécklung genannt Mikro-Frontend Architektur trennt a Web Applikatioun an kleng, onofhängeg Deeler.
Fir den Endbenotzer schéngen dës Deeler eng Eenheet ze sinn, och wa se onofhängeg gebaut goufen an dann zesummegesat goufen.
Mam Ënnerscheed datt Mikro Frontends op d'Client Säit bezéien, net d'Server Säit, vun Online Léisungen, ass d'Begrënnung, déi hinnen ënnerleien, identesch mat dee vu Mikroservicer.
Sophistikéiert Web-baséiert Produkter maachen mécht am meeschte Sënn wann Dir eng Mikro Frontend Approche benotzt.
Mikro Frontends, am Géigesaz zu engem méi konventionelle Front-End Monolith, erméiglechen vill Teams fir separat op verschidde Softwareprojeten ze kollaboréieren.
Programméierer kënne Webapps méi séier erstellen a mat méi Skalierbarkeet an Ënnerhaltbarkeet mat dësem architektoneschen Design.
Fir et einfach ze soen, all Mikro Frontend ass just e Stéck Code fir e markanten Bestanddeel vun der Websäit.
Dës Fonctiounen sinn duerch getrennten Équipë kontrolléiert haten, all vun deenen an enger bestëmmter Industrie oder Zil spezialiséiert.
Monolithesch vs Microservices vs Micro Frontend Architektur
Denkt drun ze plënneren. Gëtt et méi einfach fir Iech alles an eng Rei vu klenge Këschte mat Fachstécker ze organiséieren an all eenzel individuell ze verlageren oder dat ganzt Personal an eng enorm Këscht ze packen an op eng nei Plaz ze transportéieren?
Déi offensichtlech Léisung ass do.
Dës Analogie vergläicht déi zwee verschidde Web App Architekturen, Monolithen a Mikroservicer (och bekannt als Mikrofrontends).
Monolithesch Architektur
Dir kënnt vläicht un déi "gutt al Deeg" erënneren, wann eng komplett Applikatioun als eenzeg, kohäsiv Entitéit erstallt gouf. Sou eng Method gëtt Monolith genannt, wat en ale Begrëff fir e grousse Steenblock ass.
Dëst mécht Sënn.
Monolithesch Systemer hunn interdependent Elementer. Dofir, wann Dir eppes wëllt änneren oder eng nei Feature addéieren, ass et méiglech datt de ganze System briechen.
Och wann et éiweg ass, gëtt et heiansdo nach ëmmer. Jo, mir si bewosst vun Ärem aktuellen Ausdrock.
D'konzeptuell Divisioun vun der Codebase an zwee verschidde Komponenten - Frontend (Client-Säit) an Backend (Server-Säit) - gouf onvermeidlech wéi nei Technologien entwéckelt goufen a Softwareprodukter méi komplizéiert ginn.
Déi populärste Operatiounsmethod ass elo d'Trennung vu Bedenken tëscht der Presentatiounsschicht mat där en Endbenotzer interagéiert an alles wat am Hannergrond stattfënnt.
Et brauch zwee Software-Ingenieur-Teams, mat dem Front-End-Team déi visuell Komponenten baut an dem Back-End-Team de Webservicer, Geschäftslogik, Datenzougang, Integratiounen, etc.
Wéi och ëmmer, trotz dëser Trennung, bleift dës Strategie nach ëmmer monolithesch vun der Natur.
D'Haaptännerung ass datt mir elo zwee sizable Codeblocken hunn - de Frontend an de Backend - amplaz vun enger enormer Applikatioun. Monolithesch Architekturen mussen net schrecklech sinn; si hunn e puer Virdeeler, dorënner
- Einfach a séier Entwécklung fir kleng Uwendungen mat enger eenzeger Quellcodebase an engem ganz einfachen Design;
- Testen an Debugging si ganz einfach well all Code op enger Plaz ass, wat et méi einfach mécht fir e Team de Flux vun enger Ufro ze verfolgen an Bugs z'identifizéieren;
- Fréi an der Entwécklung vun enger Applikatioun sinn d'Käschte méi bëlleg well weder Infrastrukturkäschten nach Entwécklungskäschte entstoen bis nei Features bäigefüügt ginn.
D'Nodeeler vun dëser Strategie spigelt sech an
- Beschränkt Détachement Flexibilitéit - Équipë mussen waarden wann et nëmmen eng Handvoll vun hinnen um Projet schaffen an nei Détachement ass néideg all Kéier wann Dir de Code update;
- Nei Technologien z'adoptéieren ass Erausfuerderung, well dëst ze maachen erfuerdert e wesentlechen Deel ëmzeschreiwen, wann net de ganze Projet.
- Wann d'Zuel vun den Entwéckler eropgeet, gëtt e Code System enk verbonne, komplizéiert a schwéier ze verwalten an ze verstoen.
- Organisatoresch Themen - all Teammember muss déiselwecht Versioun vu Bibliothéiken benotzen an all Ännerungen mellen wa vill Teams un engem monolithesche Projet schaffen.
- Bedenken mat Skalierbarkeet - well d'Komponente vum Projet matenee verbonne sinn, d'Skaléierung vun hinnen getrennt stellt Schwieregkeeten, déi zu bedeitend Ënnerbriechungen a méi héich Ausgaben resultéieren.
- Déi komplex Logik vum Projet kéint schwéier sinn fir nei Teammemberen ze verstoen, besonnesch wann d'Ingenieuren, déi ursprénglech dru geschafft hunn, net méi agestallt sinn.
D'Entwécklung vu Mikroservicer an hir enk Famill, a Mikrofrontends, hunn déi primär Probleemer mat monolithesche Systemer adresséiert.
Microservices Architektur
Déi architektonesch Method bekannt als Mikroservicer erlaabt d'Schafung vu ville locker verbonnen an onofhängeg deployable méi kleng Komponenten, oder Servicer, déi en Applikatiouns-Backend ausmaachen.
All Service huet seng eege Codebase, CI / CD Pipelines, DevOps Prozeduren, a Prozesser fir se auszeféieren.
Dir kënnt gesinn datt dat monolithescht Backend Team an getrennten Teams opgedeelt ass andeems Dir d'Bild hei uewen kuckt.
Jidderee konzentréiert sech individuell op en aneren Aspekt vun der Applikatioun (wéi de Produktservice, Sichservice a Bezuelservice).
Kommunikatioun tëscht de Servicer geschitt duerch etabléiert Protokoller bekannt als APIs, sou wéi de liichtgewiichtege REST API Protokoll deen synchron Ufro-Äntwert Mustere benotzt.
Eng aner Optioun ass asynchron Kommunikatioun mat Software wéi Kafka ze benotzen, déi Kommunikatiounsstrukturen an Eventer publizéieren / abonnéieren.
Mikroservicer integréieren mam Frontend iwwer e Backend fir de Frontend (BFF) Service oder en API Gateway duerch d'Netz. BFF bitt eng personaliséiert API fir all Client, wärend API Gateways en eenzegen Zougangspunkt fir eng Sammlung vu Mikroservicer ginn.
Awer och mat autonomen Backend Komponenten an all d'Virdeeler déi se ubidden, ass de Frontend nach ëmmer e Monolith.
Dofir ass dëst wou Mikro Frontends nëtzlech sinn.
Mikro frontends Architektur
Ähnlech wéi Mikroservicer, wou locker verlinkte Komponenten vu verschiddenen Teams geréiert ginn, applizéiert d'Mikrofrontend Architektur d'Konzept op de Browser.
Dës Webapplikatioun User-Interfaces verfollegen dës Struktur, déi aus e bësse autonom Komponenten besteet.
Teams ginn och op Clientbedürfnisser oder Benotzungsfäll erstallt anstatt speziell Expertise oder Technologie.
Dofir sinn Teams a Mikroservicer a Mikro Frontend Projeten involvéiert.
- vertikal geschnidden - well et Frontend Entwéckler, Datenexperten, Backend Ingenieuren, QA Ingenieuren, asw., déi och um selwechte Projet schaffen, kreéieren se hir Features User Interface zu Datenbanken; an
- cross-functional - all Teammember dréit hir Expertise un de Grupp bäi.
Équipë kënnen och den Tech Stack auswielen, deen am Beschten hir speziell Linn vum Geschäft passt.
Een Team kann React benotze fir säi Fragment ze programméieren. En anert Team erstellt eng nei Angular Versioun. Vue.js ass een esou Beispill.
Mikro Frontends ginn a Verbindung mat verwandte Mikroservicer benotzt fir Probleemer déi Entwécklungsteams typesch mat Monolithen hunn. D'Strategie bitt déi folgend Virdeeler.
- Technologiefräiheet: Frontend Ingenieuren kënnen alternativ JavaScript Kaderen, Runtime-Ëmfeld a ganz Technologiestack auswielen ofhängeg vun de Bedierfnesser vun der Firma. Nieft der aler Architektur kéint e frësche Kader applizéiert ginn.
- E gréissere Grad vu Flexibilitéit ass méiglech well all Mikro-Frontend selbstänneg ass a kann separat entwéckelt, getest, ofgebaut an Upgrade ginn. Als Resultat, wann een Team un enger Feature schafft an e Bugfix gedréckt huet, an en anert Team muss seng eege Feature addéieren, brauche se net op dat éischt Team ze waarden fir hir Aufgab ofzeschléissen.
- Autonom Teams a Systemer: All Produktteam, an doduerch all Feature, ka mat wéineg Ofhängegkeet vun aneren funktionnéieren, wat et erméiglecht weider ze schaffen, och wann déi nooste Komponenten net verfügbar sinn.
- Multiple, méi kleng Codebases: Jidderee vun de Mikrofrontends wäert seng eege, méi handhabbar, méi kleng Codebase hunn. Manner Leit fokusséiere sech op eng spezifesch UI Komponent, vereinfachen Code Bewäertungen a verbesseren d'Gesamtorganisatioun.
- Einfach App Skaléieren: En anere Virdeel vu Mikrofrontends ass d'Fäegkeet fir all Feature individuell ze skaléieren. Am Géigesaz zu Monolithen, wou de ganze Programm all Kéier wann eng nei Feature bäigefüügt muss skaléiert ginn, mécht dëst de ganze Prozess méi effizient a punkto Zäit a Suen.
Wéi funktionnéiert de Mikro Frontend?
Wéi mir virdru gesot hunn, sinn d'Teams vertikal an der Mikro Frontend Architektur organiséiert, dat heescht datt se duerch Domain Wëssen oder Zweck getrennt sinn a verantwortlech sinn vun Ufank bis Enn fir e spezifescht Produkt.
Et kann een oder zwee Backend Mikroservicer hunn wéi och e klenge Frontend. Méi detailléiert, loosst eis d'Charakteristiken vun dësem visuellen Element ënnersichen, d'Interaktioune mat aneren UI Komponenten, an d'Integratioun an d'Homepage.
E Mikro Frontend kann sinn
- eng ganz Säit (zB eng Produktdetailsäit) oder
- Sektiounen vun der Säit, déi vun aneren Teams benotzt kënne ginn, sou wéi Header, Fousszeilen a Sichbaren.
Dir kënnt eng grouss Websäit a verschidde Säitaarte opdeelen an all Typ un e spezifescht Personal ginn fir un ze schaffen.
Wéi och ëmmer, e puer Komponente kommen dacks op ville Säiten, wéi Header, Fousszeilen, Suggestiounsblocken, asw. E Virschlagblock, zum Beispill, kann op enger Homepage, enger Produktdetailsäit oder souguer op der Kassesäit agefouert ginn.
Am Wesentlechen kënnen Teams Stécker erstellen déi aner Teams op hire Säiten benotze kënnen.
D'Mikro Frontends kënnen awer separat als verschidde Projeten ofgebaut ginn am Géigesaz zu de wiederverwendbare Komponenten.
All dëst kléngt fantastesch, awer fir eng vereenegt Interface ze kreéieren, mussen Säiten a Fragmenter iergendwéi kombinéiert ginn.
Dëst erfuerdert Frontend Integratioun, déi iwwer eng Vielfalt vu Strategien erreecht ka ginn, dorënner Routing, Kompositioun a Kommunikatioun (kuckt d'Grafik hei uewen).
läit
Wann Service vun enger Säit, déi vun engem Team kontrolléiert gëtt, erfuerderlech ass fir Zougang zu enger Säit, déi vun engem aneren Team gehéiert, ass Routing nëtzlech fir Integratioun op Säitniveau.
All Mikro Frontend gëtt als eenzeg Säit Applikatioun gehandhabt. Einfach HTML Linke kënne benotzt ginn fir Routing ze bidden.
E Benotzer kann de Browser zwéngen fir den Zilmarkup vun engem Server erofzelueden an déi aktuell Säit mat der neier ze ersetzen andeems Dir op Hyperlinks klickt.
D'App-Shell ass dee Minimum vun HTML, CSS, a JavaScript, deen en UI mécht. Och wann d'Inhaltsdaten, déi vum Server gefrot ginn, nach ëmmer waarden, kritt de Benotzer direkt eng statesch ugewisen Säit. D'Zentral App Shell déngt als Elterendeel fir déi eenzeg Säit Apps, déi vun de verschiddenen Teams erstallt goufen.
Egal wéi eng Bibliothéik oder Kader déi benotzt gëtt, Meta-Frameworks erméiglechen d'Fusioun vu verschiddene Säiten an eng eenzeg.
Kompositioun
Zesummesetzung ass de Prozess fir d'Stécker ze arrangéieren fir se an déi passend Plazen op enger Säit ze passen. An de meeschte Fäll hëlt d'Team, déi d'Säit ofsetzt, net direkt den Inhalt vum Fragment.
Amplaz plazéiert et e Plazhalter oder Marker wou de Fragment an der Markup sollt sinn.
Mat engem anere Kompositiounsprozess gëtt déi lescht Assemblée fäerdeg. D'Zesummesetzung kann an zwou Basiskategorien opgedeelt ginn: Client-Säit a Server-Säit.
Client-Säit Zesummesetzung: De Webbrowser gëtt benotzt fir HTML Markup ze kreéieren an z'änneren. All Mikro Frontend huet d'Fäegkeet fir seng Markup ze änneren an ze weisen getrennt vum Rescht vun der Säit.
Web Components, zum Beispill, erlaben Iech dës Zort Konstruktioun auszeféieren.
De Plang ass all Fragment an e Webkomponent ze maachen deen onofhängeg als a.js-Datei installéiert ka ginn, duerno kënnen d'Apps lueden an se an de Plazen, déi fir si am Thema Layout designéiert sinn, lueden an ofginn.
Web Komponente sinn ofhängeg vun der HTML an DOM API, déi aner Frontend Kaderen benotze kënnen, souwéi eng Standardmethod fir Daten iwwer Requisiten an Eventer ze schécken an ze kréien.
Server-Säit Zesummesetzung: Mat dësem Design ginn d'UI-Stécker um Server kombinéiert, wat zu enger komplett geformter Säit op de Client-Säit geschéckt gëtt, wat d'Luede beschleunegt.
D'Versammlung gëtt dacks vun engem separaten Service duerchgefouert, deen tëscht dem Webbrowser an de Webserver setzt. CDN ass eng Instanz vum Service (Inhaltsliwwerungsnetz).
Dir kënnt een oder eng Kombinatioun vun deenen zwee wielen, jee no Äre Besoinen.
Mikro Frontend Kommunikatiounsmuster
D'Mikrofrontend Architektur funktionnéiert am Beschten wann et wéineg bis keng Interaktioun tëscht de verschiddene Komponenten ass. Mikro Frontends mussen heiansdo matenee schwätzen an Informatioun deelen. Hei sinn e puer potenziell Musteren déi dozou féieren kënnen.
- Web Aarbechter: En Online-Aarbechter ass e Mechanismus, deen de Webinhalt erlaabt JavaScript am Hannergrond ze lafen, onofhängeg vun anere Scripten, an ouni d'Geschwindegkeet vun der Säit ze beaflossen. Eng eenzegaarteg Aarbechter API gëtt fir all Mikro App zur Verfügung gestallt. Dëse Virdeel ass datt Zäitopwänneg Aarbecht an engem anere Fuedem ka gemaach ginn, wat den UI Fuedem erlaabt ouni ze bremsen oder gestoppt ze ginn.
- Event Emitter: An dësem Fall kommunizéieren vill Komponente mateneen andeems se nolauschteren an op all Staatsännerungen an de Komponenten handelen, op déi se abonnéiert sinn. Aner Mikro Frontends déi op dat spezifescht Event abonnéiert hunn reagéiere wann e Mikro Frontend dat Event brennt. En Event-Emitter deen an all Mikro-Frontend agefouert gouf mécht dëst machbar.
- Callbacks a Requisiten: An dëser Rubrik definéiert Dir engem Elterendeel Komponent an Kand Komponente. D'Kommunikatioun ass an eng Bamähnlech Struktur organiséiert. Elterendeel Komponente benotzen Requisiten fir d'Donnéeën als Funktiounen erof op de Komponentebam un d'Kandkomponenten ze vermëttelen. Am Tour kann d'Kand den Elterendeel effizient alarméieren wann eppes an hirem Staat geschitt andeems se op Callbacks reagéieren. React benotzt dëse Modus.
Virdeeler vum Micro Frontend
Entwécklung a séier autonom Équipen
En onofhängegt Team kann all Deel vun enger Web App oder Websäit erstellen wann Dir eng Mikro Frontend Method benotzt.
All Team ass komplett autonom, dat heescht et ass verantwortlech fir de ganze Komponententwécklungszyklus, vun der Konzeptioun bis zur Verëffentlechung an der Postproduktioun.
Zousätzlech implizéiert et datt verschidde Teams nahtlos kënne kollaboréieren a gläichzäiteg um selwechte Projet schaffen.
Dofir sinn Verëffentlechungszyklen wesentlech méi séier wéi se mat Front-End Monolithen wieren.
Méi kleng Codebase vun Individuelle Mikro Frontends féieren zu méi proppere Code
Monolithesch Frontends hu grouss, onbestänneg Codebasen déi ëmmer méi chaotesch ginn an Erausfuerderung mat der Zäit ze managen.
Mikro frontends adresséieren dëse Problem. De Quellcode vun all Mikro Frontend ass méi handhabbar well et méi kleng, méi einfach a méi kompakt ass.
Déi allgemeng Webléisung profitéiert vu propperem Code als Konsequenz.
Verbessert App Stabilitéit Wéinst enger loose Kupplung
Eng Webléisung kann selten jee an komplett onofhängeg Stécker opgedeelt ginn. Dofir schwätze Mikro Frontends mateneen.
Wéi och ëmmer, all Link tëscht de Komponenten ass bedeitend trotz der lockerer Konnektivitéit.
Den Ausfall vun engem Komponent huet wéineg bis keen Effekt op d'Operatioun vun allen anere Komponenten, wat d'verstäerkte Stabilitéit vun enger Webléisung ubitt.
Individuell Features testen ass méi einfach gemaach
Dëse Virdeel resultéiert aus de Charakteristike vu Mikrofrontends. Baséierend op dësem architektoneschen Design ass d'Clientsäit vun enger Webléisung modulär an all Modul ass autonom.
Als Resultat ass e klengen Deel vun der User-Interface selwer ze evaluéieren ass méi einfach fir e Team ze maachen wéi e massive Monolith ze testen.
Reduzéiert Bundle Gréisst féiert zu méi séier Säit Lueden
Ee vun de primäre Ursaache vu verspéiten Laaschtzäiten a Feature-räiche monolithesche Websystemer ass d'Gréisst vun engem JavaScript Bündel. Op der anerer Säit, eng Mikro Frontend Approche mécht et méi einfach d'Säitlaaschtzäit ze reduzéieren.
E Browser muss net onnéideg Code ëmmer erëm eroflueden well eng Websäit aus e puer klenge Bündel besteet. Als Resultat ginn d'Performance vun der Säit an d'Laaschtzäit erhéicht.
Technologie Onofhängegkeet
MÉI Front-Enn Kaderen kann vun Entwéckler benotzt ginn fir eng eenzeg Online Léisung mat enger Mikrofrontend Architektur ze kreéieren.
Well all Komponent autonom ass, kann se konstruéiert ginn mat der Technologie déi am Beschten d'Aufgaben vum Team passt.
Natierlech sollten d'Programméierer virsiichteg sinn wann se Kadere fir de Softwareprojet auswielen, fir déi se zoustänneg sinn, a Konsultatiounen mat aneren Teams ginn nach ëmmer staark ugeroden.
Wéi och ëmmer, et gëtt null Chance datt Dir gezwongen sidd e legacy Kader fir d'Dauer vun der Liewensdauer vun der App ze benotzen.
Nodeeler vum Micro Frontend
Komplex Web Léisung Testen a senger ganzer
Déi verschidde Moduler vun enger Webléisung testen ass einfach wann et eng Mikrofrontend Architektur benotzt. Et ënnerscheet sech awer vun der Evaluatioun vun enger Webapplikatioun als Ganzt.
Vergewëssert Iech datt all Deeler funktionnéieren wéi virgesinn ier Dir weider geet. Dëst ka schwéier sinn well Mikrofrontends onofhängeg operéieren an separat Liwwerprozesser hunn.
Deier initial Investitiounen
Mikro Frontend Entwécklungen erfuerderen typesch wesentlech finanziell Ausgaben. Et ass deier fir vill Front-End Teams ze sammelen an ze halen.
Zousätzlech braucht Dir Gestiounspersonal fir d'Aarbecht ze organiséieren, sécherzestellen datt alles koordinéiert ass an eng exzellent Teamkommunikatioun garantéiert.
D'Komplexitéit vun Entwécklung an Deployment
D'Entwécklung an d'Deploymentprozedure kënne méi komplizéiert ginn als Resultat vun engem Mikro-Frontend Design.
Eng Léisung kéint mat ze vill Komponente vun onofhängegen Entwécklungséquipen, déi um selwechte Projet schaffen, zum Beispill, déi Problemer an der Installatiounsstadium verursaachen.
Déi richteg Assemblée vun all de Moduler an hir glat Integratioun an de Gesamtschema ass och net ëmmer einfach; dës Aarbecht erfuerdert typesch e grëndleche Verständnis vun all Ofhängegkeeten.
Probleemer fir d'Kohärenz an der Benotzererfarung z'erhalen
Eng konsequent User-Interface erhalen ass Erausfuerderung wann Teams separat op verschiddenen Deeler vun der Software schaffen.
D'Webléisung soll vun all den Entwéckler vum Projet gedeelt ginn. Soss kann et vill Widdersproch laanscht der Strooss ginn.
Konklusioun
Mikro Frontends, en zäitgenësseschen architektoneschen Design, kënnen d'Performance vu grousser Mikroservice-baséiert Webentwécklungsprojeten staark verbesseren.
Et erlaabt Programméierer déi komplett Léisung an diskret Deeler opzedeelen, déi vu verschiddenen autonomen Teams erstallt kënne ginn. Vill Virdeeler folgen dovun, dorënner méi séier Feature Roll-out, méi einfach Testen vun eenzel Moduler, a méi nahtlos Upgrades.
Awer et ginn och e puer Schwieregkeeten mat Mikrofrontends.
Eng ëmfaassend Tester vun enger Applikatioun, zum Beispill, kéint Erausfuerderung sinn.
Zousätzlech, well e grousst Team vun Ingenieuren an Administrateuren gebraucht gëtt, sinn Mikro Frontend Projeten héich deier.
Dofir, ier Dir zu enger Entscheedung kënnt, musst Dir all Komponente vun Ärem Geschäftsfall berücksichtegen.
Vladimír Čamaj
Iergendwéi hunn ech net verstanen op wéi engem Prinzip d'Kommunikatioun tëscht eenzelne Komponenten um Frontend funktionnéiert. Ech verstinn net wéi Dir Komponente verbënnt, déi a verschiddene Kaderen erstallt ginn. Et gëtt näischt am Artikel doriwwer. De System vun Evenementer an Nolauschterer gesäit aus wéi Häll op der Äerd fir mech. Wéi solle mir eis et virstellen?