Ufuerderunge fir eng Applikatioun an Kubernetes z'entwéckelen

Haut plangen ech ze schwätzen iwwer wéi Dir Uwendungen schreift a wat sinn d'Ufuerderunge fir Är Uwendung fir gutt a Kubernetes ze schaffen. Sou datt et kee Kappwéi mat der Applikatioun gëtt, sou datt Dir keng "Krabbelen" ronderëm muss erfannen a bauen - an alles funktionnéiert wéi Kubernetes selwer geduecht huet.

Dëse Virtrag ass Deel vun "Slurm Night School op Kubernetes" Dir kënnt déi oppe theoretesch Virträg vun der Owesschoul kucken op Youtube, an eng Playlist gruppéiert. Fir déi, déi Text léiwer wéi Video, hu mir dësen Artikel virbereet.

Mäin Numm ass Pavel Selivanov, de Moment sinn ech de féierende DevOps Ingenieur bei Mail.ru Cloud Solutions, mir maachen Wolleken, mir maachen Management kubernetes a sou weider. Meng Aufgaben enthalen elo Assistenz bei der Entwécklung, d'Ausrollen vun dëse Wolleken, d'Ausrollen vun den Uwendungen déi mir schreiwen an direkt d'Tools z'entwéckelen déi mir fir eis Benotzer ubidden.

Ech hunn DevOps gemaach, mengen ech fir déi lescht, wahrscheinlech, dräi Joer. Awer am Prinzip hunn ech gemaach wat DevOps mécht fir wahrscheinlech ongeféier fënnef Joer elo. Virdru war ech meeschtens an Admin-Saachen involvéiert. Ech hunn viru laanger Zäit ugefaang mat Kubernetes ze schaffen - méiglecherweis sinn ongeféier véier Joer vergaangen zënter datt ech ugefaang hunn domat ze schaffen.

Am Allgemengen hunn ech ugefaang wéi Kubernetes Versioun 1.3 war, wahrscheinlech, a vläicht 1.2 - wann et nach a senger Kandheet war. Elo ass et net méi a senger Kandheet - an et ass evident datt et eng grouss Nofro um Maart fir Ingenieuren ass, déi gäre Kubernetes maache wëllen. A Firmen hunn eng ganz héich Nofro fir esou Leit. Dofir ass dës Virtrag tatsächlech opgetaucht.

Wa mir iwwer de Plang schwätzen, vun deem ech wäert schwätzen, gesäit et esou aus, an Klammeren steet (TL;DR) - "ze laang; liest net". Meng Presentatioun haut wäert aus endlos Lëschte besteet.

Tatsächlech hunn ech selwer esou Presentatiounen net gär wann se gemaach ginn, awer dëst ass sou en Thema datt ech wéi ech dës Presentatioun virbereet hunn, einfach net wierklech erausfonnt hunn wéi ech dës Informatioun anescht organiséieren.

Well, am grousse Ganzen, dës Informatioun ass "ctrl+c, ctrl+v", vun ënner anerem eiser Wiki an der DevOps Sektioun, wou mir schrëftlech Ufuerderunge fir Entwéckler hunn: "Jongen, fir datt mir Är Applikatioun an Kubernetes, et soll esou sinn."

Dofir huet sech d'Presentatioun esou eng grouss Lëscht erausgestallt. Entschëllegt. Ech probéieren sou vill wéi méiglech ze soen fir datt et net langweileg ass wa méiglech.

Wat mir elo kucken:

• dat sinn, éischtens, Logbicher (Applikatioun Logbicher?), wat mat hinnen an Kubernetes ze maachen, wat mat hinnen ze maachen, wat se sollen;
• wat mat Konfiguratiounen an Kubernetes ze maachen, wat sinn déi bescht a schlëmmste Weeër fir eng Applikatioun fir Kubernetes ze konfiguréieren;
• Schwätze mer iwwer wat Accessibilitéitskontrollen am Allgemengen sinn, wéi se solle ausgesinn;
• loosst eis schwätzen iwwer wat e graziéise Shutdown ass;
• loosst eis erëm iwwer Ressourcen schwätzen;
• Loosst eis d'Thema vun der Datelagerung nach eng Kéier beréieren;
• an um Enn wäert ech Iech soen wat de Begrëff dës mysteriéis Cloud-native Applikatioun ass. Cloudnativeness, als Adjektiv vun dësem Begrëff.

Logbicher

Ech proposéieren mat de Logbicher unzefänken - mat wou dës Logbicher an Kubernetes gedréckt musse ginn. Elo hutt Dir eng Applikatioun a Kubernetes lancéiert. No de Klassiker, virdrun Uwendungen hunn ëmmer Logbicher iergendwou an engem Fichier geschriwwen. Schlecht Applikatiounen hunn Logbicher op eng Datei am Heemverzeichnis vum Entwéckler geschriwwen, deen d'Applikatioun lancéiert huet. Gutt Uwendungen hunn Logbicher op eng Datei iergendwou geschriwwen /var/log.

Deementspriechend, weider gutt Administrateuren haten e puer Saachen an hiren Infrastrukturen konfiguréiert datt dës Logbicher kéinte rotéieren - deeselwechte rsyslog, deen dës Logbicher kuckt a wann eppes mat hinnen geschitt, et gi vill vun hinnen, et erstellt Backupkopien, setzt Logbicher do , läscht al Dateien, méi wéi eng Woch, sechs Méint an e puer méi. An Theorie solle mir Dispositiounen hunn, sou datt einfach well d'Applikatioun Logbicher schreift, de Raum op de Produktiounsserver (Kampfserver?) net auslafen. An deementspriechend huet d'ganz Produktioun net gestoppt wéinst de Logbicher.

Wa mir an d'Welt vu Kubernetes plënneren an déi selwecht Saach do lafen, ass dat éischt wat Dir oppassen kann datt d'Leit, wéi se Logbicher an enger Datei geschriwwen hunn, se weider schreiwen.

Et stellt sech eraus datt wa mir iwwer Kubernetes schwätzen, déi richteg Plaz fir Logbicher iergendwou vun engem Docker Container ze schreiwen ass einfach se vun der Applikatioun op de sougenannte Stdout/Stderr ze schreiwen, dat heescht, d'Standard Output Streams vum Betribssystem, de Standardfehlerausgang. Dëst ass déi korrekt, einfachst a logeschst Manéier fir Logbicher am Prinzip an Docker a speziell Kubernetis ze setzen. Well wann Är Applikatioun Logbicher op Stdout / Stderr schreift, dann ass et un Docker an de Kubernetes Add-on fir ze entscheeden wat mat dëse Logbicher ze maachen. Docker wäert als Standard seng speziell Dateien am JSON Format bauen.

Hei stellt sech d'Fro, wat wäert Dir nächst mat dëse Logbicher maachen? Deen einfachste Wee ass kloer, mir hunn d'Fäegkeet ze maachen kubectl logs a kuckt op dës Logbicher vun dësen "pods". Awer, wahrscheinlech, ass dëst net eng ganz gutt Optioun - eppes anescht muss mat de Logbicher gemaach ginn.

Fir elo, loosst eis zur selwechter Zäit schwätzen, well mir d'Thema Logbicher beréiert hunn, iwwer sou eppes wéi Logbicher solle ausgesinn. Dat ass, dëst gëllt net direkt fir Kubernetes, awer wa mir ufänken ze denken wat mat Logbicher ze maachen ass, wier et gutt och iwwer dëst ze denken.

Mir brauchen eng Aart Tool, op eng frëndlech Manéier, déi dës Logbicher huelen, déi eisen Docker a seng Dateien setzt an se iergendwou schéckt. Am grousse Ganzen lancéiere mir normalerweis eng Aart Agent bannent Kubernetes a Form vun engem DaemonSet - e Log Sammler, deen einfach gesot gëtt wou d'Logbicher sinn, déi den Docker sammelt. An dëse Sammelagent hëlt se einfach, parséiert se vläicht och iergendwéi laanscht de Wee, beräichert se vläicht mat zousätzlech Meta-Informatiounen a schéckt se schlussendlech iergendwou fir ze späicheren. Variatiounen si schonn do méiglech. Déi heefegst ass wahrscheinlech Elasticsearch, wou Dir Logbicher späichere kënnt an Dir kënnt se bequem vun do erofhuelen. Dann, benotzt eng Ufro, benotzt Kibana, zum Beispill, bauen Grafike baséiert op hinnen, bauen Alarmer op Basis vun hinnen, etc.

Déi wichtegst Iddi, ech wëll et nach eng Kéier widderhuelen, ass datt am Docker, besonnesch a Kubernetes, Är Logbicher an enger Datei späicheren eng ganz schlecht Iddi ass.

Well als éischt ass et schwéier d'Logbicher am Container an enger Datei ze kréien. Dir musst als éischt an de Container goen, do ausféieren, an dann d'Logbicher kucken. Den nächste Punkt ass datt wann Dir Logbicher an enger Datei hutt, dann hunn d'Container normalerweis e minimalistescht Ëmfeld an et gi keng Utilities déi normalerweis fir normal Aarbecht mat Logbicher gebraucht ginn. Begruewt se, kuckt se, maach se an engem Texteditor op. Den nächste Moment ass wann mir Logbicher an enger Datei an engem Container hunn, wann dëse Container geläscht gëtt, verstitt Dir, d'Logbicher stierwen zesumme mat him. Deementspriechend heescht all Neistart vum Container datt et keng Logbicher méi gëtt. Nach eng Kéier, schlecht Optioun.

An de leschte Punkt ass datt bannent Container Dir normalerweis Är Uwendung hutt an dat ass et - et ass normalerweis deen eenzege Prozess deen leeft. Et gëtt guer net iwwer all Prozess geschwat deen Dateien mat Äre Logbicher rotéiere géif. Soubal d'Logbicher fänken un eng Datei ze schreiwen, heescht dat, entschëllegt, mir fänken un de Produktiounsserver ze verléieren. Well fir d'éischt si se schwéier ze fannen, kee verfolgt se, plus keen kontrolléiert se - deementspriechend wiisst d'Datei endlos bis de Raum um Server einfach ausleeft. Dofir soen ech nach eng Kéier datt d'Aloggen an Docker, besonnesch a Kubernetes, op eng Datei eng schlecht Iddi ass.

Den nächste Punkt, hei wëll ech nach eng Kéier iwwer dëst schwätzen - well mir d'Thema Logbicher beréieren, wier et gutt ze schwätzen iwwer wéi d'Logbicher solle ausgesinn fir et bequem ze maachen mat hinnen ze schaffen. Wéi ech gesot hunn, ass d'Thema net direkt mat Kubernetes verbonnen, awer et ass ganz gutt mam Thema DevOps. Am Thema Entwécklungskultur a Frëndschaft tëscht dësen zwee verschiddenen Departementer - Dev an Ops, sou datt jiddereen bequem ass.

Dëst bedeit datt am Idealfall haut Logbicher am JSON Format geschriwwe ginn. Wann Dir e puer onverständlech Applikatioun vun Ärer eegener hutt, déi Logbicher an onverständleche Formater schreift, well Dir eng Zort Print oder sou eppes setzt, dann ass et Zäit fir eng Aart Kader ze googlen, eng Aart Wrapper, déi Iech erlaabt normale Logbicher ëmzesetzen; aktivéiert Loggingsparameter am JSON do, well JSON en einfachen Format ass, ass et einfach ze parséieren.

Wann Äre JSON net no e puer Kritären funktionnéiert, weess keen wat, da schreift op d'mannst Logbicher an engem Format dat kann parséiert ginn. Hei, éischter, ass et derwäert ze denken iwwer d'Tatsaach datt, zum Beispill, wann Dir eng Rëtsch Container oder just Prozesser mat nginx leeft, a jidderee seng eege Logging-Astellungen huet, da schéngt et wahrscheinlech datt et ganz onbequem ass fir Iech analyséieren hinnen. Well fir all nei nginx Instanz musst Dir Ären eegene Parser schreiwen, well se Logbicher anescht schreiwen. Erëm, et war wahrscheinlech derwäert ze denken drun ze suergen datt all dës nginx Instanzen déiselwecht Logkonfiguratioun hunn, an all hir Logbicher absolut eenheetlech geschriwwen hunn. Dat selwecht gëllt fir absolut all Uwendungen.

Am Endeffekt wëll ech och Brennstoff fir d'Feier addéieren, datt am Idealfall Multi-Line Format Logbicher vermeide sollten. Hei ass d'Saach, wann Dir jeemools mat Log Sammler geschafft hutt, dann hutt Dir wahrscheinlech gesinn wat se Iech verspriechen, datt se mat Multi-Linn Logbicher kënne schaffen, wësse wéi se se sammelen, a sou weider. Tatsächlech, menger Meenung no, kann net een eenzege Sammler haut Multi-Linn Logbicher sammelen normalerweis, voll an ouni Feeler. Op eng mënschlech Manéier, sou datt et bequem a Feelerfräi ass.

Mee Stack Trace ass ëmmer Multi-Linn Logbicher a wéi se ze vermeiden. D'Fro hei ass datt e Log e Rekord vun engem Event ass, an Stactrace ass net tatsächlech e Log. Wa mir Logbicher sammelen an se iergendwou an Elasticsearch setzen an dann Grafike vun hinnen zéien, e puer Berichter iwwer d'Benotzeraktivitéit op Ärem Site bauen, dann wann Dir e Stack Trace kritt, heescht et datt eppes onerwaart geschitt ass an Ärer Applikatioun. An et mécht Sënn fir automatesch e Stack Trace iergendwou an e System eropzelueden deen se verfollege kann.

Dëst ass Software (déi selwecht Sentry) déi speziell gemaach ass fir mat Stack Trace ze schaffen. Et kann direkt automatiséiert Aufgaben erstellen, se un engem zouweisen, alarméieren wann Stacttraces optrieden, dës Stacttraces no engem Typ gruppéieren, a sou weider. Am Prinzip mécht et net vill Sënn fir iwwer Stactracen ze schwätzen, wa mir iwwer Logbicher schwätzen, well dëst sinn schliisslech verschidde Saachen mat verschiddenen Zwecker.

Configuratioun

Als nächst schwätze mir iwwer Konfiguratioun a Kubernetes: wat maache mat deem a wéi Uwendungen bannent Kubernetes solle konfiguréiert ginn. Am Allgemengen soen ech normalerweis datt Docker net iwwer Container geet. Jidderee weess datt Docker iwwer Container geet, och déi, déi net vill mat Docker geschafft hunn. Ech widderhuelen, Docker ass net iwwer Container.

Docker, menger Meenung no, ass iwwer Standarden. An et gi Standarde fir praktesch alles: Norme fir Är Applikatioun ze bauen, Standarde fir Är Applikatioun z'installéieren.

An dës Saach - mir hunn et virdru benotzt, et gouf just besonnesch populär mat der Erscheinung vu Container - dës Saach gëtt ENV (Environment) Variablen genannt, dat heescht Ëmfeldvariablen déi an Ärem Betribssystem sinn. Dëst ass allgemeng en ideale Wee fir Är Applikatioun ze konfiguréieren, well wann Dir Uwendungen an JAVA, Python, Go, Perl, Gott verbidd, a si kënnen all d'Datebankhost, d'Datebank Benotzer, d'Datebankpasswuertvariablen liesen, dann ass et ideal. Dir hutt Uwendungen a véier verschiddene Sprooche konfiguréiert am Datebankplang op déiselwecht Manéier. Et gi keng verschidde Konfiguratiounen méi.

Alles kann mat ENV Verännerlechen konfiguréiert ginn. Wa mir iwwer Kubernetes schwätzen, gëtt et e super Wee fir ENV Variablen direkt an der Deployment ze deklaréieren. Deementspriechend, wa mir vu geheime Daten schwätzen, da kënne mir direkt geheim Daten aus ENV Variablen (Passwierder an Datenbanken, etc.) an e Geheimnis drécken, e geheime Cluster erstellen an an der ENV Beschreiwung an der Deployment uginn datt mir net direkt deklaréieren de Wäert vun dëser Variabel, an de Wäert vun dëser Datebank Passwuert Variabel wäert aus dem geheime gelies ginn. Dëst ass Standard Kubernetes Verhalen. An dëst ass déi ideal Optioun fir Är Uwendungen ze konfiguréieren. Just um Code Niveau, erëm dat gëllt fir Entwéckler. Wann Dir DevOps sidd, kënnt Dir froen: "Jungs, léiert w.e.g. Är Uwendung fir Ëmfeldvariablen ze liesen. A mir wäerten all frou sinn."

Wann jiddereen an der Firma déiselwecht benannt Ëmfeldvariablen liest, dann ass dat super. Fir datt et net geschitt, datt déi eng op d'Postgres-Datebank waarden, déi aner op den Datenbanknumm, déi aner op eppes anescht waarden, déi aner op eng dbn vun iergendenger Aart waarden, sou datt deementspriechend Uniformitéit gëtt.

De Problem kënnt wann Dir sou vill Ëmfeldvariablen hutt datt Dir just Deployment opmaacht - an et gi fënnefhonnert Zeilen vun Ëmfeldvariablen. An dësem Fall, hutt Dir einfach Ëmfeld Variablen outgrown - an Dir braucht net méi selwer ze Folter. An dësem Fall wier et Sënn fir Konfiguratiounen ze benotzen. Dat ass, trainéiert Är Applikatioun fir Configuratiounen ze benotzen.

Déi eenzeg Fro ass datt d'Konfiguratioun net ass wat Dir denkt. Config.pi ass keng Configuratioun déi bequem ass ze benotzen. Oder e puer Konfiguratioun an Ärem eegene Format, alternativ talentéiert - dëst ass och net d'Konfiguratioun déi ech mengen.

Wat ech schwätzen ass d'Konfiguratioun an akzeptablen Formater, dat ass, bei wäitem de populärste Standard ass den .yaml Standard. Et ass kloer wéi et ze liesen, et ass mënschlech liesbar, et ass kloer wéi et aus der Applikatioun gelies gëtt.

Deementspriechend, nieft YAML, kënnt Dir och, zum Beispill, JSON benotzen, Parsing ass ongeféier sou praktesch wéi YAML wat d'Applikatiounskonfiguratioun vun do aus liesen. Et ass däitlech méi onbequem fir d'Leit ze liesen. Dir kënnt de Format probéieren, a la ini. Et ass zimmlech bequem ze liesen, aus enger mënschlecher Siicht, awer et kann onbequem sinn et automatesch ze veraarbecht, am Sënn datt wann Dir jeemools Är eege Konfiguratioune wëllt generéieren, kann den ini Format scho onbequem sinn ze generéieren.

Awer op alle Fall, egal wéi ee Format Dir wielt, de Punkt ass datt aus Kubernetes Siicht et ganz bequem ass. Dir kënnt Är ganz Konfiguratioun a Kubernetes setzen, an der ConfigMap. An dann huelt dës Configmap a frot se fir an Ärem Pod an engem spezifesche Verzeechnes montéiert ze ginn, wou Är Applikatioun d'Konfiguratioun vun dëser Configmap liest wéi wann et just eng Datei wier. Dëst ass tatsächlech wat gutt ass ze maachen wann Dir vill Konfiguratiounsoptiounen an Ärer Applikatioun hutt. Oder et ass just eng Zort komplex Struktur, et gëtt Nesting.

Wann Dir e Configmap hutt, da kënnt Dir ganz gutt Är Applikatioun léieren, zum Beispill, automatesch Ännerungen an der Datei ze verfolgen wou d'Configmap montéiert ass, an och automatesch Är Applikatioun nei lueden wann d'Konfiguratioune änneren. Dëst wier allgemeng eng ideal Optioun.

Nach eng Kéier hunn ech schonn iwwer dëst geschwat - geheim Informatioun ass net an der Configmap, geheim Informatioun ass net a Variablen, geheim Informatioun ass net a Geheimnisser. Vun do un, verbënnt dës geheim Informatioun mat der Diplomatie. Normalerweis späichere mir all Beschreiwunge vu Kubernetes Objekter, Deployementer, Configmaps, Servicer am git. Deementspriechend, d'Passwuert an d'Datebank an Git ze setzen, och wann et Äre Git ass, deen Dir intern an der Firma hutt, ass eng schlecht Iddi. Well, op e Minimum, git erënnert alles an einfach Passwierder vun do ewechzehuelen ass net sou einfach.

Gesondheetscheck

Den nächste Punkt ass dës Saach genannt Gesondheetscheck. Am Allgemengen ass e Gesondheetscheck einfach kontrolléiert datt Är Uwendung funktionnéiert. Zur selwechter Zäit schwätze mir meeschtens vu bestëmmte Webapplikatiounen, fir déi deementspriechend aus der Siicht vun der Gesondheetscheck (et ass besser net hei a weider ze iwwersetzen) dëst eng speziell URL wäert sinn, déi se als Veraarbechtung veraarbecht hunn. e Standard, si maachen normalerweis /health.

Wann Dir op dës URL Zougang, deementspriechend, seet eis Applikatioun entweder "jo, okay, alles ass gutt mat mir, 200" oder "nee, alles ass net gutt mat mir, ongeféier 500." Deementspriechend, wann eis Applikatioun net http ass, net eng Webapplikatioun, schwätze mir elo vun enger Aart Daemon, kënne mir erausfannen wéi mir Gesondheetschecken maachen. Dat ass, et ass net néideg, wann d'Applikatioun net http ass, da funktionnéiert alles ouni Gesondheetscheck an dëst kann op kee Fall gemaach ginn. Dir kënnt periodesch e puer Informatioun an der Datei aktualiséieren, Dir kënnt mat engem speziellen Kommando fir Ären Daemon kommen, wéi, daemon status, wat seet "Jo, alles ass gutt, den Daemon funktionnéiert, et ass lieweg."

Fir wat ass et? Déi éischt an offensichtlechst Saach ass wahrscheinlech firwat e Gesondheetscheck gebraucht gëtt - fir ze verstoen datt d'Applikatioun funktionnéiert. Ech mengen, et ass einfach domm, wann et elo op ass, gesäit et aus wéi wann et funktionnéiert, also kënnt Dir sécher sinn datt et funktionnéiert. An et stellt sech eraus datt d'Applikatioun leeft, de Container leeft, d'Instanz funktionnéiert, alles ass gutt - an dann hunn d'Benotzer schonn all d'Telefonsnummere vun der technescher Ënnerstëtzung ofgeschnidden a soen "wat sidd Dir ..., du ass geschlof, näischt funktionnéiert."

E Gesondheetscheck ass just esou e Wee fir aus der Siicht vum Benotzer ze gesinn datt et funktionnéiert. Eng vun de Methoden. Loosst eis et esou soen. Aus der Siicht vu Kubernetes ass dëst och e Wee fir ze verstoen wéini d'Applikatioun ufänkt, well mir verstinn datt et en Ënnerscheed ass tëscht wéini de Container gestart, erstallt a gestart gouf, a wéini d'Applikatioun direkt an dësem Container gestart gouf. Well wa mir eng duerchschnëttlech Java-Applikatioun huelen a probéieren se am Dock ze lancéieren, da fir ongeféier véierzeg Sekonnen, oder souguer eng Minutt, oder souguer zéng, kann et gutt ufänken. An dësem Fall kënnt Dir op d'mannst op seng Häfen klappen, et wäert net do äntweren, dat heescht, et ass nach net prett fir Traffic ze kréien.

Nach eng Kéier, mat der Hëllef vun engem Gesondheetscheck a mat der Tatsaach, datt mir hei dréinen, kënne mir a Kubernetes verstoen datt net nëmmen de Container an der Applikatioun eropgaang ass, awer d'Applikatioun selwer huet ugefaang, et reagéiert schonn op d' Gesondheetscheck, dat heescht mir kënnen de Verkéier dohinner schécken.

Wat ech elo schwätzen ass Bereetschaft / Liveness Tester bannent Kubernetes deementspriechend sinn eis Bereetschaft Tester verantwortlech fir d'Disponibilitéit vun der Applikatioun am Balance; Dat ass, wann Bereetschaft Tester an der Applikatioun gemaach ginn, dann ass alles ok, Client Traffic geet op d'Applikatioun. Wann d'Bereetschaftstester net duerchgefouert ginn, da mécht d'Applikatioun einfach net mat, dës speziell Instanz bedeelegt net un d'Balance, et gëtt aus dem Balance geläscht, de Client Traffic fléisst net. Deementspriechend sinn Liveness Tester bannent Kubernetes gebraucht fir datt wann d'Applikatioun festhält, se nei gestart ka ginn. Wann de Liveness Test net funktionnéiert fir eng Applikatioun déi a Kubernetes deklaréiert ass, da gëtt d'Applikatioun net nëmmen aus dem Balance geläscht, se gëtt nei gestart.

An hei ass e wichtege Punkt, deen ech wëll ernimmen: aus praktescher Siicht gëtt de Bereetschaftstest normalerweis méi dacks benotzt a méi dacks gebraucht wéi de Liveness Test. Dat ass, einfach Gedankenlos souwuel Bereetschaft wéi och Liveness Tester ze deklaréieren, well Kubernetes dat maache kann, a loosst eis alles benotzen wat et maache kann, ass net eng ganz gutt Iddi. Ech erkläre firwat. Well Punkt Nummer zwee am Test ass, datt et eng gutt Iddi wier de Basisdaten Service an Äre Gesondheetschecken ze kontrolléieren. Dëst bedeit datt wann Dir eng Webapplikatioun hutt déi e puer Informatioune gëtt, déi se dann natierlech iergendwou muss huelen. An enger Datebank, zum Beispill. Gutt, et späichert d'Informatioun déi an dës REST API an déiselwecht Datebank kënnt. Dann, deementspriechend, wann Äre Gesondheetscheck einfach reagéiert wéi kontaktéiert Slashhealth, seet d'Applikatioun "200, okay, alles ass gutt", a gläichzäiteg ass d'Datebank vun Ärer Applikatioun net zougänglech, an d'Gesondheetscheck-Applikatioun seet "200, okay, alles ass gutt " - Dëst ass eng schlecht Gesondheetscheck. Esou soll et net funktionéieren.

Dat ass, Är Demande, wann eng Demande zu et kënnt /health, et reagéiert net nëmmen, "200, ok", et geet fir d'éischt zum Beispill an d'Datebank, probéiert domat ze verbannen, mécht eppes ganz Basis do, wéi wielt een, kontrolléiert just datt et eng Verbindung an der Datebank an Dir kënnt d'Datebank ufroen. Wann dat alles erfollegräich war, dann ass d'Äntwert "200, ok." Wann et net erfollegräich ass, seet et datt et e Feeler ass, d'Datebank ass net verfügbar.

Dofir, an dëser Hisiicht, ginn ech erëm zréck op d'Bereetschafts-/Liveness-Tester - firwat Dir héchstwahrscheinlech e Readiness-Test braucht, awer e Liveness-Test ass a Fro. Well wann Dir d'Gesondheetschecken genau beschreiwt wéi ech grad gesot hunn, da stellt sech eraus datt et am Instanz Deel net verfügbar assв или со всех instancean enger Datebank, zum Beispill. Wann Dir e Bereetschaftstest deklaréiert hutt, hunn eis Gesondheetschecken ugefaang ze versoen, an deementspriechend all Uwendungen, aus deenen d'Datebank net zougänglech ass, ginn se einfach aus Balance ausgeschalt an tatsächlech "hänken" just an engem vernoléissegten Zoustand a waart op hir Datenbanken schaffen.

Wa mir e Liveness-Test deklaréiert hunn, stellt Iech vir, eis Datebank ass gebrach, an an Ärem Kubernetes fänkt d'Halschent vun allem un ze starten, well de Liveness-Test feelt. Dëst bedeit datt Dir musst nei starten. Dëst ass guer net wat Dir wëllt, ech hat souguer perséinlech Erfahrung an der Praxis. Mir haten eng Chat-Applikatioun déi an JS geschriwwe gouf an an eng Mongo Datebank gefüttert gouf. An de Problem war datt et am Ufank vu menger Aarbecht mat Kubernetes war, mir beschriwwen d'Bereetschaft, d'Liveness vun Tester op de Prinzip datt Kubernetes et maache kann, also wäerte mir et benotzen. Deementspriechend gouf de Mongo iergendwann e bëssen "déif" an d'Probe huet ugefaang ze versoen. Deementspriechend, laut dem Reentest, hunn d'Hënn ugefaang ze "killen".

Wéi Dir verstitt, wann se "dout" sinn, ass dëst en Chat, dat heescht, et gi vill Verbindunge vu Clienten déi drop hänken. Si ginn och "gekillt" - nee, net Clienten, nëmme Verbindungen - net all zur selwechter Zäit, a wéinst der Tatsaach datt se net zur selwechter Zäit ëmbruecht ginn, e puer méi fréi, e puer méi spéit, fänken se net gläichzäiteg un Zäit. Plus Standard zoufälleg, mir kënnen net mat Millisekonnen Genauegkeet d'Startzäit vun der Applikatioun all Kéier virauszesoen, sou datt se et eng Instanz gläichzäiteg maachen. Een Infospot klëmmt, gëtt an d'Balance bäigefüügt, all Cliente kommen dohinner, et kann esou eng Laascht net ausstoen, well et eleng ass, an ongeféier geschwat, do schaffen eng Dose vun hinnen, an et fällt. Deen nächste geet erop, déi ganz Laascht ass op hien, hie fällt och. Gutt, dës Falen kaskade just weider. Zum Schluss, wéi dëst geléist gouf - mir hu just de Benotzerverkéier op dës Applikatioun strikt misse stoppen, all Instanzen eropgoen loossen an dann all User Traffic op eemol starten, sou datt et schonn ënner all zéng Instanzen verdeelt gouf.

Wann et net gewiescht wier datt dësen Liveness Test ugekënnegt gouf, deen alles forcéiere géif nei ze starten, hätt d'Applikatioun et gutt gehandhabt. Awer alles vum Balance ass fir eis behënnert, well d'Datenbanken net zougänglech sinn an all Benotzer "ofgefall sinn". Dann, wann dës Datebank verfügbar ass, ass alles am Balance abegraff, awer d'Applikatioune mussen net erëm ufänken, an et ass net néideg Zäit a Ressourcen ze verschwenden. Si sinn all schonn hei, si si prett fir de Traffic, sou datt de Traffic just op ass, alles ass gutt - d'Applikatioun ass op der Plaz, alles funktionnéiert weider.

Dofir, Bereetschaft an liveness Tester sinn verschidden, och desweideren, Dir kënnt theoretesch verschidde Gesondheet Kontrollen maachen, een Typ Radius, een Typ Liv, zum Beispill, a kontrolléieren verschidde Saachen. Wärend Bereetschaftstester, kontrolléiert Är Backends. An op engem Liveness Test, zum Beispill, kontrolléiert Dir net aus der Siicht datt de Liveness Test allgemeng just eng Applikatioun ass, déi reagéiert, wann se fäeg ass ze reagéieren.

Well de Liewenstest, am grousse Ganzen, ass wa mir "stécken". Eng endlos Loop huet ugefaang oder soss eppes - a keng Ufroe méi ginn veraarbecht. Dofir ass et Sënn fir se souguer ze trennen - an aner Logik an hinnen ëmzesetzen.

Wat Dir musst beäntweren wann Dir en Test hutt, wann Dir Gesondheetschecken maacht. Et ass just wierklech e Péng. Déi, déi dëst vertraut sinn, wäerte wahrscheinlech laachen - awer eescht, ech hunn Servicer a mengem Liewen gesinn, déi an 200% vun de Fäll "XNUMX" beäntweren. Dat ass, wien erfollegräich ass. Awer gläichzäiteg am Kierper vun der Äntwert schreiwen se "sou an esou e Feeler."

Dat ass, d'Äntwert Status kënnt fir Iech - alles ass erfollegräich. Awer gläichzäiteg musst Dir de Kierper analyséieren, well de Kierper seet "entschëllegt, d'Ufro ass mat engem Feeler ofgeschloss" an dëst ass just Realitéit. Ech hunn dat am richtege Liewen gesinn.

A fir datt verschidde Leit et net witzeg fannen, an anerer fannen et ganz schmerzhaf, ass et ëmmer nach derwäert un eng einfach Regel ze halen. A Gesondheetschecken, an am Prinzip wann Dir mat Webapplikatiounen schafft.

Wann alles gutt gaang ass, da reagéiert mat der zweehonnertst Äntwert. Am Prinzip passt all zweehonnertst Äntwert Iech. Wann Dir ragsy ganz gutt liesen a wëssen, datt e puer Äntwert Status vun aneren anescht sinn, Äntwert mat de passenden: 204, 5, 10, 15, wat och ëmmer. Wann et net ganz gutt ass, dann just "zwee null null." Wann alles schlecht geet an d'Gesondheetscheck net reagéiert, dann äntwert mat engem fënnefhonnertstel. Nach eng Kéier, wann Dir versteet wéi Dir reagéiert, wéi verschidde Äntwertstatuse vuneneen ënnerscheeden. Wann Dir et net versteet, dann ass 502 Är Optioun fir op Gesondheetschecken ze reagéieren wann eppes falsch geet.

Dëst ass en anere Punkt, ech wëll e bëssen zréckkommen iwwer d'Basisdéngschter ze kontrolléieren. Wann Dir ufänkt, zum Beispill, all déi ënnerierdesch Servicer ze kontrolléieren déi hannert Ärer Applikatioun stinn - alles am Allgemengen. Wat mir aus der Siicht vun der Mikroservicearchitektur kréien, hu mir sou e Konzept wéi "niddereg Kupplung" - dat ass, wann Är Servicer minimal vuneneen ofhängeg sinn. Wann ee vun hinnen klappt, wäerten all déi aner ouni dës Funktionalitéit einfach weider schaffen. E puer vun der Funktionalitéit funktionnéiert einfach net. Deementspriechend, wann Dir all d'Gesondheetschecken unenee verbënnt, da wäert Dir um Enn eng Saach an d'Infrastruktur falen, a well se gefall ass, fänken och all d'Gesondheetschecken vun alle Servicer un - an et gëtt méi Infrastrukturen allgemeng fir de ganz Mikroservice Architektur Nr. Do ass alles däischter gaangen.

Dofir wëll ech dat nach eng Kéier widderhuelen datt Dir déi ënnerierdesch Servicer kontrolléiere musst, déi ouni déi Är Demande an honnert Prozent vun de Fäll net seng Aarbecht maache kann. Dat ass, et ass logesch datt wann Dir e REST API hutt, duerch deen de Benotzer an d'Datebank späichert oder aus der Datebank zréckkënnt, dann an der Verontreiung vun enger Datebank, kënnt Dir d'Aarbecht mat Äre Benotzer net garantéieren.

Awer wann Är Benotzer, wann Dir se aus der Datebank eraushuelt, zousätzlech mat e puer anere Metadaten beräichert sinn, vun engem aneren Backend, deen Dir agitt ier Dir eng Äntwert op de Frontend schéckt - an dëse Backend ass net verfügbar, heescht dat datt Dir Är Äntwert ouni Deel vun de Metadaten.

Als nächst hu mir och ee vun de schmerzhafte Probleemer beim Start vun Uwendungen.

Tatsächlech gëlt dëst net nëmme fir Kubernetes am grousse Ganzen, et ass just sou geschitt datt d'Kultur vun enger Aart vu Massentwécklung a besonnesch DevOps ongeféier d'selwescht Zäit wéi Kubernetes ugefaang huet. Dofir, am grousse Ganzen, stellt sech eraus datt Dir Är Applikatioun graziéis ouni Kubernetes musst zoumaachen. Och virum Kubernetes hunn d'Leit dat gemaach, awer mat der Optriede vu Kubernetes hu mir ugefaang masseg doriwwer ze schwätzen.

Graceful Shutdown

Am Allgemengen, wat ass Graceful Shutdown a firwat ass et néideg? Dëst ass ongeféier wann Är Applikatioun aus irgendege Grënn crasht, musst Dir maachen app stop - oder Dir kritt zum Beispill e Signal vum Betribssystem, Är Applikatioun muss et verstoen an eppes doriwwer maachen. De schlëmmste Fall Szenario ass natierlech wann Är Uwendung e SIGTERM kritt an ass wéi "SIGTERM, loosst eis hänken, schaffen, näischt maachen." Dëst ass eng richteg schlecht Optioun.

Eng bal gläich schlecht Optioun ass wann Är Applikatioun e SIGTERM kritt an ass wéi "si soten segterm, dat heescht datt mir ophalen, ech hunn net gesinn, ech kennen keng Benotzerufroen, ech weess net wéi eng Zort vun Ufroen un déi ech elo schaffen, si soten SIGTERM, dat heescht datt mir ophalen " Dëst ass och eng schlecht Optioun.

Wéi eng Optioun ass gutt? Den éischte Punkt ass d'Ofschloss vun Operatiounen Rechnung ze huelen. Eng gutt Optioun ass datt Äre Server nach ëmmer berücksichtegt wat et mécht wann en e SIGTERM kritt.

SIGTERM ass e mëllen Shutdown, et ass speziell entworf, et kann um Codeniveau ofgefaang ginn, et kann veraarbecht ginn, sot elo, waart, mir wäerte fir d'éischt d'Aarbecht fäerdeg maachen, déi mir hunn, da gi mir eraus.

Aus enger Kubernetes Perspektiv ass dëst wéi et ausgesäit. Wa mir zu engem Pod soen, deen am Kubernetes-Cluster leeft, "Stop w.e.g., gitt fort", oder mir ginn nei gestart, oder en Update geschitt wann Kubernetes d'Pods erstallt, schéckt Kubernetes just déiselwecht SIGTERM Message un de Pod, waart op e puer Zäit, an , Dëst ass d'Zäit datt hien waart, et ass och konfiguréiert, et gëtt sou e spezielle Parameter an Diplomer an et gëtt Graceful ShutdownTimeout genannt. Wéi Dir verstitt, heescht et net fir näischt, an et ass net fir näischt, datt mir elo doriwwer schwätzen.

Do kënne mir spezifesch soen wéi laang mir musse waarden tëscht der Zäit wou mir SIGTERM an d'Applikatioun schécken a wa mir verstinn datt d'Applikatioun schéngt verréckt ze sinn fir eppes oder "steckt" an net wäert ophalen - a mir mussen schéckt et SIGKILL, dat ass, schwéier seng Aarbecht komplett. Dat ass, deementspriechend, mir hunn eng Aart Daemon lafen, et veraarbecht Operatiounen. Mir verstinn datt am Duerchschnëtt eis Operatiounen op deenen den Daemon funktionnéiert net méi wéi 30 Sekonnen gläichzäiteg daueren. Deementspriechend, wann SIGTERM ukomm ass, verstinn mir datt eisen Daemon maximal 30 Sekonnen nom SIGTERM fäerdeg ass. Mir schreiwen et, zum Beispill, 45 Sekonnen just am Fall a soen, datt SIGTERM. Duerno waarden mir 45 Sekonnen. An der Theorie, während dëser Zäit soll den Dämon seng Aarbecht ofgeschloss hunn a sech selwer ofgeschloss hunn. Awer wann et op eemol net konnt, heescht et datt et héchstwahrscheinlech festhält - et veraarbecht eis Ufroe net méi normalerweis. An a 45 Sekonnen kënnt Dir him sécher Neel.

An hei kënnen eigentlech och 2 Aspekter berücksichtegt ginn. Als éischt, verstitt datt wann Dir eng Demande kritt hutt, Dir ugefaang iergendwéi mat ze schaffen an de Benotzer keng Äntwert ginn hutt, awer Dir hutt zum Beispill SIGTERM kritt. Et mécht Sënn et ze verfeineren an de Benotzer eng Äntwert ze ginn. Dëst ass Punkt Nummer eent an dëser Hisiicht. Punkt Nummer zwee hei ass datt wann Dir Är eege Applikatioun schreift, allgemeng d'Architektur esou baut datt Dir eng Ufro fir Är Applikatioun kritt, da fänkt Dir un, ufänkt Dateien iergendwou erofzelueden, eng Datebank erofzelueden, a wat net. Dat. Am Allgemengen, Äre Benotzer, Är Demande hänkt fir eng hallef Stonn a waart fir Iech him ze äntweren - dann, héchstwahrscheinlech, musst Dir un der Architektur schaffen. Dat ass, huelen just Rechnung souguer gesonde Mënscheverstand, datt wann Är Operatiounen kuerz sinn, dann mécht et Sënn SIGTERM ze ignoréieren an änneren. Wann Är Operatiounen laang sinn, dann mécht et kee Sënn SIGTERM an dësem Fall ze ignoréieren. Et mécht Sënn fir d'Architektur nei ze designen fir sou laang Operatiounen ze vermeiden. Also datt d'Benotzer net nëmmen hänken a waarden. Ech weess et net, maacht eng Zort Websocket do, maacht ëmgedréint Haken, déi Äre Server schonn un de Client schéckt, soss eppes, awer zwéngt de Benotzer net fir eng hallef Stonn ze hänken a waart just op eng Sessioun bis Dir äntwert him. Well et ass onberechenbar wou et kéint briechen.

Wann Är Applikatioun ofgeschloss ass, sollt Dir e passenden Ausgangscode ubidden. Dat ass, wann Är Demande gefrot gouf zouzemaachen, opzehalen, an et konnt sech selwer normal ophalen, da musst Dir net eng Zort Ausgangscode 1,5,255 zréckginn an sou weider. Alles wat net Nullcode ass, op d'mannst a Linux Systemer, ech si sécher dovun, gëtt als net erfollegräich ugesinn. Dat ass, et gëtt ugeholl datt Är Demande an dësem Fall mat engem Feeler ofgeschloss ass. Deementspriechend, op eng frëndlech Manéier, wann Är Uwendung ouni Feeler ofgeschloss ass, seet Dir 0 op der Ausgab. Wann Är Applikatioun aus irgendege Grënn feelt, seet Dir net-0 am Ausgang. An Dir kënnt mat dëser Informatioun schaffen.

An déi lescht Optioun. Et ass schlecht wann Äre Benotzer eng Ufro schéckt an eng hallef Stonn hänkt wärend Dir se veraarbecht. Mee am Allgemengen, géif ech gären och soen iwwer wat allgemeng wäert aus dem Client senger Säit ass. Et ass egal ob Dir eng mobil Applikatioun, Front-End, etc. Et ass néideg ze berücksichtegen datt allgemeng d'Sessioun vum Benotzer kann ofgeschloss ginn, alles ka geschéien. Eng Demande kann geschéckt ginn, zum Beispill, underprocessed a keng Äntwert zréck. Äre Frontend oder Är mobil Applikatioun - all Frontend am Allgemengen, loosst eis et esou soen - sollt dëst Rechnung droen. Wann Dir mat Websockets schafft, ass dëst allgemeng de schlëmmste Péng, deen ech jeemools haten.

Wann d'Entwéckler vun e puer reguläre Chats dat net wëssen, stellt sech eraus, de Websocket ka briechen. Fir si, wann eppes am Proxy geschitt, änneren mir just d'Konfiguratioun, an et mécht e Reload. Natierlech sinn all laanglieweg Sessiounen an dësem Fall zerräissen. Entwéckler kommen bei eis lafen a soen: "Jongen, wat maacht Dir, de Chat ass fir all eis Clienten opgebrach!" Mir soen hinnen: "Wat maacht Dir? Sinn Är Clienten net fäeg nei ze konnektéieren? Si soen: "Nee, mir brauchen d'Sessioune fir net ze räissen." Kuerz gesot, dëst ass eigentlech Nonsens. D'Client Säit muss berücksichtegt ginn. Besonnesch, wéi ech soen, mat laangliewege Sessiounen wéi Websockets, kann et briechen an, onnotéiert vum Benotzer, musst Dir fäeg sinn esou Sessiounen nei z'installéieren. An dann ass alles perfekt.

Ressourcen

Eigentlech, hei wäert ech Iech just eng direkt Geschicht erzielen. Erëm aus dem richtege Liewen. Déi krankst Saach, déi ech jeemools iwwer Ressourcen héieren hunn.

Ressourcen an dësem Fall, ech mengen eng Aart vun Ufroen, Limiten déi Dir op Pods an Äre Kubernetes Cluster setzen kënnt. Déi witzegst Saach, déi ech vun engem Entwéckler héieren hunn ... Ee vun mengen Matbierger Entwéckler op enger fréierer Aarbechtsplaz sot eemol: "Meng Applikatioun fänkt net am Cluster un." Ech hu gekuckt fir ze gesinn datt et net ugefaang huet, awer entweder huet et net an d'Ressourcen gepasst, oder si hu ganz kleng Grenzen gesat. Kuerz gesot, d'Applikatioun kann net starten wéinst Ressourcen. Ech soen: "Et fänkt net un wéinst Ressourcen, Dir entscheet wéi vill Dir braucht a setzt en adäquate Wäert." Hie seet: "Wat fir eng Ressourcen?" Ech ugefaang him ze erklären, datt Kubernetes, Grenzen op Ufroen a bla, bla, bla muss gesat ginn. De Mann huet fënnef Minutten nolauschtert, wénkt a sot: "Ech sinn heihinner komm fir als Entwéckler ze schaffen, ech wëll näischt iwwer Ressourcen wëssen. Ech sinn hei komm fir Code ze schreiwen an dat ass et. Et ass traureg. Dëst ass e ganz traurege Konzept aus der Siicht vum Entwéckler. Besonnesch an der moderner Welt, souzesoen, vu progressiven Devops.

Firwat sinn iwwerhaapt Ressourcen gebraucht? Et ginn 2 Aarte vu Ressourcen a Kubernetes. E puer ginn Ufroe genannt, anerer ginn Limiten genannt. Mat Ressourcen wäerte mir verstoen datt et am Fong ëmmer nëmmen zwou Basisbeschränkungen sinn. Dat ass, CPU Zäit Grenzen an RAM Grenzen fir e Container Lafen an Kubernetes.

Eng Limit setzt eng iewescht Limit op wéi eng Ressource an Ärer Applikatioun benotzt ka ginn. Dat ass, deementspriechend, wann Dir 1GB vum RAM an de Grenzen seet, da wäert Är Applikatioun net méi wéi 1GB vum RAM benotzen. A wann hien op eemol wëll a probéiert dëst ze maachen, da wäert e Prozess genannt oom Killer, aus Erënnerung, dat heescht, kommen an Är Applikatioun ëmbréngen - dat ass, et wäert einfach nei starten. Uwendungen wäerten net op Basis vun der CPU nei starten. Am Sënn vun der CPU, wann eng Applikatioun probéiert vill ze benotzen, méi wéi an de Grenzen spezifizéiert, gëtt d'CPU einfach strikt ausgewielt. Dëst féiert net zu Restarts. Dëst ass d'Limite - dat ass déi iewescht Grenz.

An et gëtt eng Demande. Eng Ufro ass wéi Kubernetes versteet wéi d'Noden an Ärem Kubernetes Cluster mat Uwendungen populéiert sinn. Dat ass, eng Demande ass eng Zort Engagement vun Ärer Demande. Et seet wat ech benotze wëll: "Ech hätt gär datt Dir sou vill CPU an esou vill Erënnerung fir mech reservéiert." Sou eng einfach Analogie. Wat wa mir en Node hunn, deen ech weess net, 8 CPUs am Ganzen. An e Pod kënnt dohinner, deem seng Ufroe soen 1 CPU, dat heescht datt den Node 7 CPUs lénks huet. Dat ass, deementspriechend, soubal 8 Pods bei dësem Node ukommen, jidderee vun deenen 1 CPU an hiren Ufroen huet, den Node, wéi aus der Siicht vu Kubernetes, aus der CPU ausgelaf ass a méi Pods mat Ufroe kënnen net sinn op dësem Node lancéiert. Wann all d'Noden aus der CPU lafen, da fänkt de Kubernetes un ze soen datt et keng gëeegent Noden am Cluster sinn fir Är Pods auszeféieren, well d'CPU ausgelaf ass.

Firwat sinn Ufroe gebraucht a firwat ouni Ufroen, ech mengen et ass net néideg eppes a Kubernetes ze starten? Loosst eis eng hypothetesch Situatioun virstellen. Dir lancéiert Är Applikatioun ouni Ufroen, Kubernetes weess net wéi vill vun deem Dir hutt, op wéi eng Noden Dir et drécke kënnt. Ma, hien dréckt, dréckt, dréckt op d'Knuet. Irgendwann fänkt Dir un Traffic op Är Applikatioun ze kréien. An eng vun den Uwendungen fänkt op eemol un Ressourcen ze benotzen bis zu de Grenzen déi se no de Grenzen huet. Et stellt sech eraus datt et eng aner Applikatioun an der Géigend ass an et brauch och Ressourcen. De Node fänkt eigentlech kierperlech aus Ressourcen ze lafen, Zum Beispill, OP. De Node fänkt eigentlech kierperlech aus Ressourcen, Zum Beispill, zoufälleg Zougang Erënnerung (RAM). Wann e Knuet aus Kraaft leeft, stoppt als éischt den Docker ze reagéieren, dann de Cubelet, dann d'OS. Si ginn einfach onbewosst an ALLES wäert definitiv ophalen fir Iech ze schaffen. Dat ass, dëst féiert dozou datt Ären Node festhält an Dir musst et nei starten. Kuerz gesot, d'Situatioun ass net ganz gutt.

A wann Dir Ufroen hutt, sinn d'Limiten net ganz anescht, op d'mannst net vill Mol méi wéi d'Limiten oder Ufroen, da kënnt Dir sou eng normal, rational Fëllung vun Uwendungen iwwer Noden vu Kubernetes Cluster hunn. Zur selwechter Zäit ass Kubernetes ongeféier bewosst wéi vill vun deem et wou setzt, wéi vill vun deem wou benotzt gëtt. Dat ass, et ass just esou e Moment. Et ass wichteg et ze verstoen. An et ass wichteg ze kontrolléieren datt dëst uginn ass.

Datenspeicher

Eise nächste Punkt ass iwwer Datelagerung. Wat mat hinnen ze maachen an am Allgemengen, wat mat Persistenz zu Kubernetes ze maachen?

Ech mengen, erëm, bannent eisem Owend Schoul, et gouf en Thema iwwer d'Datebank zu Kubernetes. An et schéngt mir datt ech souguer ongeféier weess wat Är Kollegen Iech gesot hunn wéi se gefrot goufen: "Ass et méiglech eng Datebank op Kubernetes ze lafen?" Aus e puer Grënn schéngt et mir datt Är Kollegen Iech sollten soen datt wann Dir d'Fro stellt, ob et méiglech ass eng Datebank zu Kubernetes ze lafen, dann ass et onméiglech.

D'Logik hei ass einfach. Just am Fall, wäert ech nach eng Kéier erklären, wann Dir e wierklech coolen Typ sidd, deen e zimlech Feeler-tolerante System vu verdeelt Netzwierklagerung ka bauen, verstitt wéi Dir eng Datebank an dëse Fall passt, wéi Cloud native a Container soll funktionnéieren an enger Datebank am Allgemengen. Wahrscheinlech hutt Dir keng Fro iwwer wéi Dir et leeft. Wann Dir esou eng Fro hutt, an Dir wëllt sécherstellen datt et alles entfalt a richteg zum Doud an der Produktioun steet an ni fällt, da geschitt dat net. Dir sidd garantéiert Iech selwer an de Fouss mat dëser Approche ze schéissen. Dofir ass et besser net ze maachen.

Wat solle mir mat den Donnéeën maachen, déi eis Applikatioun späichere wëllt, e puer Biller, déi d'Benotzer eroplueden, e puer Saachen, déi eis Applikatioun generéiert wärend senger Operatioun, zum Beispill beim Start? Wat mat hinnen zu Kubernetes ze maachen?

Am Allgemengen, am Idealfall, jo, natierlech, Kubernetes ass ganz gutt entworf a gouf allgemeng ufanks fir stateless Uwendungen konzipéiert. Dat ass, fir déi Uwendungen déi guer keng Informatioun späicheren. Dëst ass ideal.

Awer natierlech ass déi ideal Optioun net ëmmer. Also wat? Den éischten an einfachste Punkt ass eng Zort S3 ze huelen, just net eng hausgemaachte, déi och onkloer ass wéi et funktionnéiert, awer vun engem Provider. E gudden, normale Provider - a léiert Är Applikatioun S3 ze benotzen. Dat ass, wann Äre Benotzer eng Datei eropluede wëllt, sot "hei, w.e.g. lued se op S3 erop." Wann hien et wëll kréien, sot: "Hei ass e Link op S3 zréck an huelt et vun hei." Dëst ass ideal.

Wann op eemol aus iergendengem Grond dës ideal Optioun net gëeegent ass, Dir hutt eng Applikatioun déi Dir net geschriwwen hutt, Dir entwéckelt net, oder et ass eng Aart vu schrecklecher Legacy, et kann de S3 Protokoll net benotzen, awer muss mat lokalen Verzeichnisser schaffen lokal Classeure. Huelt eppes méi oder manner einfach, deploy Kubernetes. Dat ass, direkt de Ceph fir e puer minimal Aufgaben ze fechen, et schéngt mir, ass eng schlecht Iddi. Well Ceph ass natierlech gutt a moudesch. Awer wann Dir net wierklech versteet wat Dir maacht, dann wann Dir eppes op Ceph gesat hutt, kënnt Dir ganz einfach an einfach ni méi dobaussen erauskommen. Well, wéi Dir wësst, späichert Ceph Daten a sengem Cluster a binärer Form, an net a Form vun einfachen Dateien. Dofir, wann op eemol de Ceph Cluster brécht, da gëtt et eng komplett an héich Wahrscheinlechkeet datt Dir Är Donnéeën ni méi vun do kritt.

Mir wäerten e Cours op Ceph hunn, Dir kënnt vertraut Iech mam Programm a schéckt eng Demande of.

Dofir ass et besser eppes einfach ze maachen wéi en NFS Server. Kubernetes kënne mat hinnen schaffen, Dir kënnt e Verzeechnes ënner engem NFS Server montéieren - Är Applikatioun ass grad wéi e lokale Verzeichnis. Zur selwechter Zäit musst Dir natierlech verstoen datt Dir nach eng Kéier eppes mat Ärem NFS maache musst, Dir musst verstoen datt et heiansdo onzougänglech ka ginn an d'Fro betruecht wat Dir an dësem Fall maache wäert. Vläicht sollt et iergendwou op enger separater Maschinn gebackupt ginn.

Den nächste Punkt iwwer deen ech geschwat hunn ass wat ze maachen wann Är Applikatioun e puer Dateie wärend der Operatioun generéiert. Zum Beispill, wann et ufänkt, generéiert se e puer statesch Datei, déi op e puer Informatioun baséiert, déi d'Applikatioun eréischt beim Start kritt. Wat e Moment. Wann et net vill esou Donnéeën ass, da musst Dir guer net stéieren, just dës Applikatioun fir Iech selwer installéieren a schaffen. Déi eenzeg Fro hei ass wat, kuckt. Ganz oft, all Zorte vu Legacy Systemer, wéi WordPress an sou weider, besonnesch mat modifizéierten eng Aart vu clever Plugins, clever PHP Entwéckler, wësse se oft wéi se et maachen, fir datt se eng Zort Datei fir sech selwer generéieren. Deementspriechend generéiert een eng Datei, déi zweet generéiert eng zweet Datei. Si sinn ënnerschiddlech. Balance geschitt am Kubernetes Cluster vum Client einfach duerch Zoufall. Deementspriechend stellt sech eraus, datt si zum Beispill net wësse wéi se zesumme schaffen. Een gëtt eng Informatioun, déi aner gëtt dem Benotzer eng aner Informatioun. Dëst ass wat Dir sollt vermeiden. Dat ass, a Kubernetes, alles wat Dir lancéiert ass garantéiert a verschidde Fäll ze schaffen. Well Kubernetes ass eng bewegt Saach. Deementspriechend kann hien alles bewegen, wéini e wëll, ouni iwwerhaapt iergendeen ze froen. Dofir musst Dir op dëst zielen. Alles wat an enger Instanz lancéiert gëtt, wäert fréier oder spéider versoen. Der méi Reservatioun Dir hutt, der besser. Awer nach eng Kéier, ech soen, wann Dir e puer esou Dateien hutt, da kënnt Dir se direkt ënnert Iech setzen, si waacht e klenge Betrag. Wann et e bësse méi vun hinnen sinn, sollt Dir se wahrscheinlech net am Container drécken.

Ech géif roden datt et sou eng wonnerbar Saach an Kubernetes ass, Dir kënnt Volumen benotzen. Besonnesch gëtt et e Volume vun Typ eidel Dir. Dat ass, et ass just datt Kubernetes automatesch e Verzeechnes a senge Serviceverzeichnisser um Server erstellt wou Dir ugefaang hutt. An hien wäert Iech et ginn, fir datt Dir et benotze kënnt. Et gëtt nëmmen ee wichtege Punkt. Dat ass, Är Donnéeën ginn net am Container gespäichert, mee am Host op deem Dir leeft. Ausserdeem kënne Kubernetes esou eidel Dirs ënner normaler Konfiguratioun kontrolléieren an ass fäeg hir maximal Gréisst ze kontrolléieren an net ze iwwerschreiden. Deen eenzege Punkt ass datt dat wat Dir an eidelen Dir geschriwwen hutt net während dem Pod-Restart verluer geet. Dat ass, wann Äre Pod duerch Feeler fällt an erëm eropgeet, wäert d'Informatioun am eidelen Dir néierens goen. Hie kann et erëm op engem neie Start benotzen - an dat ass gutt. Wann Äre Pod iergendwou verléisst, da verléisst hien natierlech ouni Daten. Dat ass, soubal de Pod aus dem Node wou et mat eidelen Dir lancéiert gouf verschwënnt, gëtt eidel Dir geläscht.

Wat ass soss gutt iwwer eidel Dir? Zum Beispill kann et als Cache benotzt ginn. Loosst eis virstellen datt eis Applikatioun eppes op der Flucht generéiert, et de Benotzer gëtt an et fir eng laang Zäit mécht. Dofir generéiert d'Applikatioun, zum Beispill, a gëtt et de Benotzer, a gläichzäiteg späichert se iergendwou, sou datt d'nächst Kéier de Benotzer fir déiselwecht Saach kënnt, et méi séier gëtt et direkt generéiert ze ginn. Eidel Dir kënnt Kubernetes gefrot ginn an Erënnerung ze schafen. An dofir kënnen Är Cache generell mat Blitzgeschwindegkeet funktionnéieren - wat d'Disk Access Geschwindegkeet ugeet. Dat ass, Dir hutt en eidelen Dir an der Erënnerung, am OS ass et an der Erënnerung gespäichert, awer fir Iech, fir de Benotzer am Pod, gesäit et aus wéi just e lokale Verzeichnis. Dir braucht d'App net fir spezifesch Magie ze léieren. Dir huelt just Är Datei direkt an e Verzeichnis, awer tatsächlech an Erënnerung am OS. Dëst ass och eng ganz praktesch Feature a punkto Kubernetes.

Wéi eng Problemer huet Minio? Den Haaptproblem mam Minio ass datt fir datt dës Saach funktionnéiert, et muss iergendwou lafen, an et muss eng Aart Dateiesystem sinn, dat heescht Späicheren. An hei stousse mir op déi selwecht Problemer, déi de Ceph huet. Dat ass, Minio muss seng Dateien iergendwou späicheren. Et ass einfach en HTTP-Interface fir Är Dateien. Ausserdeem ass d'Funktionalitéit kloer méi aarm wéi déi vum Amazon S3. Virdrun war et net fäeg de Benotzer richteg ze autoriséieren. Elo, souwäit ech weess, kann et schonn Eemere mat verschiddenen Autorisatioune kreéieren, awer nach eng Kéier schéngt et mir, datt den Haaptproblem, souzesoen, den ënnerierdesche Späichersystem op e Minimum ass.

Wéi beaflosst Empty Dir an Erënnerung d'Limiten? Beaflosst op kee Fall Grenzen. Et läit an der Erënnerung vum Host, an net an der Erënnerung vun Ärem Container. Dat ass, Äre Container gesäit net déi eidel Dir an der Erënnerung als Deel vu senger besat Erënnerung. De Host gesäit dat. Deementspriechend, jo, aus der Siicht vun kubernetes, wann Dir ufänkt dëst ze benotzen, wier et gutt ze verstoen datt Dir en Deel vun Ärer Erënnerung un eidel Dir widmet. An deementspriechend, verstitt datt d'Erënnerung net nëmme wéinst Uwendungen auslafe kann, awer och well een un dës eidel Dir schreift.

Cloudnativitéit

An dat lescht Ënnerthema ass wat Cloudnative ass. Firwat ass et néideg? Cloudnativeness a sou weider.

Dat ass, déi Uwendungen déi fäeg a geschriwwe sinn fir an enger moderner Cloudinfrastruktur ze schaffen. Awer tatsächlech huet Cloudnative en aneren esou Aspekt. Datt dëst net nëmmen eng Applikatioun ass, déi all Ufuerderunge vun enger moderner Cloud-Infrastruktur berücksichtegt, mä och weess wéi een mat dëser moderner Cloud-Infrastruktur schafft, profitéiert vun de Virdeeler an Nodeeler vun der Tatsaach, datt et an dëse Wolleke funktionnéiert. Gitt net nëmmen iwwer Bord a schafft an de Wolleken, awer profitéiert vun de Virdeeler fir an der Wollek ze schaffen.

Loosst eis just Kubernetes als Beispill huelen. Är Applikatioun leeft a Kubernetes. Är Applikatioun kann ëmmer, oder éischter d'Admins fir Är Applikatioun, ëmmer e Servicekonto erstellen. Dat ass, e Kont fir Autorisatioun an Kubernetes selwer a sengem Server. Füügt e puer Rechter déi mir do brauchen. An Dir kënnt Zougang zu Kubernetes aus Ärer Applikatioun. Wat kënnt Dir esou maachen? Zum Beispill, vun der Applikatioun, kritt Daten iwwer wou Är aner Uwendungen, aner ähnlech Instanzen lokaliséiert sinn, an zesummen iergendwéi op Kubernetes clusteren, wann et esou e Besoin ass.

Nach eng Kéier hu mir wuertwiertlech e Fall viru kuerzem. Mir hunn ee Controller deen d'Schlaang iwwerwaacht. A wann e puer nei Aufgaben an dëser Schlaang erschéngen, geet et op Kubernetes - a bannent Kubernetes erstellt en neie Pod. Gëtt dësem Pod eng nei Aufgab an am Kader vun dësem Pod mécht de Pod d'Aufgab, schéckt eng Äntwert op de Controller selwer, an de Controller mécht dann eppes mat dëser Informatioun. Zum Beispill füügt et eng Datebank op. Dat ass, erëm, dëst ass e Plus vun der Tatsaach datt eis Applikatioun a Kubernetes leeft. Mir kënnen déi agebaute Kubernetes Funktionalitéit selwer benotzen fir iergendwéi d'Funktionalitéit vun eiser Applikatioun méi bequem auszebauen an ze maachen. Dat ass, verstoppt keng Aart vu Magie iwwer wéi eng Applikatioun lancéiert gëtt, wéi een en Aarbechter lancéiert. A Kubernetes schéckt Dir einfach eng Ufro an der App wann d'Applikatioun am Python geschriwwe gëtt.

Datselwecht gëlt wa mir iwwer Kubernetes goen. Mir hunn eis Kubernetes iergendwou lafen - et ass gutt wann et an enger Aart vu Wollek ass. Nach eng Kéier kënne mir benotzen, a souguer sollen, ech gleewen, d'Fäegkeete vun der Wollek selwer benotzen, wou mir lafen. Vun den elementar Saachen, déi d'Wollek eis liwwert. Balancéieren, dat heescht, mir kënne Cloud Balancer erstellen an se benotzen. Dëst ass en direkten Virdeel vun deem wat mir kënne benotzen. Well Cloud Balancing, éischtens, einfach domm Verantwortung vun eis hëlt fir wéi et funktionnéiert, wéi et konfiguréiert ass. Plus et ass ganz bequem, well regelméisseg Kubernetes kënne mat Wolleken integréieren.

Datselwecht gëlt fir Skaléieren. Regelméisseg Kubernetes kënne mat Cloud Ubidder integréieren. Wësst wéi ze verstoen datt wann de Stärekoup aus Knäpper leeft, dat heescht de Knuetraum ass ausgaang, da musst Dir derbäisetzen - Kubernetes selwer wäert nei Wirbelen op Äre Stärekoup addéieren an ufänken Pods op hinnen ze starten. Dat ass, wann Är Belaaschtung kënnt, fänkt d'Zuel vun den Hierden erop. Wann d'Noden am Cluster fir dës Pods auslafen, lancéiert Kubernetes nei Noden an deementspriechend kann d'Zuel vun de Pods nach ëmmer eropgoen. An et ass ganz bequem. Dëst ass eng direkt Geleeënheet fir de Stärekoup op der Flucht ze skaléieren. Net ganz séier, am Sënn datt et keng Sekonn ass, et ass méi wéi eng Minutt fir nei Wirbelen ze addéieren.

Awer aus menger Erfahrung, erëm, et ass déi coolst Saach déi ech je gesinn hunn. Wann de Cloudnative Stärekoup skaléiert baséiert op Zäit vum Dag. Et war e Backend Service dee vu Leit am Back Office benotzt gouf. Dat ass, si kommen um 9 Auer op d'Aarbecht, fänken un de System unzemellen, an deementspriechend fänkt de Cloudnative Cluster, wou et alles leeft, ze schwellen, nei Pods lancéieren, sou datt jiddereen, deen op d'Aarbecht kënnt, mat der Applikatioun ka schaffen. Wa se um 8 oder 6 Auer op d'Aarbecht verloossen, mierken d'Kubernetes-Cluster datt keen d'Applikatioun méi benotzt a fänken un ze schrumpelen. Spuere bis zu 30 Prozent si garantéiert. Et huet deemools an Amazon geschafft, deemools war et keen an Russland, deen et esou gutt konnt maachen.

Ech soen Iech direkt, d'Erspuernisser sinn 30 Prozent einfach well mir Kubernetes benotzen a profitéieren vun de Fäegkeeten vun der Wollek. Elo kann dat a Russland gemaach ginn. Ech wäert net fir jiddereen Reklamm, natierlech, mee loosse mer just soen, datt et Fournisseur sinn, déi dëst maachen kann, gëtt et direkt aus der Këscht mat engem Knäppchen.

Et gëtt nach ee leschte Punkt op deen ech och gären Är Opmierksamkeet opmierksam maachen. Fir datt Är Applikatioun, Är Infrastruktur Cloudnative ass, mécht et Sënn fir endlech d'Approche mam Numm Infrastructure als Code unzepassen Applikatioun, Är Geschäftslogik a Form vu Code. A schafft domat als Code, dat heescht, test et, rullt et aus, späichert et a git, gëlt CICD derbäi.

A genee dat erlaabt Iech, éischtens, ëmmer Kontroll iwwer Är Infrastruktur ze hunn, ëmmer ze verstoen a wéi engem Zoustand et ass. Zweetens, vermeit manuell Operatiounen déi Feeler verursaachen. Drëttens, vermeit einfach wat Ëmsaz genannt gëtt, wann Dir dauernd déiselwecht manuell Aufgaben ausféiere musst. Véiertens, et erlaabt Iech vill méi séier ze recuperéieren am Fall vun engem Echec. A Russland, all Kéier wann ech iwwer dëst schwätzen, ginn et ëmmer eng grouss Zuel vu Leit, déi soen: "Jo, et ass kloer, awer Dir hutt Approchen, kuerz, et ass net néideg fir eppes ze fixéieren." Awer et ass wouer. Wann eppes an Ärer Infrastruktur gebrach ass, dann aus der Siicht vun der Cloudnative Approche an aus der Siicht vun der Infrastruktur als Code, anstatt et ze fixéieren, op de Server ze goen, erauszefannen wat gebrach ass an et fixéieren, ass et méi einfach fir de Server ze läschen an erëm ze kreéieren. An ech wäert dat alles restauréieren.

All dës Themen ginn am Detail diskutéiert Kubernetes Video Coursen: Junior, Basic, Mega. Duerch de Link kënnt Dir Iech mam Programm a Konditioune vertraut maachen. Déi bequem Saach ass datt Dir Kubernetes beherrscht andeems Dir vun doheem studéiert oder 1-2 Stonnen den Dag schafft.

Source: will.com