Serverlos ass net iwwer de kierperleche Fehlen vu Serveren. Dëst ass keen Container Killer oder e passéierenden Trend. Dëst ass eng nei Approche fir Systemer an der Wollek ze bauen. Am heutegen Artikel wäerte mir d'Architektur vun Serverless Uwendungen beréieren, loosst eis kucken wéi eng Roll de Serverless Service Provider an Open-Source Projeten spillen. Schlussendlech schwätze mer iwwer d'Problemer fir Serverless ze benotzen.
Ech wëll e Server Deel vun enger Applikatioun (oder souguer en Online Store) schreiwen. Dëst kéint e Chat, en Inhaltsverëffentlechungsservice oder e Lastbalancer sinn. Op alle Fall wäert et vill Kappwéi sinn: Dir musst d'Infrastruktur virbereeden, d'Applikatiounsofhängegkeet bestëmmen an iwwer de Hostbetribssystem denken. Da musst Dir kleng Komponenten aktualiséieren, déi net d'Operatioun vum Rescht vum Monolith beaflossen. Gutt, loosst eis net iwwer d'Skaléierung ënner Laascht vergiessen.
Wat wa mir ephemeral Container huelen, an deenen déi erfuerderlech Ofhängegkeete scho virinstalléiert sinn, an d'Container selwer vuneneen a vum Host OS isoléiert sinn? Mir wäerten de Monolith a Mikroservicer opdeelen, déi jidderee kann onofhängeg vun deenen aneren aktualiséiert a skaléiert ginn. Andeems Dir de Code an esou engem Container setzt, kann ech et op all Infrastruktur lafen. Scho besser.
Wat wann Dir keng Container wëllt konfiguréieren? Ech wëll net iwwer d'Skaléierung vun der Applikatioun denken. Ech wëll net fir Idle Lafen Container bezuelen wann d'Laascht op de Service minimal ass. Ech wëll Code schreiwen. Focus op d'Geschäftslogik a bréngt Produkter mat der Liichtgeschwindegkeet op de Maart.
Esou Gedanken hunn mech zu serverlosen Informatik gefouert. Serverlos an dësem Fall heescht net de kierperleche Fehlen vu Serveren, mee d'Feele vun Infrastrukturmanagement Kappwéi.
D'Iddi ass datt d'Applikatiounslogik an onofhängeg Funktiounen opgedeelt ass. Si hunn eng Eventstruktur. All Funktioun mécht eng "Mikrotask". Alles wat vum Entwéckler erfuerderlech ass, ass d'Funktiounen an d'Konsole ze lueden, déi vum Cloud Provider geliwwert gëtt a se mat Eventquellen korreléieren. De Code gëtt op Nofro an engem automatesch virbereet Container ausgefouert ginn, an ech bezuelen just fir d'Ausféierung Zäit.
Loosst eis kucken wéi den Applikatiounsentwécklungsprozess elo ausgesäit.
Vun der Säit vum Entwéckler
Virdrun hu mir ugefaang iwwer eng Applikatioun fir en Online Store ze schwätzen. An der traditioneller Approche gëtt d'Haaptlogik vum System duerch eng monolithesch Applikatioun gemaach. An de Server mat der Applikatioun leeft konstant, och wann et keng Laascht ass.
Fir op Serverlos ze plënneren, briechen mir d'Applikatioun a Mikrotasks. Mir schreiwen eis eege Funktioun fir all vun hinnen. D'Funktioune sinn onofhängeg vuneneen a späicheren keng Staatsinformatioun (statlos). Si kënne souguer a verschiddene Sprooche geschriwwe ginn. Wann ee vun hinnen "fällt", wäert déi ganz Applikatioun net ophalen. D'Applikatiounsarchitektur wäert esou ausgesinn:
D'Divisioun a Funktiounen am Serverless ass ähnlech wéi mat Mikroservicer ze schaffen. Awer e Mikroservice kann verschidden Aufgaben ausféieren, an eng Funktioun sollt am Idealfall eng maachen. Loosst eis virstellen datt d'Aufgab ass Statistiken ze sammelen an se op Ufro vum Benotzer ze weisen. An der Mikroservice Approche gëtt eng Aufgab vun engem Service mat zwee Entréespunkte gemaach: Schreiwen a Liesen. Am serverlosen Informatik wäerten dës zwou verschidde Funktiounen sinn déi net matenee verbonne sinn. Den Entwéckler spuert Rechenressourcen, wann zum Beispill Statistike méi dacks aktualiséiert ginn wéi se erofgeluede ginn.
Serverlos Funktiounen mussen a kuerzer Zäit (Timeout) ausgefouert ginn, wat vum Serviceprovider bestëmmt gëtt. Zum Beispill, fir AWS ass den Timeout 15 Minutten. Dëst bedeit datt laanglieweg Funktiounen musse geännert ginn fir d'Ufuerderungen ze passen - dat ass wat Serverless vun anere populäre Technologien haut ënnerscheet (Container a Plattform als Service).
Mir ginn all Funktioun en Event zou. En Event ass en Ausléiser fir eng Handlung:
Manifestatioun
D'Aktioun déi d'Funktioun ausféiert
E Produktbild gouf an de Repository eropgelueden.
Kompriméiert d'Bild an lued an e Verzeechnes erop
Déi kierperlech Geschäft Adress gouf an der Datebank aktualiséiert
Lued eng nei Plaz op Kaarten
De Client bezilt fir d'Wueren
Start Bezuelen Veraarbechtung
Eventer kënnen HTTP-Ufroen, Streamingdaten, Messageschlaangen, asw. Eventquellen sinn Ännerungen oder Optriede vun Daten. Zousätzlech kënnen d'Funktioune vun engem Timer ausgeléist ginn.
D'Architektur gouf ausgeschafft, an d'Applikatioun gouf bal serverlos. Als nächst gi mir op de Service Provider.
Vun der Säit vum Provider
Typesch gëtt serverlos Informatik vu Cloud Service Ubidder ugebueden. Si ginn anescht genannt: Azure Funktiounen, AWS Lambda, Google Cloud Funktiounen, IBM Cloud Funktiounen.
Mir benotzen de Service iwwer d'Konsole vum Provider oder de perséinleche Kont. Funktiounscode kann op eng vun de folgende Weeër erofgeluede ginn:
- Schreift Code an agebaute Redaktoren iwwer d'Webkonsole,
- Luet den Archiv mam Code erof,
- schafft mat ëffentlechen oder private Git Repositories.
Hei setzen mir d'Evenementer op déi d'Funktioun nennen. D'Sets vun Eventer kënne fir verschidde Fournisseuren ënnerscheeden.
De Fournisseur huet de Function as a Service (FaaS) System op senger Infrastruktur gebaut an automatiséiert:
- De Funktiounscode endet am Stockage op der Provider Säit.
- Wann en Event geschitt, ginn Container mat engem preparéierten Ëmfeld automatesch um Server ofgesat. All Fonktioun Instanz huet seng eege isoléiert Container.
- Vun der Späichere gëtt d'Funktioun an de Container geschéckt, berechent a gëtt d'Resultat zréck.
- D'Zuel vu parallelen Eventer wiisst - d'Zuel vun de Container wiisst. De System scaléiert automatesch. Wann d'Benotzer net op d'Funktioun kommen, ass se inaktiv.
- De Provider setzt d'Idle Zäit fir Container - wann während dëser Zäit Funktiounen net am Container schéngen, gëtt et zerstéiert.
Op dës Manéier kréien mir Serverless aus der Këscht. Mir bezuele fir de Service mam Pay-as-you-go Modell an nëmme fir déi Funktiounen déi benotzt ginn, an nëmme fir d'Zäit wou se benotzt goufen.
Fir Entwéckler un de Service aféieren, bidden Ubidder bis zu 12 Méint gratis Testen, awer limitéieren d'total Berechnungszäit, d'Zuel vun den Ufroen pro Mount, d'Fongen oder d'Energieverbrauch.
Den Haaptvirdeel fir mat engem Provider ze schaffen ass d'Fäegkeet sech keng Suergen iwwer Infrastrukturen (Server, virtuelle Maschinnen, Container) ze maachen. Fir säin Deel kann de Provider FaaS implementéieren souwuel mat hiren eegenen Entwécklungen wéi och mat Open-Source Tools. Loosst eis weider iwwer si schwätzen.
Vun der Open Source Säit
D'Open-Source Gemeinschaft huet aktiv un Serverless Tools fir déi lescht puer Joer geschafft. Déi gréisste Maartspiller droen och zur Entwécklung vu serverlosen Plattformen bäi:
- Google bitt Entwéckler säin Open-Source Tool - . IBM, RedHat, Pivotal a SAP hunn un hirer Entwécklung deelgeholl;
- IBM op enger Serverloser Plattform geschafft , deen dunn e Projet vun der Apache Foundation gouf;
- Microsoft deelweis opgemaach der Plattform Code .
Entwécklungen sinn och amgaang a Richtung Serverlos Kaderen. и a preparéiert Kubernetes Cluster ofgebaut, Wierker souwuel mat Kubernetes an Docker Swarm. De Kader handelt als eng Zort Controller - op Ufro preparéiert et e Runtime-Ëmfeld am Stärekoup, lancéiert dann eng Funktioun do.
Frameworks verloosse Plaz fir d'Tool ze konfiguréieren fir Äre Besoinen ze passen. Also, a Kubeless kann en Entwéckler d'Funktioun Ausféierung Timeout konfiguréieren (de Standardwäert ass 180 Sekonnen). Fission, an engem Versuch, de Kalestartproblem ze léisen, proposéiert datt e puer Container déi ganzen Zäit lafen (obwuel dëst Ressourcenstoppkäschte mat sech bréngt). An OpenFaaS bitt eng Rei vun Trigger fir all Goût a Faarf: HTTP, Kafka, Redis, MQTT, Cron, AWS SQS, NATs an anerer.
Instruktioune fir unzefänken kënnen an der offizieller Dokumentatioun vun de Kaderen fonnt ginn. Mat hinnen ze schaffen erfuerdert e bësse méi Fäegkeeten wéi wann Dir mat engem Provider schafft - dëst ass op d'mannst d'Fäegkeet fir e Kubernetes Cluster iwwer de CLI ze starten. Am meeschten, enthalen aner Open-Source Tools (zum Beispill de Kafka Queue Manager).
Egal wéi mir mat Serverless schaffen - duerch e Provider oder Open-Source benotzt, kréie mir eng Rei Virdeeler an Nodeeler vun der Serverless Approche.
Aus der Siicht vu Virdeeler an Nodeeler
Serverless entwéckelt d'Iddie vun enger Containerinfrastruktur an enger Mikroservice Approche, an där Teams an engem méisproochege Modus kënne schaffen ouni un enger Plattform gebonnen ze sinn. E System bauen ass vereinfacht a Feeler si méi einfach ze korrigéieren. Microservice Architektur erlaabt Iech nei Funktionalitéit fir de System vill méi séier ze addéieren wéi am Fall vun enger monolithescher Applikatioun.
Serverlos reduzéiert d'Entwécklungszäit nach méi, erlaabt den Entwéckler eleng op d'Geschäftslogik an d'Kodéierung vun der Applikatioun ze fokusséieren. Als Resultat gëtt d'Zäit op de Maart fir Entwécklungen reduzéiert.
Als Bonus kréie mir automatesch Skala fir d'Laascht, a mir bezuelen nëmme fir déi benotzt Ressourcen an nëmmen zu der Zäit wou se benotzt ginn.
Wéi all Technologie huet Serverless Nodeeler.
Zum Beispill kann esou en Nodeel d'Kältestartzäit sinn (am Duerchschnëtt bis zu 1 Sekonn fir Sprooche wéi JavaScript, Python, Go, Java, Ruby).
Engersäits, an der Realitéit, hänkt d'Kältestartzäit vu ville Variabelen of: d'Sprooch an där d'Funktioun geschriwwe gëtt, d'Zuel vun de Bibliothéiken, d'Quantitéit vum Code, d'Kommunikatioun mat zousätzleche Ressourcen (déi selwecht Datenbanken oder Authentifikatiounsserver). Well den Entwéckler dës Verännerlechen kontrolléiert, kann hien d'Startzäit reduzéieren. Awer op der anerer Säit kann den Entwéckler d'Startzäit vum Container net kontrolléieren - alles hänkt vum Provider of.
E kale Start kann an e waarme Start ginn wann eng Funktioun e Container lancéiert vun engem fréiere Event weiderbenotzt. Dës Situatioun wäert an dräi Fäll entstoen:
- wann Clienten dacks de Service benotzen an d'Zuel vun den Uruff un d'Funktioun eropgeet;
- wann de Provider, Plattform oder Kader erlaabt Iech e puer Container déi ganzen Zäit ze halen;
- wann den Entwéckler Funktiounen op engem Timer leeft (soen all 3 Minutten).
Fir vill Uwendungen ass e Kale Start kee Problem. Hei musst Dir op der Aart an Aufgaben vum Service bauen. Eng Startverzögerung vun enger Sekonn ass net ëmmer kritesch fir eng Geschäftsapplikatioun, awer et kann kritesch fir medizinesch Servicer ginn. An dësem Fall wäert d'serverlos Approche wahrscheinlech net méi passend sinn.
Den nächsten Nodeel vu Serverless ass déi kuerz Liewensdauer vun enger Funktioun (Timeout wärend där d'Funktioun muss ausgefouert ginn).
Awer, wann Dir mat laangliewege Aufgaben muss schaffen, kënnt Dir eng Hybridarchitektur benotzen - Serverless mat enger anerer Technologie kombinéieren.
Net all Systemer kënne mat dem Serverless Schema schaffen.
E puer Applikatiounen späicheren nach ëmmer Daten a Staat wärend der Ausféierung. E puer Architekturen bleiwen monolithesch an e puer Feature wäerte laang liewen. Wéi och ëmmer (wéi Cloud Technologien an dann Container), Serverless ass eng Technologie mat enger grousser Zukunft.
An dëser Aart a Weis wéilt ech glat op d'Thema vun der Serverless Approche weidergoen.
Vun der Applikatioun Säit
Fir 2018, de Prozentsaz vun der Serverloser Notzung . Ënnert de Firmen, déi d'Technologie schonn an hire Servicer ëmgesat hunn, sinn esou Maartgiganten wéi Twitter, PayPal, Netflix, T-Mobile, Coca-Cola. Zur selwechter Zäit musst Dir verstoen datt Serverless keng Panacea ass, awer e Tool fir eng gewësse Palette vu Probleemer ze léisen:
- Reduzéieren Ressource Ausdauer. Et ass net néideg permanent eng virtuell Maschinn ze halen fir Servicer déi wéineg Uruff hunn.
- Prozess Daten op der fléien. Kompriméiere Biller, schneiden Hannergrënn aus, änneren Videokodéierung, schafft mat IoT Sensoren, maacht mathematesch Operatiounen.
- "Kleim" aner Servicer zesummen. Git Repository mat internen Programmer, Chat Bot am Slack mat Jira a Kalenner.
- Balance d'Laascht. Loosst eis hei méi genau kucken.
Loosst eis soen datt et e Service gëtt deen 50 Leit unzitt. Ënnert et ass eng virtuell Maschinn mat schwaach Hardware. Vun Zäit zu Zäit erhéicht d'Laascht op de Service wesentlech. Da kann schwaach Hardware net eens ginn.
Dir kënnt e Balancer am System enthalen deen d'Laascht verdeelt, sot iwwer dräi virtuell Maschinnen. Op dëser Etapp kënne mir d'Laascht net genee viraussoen, sou datt mir eng gewësse Quantitéit u Ressourcen "an der Reserve" lafen. A mir iwwerbezuelen fir Ausdauer.
An esou enger Situatioun kënne mir de System duerch eng Hybrid Approche optimiséieren: mir verloossen eng virtuell Maschinn hannert dem Lastbalancer an setzen e Link op de Serverless Endpoint mat Funktiounen. Wann d'Laascht d'Schwell iwwerschreift, lancéiert de Balancer Funktiounsinstanzen déi en Deel vun der Ufroveraarbechtung iwwerhuelen.
Sou kann Serverless benotzt ginn, wou et néideg ass eng grouss Unzuel vun Ufroen net ze dacks, awer intensiv ze veraarbecht. An dësem Fall ass e puer Funktiounen fir 15 Minutten méi rentabel wéi eng virtuell Maschinn oder Server déi ganzen Zäit ze halen.
Mat all de Virdeeler vum Serverless Computing, virun der Implementatioun, sollt Dir als éischt d'Applikatiounslogik evaluéieren a verstoen wéi eng Probleemer Serverless an engem bestëmmte Fall léise kënnen.
Serverlos a Selectel
Bei Selectel si mir schonn iwwer eis Kontrollpanel. Elo bauen mir eis eege FaaS Plattform. Mir wëllen datt d'Entwéckler fäeg sinn hir Probleemer mat Serverless duerch eng praktesch, flexibel Interface ze léisen.
Wann Dir Iddien hutt iwwer wat déi ideal FaaS Plattform soll sinn a wéi Dir Serverless an Äre Projete benotze wëllt, deelt se an de Kommentaren. Mir wäerten Är Wënsch bei der Entwécklung vun der Plattform berücksichtegen.
Material benotzt am Artikel:
Source: will.com