Moien alleguer! Mir hu super Neiegkeeten, OTUS lancéiert de Cours erëm am Juni , a Verbindung mat deem mir traditionell nëtzlecht Material mat Iech deelen.
Wann Dir dës ganz Saach vu Mikroservicer ouni Kontext begéint hutt, wier Dir verginn fir ze denken datt et e bësse komesch ass. Eng Applikatioun opzedeelen a Fragmenter verbonne mat engem Netz bedeit onbedéngt komplex Feeler Toleranzmodi un de resultéierende verdeelte System ze addéieren.
Och wann dës Approche involvéiert ass et a vill onofhängeg Servicer ofzebriechen, ass d'Ennziel vill méi wéi just dës Servicer op verschiddene Maschinnen ze lafen. Mir schwätzen hei vun der Interaktioun mat der Äussewelt, déi och a senger Essenz verdeelt ass. Net am technesche Sënn, mä éischter am Sënn vun engem Ökosystem, deen aus ville Leit, Teams, Programmer besteet, an all eenzel vun dësen Deeler iergendwéi seng Aarbecht muss maachen.
Firmen, zum Beispill, sinn eng Sammlung vu verdeelt Systemer déi kollektiv zu der Erreeche vun engem Zil bäidroen. Mir hunn dës Tatsaach fir Joerzéngte ignoréiert, probéiert d'Vereenegung duerch FTPing Dateien z'erreechen oder d'Entreprise Integratiounsinstrumenter ze benotzen, während mir op eis eegen isoléiert Ziler fokusséieren. Mä mat dem Optrëtt vun Servicer, alles geännert. D'Servicer hunn eis gehollef iwwer den Horizont ze kucken an eng Welt vun interdependente Programmer ze gesinn déi zesumme schaffen. Wéi och ëmmer, fir erfollegräich ze schaffen, ass et néideg zwou fundamental verschidde Welten z'erkennen an ze designen: déi extern Welt, wou mir an engem Ökosystem vu villen anere Servicer liewen, an eis perséinlech, intern Welt, wou mir eleng regéieren.
Dës verdeelt Welt ass anescht wéi déi, an där mir opgewuess sinn a gewinnt sinn. D'Prinzipien vun der Konstruktioun vun der traditioneller monolithescher Architektur stinn net géint d'Kritik. Also dës Systemer richteg ze kréien ass méi wéi e coolt Whiteboard Diagramm ze kreéieren oder e coole Beweis vum Konzept. De Punkt ass sécherzestellen datt esou e System iwwer eng laang Zäit erfollegräich funktionnéiert. Glécklecherweis sinn d'Servicer scho laang, obwuel se anescht ausgesinn. sinn nach ëmmer relevant, souguer mat Docker, Kubernetes a liicht schaarf Hipster Baart.
Also haut kucke mer wéi d'Regele geännert hunn, firwat mir mussen iwwerdenken wéi mir Servicer ugoen an d'Donnéeën déi se unenee weiderginn, a firwat mir komplett aner Tools brauchen fir dat ze maachen.
Encapsulation wäert net ëmmer Äre Frënd sinn
Mikroservicer kënnen onofhängeg vuneneen operéieren. Et ass dës Immobilie déi hinnen de gréisste Wäert gëtt. Dës selwecht Immobilie erlaabt Servicer ze skaléieren a wuessen. Net sou vill am Sënn vun der Skaléierung op Quadrillions Benotzer oder Petabytes vun Daten (obwuel déi och do hëllefe kënnen), mee am Sënn vun der Skaléierung vu Leit wéi Teams an Organisatiounen kontinuéierlech wuessen.
Wéi och ëmmer, Onofhängegkeet ass en zweeschneidegt Schwäert. Dat ass, de Service selwer kann einfach an natierlech lafen. Awer wann eng Funktioun an engem Service implementéiert gëtt, deen d'Benotzung vun engem anere Service erfuerdert, da musse mir um Enn bal gläichzäiteg Ännerungen u béide Servicer maachen. An engem Monolith ass dëst einfach ze maachen, Dir maacht just eng Ännerung a schéckt se op d'Verëffentlechung, awer am Fall vun der Synchroniséierung vun onofhängege Servicer gëtt et méi Probleemer. Koordinatioun tëscht Teams a Verëffentlechungszyklen zerstéiert d'Agilitéit.
Als Deel vun der Standard Approche probéieren se einfach lästeg End-to-End Ännerungen ze vermeiden, d'Funktionalitéit tëscht Servicer kloer ze trennen. Single Sign-on Service kann e gutt Beispill hei sinn. Et huet eng kloer definéiert Roll déi et vun anere Servicer differenzéiert. Dës kloer Trennung bedeit datt an enger Welt vu séier verännerleche Fuerderungen un d'Servicer ronderëm, den Single Sign-on Service onwahrscheinlech ännert. Et existéiert an engem streng limitéierten Kontext.
De Problem ass datt an der realer Welt Geschäftsservicer net déiselwecht reng Trennung vu Rollen déi ganzen Zäit kënnen erhalen. Zum Beispill funktionnéieren déiselwecht Geschäftsservicer zu engem gréissere Mooss mat Daten aus aneren ähnlechen Servicer. Wann Dir am Online Retail involvéiert sidd, da wäert d'Veraarbechtung vun Bestellungsfloss, Produktkatalog oder Benotzerinformatioun eng Fuerderung fir vill vun Äre Servicer ginn. Jidderee vun de Servicer brauch Zougang zu dësen Donnéeën fir ze bedreiwen.
Déi meescht Geschäftsservicer deelen deeselwechten Datestroum, sou datt hir Aarbecht ëmmer matenee verbonnen ass.
Domat komme mer zu engem wichtege Punkt, deen derwäert ass ze schwätzen. Wärend Servicer gutt funktionnéieren fir Infrastrukturkomponenten déi gréisstendeels isoléiert funktionnéieren, sinn déi meescht Geschäftsservicer um Enn vill méi enk intertwined.
Daten Dichotomie
Serviceorientéiert Approche kënne scho existéieren, awer se feelen nach ëmmer Asiicht wéi grouss Quantitéiten un Daten tëscht Servicer deelen.
Den Haaptproblem ass datt d'Donnéeën an d'Servicer net getrennt sinn. Engersäits encouragéiert d'Verkapselung eis Daten ze verstoppen sou datt Servicer vuneneen getrennt kënne ginn an hire Wuesstum a weider Ännerungen erliichteren. Op der anerer Säit musse mir fäeg sinn gedeelt Daten fräi ze deelen an z'eroberen, sou wéi all aner Donnéeën. Et geet drëm, direkt kënnen ze schaffen, sou fräi wéi an all aner Informatiounssystem.
Wéi och ëmmer, Informatiounssystemer hu wéineg mat Verkapselung ze dinn. Tatsächlech ass et ganz de Géigendeel. Datenbanken maachen alles wat se kënne fir Zougang zu den Daten ze bidden déi se späicheren. Si kommen mat engem mächtege deklarativen Interface deen Iech erlaabt d'Donnéeën z'änneren wéi Dir braucht. Esou Funktionalitéit ass wichteg an der virleefeg Fuerschungsstadium, awer net fir d'wuessend Komplexitéit vun engem stänneg evoluéierende Service ze managen.
An hei entsteet en Dilemma. Widdersproch. Dichotomie. Iwwerhaapt, Informatiounssystemer sinn iwwer Daten ze liwweren, a Servicer sinn iwwer Verstoppen.
Dës zwou Kräfte si fundamental. Si ënnersträichen vill vun eiser Aarbecht, kämpfen stänneg fir Exzellenz an de Systemer déi mir bauen.
Wéi Servicesystemer wuessen an evoluéieren, gesi mir d'Konsequenze vun der Date-Dichotomie op vill Manéiere. Entweder d'Service-Interface wäert wuessen, eng ëmmer méi grouss Gamme vu Funktionalitéit ubidden a fänkt un wéi eng ganz ausgefalene hausgemaachte Datebank ze kucken, oder mir wäerte frustréiert ginn an e Wee implementéieren fir ganz Sätz vun Daten vu Service zum Service ze recuperéieren oder ze réckelen.
Am Tour, eppes ze kreéieren dat ausgesäit wéi eng ausgefalene hausgemaachte Datebank wäert zu enger ganzer Rei vu Probleemer féieren. Mir ginn net an Detailer iwwer firwat et geféierlech ass gedeelt Datebank, Loosst eis just soen datt et bedeitend deier Ingenieur an operationell duerstellt fir d'Firma déi probéiert et ze benotzen.
Wat méi schlëmm ass, ass datt d'Datevolumen Service Grenzproblemer vergréisseren. Wat méi gedeelt Donnéeën an engem Service sinn, wat méi komplex d'Interface gëtt an dest méi schwéier ass et ze kombinéieren Datesets aus verschiddene Servicer.
Déi alternativ Approche fir ganz Datesets ze extrahieren an ze verschwannen huet och seng Probleemer. Eng gemeinsam Approche fir dës Fro gesäit aus wéi einfach de ganzen Dataset zréckzéien an ze späicheren, an duerno lokal an all Konsuméiere Service ze späicheren.
De Problem ass datt verschidde Servicer d'Donnéeën déi se verbrauchen anescht interpretéieren. Dës Donnéeë sinn ëmmer bei der Hand. Si gi geännert a lokal veraarbecht. Zimlech séier si se ophalen eppes gemeinsam mat den Daten an der Quell ze hunn.
Wat d'Kopie méi mutéierbar sinn, wat méi d'Donnéeën mat der Zäit variéieren.
Fir d'Saach méi schlëmm ze maachen, sinn esou Donnéeën am Réckbléck schwéier ze korrigéieren ( Dëst ass wou et wierklech zur Rettung kënnt). Tatsächlech entstinn e puer vun den intractable Technologieproblemer, déi d'Geschäfter konfrontéieren, aus den ënnerschiddlechen Donnéeën, déi sech vun der Applikatioun op d'Applikatioun multiplizéiert.
Fir eng Léisung fir dëse Problem ze fannen, musse mir anescht iwwer gemeinsam Daten denken. Si mussen éischt Klass Objete ginn an den Architekturen déi mir bauen. rifft esou Donnéeën "extern", an dat ass eng ganz wichteg Fonktioun. Mir brauche Verschlësselung fir datt mir net déi bannenzeg Aarbecht vun engem Service ausstelle, awer mir mussen et einfach maachen fir Servicer Zougang zu gemeinsamen Donnéeën ze kréien fir datt se hir Aarbecht richteg maachen.
De Problem ass datt keng Approche haut relevant ass, well weder d'Service-Interfaces, nach d'Messaging, nach d'Shared Database eng gutt Léisung bidden fir mat externen Donnéeën ze schaffen. Service Interfaces si schlecht gëeegent fir Datenaustausch op all Skala. Messagerie bewegt Daten awer späichert seng Geschicht net, sou datt d'Date mat der Zäit korrupt ginn. Shared Database konzentréieren ze vill op ee Punkt, wat de Fortschrëtt zréckhält. Mir stinn zwangsleefeg an engem Zyklus vun Datenfehler:
Zyklus vun Daten Echec
Streams: eng dezentraliséiert Approche fir Daten a Servicer
Idealerweis musse mir d'Art a Weis wéi d'Servicer mat gedeelt Daten funktionnéieren änneren. Zu dësem Zäitpunkt steet entweder Approche mat der genannter Dichotomie, well et kee Zauberstaub gëtt, deen drop gesprëtzt ka ginn fir et ze verschwannen. Wéi och ëmmer, mir kënnen de Problem iwwerdenken an e Kompromiss erreechen.
Dëse Kompromëss implizéiert e gewësse Grad vun Zentraliséierung. Mir kënnen de verdeelte Logmechanismus benotzen well et zouverlässeg, skalierbar Streame gëtt. Mir wëllen elo datt Servicer kënne matmaachen an op dëse gemeinsame Threads operéieren, awer mir wëllen komplex zentraliséiert Gott Services vermeiden déi dës Veraarbechtung maachen. Dofir ass déi bescht Optioun fir Streamveraarbechtung an all Konsumentservice ze bauen. Op dës Manéier kënnen d'Servicer fäeg sinn Datesätz aus verschiddene Quellen ze kombinéieren a mat hinnen ze schaffen wéi se brauchen.
Ee Wee fir dës Approche z'erreechen ass duerch d'Benotzung vun enger Streaming Plattform. Et gi vill Méiglechkeeten, awer haut wäerte mir de Kafka kucken, well d'Benotzung vu senger Stateful Stream Processing erlaabt eis de presentéierte Problem effektiv ze léisen.
Mat engem verdeelt Logmechanismus erlaabt eis de gutt getraffene Wee ze verfollegen a Messagerie ze benotzen fir mat ze schaffen . Dës Approche gëtt als besser Skaléierung a Partitionéierung ugesinn wéi den Ufro-Äntwert Mechanismus well et Kontroll vum Flow un den Empfänger gëtt anstatt dem Sender. Wéi och ëmmer, fir alles an dësem Liewen musst Dir bezuelen, an hei braucht Dir e Broker. Awer fir grouss Systemer ass den Ofwiesselung et wäert (wat vläicht net de Fall ass fir Är duerchschnëttlech Webapplikatioun).
Wann e Broker verantwortlech ass fir verdeelt Logbicher anstatt en traditionelle Messageriesystem, kënnt Dir vun zousätzleche Funktiounen profitéieren. Den Transport ka linear bal sou gutt wéi e verdeelt Dateiesystem skaléieren. D'Donnéeë kënnen a Logbicher fir eng zimlech laang Zäit gespäichert ginn, sou datt mir net nëmmen Messageaustausch kréien, awer och Informatiounsspeicher. Skalierbar Späichere ouni Angscht virum verännerleche gemeinsame Staat.
Dir kënnt dann statesch Streamveraarbechtung benotze fir deklarativ Datebank Tools fir d'Konsuméiere vu Servicer ze addéieren. Dëst ass eng ganz wichteg Iddi. Wärend d'Donnéeën a gemeinsame Streame gespäichert ginn, op déi all Servicer Zougang kënnen, ass d'Aggregatioun an d'Veraarbechtung, déi de Service mécht, privat. Si fannen sech an engem streng limitéierten Kontext isoléiert.
Eliminéiert Datendichotomie andeems Dir den onverännerbare Staatsstroum trennt. Füügt dann dës Funktionalitéit un all Service mat Stateful Stream Processing.
Also, wann Äre Service mat Bestellungen, e Produktkatalog, e Lager muss schaffen, da wäert e vollen Zougang hunn: nëmmen Dir wäert entscheeden wéi eng Donnéeën ze kombinéieren, wou se veraarbecht ginn a wéi se sech mat der Zäit änneren. Trotz der Tatsaach, datt d'Donnéeën gedeelt ginn, ass d'Aarbecht mat hinnen komplett dezentraliséiert. Et gëtt bannent all Service produzéiert, an enger Welt wou alles no Äre Reegele geet.
Deelt Daten ouni seng Integritéit ze kompromittéieren. Encapsuléiert d'Funktioun, net d'Quell, an all Service deen et brauch.
Et geschitt, datt d'Donnéeën masseg geplënnert musse ginn. Heiansdo erfuerdert e Service eng lokal historesch Datesaz an der gewielter Datebankmotor. Den Trick ass datt Dir kënnt garantéieren datt, wann néideg, eng Kopie vun der Quell restauréiert ka ginn andeems Dir op de verdeelte Logmechanismus kënnt. Connectoren am Kafka maachen eng super Aarbecht dovun.
Also, d'Approche, déi haut diskutéiert gëtt, huet verschidde Virdeeler:
- Daten ginn a Form vu gemeinsame Streame benotzt, déi laang a Logbicher kënne gespäichert ginn, an de Mechanismus fir mat gemeinsamen Donnéeën ze schaffen ass an all eenzelne Kontext hardwired, wat et erlaabt Servicer einfach a séier ze schaffen. Op dës Manéier kann d'Dichotomie vun den Donnéeën ausgeglach ginn.
- Daten aus verschiddene Servicer kënnen einfach a Sets kombinéiert ginn. Dëst vereinfacht d'Interaktioun mat gedeelt Daten an eliminéiert d'Noutwendegkeet fir lokal Datesätz an der Datebank z'erhalen.
- Stateful Stream Processing cache nëmmen Daten, an d'Quell vun der Wourecht bleift déi allgemeng Logbicher, sou datt de Problem vun der Datekorruptioun iwwer Zäit net sou akut ass.
- Am Kär sinn d'Servicer dategedriwwen, dat heescht datt trotz den ëmmer méi wuessende Volumen vun Daten, Servicer nach ëmmer séier op Geschäftsevenementer reagéiere kënnen.
- Skalierbarkeetprobleemer falen op de Broker, net op de Servicer. Dëst reduzéiert d'Komplexitéit vun de Schreiwe Servicer wesentlech, well et net néideg ass iwwer Skalierbarkeet ze denken.
- Nei Servicer bäizefügen erfuerdert keng Ännerung vun alen, sou datt nei Servicer konnektéieren gëtt méi einfach.
Wéi Dir gesitt, ass dëst méi wéi just REST. Mir hunn eng Rei vun Tools kritt, déi Iech erlaabt dezentraliséiert mat gemeinsamen Donnéeën ze schaffen.
Net all Aspekter goufen am Artikel vun haut behandelt. Mir mussen nach erausfannen, wéi een tëscht dem Ufro-Äntwert Paradigma an dem Event-driven Paradigma balancéiert. Mee mir wäerte mat deem nächste Kéier beschäftegen. Et ginn Themen déi Dir musst besser kennen léieren, zum Beispill firwat Stateful Stream Processing sou gutt ass. Mir wäerten iwwer dëst am drëtten Artikel schwätzen. An et ginn aner mächteg Konstrukter, vun deenen mir profitéiere kënnen, wa mir eis op déi, zum Beispill, . Et ass e Spillwechsler fir verdeelt Geschäftssystemer well et Transaktiounsgarantie fir an enger skalierbarer Form. Dëst wäert am véierten Artikel diskutéiert ginn. Schlussendlech musse mir iwwer d'Ëmsetzungsdetailer vun dëse Prinzipien goen.
Awer fir de Moment, erënnere just dëst: d'Datendichotomie ass eng Kraaft déi mir konfrontéieren wann Dir Geschäftsservicer bauen. A mir mussen dëst erënneren. Den Trick ass alles op de Kapp ze dréinen a gedeelt Daten als éischtklasseg Objeten ze behandelen. Stateful Stream Processing bitt en eenzegaartege Kompromiss dofir. Et vermeit zentraliséiert "Gott Komponenten" déi Fortschrëtter zréckhalen. Ausserdeem garantéiert et d'Agilitéit, d'Skalierbarkeet an d'Widderstandsfäegkeet vun den Datenstreaming Pipelines a füügt se un all Service un. Dofir kënne mir op den allgemenge Stroum vum Bewosstsinn konzentréieren, op deen all Service mat sengen Donnéeën konnektéieren a schaffen. Dëst mécht Servicer méi skalierbar, austauschbar an autonom. Also si wäerten net nëmme gutt op Whiteboards an Hypothesen Tester kucken, awer si wäerten och fir Joerzéngte schaffen an evoluéieren.
Source: will.com