ბიბლიოთეკა
00/07 · ~34 წთ
GUIDEDECK · ფრონტენდები, რომლებიც გუნდთან ერთად იზრდება

მოდულური & მიკროფრონტენდული
არქიტექტურა
ფრონტენდებისთვის, რომლებიც იზრდება.

34-წუთიანი სამუშაო სესია იმაზე, როგორ გავავლოთ საზღვრები ბრაუზერში — მოდულების დაწყვილებიდან, მონორეპოებისა და მოდულური მონოლითის გავლით, მიკროფრონტენდებამდე და Module Federation-მდე. ერთი გულახდილი გზავნილით: აირჩიეთ უფრო მარტივი ვარიანტი მანამ, სანამ ნამდვილად შეგიძლიათ.

~34 წთდამწყები → საშუალოფრონტენდი / ბილდი
გადაახვიეთ
01 · რატომ დავანაწილოთ 4 წთ

ფრონტენდი უბრალოდ კოდია —
იგივე საზღვრების წესები მოქმედებს.

ყველაფერი, რაც დაწყვილებისა და კოჰეზიის შესახებ OOP & არქიტექტურიდან იცით, პირდაპირ ბრაუზერშიც გადმოდის. მოდულური ფრონტენდი ის არის, სადაც ერთი ფუნქციონალის პოვნა, შეცვლა და გაშვება შეგიძლიათ ისე, რომ მთელი აპლიკაცია არ გამოათრიოთ. ეს დეკი კონკრეტულად ბილდის კუთხეს ეხება — როგორ აისახება ეს საზღვრები ფაილებზე, პაკეტებზე და დეპლოებზე.

მოდული — კოდის თვითკმარი ერთეული ნათელი საჯარო ზედაპირით და დამალული შიგთავსით. ფრონტენდზე მოდული შეიძლება იყოს დირექტორია, npm პაკეტი ან მთელი, დამოუკიდებლად აგებული აპლიკაცია. ერთეული იცვლება; მიზანი — არასოდეს: დააჯგუფეთ ის, რაც ერთად იცვლება, და ჯგუფებს შორის დატოვეთ თხელი, ცხადი საზღვარი.

ორი მტერი — ბრაუზერში

  • დაწყვილება — ღრმა იმპორტი მთელ აპლიკაციაში წვდება (../../checkout/internals/tax). შეეხებით ერთ ფუნქციონალს და CI-ში სრულიად უკავშირო ეკრანი ტყდება.
  • დაბალი კოჰეზია — ერთი utils/ დირექტორია ფლობს თარიღების არითმეტიკას, API გამოძახებებს და თარიღის ამრჩევს. მისი დასახელება ვერავინ ახერხებს, ამიტომ მას ყველაფერი იმპორტს უკეთებს.

მოდულარიზაცია წამალია როგორც კლასის დონეზე (OOP & არქიტექტურა), ისე სისტემის დონეზე (არქიტექტურული პატერნები & სტილები — ბექენდის ეკვივალენტი). აქ მას ბილდზე ვიყენებთ.

cart
pay
cart
pay
საერთო კონტრაქტი
auth
feed
auth
feed
ჩახლართული
გამიჯნული

მარცხნივ: ყოველი ფუნქციონალი ყველა დანარჩენს იმპორტს უკეთებს. მარჯვნივ: ფუნქციონალები მხოლოდ საერთო, ცხადი კონტრაქტის გავლით ხვდებიან ერთმანეთს.

სიმპტომი

40-წუთიანი ბილდი

ერთსტრიქონიანი ტექსტური ცვლილება მთელ აპლიკაციას თავიდან აგებს და თავიდან დეპლოის. ნელი უკუკავშირი საზღვრების პრობლემაა და არა CI-ის.

სიმპტომი

მერჯის კონფლიქტების გადასახადი

ხუთი გუნდი, რომელიც ერთსა და იმავე routes.tsx-ს არედაქტირებს, ნიშნავს, რომ ყოველი PR ყველა დანარჩენს ეომება. მფლობელობა ბუნდოვანია, რადგან ნაკერებიც ბუნდოვანია.

მიზანი

ცვლილების ლოკალურობა

მთელი დღის წესრიგი ესაა: ცვლილება ერთ, კარგად დასახელებულ ადგილს უნდა ეხებოდეს, აფეთქების რადიუსი კი იმ საზღვართან უნდა ჩერდებოდეს, რომელსაც თვალით ხედავთ.

02 · მონორეპო vs პოლირეპო 5 წთ

სად ცხოვრობს კოდი —
ეს არის საზღვრის პირველი გადაწყვეტილება.

ნებისმიერ დახვეწილ არქიტექტურამდე ირჩევთ, როგორ განლაგდება რეპოზიტორიები. ეს მიკროფრონტენდებისგან დამოუკიდებელია — მოდულურ მონოლითსაც და მიკროფრონტენდულ სისტემასაც ორივე განლაგებაში შეუძლია ცხოვრება. ჯერ ტერმინოლოგია დაალაგეთ.

მონორეპო — ერთი რეპოზიტორია, რომელიც ბევრ აპლიკაციასა და საერთო პაკეტს იტევს, ერთად აიგება და ერთად ვერსიონირდება. პოლირეპო — ბევრი რეპოზიტორია, თითო აპლიკაციაზე ან ბიბლიოთეკაზე, თითოეული დამოუკიდებლად ვერსიონირებული და გამოშვებული. არცერთი არაა "მიკროფრონტენდები"; ორივე უბრალოდ იმას აღწერს, სად წევს ფაილები.
repo/
ერთი install · ერთი PR · ატომური
shop რეპო
admin რეპო
apps/shop
ui-lib რეპო
apps/admin
packages/ui
packages/utils
npm რეგისტრი
მონორეპო
პოლირეპო
გამოქვეყნება · ვერსია · გამოყენება

მონორეპო: საერთო კოდი დირექტორიაა, რომელსაც პირდაპირ იმპორტს უკეთებთ. პოლირეპო: საერთო კოდი გამოქვეყნებული პაკეტია, რომლის ვერსიასაც ამაგრებთ.

Workspaces & საერთო პაკეტები

workspace არის მონორეპოს ფუნქციონალი (npm-ში, pnpm-ში ან Yarn-ში), რომელიც ერთ აპლიკაციას საშუალებას აძლევს, მეზობელ პაკეტზე სახელით იყოს დამოკიდებული — @acme/ui — გამოქვეყნების ნაბიჯის გარეშე. პაკეტების მენეჯერი მას სიმლინკით აკავშირებს; რედაქტირება მთელ რეპოზიტორიაში მყისვე ჩანს.

# pnpm-workspace.yaml — გამოაცხადეთ წევრები packages: - "apps/*" - "packages/*"
{ "name": "shop", "dependencies": { "@acme/ui": "workspace:*" // მეზობელი, და არა npm-იდან } }

მონორეპო — ბრწყინავს, როცა

  • ერთი ცვლილება მოიცავს აპლიკაციასაც და საერთო ბიბლიოთეკასაც — ჩააგდეთ ერთ ატომურ PR-ში, ვერსიების ცეკვის გარეშე.
  • გინდათ ერთგვაროვანი ინსტრუმენტები, ლინტი და ტიპები ყველაფერზე.
  • კომპრომისი: სჭირდება ჭკვიანი ბილდის ინსტრუმენტი (შემდეგი სექცია), თორემ CI მთელ სამყაროს თავიდან აგებს.

პოლირეპო — ბრწყინავს, როცა

  • გუნდებს სურთ მკაცრი რელიზის დამოუკიდებლობა და ცალკე წვდომის კონტროლი თითო რეპოზიტორიაზე.
  • ბიბლიოთეკას ჰყავს გარე მომხმარებლები და აქვს რეალური სემანტიკური ვერსიონირების კონტრაქტი.
  • კომპრომისი: განივი ცვლილებები მრავალ-PR-იან, ვერსიის ასაწევ რუტინად იქცევა.

მონორეპო ≠ მონოლითი, პოლირეპო ≠ მიკროფრონტენდები. კოდის განლაგება და რანტაიმის არქიტექტურა დამოუკიდებელი არჩევანებია — ნუ აურევთ ერთმანეთში.

03 · მოდულური მონოლითი (ფრონტენდი) 5 წთ

ერთი აპლიკაცია, ბევრი სუფთა მოდული —
და ჩვეულებრივ ესეც საკმარისია.

სანამ აპლიკაციას ცალ-ცალკე დეპლოირებად ნაწილებად დაშლით, აიღეთ იაფად მოსაპოვებელი 90%: ერთი ბილდი, დალაგებული ფუნქციონალის მოდულებად, ისეთი საზღვრებით, რომლებსაც მართლა აღასრულებთ. სწორედ ეს არის ის ნაგულისხმევი ვარიანტი, რომელსაც გვინდა, რომ მიმართოთ.

მოდულური მონოლითი — ერთი დეპლოირებადი ფრონტენდი, შიგნიდან ფუნქციონალის მოდულებად დაყოფილი; თითოეული ფლობს თავის UI-ს, მდგომარეობასა და მონაცემებთან წვდომას და სხვებს მხოლოდ გამოქვეყნებული ზედაპირით ესაუბრება. ერთი ბილდი, ერთი დეპლოი — და შიგნით ბევრი კარგად შემოღობილი ოთახი.
src/ features/ checkout/ index.ts // the ONLY public door ui/ model/ api/ // internals — private catalog/ index.ts ui/ model/ api/ shared/ // design system, types // rule: import from "features/x", never "features/x/ui/..."

ყოველი ფუნქციონალი ერთ index.ts კარს აქვეყნებს; დანარჩენი ყველაფერი პრივატულია. shared ქვემოთ დგას და მასზე ყველა არის დამოკიდებული.

გახადეთ საზღვარი რეალური

  • ბარელ-ექსპორტები — ფუნქციონალის index.ts მისი საჯარო API-ია; ღრმა გზები შიდა რჩება.
  • დაალინტეთ ნაკერები — იმპორტის საზღვრის წესი (ESLint no-restricted-imports ან Nx/Sheriff-ის საზღვრების კონფიგი) გვერდის ავლისას ბილდს აგდებს.
  • დამოკიდებულების მიმართულება — ფუნქციონალები დამოკიდებულია shared-ზე და არასოდეს ერთმანეთის შიგთავსზე. იგივე წესი, რაც არქიტექტურულ პატერნებში: "დამოკიდებულებები შიგნით მიმართეთ".
  • ჩატვირთეთ ზარმაცად თითო როუტზე — დაანაწილეთ ფუნქციონალები კოდის დონეზე, რომ დიდმა აპლიკაციამაც პატარა ბანდლები გაუშვას. "დამოუკიდებლობის" შეგრძნების უმეტესობას იღებთ საოპერაციო ხარჯის გარეშე.

როდის არის ეს საკმარისი (უმეტეს შემთხვევაში)

  • ფრეიმვორკის ერთი ვერსია, ერთი როუტერი, ერთი დიზაინ სისტემა — უფასოდ საერთო, მომხმარებლებთან დუბლიკატები არ მიდის.
  • რეფაქტორინგი ჩვეულებრივი PR-ია და არა რეპოზიტორიათაშორისი მიგრაცია.
  • ერთი ბანდლის ოპტიმიზაცია ადვილია: ერთი vendor ჩანკი, ერთი Core Web Vitals ნაკრები საყურებლად.

ჰგავს  კარგად მოწესრიგებულ სახლს ჩაკეტილი ოთახებით — და არა ცალკეული შენობების ქუჩას, რომელზეც ფეხით უნდა იაროთ.

04 · მიკროფრონტენდები 6 წთ

UI-ის დაშლა
დამოუკიდებლად დეპლოირებად აპლიკაციებად.

მიკროფრონტენდული არქიტექტურა მიკროსერვისების იდეას ბრაუზერამდე ავრცელებს: UI-ის ყოველ ნაჭერს ცალკე გუნდი ფლობს, აგებს და უშვებს საკუთარი რიტმით. მძლავრია — და, მიკროსერვისების მსგავსად, ხშირად ინერგება მანამ, სანამ ის ნამდვილად საჭირო გახდება.

მიკროფრონტენდი — UI-ის დამოუკიდებლად დეპლოირებადი ნაწილი, რომელსაც ერთი გუნდი ფლობს თავიდან ბოლომდე. განმსაზღვრელი ტესტი დეპლოის საზღვარია: შეუძლია თუ არა გუნდს, თავისი ნაჭერი პროდაქშენში გაუშვას რელიზის სხვებთან შეთანხმების გარეშე? თუ არა, ეს უბრალოდ მოდულია.

ნაწილების ინტეგრაციის სამი გზა

მთელი პრობლემა კომპოზიციაა: როგორ იქცევა ცალ-ცალკე აგებული ნაჭრები მომხმარებლისთვის ერთ გვერდად? არსებობს ინტეგრაციის სამი მომენტი — და თითოეული სრულიად სხვანაირად ცვლის დამოუკიდებლობას სიმარტივეზე.

ბილდის დროს

კომპოზიცია პაკეტებით

ყოველი გუნდი აქვეყნებს npm პაკეტს; ჰოსტი მათ აინსტალირებს და ბანდლში აერთიანებს. მარტივი და ტიპებით უსაფრთხო — მაგრამ გუნდის ცვლილება მხოლოდ მაშინ გადის, როცა ჰოსტი თავიდან დეპლოის. ნამდვილად დამოუკიდებელი არაა.

სერვერზე

შეაკერეთ სერვერზე

edge/სერვერის შრე ყოველი გუნდის სერვისიდან მიღებულ HTML ფრაგმენტებს ერთ დოკუმენტად კრავს (SSI, ESI ან თანამედროვე ფრეიმვორკები). შესანიშნავი პირველი დახატვა და SEO; ასაწყობად სერვერის ინფრასტრუქტურა სჭირდება.

რანტაიმში

ჩატვირთეთ ბრაუზერში

შელი ყოველი გუნდის ბანდლს ცოცხლად, URL-ით ტვირთავს. გუნდი დეპლოის თავის ბანდლს და ის ჰოსტის თავიდან აგების გარეშე ჩნდება — დეპლოის ნამდვილი დამოუკიდებლობა. Module Federation სწორედ აქ ცხოვრობს (შემდეგში).

რელიზის ნამდვილ დამოუკიდებლობას მხოლოდ სერვერზე და რანტაიმში ინტეგრაცია იძლევა. თუ მიკროფრონტენდებს დანერგავთ და ბილდის დროზე დარჩებით, სირთულეში უკვე გადაიხადეთ, დაწყვილება კი შეინარჩუნეთ.

05 · Module Federation 5 წთ

კოდის გაზიარება აპლიკაციებს შორის
რანტაიმში.

Module Federation არის ბანდლერის ფუნქციონალი, რომელმაც რანტაიმის მიკროფრონტენდები პრაქტიკული გახადა. ერთი აპლიკაცია (ჰოსტი) ქსელით ტვირთავს კოდს, რომელსაც მეორე (რემოუთი) აქვეყნებს, და ისინი საერთო ბიბლიოთეკებს იზიარებენ, რომ React ხუთჯერ არ გაიგზავნოს.

Module Federation — ბანდლერის შესაძლებლობა (წარმოშობით Webpack 5-იდან, ახლა Rspack-შიც და Vite-ის პლაგინითაც), სადაც რემოუთი აქვეყნებს მოდულებს, ჰოსტი კი მათ რანტაიმში, URL-ით აიმპორტებს. მთავარია, ორივე აცხადებს საერთო დამოკიდებულებებს, რომ React-ის მსგავსი სინგლტონი ერთხელ ჩაიტვირთოს.
new ModuleFederationPlugin({ name: "feed", filename: "remoteEntry.js", exposes: { "./Feed": "./src/Feed" }, // საჯარო shared: { react: { singleton: true } }, })
const Feed = React.lazy(() => import("feed/Feed")) // იხსნება ქსელით // ხატავს გუნდის უახლეს დეპლოის — ჰოსტის თავიდან აგების გარეშე

ჰოსტი feed/Feed-ს რემოუთის remoteEntry.js-იდან აიმპორტებს; ორივე ერთსა და იმავე React-ის ინსტანციას იზიარებს.

მოგება

დეპლოის დამოუკიდებლობა

გაუშვით რემოუთი და ჰოსტი მას შემდეგივე ჩატვირთვაზე აიღებს — შეთანხმებული რელიზის გარეშე. სწორედ ამ შესაძლებლობას ყიდულობდით.

მინუსი

საერთო ვერსიის რისკი

singleton-ის შეუსაბამობა (React-ის ორი მაჟორული ვერსია) რანტაიმში ჰუკებს ამტვრევს. საერთო ვერსიები გუნდებს შორის უნდა მართოთ — კონტრაქტები კომპილაციის დროიდან რანტაიმში გადადის.

მინუსი

რანტაიმის ჩავარდნის რეჟიმები

რემოუთი შეიძლება იყოს ჩავარდნილი, ნელი ან 404. ახლა გჭირდებათ ჩანაცვლებები, შეცდომების საზღვრები და ვერსიის შემოწმებები, რომლებსაც ბანდლერი ადრე უფასოდ გაძლევდათ.

06 · ინსტრუმენტთა პეიზაჟი 5 წთ

ორი ხელსაწყოთა ნაკრები:
რეპოს ორკესტრირება და UI-ის ინტეგრაცია.

ნუ აურევთ ერთმანეთში. მონორეპოს ინსტრუმენტები დიდი რეპოზიტორიის აგებასა და ტესტირებას აჩქარებს; ინტეგრაციის ინსტრუმენტები ცალ-ცალკე აგებულ UI-ებს ერთად კერავს. ხშირად გჭირდებათ მონორეპოს ინსტრუმენტი და არავითარი ინტეგრაციის ინსტრუმენტი.

დააჩქარეთ ერთი დიდი რეპო — აირჩიეთ ამბიციის მიხედვით

pnpm workspaces

საბაზისო ვარიანტი

უბრალოდ პაკეტების მენეჯერის workspace ფუნქციონალი — აკავშირებს მეზობელ პაკეტებს, აერთიანებს ინსტალაციებს.

  • დადებითი — ნულოვანი დამატებითი ინსტრუმენტი; ჩაშენებულია.
  • უარყოფითი — არც ამოცანების ქეშირება, არც affected-graph; სკრიპტები ყველაფერს თავიდან აგებს.
Turborepo

სწრაფი ამოცანების გამშვები

ქეშირებადი ამოცანების გრაფი თქვენს არსებულ სკრიპტებზე — თავიდან მხოლოდ შეცვლილი იგება.

  • დადებითი — მცირე კონფიგურაცია, დისტანციური ქეში, შესანიშნავად მუშაობს pnpm-თან.
  • უარყოფითი — მხოლოდ ორკესტრირება; არც გენერატორები, არც ჩაშენებული საზღვრების წესები.
Nx

ყველაფერი კომპლექტში

ქეშირება პლუს პროექტის გრაფი, კოდის გენერატორები და აღსრულებადი მოდულების საზღვრები.

  • დადებითი — საზღვრებისა & affected-graph-ის ყველაზე ძლიერი მხარდაჭერა მასშტაბზე.
  • უარყოფითი — მეტი შესასწავლი კონცეფცია; პატარა რეპოსთვის შეიძლება მძიმედ მოგეჩვენოთ.
როგორ ავირჩიოთ
დაიწყეთ pnpm workspaces-ით. დაამატეთ Turborepo, როცა CI შენელდება. Nx-ს მიმართეთ, როცა გჭირდებათ აღსრულებული საზღვრები და affected-გრაფი ბევრ აპლიკაციაზე.

შეაკერეთ ცალკეული UI-ები — მხოლოდ თუ ნამდვილად გჭირდებათ

Module Federation

გაზიარება რანტაიმში

ბანდლერის დონის რემოუთები საერთო დამოკიდებულებებით (Webpack/Rspack; Vite-ის პლაგინი).

  • დადებითი — რეალური დეპლოის დამოუკიდებლობა, დუბლირების გარეშე ბიბლიოთეკები.
  • უარყოფითი — ვერსიების დაწყვილება რანტაიმში; ბილდის კონფიგურაცია დასაუფლებელია.
Vite federation

MF Vite-სთვის

თემის პლაგინი, რომელსაც federation Vite/Rollup ბილდებში შემოაქვს.

  • დადებითი — ინარჩუნებს Vite-ის სწრაფ სამუშაო ციკლს.
  • უარყოფითი — ნაკლებად მომწიფებული; dev და prod შორის პარიტეტის უცნაურობები.
single-spa

აპლიკაციების ორკესტრატორი

როუტერი, რომელიც ერთ გვერდზე მთელ ფრეიმვორკულ აპლიკაციებს რთავს და თიშავს.

  • დადებითი — შეურიეთ React + Vue + Angular; ნათელი სასიცოცხლო ციკლი.
  • უარყოფითი — მძიმე შეერთება; დამოკიდებულებების დუბლირებას თავად არ აშორებს.
iframes

მკაცრი იზოლაცია

ბრაუზერის საკუთარი საზღვარი — ცალკე დოკუმენტი თითო ნაწილზე.

  • დადებითი — უტყუარი CSS/JS იზოლაცია; ნებისმიერი სტეკი.
  • უარყოფითი — მოუხერხებელი როუტინგი, ზომები და საერთო მდგომარეობა; დუბლირებული payload.
როგორ ავირჩიოთ
ერთი ფრეიმვორკი და გინდათ დუბლირების მოშორება → Module Federation (Vite-ზე — Vite-ის პლაგინი). შერეული ფრეიმვორკები ან მიგრაცია → single-spa. მესამე მხარის ან საშიში კონტენტი, რომელსაც სრული იზოლაცია სჭირდება → iframes.

შენიშნეთ: მონორეპოს ინსტრუმენტი თითქმის ყველას სჭირდება; ინტეგრაციის ინსტრუმენტი — გაცილებით ნაკლებს. მეორე მხოლოდ მაშინ აიღეთ, როცა დეპლოის საზღვარი რეალური, დღევანდელი მოთხოვნაა — და არა ოდესღაც სამომავლო.

07 · როდის არა · არჩევა · შეჯამება 4 წთ

მიკროფრონტენდები ძლიერია —
და ზედმეტად ხშირად გამოიყენება.

მიკროსერვისების მსგავსად, ისინი ორგანიზაციულ პრობლემას წყვეტს (დამოუკიდებელი გუნდები დამოუკიდებლად უშვებენ რელიზებს) რეალური ტექნიკური ფასის სანაცვლოდ. თუ ორგანიზაციული პრობლემა არ გაქვთ, ამ ფასს ტყუილად იხდით.

×N

დუბლირებული ფრეიმვორკის payload მიდის მომხმარებლებთან, თუ გაზიარება იდეალური არაა — რეალური Core Web Vitals გადასახადი.

↑

რანტაიმის ჩავარდნის ზედაპირი: ყოველი რემოუთი ქსელური დამოკიდებულებაა, რომელსაც გვერდის გატეხვა შეუძლია.

⇄

ვერსიების მართვა გუნდებს შორის — ერთი დიზაინ-სისტემა და ფრეიმვორკის ერთი მაჟორი, სამუდამოდ კოორდინირებული.

1

მოდულური მონოლითი ამათგან არაფერს იხდის და მოდულარობის 90%-ს მაინც გაძლევთ. დაიწყეთ აქედან.

აირჩიეთ გააზრებულად

  • ნაგულისხმევი: მოდულური მონოლითი მონორეპოში. საზღვრებს lint აღასრულებს, ფუნქციონალი ზარმაცად იტვირთება.
  • დამოუკიდებელი გუნდები, ერთი დიდი პროდუქტი და დეპლოის რიგში დგომა ნამდვილი ტკივილია? მაშინ — რანტაიმის მიკროფრონტენდები (Module Federation).
  • ძველი სისტემის მიგრაცია / შერეული ფრეიმვორკები? single-spa ან iframes როგორც გარდამავალი ეტაპი და არა დანიშნულების ადგილი.
  • გულახდილი ტესტი: დაასახელეთ გუნდი და დეპლოი, რომელსაც ეს საზღვარი ხსნის. ვერ დაასახელეთ → საზღვარიც არ გჭირდებათ.

"სჭირდება თუ არა დღეს ორ გუნდს ერთი და იმავე UI-ის დეპლოი სხვადასხვა გრაფიკით?"

  • არა → მოდულური მონოლითი. დასრულდა.
  • დიახ → მიკროფრონტენდები, რანტაიმის ინტეგრაცია და ბიუჯეტი მართვისთვის.

ამ დეკში ყველაფერი ამ ერთ კითხვამდე დაიყვანება. იხილეთ აგრეთვე მიკროსერვისების კომპრომისები — არქიტექტურული პატერნები & სტილები.

1ჯერ საზღვრები. დაწყვილება და კოჰეზია წყვეტს ყველაფერს — ბილდი უბრალოდ ის ადგილია, სადაც ისინი ჩნდება.
2რეპოს განლაგება ≠ არქიტექტურა. მონორეპო vs პოლირეპო დამოუკიდებელია იმისგან, მონოლითია თუ მიკროფრონტენდები.
3უპირატესობა მოდულურ მონოლითს. ერთი ბილდი, შემოღობილი ფუნქციონალი, აღსრულებული იმპორტები — ის იმარჯვებს, სანამ ნამდვილად არ დაგჭირდებათ დამოუკიდებელი დეპლოები.
4დამოუკიდებლობას ფასი აქვს. რანტაიმის ინტეგრაცია დეპლოის თავისუფლებას ყიდულობს და ანგარიშს გიწერთ დუბლირებული payload-ით, რანტაიმის ჩავარდნებითა და ვერსიების მართვით.
5აიღეთ რეალური ორგანიზაციული პრობლემისთვის. დაასახელეთ გუნდი და დეპლოი, რომელსაც საზღვარი ხსნის — ან დატოვეთ მარტივად.
ცოდნის შემოწმება

დაგამახსოვრდათ?

ხუთი სწრაფი კითხვა საზღვრებზე, რეპოებზე, მოდულურ მონოლითზე, მიკროფრონტენდებსა და Module Federation-ზე — მყისიერი შედეგი, ავტორიზაციის გარეშე.

შეაფასეთ ეს დასტა
იყავით პირველი

ნავიგაცია ← → ღილაკებით ან სქროლით · უკან ბიბლიოთეკაში