One-Cloud - Datacenter Niveau OS an Odnoklassniki

Aloha, Leit! Mäin Numm ass Oleg Anastasyev, ech schaffen bei Odnoklassniki an der Plattform Team. An nieft mir ass et vill Hardware déi an Odnoklassniki funktionnéiert. Mir hunn véier Datenzentren mat ongeféier 500 Racken mat méi wéi 8 Tausend Server. Zu engem gewëssen Zäitpunkt hu mir gemierkt datt d'Aféierung vun engem neie Gestiounssystem eis erlaabt Ausrüstung méi effizient ze lueden, Zougangsmanagement erliichtert, d'(Nei)Verdeelung vu Rechenressourcen automatiséieren, de Start vun neie Servicer beschleunegen an d'Äntwerten beschleunegen. zu groussen Accidenter.

Wat ass dovunner komm?

Nieft mir an enger Rëtsch Hardware ginn et och Leit, déi mat dëser Hardware schaffen: Ingenieuren, déi direkt an de Rechenzentren sinn; Netzwierker déi Netzwierksoftware opbauen; Administrateuren, oder SREs, déi Infrastruktur Widderstandsfäegkeet ubidden; an Entwécklungsteams, jidderee vun hinnen ass verantwortlech fir en Deel vun de Funktiounen vum Portal. D'Software déi se kreéieren funktionnéiert sou eppes:

Benotzer Ufroe ginn souwuel op de Fronte vum Haaptportal kritt www.ok.ru, an op anerer, zum Beispill op der Musek API Fronte. Fir d'Geschäftslogik ze veraarbecht, ruffen se den Applikatiounsserver, deen, wann Dir d'Ufro veraarbecht, déi néideg spezialiséiert Mikroservicer nennt - One-Graf (Grafik vu soziale Verbindungen), User-Cache (Cache vu Benotzerprofile), etc.

Jiddereng vun dëse Servicer ass op ville Maschinnen agesat, a jidderee vun hinnen huet verantwortlech Entwéckler verantwortlech fir de Fonctionnement vun de Moduler, hir Operatioun an technologesch Entwécklung. All dës Servicer lafen op Hardware-Serveren, a bis viru kuerzem hu mir genee eng Aufgab pro Server lancéiert, also si war fir eng spezifesch Aufgab spezialiséiert.

Firwat? Dës Approche huet verschidde Virdeeler:

• Erliichtert Mass Gestioun. Loosst eis soen datt eng Aufgab e puer Bibliothéiken erfuerdert, e puer Astellungen. An dann ass de Server genee eng spezifesch Grupp zougewisen, d'cfengine Politik fir dës Grupp gëtt beschriwwen (oder et ass scho beschriwwe ginn), an dës Konfiguratioun gëtt zentral an automatesch op all Server an dëser Grupp ausgerullt.
• Vereinfacht Diagnostik. Loosst eis soen datt Dir d'verstäerkte Belaaschtung op den zentrale Prozessor kuckt a realiséiere datt dës Belaaschtung nëmmen duerch d'Aufgab generéiert ka ginn, déi op dësem Hardwareprozessor leeft. D'Sich no engem Schold geet ganz séier op.
• Vereinfacht Iwwerwaachung. Wann eppes mam Server falsch ass, mellt de Monitor et, an Dir wësst genee wien d'Schold ass.

E Service, deen aus e puer Repliken besteet, gëtt e puer Server zougewisen - ee fir all. Dann ass d'Rechenressource fir de Service ganz einfach verdeelt: d'Zuel vun de Serveren deen de Service huet, déi maximal Quantitéit u Ressourcen déi et verbrauche kann. "Einfach" heescht hei net datt et einfach ass ze benotzen, awer am Sënn datt d'Ressourceallokatioun manuell gemaach gëtt.

Dës Approche huet eis och erlaabt spezialiséiert Eisen Konfiguratiounen fir eng Aufgab op dësem Server lafen. Wann d'Aufgab grouss Quantitéiten un Daten späichert, da benotze mir e 4U Server mat engem Chassis mat 38 Scheiwen. Wann d'Aufgab reng computational ass, da kënne mir e méi bëllegen 1U Server kafen. Dëst ass berechnungseffizient. Dës Approche erlaabt eis ënner anerem véiermol manner Maschinnen ze benotzen mat enger Laascht vergläichbar mat engem frëndlechen sozialen Netzwierk.

Esou Effizienz an der Notzung vun Rechen Ressourcen soll och wirtschaftlech Effizienz garantéieren, wa mir aus der Viraussetzung virgoen, datt déi deier Saach Serveren ass. Fir eng laang Zäit war Hardware déi deiersten, a mir hu vill Efforte gemaach fir de Präis vun der Hardware ze reduzéieren, mat Feelertoleranzalgorithmen ze kommen fir d'Hardware Zouverlässegkeet Ufuerderunge ze reduzéieren. An haut hu mir d'Bühn erreecht wou de Präis vum Server net méi entscheedend ass. Wann Dir déi lescht Exotik net berücksichtegt, dann ass d'spezifesch Konfiguratioun vun de Serveren am Rack egal. Elo hu mir en anere Problem - de Präis vum Raum, deen vum Server am Rechenzentrum besat ass, dat ass de Raum am Rack.

Mir realiséieren datt dëst de Fall war, hu mir beschloss ze berechnen wéi effektiv mir d'Racken benotzen.
Mir hunn de Präis vum mächtegste Server vun de wirtschaftlech gerechtfäerdegten geholl, berechent wéivill esou Serveren mir an Racken kéinte placéieren, wéivill Aufgaben mir op hinnen lafen op Basis vum ale Modell "een Server = eng Aufgab" a wéi vill esou Aufgaben kënnen d'Ausrüstung benotzen. Si hunn gezielt an Tréinen gefall. Et huet sech erausgestallt datt eis Effizienz beim Gebrauch vu Racken ongeféier 11% ass. D'Konklusioun ass evident: mir mussen d'Effizienz vun der Benotzung vun Datenzenter erhéijen. Et géif schéngen datt d'Léisung evident ass: Dir musst e puer Aufgaben op engem Server gläichzäiteg lafen. Awer hei fänken d'Schwieregkeeten un.

D'Masskonfiguratioun gëtt dramatesch méi komplizéiert - et ass elo onméiglech fir eng Grupp un e Server ze ginn. No allem, elo kënnen e puer Aufgabe vu verschiddene Kommandoen op engem Server gestart ginn. Zousätzlech kann d'Konfiguratioun konfliktend sinn fir verschidden Uwendungen. Diagnos gëtt och méi komplizéiert: wann Dir e verstäerkten CPU- oder Diskverbrauch op engem Server gesitt, wësst Dir net wéi eng Aufgab Problemer mécht.

Awer den Haapt Saach ass datt et keng Isolatioun gëtt tëscht Aufgaben déi op der selwechter Maschinn lafen. Hei, zum Beispill, ass eng Grafik vun der duerchschnëttlecher Äntwertzäit vun enger Servertask virun an no enger anerer Berechnungsapplikatioun um selwechte Server gestart, op kee Fall am Zesummenhang mat der éischter - d'Äntwertzäit vun der Haaptaufgab ass wesentlech eropgaang.

Natierlech musst Dir Aufgaben entweder a Container oder a virtuelle Maschinnen lafen. Well bal all eis Aufgaben ënner engem OS (Linux) lafen oder dofir ugepasst sinn, brauche mir net vill verschidde Betribssystemer z'ënnerstëtzen. Deementspriechend ass d'Virtualiséierung net gebraucht; Wéinst der zousätzlecher Overhead wäert et manner effizient sinn wéi Containeriséierung.

Als Implementatioun vu Container fir Aufgaben direkt op Serveren ze lafen, ass Docker e gudde Kandidat: Dateiesystembiller léisen Problemer mat konfliktende Konfiguratiounen gutt. D'Tatsaach, datt Biller aus verschiddene Schichten zesummegesat kënne ginn, erlaabt eis d'Quantitéit un Daten wesentlech ze reduzéieren fir se op der Infrastruktur z'installéieren, gemeinsame Deeler an getrennten Basisschichten ze trennen. Da ginn déi grondleeënd (an déi voluminösst) Schichten zimlech séier duerch déi ganz Infrastruktur cachéiert, a fir vill verschidden Aarte vun Uwendungen a Versiounen ze liwweren, brauche just kleng Schichten iwwerdroe ginn.

Plus, e fäerdege Registry a Bildtagging am Docker ginn eis fäerdege Primitiv fir d'Versioun an d'Liwwerung vum Code fir d'Produktioun.

Docker, wéi all aner ähnlech Technologie, bitt eis e gewëssen Niveau vun der Containerisolatioun aus der Këscht. Zum Beispill, Erënnerung Isolatioun - all Container gëtt eng Limite op d'Benotzung vun Maschinn Erënnerung ginn, doriwwer eraus wäert et net konsuméieren. Dir kënnt och Container isoléieren op Basis vun der CPU Benotzung. Fir eis war d'Standardisolatioun awer net genuch. Awer méi doriwwer ënnendrënner.

Direkt Lafen Container op Serveren ass nëmmen en Deel vum Problem. Deen aneren Deel ass am Zesummenhang mat Hosting Container op Serveren. Dir musst verstoen wat Container kann op deem Server gesat ginn. Dëst ass net sou eng einfach Aufgab, well Container musse sou dicht wéi méiglech op Server plazéiert ginn ouni hir Geschwindegkeet ze reduzéieren. Esou Placement kann och aus engem Feeler Toleranz Siicht schwéier ginn. Dacks wëlle mir Repliken vum selwechte Service a verschiddene Racken oder souguer a verschiddene Raim vum Rechenzentrum placéieren, sou datt wann e Rack oder Sall feelt, verléiere mir net direkt all Service Replicaen.

Container manuell verdeelen ass keng Optioun wann Dir 8 Tausend Server an 8-16 Tausend Container hutt.

Zousätzlech wollte mir d'Entwéckler méi Onofhängegkeet an der Ressourceallokatioun ginn, fir datt se hir Servicer an der Produktioun selwer kënne hosten, ouni d'Hëllef vun engem Administrateur. Zur selwechter Zäit wollte mir d'Kontroll behalen, sou datt e klengen Service net all d'Ressourcen vun eise Rechenzentren verbraucht.

Natierlech brauche mir eng Kontrollschicht déi dëst automatesch géif maachen.

Also si mir zu engem einfachen a verständleche Bild komm, dat all Architekten adore: dräi Quadrat.

One-Cloud Masters ass e Failover Cluster verantwortlech fir Cloud Orchestratioun. Den Entwéckler schéckt e Manifest un de Meeschter, deen all déi néideg Informatioun enthält fir de Service ze hosten. Baséierend op et gëtt de Meeschter Kommandoen fir ausgewielte Minions (Maschinnen entworf fir Container ze lafen). D'Minions hunn eisen Agent, deen de Kommando kritt, seng Kommandoen un Docker erausginn, an Docker konfiguréiert den Linux Kernel fir de entspriechende Container ze starten. Zousätzlech fir Kommandoen auszeféieren, bericht den Agent kontinuéierlech dem Meeschter iwwer Ännerungen am Zoustand vun der Minionmaschinn an de Container déi drop lafen.

Ressource Allocatioun

Loosst eis elo de Problem vun enger méi komplexer Ressourceallokatioun fir vill Minions kucken.

Eng Rechenressource an engem Cloud ass:

• De Betrag vun der Prozessorkraaft verbraucht vun enger spezifescher Aufgab.
• D'Quantitéit un Erënnerung verfügbar fir d'Aufgab.
• Netzverkéier. Jiddereng vun den Minions huet eng spezifesch Netzwierk-Interface mat limitéierter Bandbreedung, sou datt et onméiglech ass Aufgaben ze verdeelen ouni d'Quantitéit vun Daten ze berücksichtegen, déi se iwwer d'Netz vermëttelen.
• Disken. Zousätzlech, selbstverständlech, fir de Raum fir dës Aufgaben, verdeele mir och den Typ vun Disk: HDD oder SSD. Disks kënnen eng endlech Unzuel vun Ufroen pro Sekonn déngen - IOPS. Dofir, fir Aufgaben, déi méi IOPS generéieren wéi eng eenzeg Scheif kann handhaben, verdeele mir och "Spindles" - dat heescht, Disk-Geräter, déi exklusiv fir d'Aufgab reservéiert musse sinn.

Dann fir e puer Service, zum Beispill fir Benotzer-Cache, kënne mir déi verbraucht Ressourcen op dës Manéier notéieren: 400 Prozessorkären, 2,5 TB Erënnerung, 50 Gbit / s Traffic a béid Richtungen, 6 TB HDD Plaz op 100 Spindelen. Oder an enger méi vertrauter Form wéi dës:

alloc:
    cpu: 400
    mem: 2500
    lan_in: 50g
    lan_out: 50g
    hdd:100x6T

Benotzer-Cache Service Ressourcen verbrauchen nëmmen en Deel vun all verfügbare Ressourcen an der Produktiounsinfrastruktur. Dofir wëll ech sécherstellen datt op eemol, wéinst engem Bedreiwer Feeler oder net, de Benotzer-Cache net méi Ressourcen verbraucht wéi et zougewisen ass. Dat heescht, mir mussen Ressourcen limitéieren. Mee wat kéinte mir d'Quot binden?

Komme mer zréck op eist immens vereinfacht Diagramm vun der Interaktioun vu Komponenten a zéien et mat méi Detailer - wéi dëst:

Wat d'Aen opfällt:

• De Web Frontend a Musek benotzen isoléiert Cluster vum selwechte Applikatiounsserver.
• Mir kënnen déi logesch Schichten z'ënnerscheeden, zu deenen dës Cluster gehéieren: Fronten, Cache, Datelagerung a Managementschicht.
• De Frontend ass heterogen; et besteet aus verschiddene funktionnelle Subsystemer.
• Cache kënnen och iwwer de Subsystem verspreet ginn, deem seng Donnéeën se cache.

Loosst eis d'Bild nach eng Kéier zéien:

Bah! Jo, mir gesinn eng Hierarchie! Dëst bedeit datt Dir Ressourcen a gréissere Stécker verdeele kënnt: e verantwortlechen Entwéckler un engem Node vun dëser Hierarchie entspriechend dem funktionnelle Subsystem (wéi "Musek" am Bild) zouzeschreiwen, a befestegt eng Quot op deeselwechten Niveau vun der Hierarchie. Dës Hierarchie erlaabt eis och Servicer méi flexibel ze organiséieren fir d'Gestioun ze vereinfachen. Zum Beispill verdeele mir de ganzen Web, well dëst eng ganz grouss Gruppéierung vu Serveren ass, a verschidde méi kleng Gruppen, déi am Bild als Group1, Group2 ugewise ginn.

Andeems Dir déi extra Zeilen ewechhuelt, kënne mir all Node vun eisem Bild an enger flaacher Form schreiwen: group1.web.front, api.music.front, user-cache.cache.

Esou komme mer zum Konzept vun der „hierarchescher Schlaang“. Et huet en Numm wéi "group1.web.front". Eng Quote fir Ressourcen a Benotzerrechter gëtt et zougewisen. Mir ginn der Persoun vun DevOps d'Rechter fir e Service an d'Schlaang ze schécken, an esou en Employé kann eppes an der Schlaang lancéieren, an d'Persoun vun OpsDev wäert Adminrechter hunn, an elo kann hien d'Schlaang verwalten, d'Leit do zouginn, ginn dëse Leit Rechter, etc.. Servicer, déi op dëser Schlaang lafen, lafen bannent der Quote vun der Schlaang. Wann de Rechenquote vun der Schlaang net genuch ass fir all Servicer gläichzäiteg auszeféieren, da gi se sequentiell ausgefouert, sou datt d'Schlaang selwer bilden.

Loosst eis d'Servicer méi no kucken. E Service huet e vollqualifizéierten Numm, deen ëmmer den Numm vun der Schlaang enthält. Da wäert de Front Web Service den Numm hunn ok-web.group1.web.front. An den Applikatiounsserverservice deen et zougitt gëtt genannt ok-app.group1.web.front. All Service huet e Manifest, deen all déi néideg Informatioune fir d'Plazéierung op spezifesch Maschinnen spezifizéiert: wéivill Ressourcen dës Aufgab verbraucht, wéi eng Konfiguratioun dofir gebraucht gëtt, wéivill Repliken et solle sinn, Eegeschafte fir Feeler vun dësem Service ze handhaben. An nodeems de Service direkt op d'Maschinnen gesat gëtt, erschéngen seng Instanzen. Si ginn och eendeiteg benannt - als Instanznummer an Servicenumm: 1.ok-web.group1.web.front, 2.ok-web.group1.web.front, …

Dëst ass ganz bequem: andeems Dir nëmmen den Numm vum lafende Container kuckt, kënne mir direkt vill erausfannen.

Loosst eis elo méi no kucken wat dës Instanzen tatsächlech ausféieren: Aufgaben.

Aufgab Isolatioun Klassen

All Aufgaben am OK (an, wahrscheinlech, iwwerall) kënnen a Gruppen opgedeelt ginn:

• Kuerz latency Aufgaben - prod. Fir sou Aufgaben a Servicer ass d'Äntwertverzögerung (Latency) ganz wichteg, wéi séier all Ufro vum System veraarbecht gëtt. Beispiller vun Aufgaben: Webfronten, Cache, Applikatiounsserver, OLTP Späicheren, asw.
• Berechnungsproblemer - Batch. Hei ass d'Veraarbechtungsgeschwindegkeet vun all spezifeschen Ufro net wichteg. Fir si ass et wichteg wéi vill Berechnungen dës Aufgab an enger bestëmmter (laanger) Zäit (Duerchgang) mécht. Dëst wäert all Aufgabe vu MapReduce, Hadoop, Maschinnléieren, Statistik sinn.
• Hannergrond Aufgaben - Idle. Fir sou Aufgaben si weder Latenz nach Duerchsatz ganz wichteg. Dëst beinhalt verschidden Tester, Migratiounen, Neiberechnungen a Konversioun vun Daten vun engem Format an en anert. Engersäits si se ähnlech wéi berechent, op der anerer Säit ass et eis egal wéi séier se fäerdeg sinn.

Loosst d'gesinn wéi esou Aufgaben Ressourcen verbrauchen, zum Beispill den zentrale Prozessor.

Kuerz Retard Aufgaben. Sou eng Aufgab wäert e CPU Konsummuster ähnlech wéi dëst hunn:

Eng Ufro vum Benotzer gëtt fir d'Veraarbechtung kritt, d'Aufgab fänkt un all verfügbare CPU Cores ze benotzen, veraarbecht et, gëtt eng Äntwert zréck, waart op déi nächst Ufro a stoppt. Déi nächst Ufro ass ukomm - erëm hu mir alles gewielt wat do war, berechent, a waarden op déi nächst.

Fir d'Mindestlatenz fir sou eng Aufgab ze garantéieren, musse mir déi maximal Ressourcen huelen déi se verbraucht an déi erfuerderlech Unzuel vu Kären op der Minion reservéieren (d'Maschinn déi d'Aufgab ausféiert). Dann ass d'Reservatiounsformel fir eise Problem wéi follegt:

alloc: cpu = 4 (max)

a wa mir eng Minionmaschinn mat 16 Kären hunn, da kënne genee véier esou Aufgaben drop gesat ginn. Mir bemierken besonnesch datt den duerchschnëttleche Prozessorverbrauch vu sou Aufgaben dacks ganz niddereg ass - wat evident ass, well e wesentlechen Deel vun der Zäit d'Aufgab op eng Ufro waart an näischt mécht.

Berechnung Aufgaben. Hir Muster wäert liicht anescht sinn:

Den duerchschnëttleche CPU Ressourceverbrauch fir sou Aufgaben ass zimlech héich. Dacks wëlle mir datt eng Berechnungsaufgab an enger gewësser Zäit fäerdeg ass, also musse mir d'Mindestzuel vu Prozessoren reservéieren déi se brauch fir datt déi ganz Berechnung an enger akzeptabeler Zäit fäerdeg ass. Seng Reservéierungsformel wäert esou ausgesinn:

alloc: cpu = [1,*)

"Plaz w.e.g. et op e Minion, wou et op d'mannst ee fräie Kär ass, an dann sou vill wéi et sinn, wäert et alles verschwannen."

Hei ass d'Effizienz vum Gebrauch scho vill besser wéi op Aufgaben mat enger kuerzer Retard. Awer de Gewënn wäert vill méi grouss sinn wann Dir béid Aarte vun Aufgaben op enger Minionmaschinn kombinéiert a seng Ressourcen ënnerwee verdeelt. Wann eng Aufgab mat enger kuerzer Verzögerung e Prozessor erfuerdert, kritt se se direkt, a wann d'Ressourcen net méi gebraucht ginn, gi se op d'Rechentask transferéiert, dh eppes wéi dat:

Awer wéi maachen ech dat?

Als éischt kucke mer de Prod a seng Alloc: cpu = 4. Mir mussen véier Käre reservéieren. Am Docker Run kann dëst op zwou Weeër gemaach ginn:

• Mat Optioun --cpuset=1-4, dh véier spezifesch Kären op der Maschinn op d'Aufgab ze verdeelen.
• Ze benotzen --cpuquota=400_000 --cpuperiod=100_000, eng Quote fir Prozessor Zäit zouzeschreiwen, dh uginn datt all 100 ms Echtzäit d'Aufgab net méi wéi 400 ms Prozessor Zäit verbraucht. Déi selwecht véier Käre ginn kritt.

Awer wéi eng vun dëse Methoden ass gëeegent?

cpuset gesäit ganz attraktiv aus. D'Aufgab huet véier engagéierten Cores, dat heescht datt Prozessor Cache sou effizient wéi méiglech funktionnéieren. Dëst huet och en Nodeel: mir mussen d'Aufgab iwwerhuelen fir d'Berechnungen iwwer déi entlaascht Käre vun der Maschinn ze verdeelen amplaz vum OS, an dëst ass eng zimlech net-trivial Aufgab, besonnesch wa mir probéieren Batch-Aufgaben op sou eng Plaz ze setzen. Maschinn. Tester hu gewisen datt d'Optioun mat enger Quote hei besser passt: sou huet de Betribssystem méi Fräiheet beim Choix vum Kär fir d'Aufgab am aktuellen Moment ze maachen an d'Prozessorzäit gëtt méi effizient verdeelt.

Loosst eis erausfannen wéi Dir Reservatiounen am Docker maache baséiert op der Minimum Unzuel vu Kären. D'Quote fir Batch Aufgaben ass net méi uwendbar, well et net néideg ass de Maximum ze limitéieren, et geet duer fir just de Minimum ze garantéieren. An hei passt d'Optioun gutt docker run --cpushares.

Mir hunn eis eens datt wann e Batch eng Garantie fir op d'mannst ee Kär erfuerdert, da weisen mir --cpushares=1024, a wann et op d'mannst zwee Käre sinn, da weisen mir --cpushares=2048. CPU Aktien stéieren op kee Fall mat der Verdeelung vun der Prozessorzäit soulaang et genuch ass. Also, wann de Prod de Moment net all seng véier Käre benotzt, gëtt et näischt limitéiert Batch Aufgaben, a si kënnen zousätzlech Prozessor Zäit benotzen. Awer an enger Situatioun wou et e Mangel u Prozessoren ass, wann d'Prod all véier vu senge Käre verbraucht huet an seng Quote erreecht huet, gëtt déi verbleiwen Prozessorzäit proportional op cpushares opgedeelt, dh an enger Situatioun vun dräi gratis Cores, gëtt een ginn eng Aufgab mat 1024 cpushares, an déi reschtlech zwee ginn eng Aufgab mat 2048 cpushares.

Awer Quoten an Aktien ze benotzen ass net genuch. Mir musse sécherstellen datt eng Aufgab mat enger kuerzer Verspéidung Prioritéit iwwer eng Batch Aufgab kritt wann Dir Prozessor Zäit verdeelt. Ouni esou Prioritéit, wäert d'Batch Aufgab all Prozessor Zäit huelen am Moment wou se vum Prod gebraucht gëtt. Et gi keng Container Prioritéit Optiounen am Docker Run, awer Linux CPU Scheduler Politiken kommen praktesch. Dir kënnt iwwer si am Detail liesen hei, an am Kader vun dësem Artikel wäerte mir se kuerz duerchgoën:

• SCHED_OTHER
  Par défaut kréien all normale Benotzerprozesser op enger Linux Maschinn.
• SCHED_BATCH
  Entworf fir Ressource-intensiv Prozesser. Wann Dir eng Aufgab op engem Prozessor placéiert, gëtt eng sougenannt Aktivéierungsstrof agefouert: sou eng Aufgab ass manner wahrscheinlech fir Prozessorressourcen ze kréien wann se am Moment vun enger Aufgab mat SCHED_OTHER benotzt gëtt
• SCHED_IDLE
  En Hannergrondprozess mat enger ganz niddereger Prioritéit, souguer manner wéi flott -19. Mir benotzen eis Open Source Bibliothéik eent-no, fir déi néideg Politik ze setzen beim Start vum Container andeems Dir rufft

one.nio.os.Proc.sched_setscheduler( pid, Proc.SCHED_IDLE )

Awer och wann Dir net op Java programméiert, kann datselwecht mat dem chrt Kommando gemaach ginn:

chrt -i 0 $pid

Loosst eis all eis Isolatiounsniveauen an eng Tabell zesummefaassen fir Kloerheet:

Isolatioun Klass
Alloc Beispill
Docker Run Optiounen
sched_setscheduler chrt*

Prod
cpu = 4
--cpuquota=400000 --cpuperiod=100000
SCHED_OTHER

Batch
CPU = [1, *)
--cpushares=1024
SCHED_BATCH

Idle
CPU= [2, *)
--cpushares=2048
SCHED_IDLE

*Wann Dir chrt vu bannent engem Container maacht, brauch Dir vläicht d'sys_nice Fäegkeet, well Standard Docker dës Fäegkeet läscht wann Dir de Container start.

Awer Aufgaben verbrauchen net nëmmen de Prozessor, awer och de Verkéier, wat d'Latenz vun enger Netzwierktask nach méi beaflosst wéi déi falsch Allokatioun vu Prozessorressourcen. Dofir wëlle mir natierlech genee datselwecht Bild fir de Verkéier kréien. Dat ass, wann eng Prod Task e puer Päckchen an d'Netz schéckt, limitéiere mir déi maximal Geschwindegkeet (Formel alloc: lan=[*,500mbps) ), mat deem Prod dat maache kann. A fir Batch garantéieren mir nëmmen de Minimum Duerchsatz, awer limitéieren net de Maximum (Formel alloc: lan=[10Mbps,*) ) An dësem Fall soll de Prodverkéier Prioritéit iwwer Batch-Aufgaben kréien.
Hei Docker huet keng Primitiv déi mir benotze kënnen. Awer et kënnt eis zur Hëllef Linux Verkéier Kontroll. Mir konnten dat gewënschte Resultat mat Hëllef vun Disziplin erreechen Hierarchesch Fair Service Curve. Mat senger Hëllef ënnerscheede mir zwou Klassen vum Traffic: héich Prioritéit Prod a Low-Prioritéit Batch / Idle. Als Resultat ass d'Konfiguratioun fir erausginn Traffic esou:

hei 1:0 ass de "root qdisc" vun der hsfc Disziplin; 1: 1 - hsfc Kand Klass mat enger total bandwidth Limite vun 8 Gbit / s, ënner deenen d'Kand Klassen vun all Container gesat ginn; 1:2 - d'hsfc Kannerklass ass gemeinsam fir all Batch an Idle Aufgaben mat enger "dynamescher" Limit, déi hei ënnen diskutéiert gëtt. Déi reschtlech hsfc Kand Klassen sinn engagéierten Klassen fir aktuell Lafen Prod Container mat Grenzen entspriechend hire Manifestatiounen - 450 an 400 Mbit / s. All hsfc Klass gëtt eng qdisc Schlaang fq oder fq_codel zougewisen, jee no der Linux Kernel Versioun, fir Paketverloscht während Traffic Bursts ze vermeiden.

Typesch, tc Disziplinnen déngen nëmmen ausgaang Traffic ze prioritéieren. Awer mir wëllen och den Entréeën Traffic prioritär stellen - schliisslech kann e puer Batchtask ganz einfach de ganzen erakommende Kanal auswielen, zum Beispill eng grouss Partie vun Inputdaten fir Map&Reduce kréien. Fir dëst benotze mir de Modul ifb, déi eng ifbX virtuell Interface fir all Netzwierkschnëtt erstellt an den Entréeën Traffic vun der Interface op den erausginnen Traffic op ifbX ëmgeleet. Weider, fir ifbX, funktionnéieren all déiselwecht Disziplinnen fir den ausgaangende Traffic ze kontrolléieren, fir deen d'hsfc Konfiguratioun ganz ähnlech wäert sinn:

Während den Experimenter, hu mir erausfonnt, datt hsfc déi bescht Resultater weist, wann der 1: 2 Klass vun Net-Prioritéit Batch / Idle Verkéier limitéiert op Minion Maschinnen net méi wéi eng bestëmmte Fräistouss. Soss huet Net-Prioritéit Verkéier ze vill Impakt op d'Latenz vun prod Aufgaben. miniond bestëmmt den aktuellen Betrag u fräier Bandbreedung all Sekonn, moosst den duerchschnëttleche Verkéiersverbrauch vun all Prod-Aufgaben vun engem bestëmmte Minion an subtracting et aus dem Reseau Interface bandwidth mat engem klenge Spillraum, d.h.

Bands sinn onofhängeg fir Entréeën an erausginn Traffic definéiert. An no den neie Wäerter reconfigures miniond der Net-Prioritéit Klass Limite 1:2.

Also hu mir all dräi Isolatiounsklassen ëmgesat: Prod, Batch an Idle. Dës Klassen beaflossen immens d'Leeschtungscharakteristike vun Aufgaben. Dofir hu mir décidéiert dëst Attribut un der Spëtzt vun der Hierarchie ze setzen, sou datt wann Dir den Numm vun der hierarchescher Schlaang kuckt, et direkt kloer ass wat mir ze dinn hunn:

All eis Frënn Web и Musek d'Fronten ginn dann an der Hierarchie ënner prod. Zum Beispill, ënner Batch, loosst eis de Service placéieren Musek Katalog, déi periodesch e Katalog vu Tracks aus enger Rei vun mp3 Dateien erstallt, déi op Odnoklassniki eropgeluede ginn. E Beispill vun engem Service ënner Idle wier Musek Transformator, wat de Musekvolumenniveau normaliséiert.

Mat den extra Linnen erëm ewechgeholl, kënne mir eis Servicenimm méi flaach schreiwen andeems Dir d'Taskisolatiounsklass um Enn vum vollen Servicenumm bäidréit: web.front.prod, catalog.music.batch, transformer.music.idle.

An elo, kuckt op den Numm vum Service, mir verstinn net nëmmen wat Funktioun et mécht, mä och seng Isolatioun Klass, dat heescht seng Kritik, etc.

Alles ass super, awer et gëtt eng bitter Wourecht. Et ass onméiglech komplett Aufgaben ze isoléieren déi op enger Maschinn lafen.

Wat mir et fäerdeg bruecht hunn ze erreechen: wann Batch intensiv verbraucht nëmmen CPU Ressourcen, dann mécht den agebaute Linux CPU Scheduler seng Aarbecht ganz gutt, an et gëtt praktesch keen Impakt op d'Prod Task. Awer wann dës Batch Aufgab ufänkt aktiv mat Erënnerung ze schaffen, da erschéngt de géigesäitege Afloss schonn. Dëst geschitt well d'Prod Task "ausgewäsch" gëtt aus de Memory Caches vum Prozessor - als Resultat gëtt de Cache vermësst erop, an de Prozessor veraarbecht d'Prod Task méi lues. Sou eng Batch Aufgab kann d'Latenz vun eisem typesche Prod Container ëm 10% erhéijen.

Traffic isoléieren ass nach méi schwéier wéinst der Tatsaach, datt modern Netzwierkkaarten eng intern Schlaang vu Päck hunn. Wann de Paket vun der Batchtask als éischt dohinner kënnt, da wäert et als éischt iwwer de Kabel iwwerdroen ginn, an näischt kann doriwwer gemaach ginn.

Zousätzlech hu mir bis elo nëmmen de Problem vun der Prioritéit vum TCP-Traffic léisen: d'Hsfc Approche funktionnéiert net fir UDP. An och am Fall vum TCP Traffic, wann d'Batch Task vill Traffic generéiert, gëtt dëst och ongeféier 10% Erhéijung vun der Verzögerung vun der Prod Task.

Feeler Toleranz

Ee vun den Ziler bei der Entwécklung vun engem Cloud war d'Feeltoleranz vun Odnoklassniki ze verbesseren. Dofir wëll ech als nächst méi detailléiert méiglech Szenarie vu Feeler an Accidenter betruechten. Loosst eis mat engem einfachen Szenario ufänken - e Containerfehler.

De Container selwer kann op verschidde Weeër versoen. Dëst kéint eng Aart Experiment, Käfer oder Feeler am Manifest sinn, wéinst deem d'Prod Task ufänkt méi Ressourcen ze konsuméieren wéi am Manifest uginn. Mir haten e Fall: en Entwéckler huet e komplexe Algorithmus implementéiert, et vill Mol ëmgeschafft, sech selwer iwwerduecht a gouf sou duercherneen datt de Problem schlussendlech op eng ganz net-trivial Manéier geschloen gouf. A well d'Prod Task eng méi héich Prioritéit huet wéi all aner op déiselwecht Minions, huet et ugefaang all verfügbare Prozessorressourcen ze konsuméieren. An dëser Situatioun huet d'Isolatioun, oder éischter d'CPU Zäitquote, den Dag gerett. Wann eng Aufgab eng Quote zougewisen gëtt, verbraucht d'Aufgab net méi. Dofir, batch an aner prod Aufgaben, déi op der selwechter Maschinn lafen, näischt gemierkt.

Déi zweet méiglech Problem ass de Container falen. An hei Restart Politik retten eis, jidderee weess se, Docker selwer mécht eng super Aarbecht. Bal all prod Aufgaben hunn eng ëmmer Restart Politik. Heiansdo benotze mir on_failure fir Batch Aufgaben oder fir Prod Container ze Debugging.

Wat kënnt Dir maachen wann e ganze Minion net verfügbar ass?

Natierlech, lafen de Container op enger anerer Maschinn. Den interessanten Deel hei ass wat geschitt mat der IP Adress(en) déi dem Container zougewisen sinn.

Mir kënnen Container déi selwecht IP Adressen zouginn wéi d'Minion Maschinnen op deenen dës Container lafen. Dann, wann de Container op enger anerer Maschinn lancéiert gëtt, ännert seng IP Adress, an all Cliente musse verstoen datt de Container geplënnert ass, an elo musse se op eng aner Adress goen, déi e separaten Service Discovery Service erfuerdert.

Service Discovery ass bequem. Et gi vill Léisungen um Maart vu variabelen Grad vu Feelertoleranz fir e Serviceregister z'organiséieren. Dacks implementéieren esou Léisunge Loadbalancer Logik, späicheren zousätzlech Konfiguratioun a Form vu KV Späicheren, asw.
Wéi och ëmmer, mir wëllen d'Noutwennegkeet vermeiden fir e separaten Registry ëmzesetzen, well dëst bedeit datt e kriteschen System agefouert gëtt deen vun all Servicer an der Produktioun benotzt gëtt. Dëst bedeit datt dëst e potenzielle Punkt vum Echec ass, an Dir musst eng ganz Feeler-tolerant Léisung wielen oder entwéckelen, déi selbstverständlech ganz schwéier, Zäitopwendeg an deier ass.

An nach ee groussen Nodeel: Fir datt eis al Infrastruktur mat der neier funktionnéiert, musse mir absolut all Aufgaben iwwerschreiwe fir eng Zort Service Discovery System ze benotzen. Et gëtt vill Aarbecht, an op e puer Plazen ass et bal onméiglech wann et ëm Low-Level Geräter kënnt, déi um OS Kernel Niveau oder direkt mat der Hardware funktionnéieren. Ëmsetzung vun dëser Funktionalitéit mat etabléierten Léisungsmuster, wéi z Säit Auto géif op e puer Plazen eng zousätzlech Laascht bedeiten, an anerer - eng Komplikatioun vun der Operatioun an zousätzlech Ausfallszenarien. Mir wollten d'Saachen net komplizéiere, also hu mir décidéiert d'Benotzung vu Service Discovery fakultativ ze maachen.

An One-Cloud folgt d'IP dem Container, dh all Task Instanz huet seng eege IP Adress. Dës Adress ass "statesch": et gëtt un all Instanz zougewisen wann de Service fir d'éischt an d'Wollek geschéckt gëtt. Wann e Service eng aner Unzuel vun Instanzen während sengem Liewen hat, da gëtt et um Enn sou vill IP Adressen zougewisen wéi et maximal Instanzen waren.

Duerno änneren dës Adressen net: si ginn eemol zougewisen an existéieren weider am ganze Liewen vum Service an der Produktioun. IP Adressen verfollegen Container iwwer de Reseau. Wann de Container op eng aner Minion transferéiert gëtt, da wäert d'Adress et verfollegen.

Also ännert d'Mapping vun engem Servicenumm op seng Lëscht vun IP Adressen ganz selten. Wann Dir nach eng Kéier d'Nimm vun de Serviceinstanzen kuckt, déi mir am Ufank vum Artikel ernimmt hunn (1.ok-web.group1.web.front.prod, 2.ok-web.group1.web.front.prod, …), wäerte mir bemierken datt se d'FQDNs gleewen déi an DNS benotzt ginn. Dat ass richteg, fir d'Nimm vun de Serviceinstanzen op hir IP Adressen ze mapen, benotze mir den DNS Protokoll. Ausserdeem gëtt dës DNS all reservéiert IP Adresse vun all Container zréck - souwuel lafen a gestoppt (loosst eis soen datt dräi Repliken benotzt ginn, a mir hunn fënnef Adresse reservéiert do - all fënnef ginn zréck). Clienten, déi dës Informatioun kritt hunn, probéieren eng Verbindung mat all de fënnef Repliken ze etabléieren - an esou bestëmmen déi funktionnéieren. Dës Optioun fir d'Disponibilitéit ze bestëmmen ass vill méi zouverlässeg; et beinhalt weder DNS oder Service Discovery, dat heescht datt et keng schwiereg Problemer ze léisen fir d'Relevanz vun Informatioun a Feelertoleranz vun dëse Systemer ze garantéieren. Ausserdeem, a kriteschen Servicer, op deenen d'Operatioun vum ganze Portal hänkt, kënne mir guer net DNS benotzen, awer einfach IP Adressen an d'Konfiguratioun aginn.

D'Ëmsetzung vun sou engem IP Transfert hannert Container kann net-trivial sinn - a mir kucken wéi et mat dem folgenden Beispill funktionnéiert:

Loosst d'soen der eent-Wollek Meeschtesch gëtt de Kommando Minion M1 lafen 1.ok-web.group1.web.front.prod mat Adress 1.1.1.1. Wierker op engem Minion Vugel, déi dës Adress op speziell Serveren annoncéiert route reflector. Déi lescht hunn eng BGP Sessioun mat der Netzhardware, an där d'Adressroute 1.1.1.1 op M1 iwwersat gëtt. M1 routes Päckchen am Container mat Linux. Et ginn dräi Route Reflektor Serveren, well dëst e ganz kriteschen Deel vun der One-Cloud Infrastruktur ass - ouni si funktionnéiert d'Netzwierk an enger Cloud net. Mir setzen se a verschiddene Racken, wa méiglech a verschiddene Raim vum Rechenzentrum, fir d'Wahrscheinlechkeet ze reduzéieren datt all dräi gläichzäiteg feelen.

Loosst eis elo unhuelen datt d'Verbindung tëscht dem One-Cloud Master an dem M1 Minion verluer ass. Den One-Cloud Master wäert elo un der Virgab handelen datt M1 komplett gescheitert ass. Dat ass, et gëtt de Kommando dem M2 Minion fir ze starten web.group1.web.front.prod mat der selwechter Adress 1.1.1.1. Elo hu mir zwee konfliktrouten am Netz fir 1.1.1.1: op M1 an op M2. Fir esou Konflikter ze léisen, benotze mir de Multi Exit Discriminator, deen an der BGP Ukënnegung spezifizéiert ass. Dëst ass eng Zuel déi d'Gewiicht vun der ugekënnegter Streck weist. Ënnert de konfliktende Strecken gëtt de Wee mam ënneschten MED-Wäert ausgewielt. D'One-Cloud Master ënnerstëtzt MED als integralen Deel vun Container IP Adressen. Fir d'éischte Kéier gëtt d'Adress mat enger genuch grousser MED = 1 geschriwwen. An der Situatioun vun esou engem Noutcontainertransfer reduzéiert de Meeschter de MED, an de M000 ​​kritt schonn de Kommando fir d'Adress 000 mat MED = Reklamm ze kréien. 2 1.1.1.1. D'Instanz déi op M999 leeft bleift bei an dësem Fall gëtt et keng Verbindung, a säi weider Schicksal interesséiert eis wéineg bis d'Verbindung mam Meeschter restauréiert ass, wann hien wéi en alen Take gestoppt gëtt.

Crash

All Datenzenter Management Systemer handhaben ëmmer kleng Feeler akzeptabel. Container Iwwerfloss ass d'Norm bal iwwerall.

Loosst eis kucken wéi mir en Noutfall behandelen, wéi zum Beispill e Stroumausfall an engem oder méi Zëmmeren vun engem Datenzenter.

Wat bedeit en Accident fir en Datacenter Management System? Als éischt ass dëst e massive eemolege Feeler vu ville Maschinnen, an de Kontrollsystem muss vill Container zur selwechter Zäit migréieren. Awer wann d'Katastroph ganz grouss ass, da kann et geschéien datt all Aufgaben net op aner Minions nei zougewisen kënne ginn, well d'Ressourcekapazitéit vum Rechenzentrum ënner 100% vun der Laascht fällt.

Dacks sinn Accidenter begleet vum Ausfall vun der Kontrollschicht. Dëst ka geschéien wéinst dem Versoen vu senger Ausrüstung, awer méi dacks wéinst der Tatsaach, datt Accidenter net getest ginn, an d'Kontrollschicht selwer fällt wéinst der verstäerkter Belaaschtung.

Wat kënnt Dir iwwer all dëst maachen?

Massemigratiounen bedeiten datt et eng grouss Zuel vun Aktivitéiten, Migratiounen an Détachementer an der Infrastruktur geschitt. Jiddereng vun den Migratiounen kann e puer Zäit huelen néideg fir Container Biller ze Minions ze liwweren an unpacken, lancéiere an initialize Container, etc.. Dofir ass et wënschenswäert, datt méi wichteg Aufgaben lancéiert ginn ier manner wichteg.

Loosst eis nach eng Kéier d'Hierarchie vun de Servicer kucken, déi mir vertraut sinn a probéieren ze entscheeden wéi eng Aufgaben mir als éischt wëllen ausféieren.

Natierlech sinn dat d'Prozesser déi direkt an der Veraarbechtung vun de Benotzerfuerderunge involvéiert sinn, dh Prod. Mir weisen dat mat Placement Prioritéit - eng Nummer déi un d'Schlaang zougewisen ka ginn. Wann eng Schlaang eng méi héich Prioritéit huet, ginn hir Servicer als éischt gesat.

Op Prod ginn mir méi héich Prioritéiten, 0; op der Partie - e bësse méi niddereg, 100; op Idle - souguer méi niddereg, 200. Prioritéite ginn hierarchesch applizéiert. All Aufgaben méi niddereg an der Hierarchie hunn eng entspriechend Prioritéit. Wa mir wëllen datt Cache bannent Prod virum Frontends lancéiert ginn, da setzen mir Prioritéite fir Cache = 0 an un Front Subqueues = 1. Wa mir zum Beispill wëllen datt den Haaptportal fir d'éischt vun de Fronten lancéiert gëtt, an nëmmen d'Musekfront. dann, da kënne mir déi lescht eng méi niddereg Prioritéit zouginn - 10.

Den nächste Problem ass de Mangel u Ressourcen. Also, eng grouss Quantitéit vun Ausrüstung, ganz Säll vum Rechenzentrum, gescheitert, a mir hunn esou vill Servicer relancéiert, datt elo net genuch Ressourcen fir jiddereen sinn. Dir musst entscheeden wéi eng Aufgaben ze opferen fir déi Haaptkritesch Servicer lafen ze halen.

Am Géigesaz zu der Placement Prioritéit, kënne mir net ondifferenzéiert all Batch Aufgaben opferen; e puer vun hinnen si wichteg fir d'Operatioun vum Portal. Dofir hu mir separat beliicht Viraussetzung Prioritéit Aufgaben. Wann plazéiert, kann eng méi héich Prioritéit Aufgab preempt, dh ophalen, eng manner Prioritéit Aufgab wann et keng méi fräi Minions. An dësem Fall wäert eng Aufgab mat enger niddereger Prioritéit wahrscheinlech onplazéiert bleiwen, dh et gëtt net méi e passende Minion fir et mat genuch gratis Ressourcen.

An eiser Hierarchie ass et ganz einfach eng Preemptiounsprioritéit ze spezifizéieren sou datt Prod- a Batch-Aufgaben Idle Aufgaben virausgoen oder stoppen, awer net géigesäiteg, andeems Dir eng Prioritéit fir Idle gläich wéi 200 spezifizéiert. Just wéi am Fall vun der Placement Prioritéit, mir kann eis Hierarchie benotzen fir méi komplex Regelen ze beschreiwen. Zum Beispill, loosst eis uginn datt mir d'Musekfunktioun opferen wa mir net genuch Ressourcen fir den Haaptwebportal hunn, d'Prioritéit fir déi entspriechend Noden méi niddereg setzen: 10.

Ganzen DC Accidenter

Firwat kéint de ganzen Datenzenter versoen? Element. War e gudde Post den Hurrikan huet d'Aarbecht vum Rechenzentrum beaflosst. D'Elementer kënnen als Obdachlos Leit ugesi ginn, déi eemol d'Optik an der Manifold verbrannt hunn, an den Datenzenter komplett de Kontakt mat anere Site verluer. D'Ursaach vum Echec kann och e mënschleche Faktor sinn: de Bedreiwer wäert esou e Kommando erausginn datt de ganze Rechenzentrum falen. Dëst kéint geschéien wéinst engem grousse Feeler. Am Allgemengen, Zesummebroch vun Datenzentren ass net ongewéinlech. Dat geschitt bei eis eemol all puer Méint.

An dat ass wat mir maache fir ze verhënneren datt iergendeen #alive tweetingt.

Déi éischt Strategie ass Isolatioun. All One-Cloud Instanz ass isoléiert a ka Maschinnen an nëmmen engem Rechenzentrum verwalten. Dat ass, de Verloscht vun enger Wollek wéinst Käferen oder falsch Bedreiwer Kommandoen ass de Verloscht vun nëmmen engem Rechenzentrum. Mir si prett fir dëst: Mir hunn eng Redundanzpolitik an där Repliken vun der Applikatioun an Daten an allen Datenzentere sinn. Mir benotze Feeler-tolerant Datenbanken a testen periodesch fir Feeler.
Zënter haut hu mir véier Datenzenteren, dat heescht véier separat, komplett isoléiert Instanzen vun engem Cloud.

Dës Approche schützt net nëmmen géint kierperlech Echec, mee kann och géint Bedreiwer Feeler schützen.

Wat soss kann mam mënschleche Faktor gemaach ginn? Wann en Bedreiwer der Wollek e komeschen oder potenziell geféierleche Kommando gëtt, kann hien op eemol gefrot ginn e klenge Problem ze léisen fir ze kucken wéi gutt hien geduecht huet. Zum Beispill, wann dëst eng Zort Mass Stop vu ville Repliken ass oder just e komeschen Kommando - d'Zuel vun de Repliken reduzéieren oder den Numm vum Bild änneren, an net nëmmen d'Versiounsnummer am neie Manifest.

Resultater

Distinctive Features vun One-Cloud:

• Hierarchesch a visuell Benennungsschema fir Servicer a Container, wat Iech erlaabt ganz séier erauszefannen, wat d'Aufgab ass, op wat et bezunn ass a wéi se funktionnéiert a wien dofir verantwortlech ass.
• Mir gëllen eis Technik fir Produkt- a Batch-KombinatiounAufgaben op Minions fir d'Effizienz vum Machine Sharing ze verbesseren. Amplaz cpuset benotze mir CPU Quoten, Aktien, CPU Scheduler Politiken a Linux QoS.
• Et war net méiglech Container komplett op der selwechter Maschinn ze isoléieren, mä hire géigesäitege Afloss bleift bannent 20%.
• D'Organisatioun vun Servicer an eng Hierarchie hëlleft mat automatescher Katastropherhuelung benotzt Placement an Viraussetzunge Prioritéite.

FAQ

Firwat hu mir keng fäerdeg Léisung geholl?

• Verschidde Klassen vun der Aufgab Isolatioun erfuerderen aner Logik wann se op Minions gesat ginn. Wann Prod Aufgaben plazéiert kënne ginn andeems se Ressourcen reservéieren, da musse Batch- an Idle Aufgaben plazéiert ginn, déi aktuell Notzung vu Ressourcen op Minion Maschinnen verfollegen.
• De Besoin fir Ressourcen ze berücksichtegen, déi vun Aufgaben verbraucht ginn, wéi:
  • Netz Bandbreedung;
  • Typen an "Spindles" vu Scheiwen.
• De Besoin fir d'Prioritéite vun de Servicer während der Noutfallsreaktioun unzeweisen, d'Rechter an d'Quoten vun de Befehle fir Ressourcen, déi duerch hierarchesch Schlaangen an engem Cloud geléist gëtt.
• De Besoin fir mënschlech Benennung vu Container ze hunn fir d'Äntwertzäit op Accidenter an Tëschefäll ze reduzéieren
• D'Onméiglechkeet vun enger eemoleger verbreet Ëmsetzung vun Service Discovery; de Besoin fir eng laang Zäit mat Aufgaben ze coexistéieren, déi op Hardware Hosten gehost ginn - eppes wat duerch "statesch" IP Adressen no Container geléist gëtt, an als Konsequenz de Besoin fir eenzegaarteg Integratioun mat enger grousser Netzwierkinfrastruktur.

All dës Funktiounen erfuerderen bedeitend Ännerunge vun existente Léisunge fir eis ze passen, a mir hunn d'Quantitéit vun der Aarbecht bewäert, hu mir gemierkt datt mir eis eege Léisung mat ongeféier déiselwecht Aarbechtskäschte kënne entwéckelen. Awer Är Léisung wäert vill méi einfach sinn ze bedreiwen an z'entwéckelen - et enthält keng onnéideg Abstraktiounen déi Funktionalitéit ënnerstëtzen déi mir net brauchen.

Fir déi, déi déi lescht Zeilen liesen, Merci fir Är Gedold an Opmierksamkeet!

Source: will.com