Webapplikatioune ginn elo iwwerall benotzt, an ënner all Transportprotokoller besetzt HTTP den Deel vum Léiw. Wann Dir d'Nuancen vun der Webapplikatiounsentwécklung studéiert, bezuelen déi meescht Leit ganz wéineg Opmierksamkeet op de Betribssystem wou dës Uwendungen tatsächlech lafen. D'Trennung vun Entwécklung (Dev) an Operatiounen (Ops) huet d'Situatioun nëmmen verschlechtert. Awer mam Opstig vun der DevOps Kultur ginn d'Entwéckler verantwortlech fir hir Uwendungen an der Wollek ze lafen, sou datt et ganz nëtzlech ass fir se grëndlech mat dem Backend vum Betribssystem vertraut ze ginn. Dëst ass besonnesch nëtzlech wann Dir probéiert e System fir Dausende oder Zéngdausende vu simultane Verbindungen z'installéieren.

D'Limitatiounen an de Webservicer si ganz ähnlech wéi déi an aneren Uwendungen. Egal ob et Laaschtbalancer oder Datebankserver ass, all dës Uwendungen hunn ähnlech Probleemer an engem High-Performance-Ëmfeld. Dës fundamental Aschränkungen ze verstoen a wéi Dir se am Allgemengen iwwerwanne kënnt hëlleft Iech d'Performance an d'Skalierbarkeet vun Äre Webapplikatiounen ze evaluéieren.

Ech schreiwen dës Serie vun Artikelen als Äntwert op Froen vu jonken Entwéckler, déi gutt informéiert Systemarchitekten wëlle ginn. Et ass onméiglech kloer Linux Applikatiounsoptimiséierungstechniken ze verstoen ouni an d'Basis ze tauchen wéi se um Betribssystemniveau funktionnéieren. Och wann et vill Aarte vun Uwendungen gëtt, wëll ech an dëser Serie Web-baséiert Uwendungen entdecken anstatt Desktop Uwendungen wéi e Browser oder Texteditor. Dëst Material ass fir Entwéckler an Architekten geduecht déi wëlle verstoen wéi Linux oder Unix Programmer funktionnéieren a wéi se se fir héich Leeschtung strukturéieren.

Linux ass Server Sall Betribssystem, a meeschtens lafen Är Uwendungen op dësem OS. Och wann ech "Linux" soen, kënnt Dir meeschtens sécher dovun ausgoen datt ech all Unix-ähnlech Betribssystemer allgemeng mengen. Wéi och ëmmer, ech hunn de begleedende Code op anere Systemer net getest. Also, wann Dir un FreeBSD oder OpenBSD interesséiert sidd, kënnen Är Resultater variéieren. Wann ech eppes Linux-spezifesch probéieren, weisen ech et op.

Och wann Dir dëst Wëssen benotze kënnt fir eng App vun Null ze bauen an et wäert perfekt optimiséiert ginn, ass et am beschten dat net ze maachen. Wann Dir en neie Webserver an C oder C++ schreift fir Är Geschäftsapplikatioun vun Ärer Organisatioun, kann dëst Äre leschten Dag op der Aarbecht sinn. Wéi och ëmmer, d'Struktur vun dësen Uwendungen ze kennen hëlleft bei der Wiel vun existente Programmer. Dir wäert fäeg sinn Prozess-baséiert Systemer mat thread-baséiert Systemer wéi och Event-baséiert ze vergläichen. Dir wäert verstoen a schätzen firwat Nginx besser leeft wéi Apache httpd, firwat eng Tornado baséiert Python Applikatioun méi Benotzer kann déngen am Verglach mat enger Django baséiert Python Applikatioun.

ZeroHTTPd: Léierinstrument

ZeroHTTPd ass e Webserver deen ech vun Null an C als Léierinstrument geschriwwen hunn. Et huet keng extern Ofhängegkeeten, dorënner Zougang zu Redis. Mir lafen eis eege Redis Prozeduren. Kuckt hei ënnen fir méi Detailer.

Och wa mir d'Theorie laang kéinte diskutéieren, gëtt et näischt besser wéi Code ze schreiwen, et auszeféieren an all Serverarchitekturen mateneen ze vergläichen. Dëst ass déi offensichtlechst Method. Dofir schreiwen mir en einfachen ZeroHTTPd Webserver mat all Modell: Prozess-baséiert, thread-baséiert, an Event-baséiert. Loosst eis all eenzel vun dësen Serveren kucken a kucken wéi se matenee vergläicht. ZeroHTTPd gëtt an enger eenzeger C Datei implementéiert. Den Event-baséierten Server enthält aussch, eng super Hash-Table Implementatioun déi an enger eenzeger Header Datei kënnt. An anere Fäll sinn et keng Ofhängegkeeten, fir de Projet net ze komplizéieren.

Et gi vill Kommentaren am Code fir Iech ze hëllefen ze verstoen. Als einfache Webserver an e puer Zeilen Code ze sinn, ZeroHTTPd ass och e minimale Kader fir Webentwécklung. Et huet limitéiert Funktionalitéit, awer ass fäeg statesch Dateien a ganz einfach "dynamesch" Säiten ze déngen. Ech muss soen datt ZeroHTTPd gutt ass fir ze léieren wéi een High-Performance Linux Uwendungen erstellt. Duerch a grouss, déi meescht Webservicer waarden op Ufroen, kontrolléiert se a veraarbecht se. Dëst ass genau wat ZeroHTTPd wäert maachen. Dëst ass en Instrument fir ze léieren, net d'Produktioun. Et ass net super beim Fehlerhandhabung an ass onwahrscheinlech mat beschte Sécherheetspraktiken ze prägen (oh jo, ech hunn benotzt strcpy) oder déi schlau Tricken vun der Sprooch C. Mee ech hoffen, datt se hir Aarbecht gutt mécht.

ZeroHTTPd Haaptsäit. Et kann verschidden Dateitypen ausginn, dorënner Biller

Gaascht Buch Applikatioun

Modern Webapplikatiounen sinn normalerweis net op statesch Dateien limitéiert. Si hunn komplex Interaktioune mat verschiddenen Datenbanken, Cache, etc. Also wäerte mir eng einfach Webapplikatioun mam Numm "Guest Book" erstellen, wou d'Besucher Entréen ënner hirem Numm verloossen. D'Gäscht Buch Geschäfter Entréen virdrun lénks. Et gëtt och e Besuchszähler um Enn vun der Säit.

Webapplikatioun "Guest Book" ZeroHTTPd

De Visiteur Konter a Gaascht Buch Entréen sinn am Redis gespäichert. Fir Kommunikatioun mat Redis ginn eegen Prozeduren ëmgesat; si hänken net vun der externer Bibliothéik of. Ech sinn net e grousse Fan fir Homebrew Code auszerollen wann et ëffentlech verfügbar a gutt getest Léisunge gëtt. Awer den Zweck vun ZeroHTTPd ass d'Linux Leeschtung an den Zougang zu externe Servicer ze studéieren, wärend HTTP-Ufroen déngen huet e seriöse Performance Impakt. Mir mussen d'Kommunikatioune mat Redis an all eise Serverarchitekturen voll kontrolléieren. A verschiddenen Architekturen benotze mir Blockéierungsappellen, an anerer benotze mir Event-baséiert Prozeduren. Mat enger externer Redis Clientbibliothéik gëtt dës Kontroll net ubidden. Zousätzlech mécht eise klenge Redis Client nëmmen e puer Funktiounen (kréien, astellen, an inkrementéieren e Schlëssel; kréien an un eng Array bäiginn). Zousätzlech ass de Redis Protokoll extrem elegant an einfach. Dir braucht et net emol speziell ze léieren. Déi ganz Tatsaach datt de Protokoll all d'Aarbecht an ongeféier honnert Zeilen Code mécht weist wéi gutt duerchduecht et ass.

Déi folgend Figur weist wat d'Applikatioun mécht wann de Client (Browser) Ufroen /guestbookURL.

Wéi de Gaascht Buch Applikatioun Wierker

Wann eng Gaaschtbuch Säit muss ausgestallt ginn, gëtt et een Uruff un de Dateiesystem fir d'Schabloun an d'Erënnerung ze liesen an dräi Netzwierkerruff un Redis. D'Schabloundatei enthält de gréissten Deel vum HTML Inhalt fir d'Säit am Screenshot hei uewen. Et ginn och speziell Plazhalter fir den dynameschen Deel vum Inhalt: Posts a Visiteurenteller. Mir kréien se vu Redis, setzen se an d'Säit a ginn dem Client voll forméierten Inhalt. Den drëtten Uruff un Redis kann vermeit ginn well Redis den neie Schlësselwäert zréckkënnt wann se eropgebaut ginn. Wéi och ëmmer, fir eise Server, deen eng asynchron Event-baséiert Architektur huet, sinn vill Netzwierker e gudden Test fir Léierzwecker. Also verwerfe mir de Redis Retourwäert vun der Unzuel vun de Besucher a froen et mat engem separaten Uruff.

Serverarchitekturen ZeroHTTPd

Mir bauen siwe Versioune vun ZeroHTTPd mat der selwechter Funktionalitéit awer verschidden Architekturen:

Iterativ
Fork Server (e Kand Prozess pro Ufro)
Pre-Fork Server (Pre-Fork vu Prozesser)
Server mat Ausféierung Threads (een Thread pro Ufro)
Server mat Pre-Thread Kreatioun
Architektur baséiert poll()
Architektur baséiert epoll

Mir moossen d'Performance vun all Architektur andeems de Server mat HTTP-Ufroen lued. Awer wann Dir héich parallel Architekturen vergläicht, erhéicht d'Zuel vun den Ufroen. Mir testen dräimol a berechnen den Duerchschnëtt.

Testmethodologie

ZeroHTTPd Luede Testen Setup

Et ass wichteg datt wann Dir Tester leeft, all Komponenten net op der selwechter Maschinn lafen. An dësem Fall entstinn d'OS zousätzlech Scheduling Overhead wéi Komponente fir CPU konkurréiere. D'Messung vum Betribssystem Overhead vun jiddereng vun den ausgewielten Serverarchitekturen ass ee vun de wichtegsten Ziler vun dëser Übung. Méi Variablen derbäisetzen wäert de Prozess schiedlech ginn. Dofir funktionnéiert d'Astellung am Bild hei uewen am beschten.

Wat mécht jiddereng vun dësen Serveren?

load.unixism.net: Dëst ass wou mir lafen ab, Apache Benchmark Utility. Et generéiert d'Laascht déi néideg ass fir eis Serverarchitekturen ze testen.
nginx.unixism.net: Heiansdo wëlle mir méi wéi eng Instanz vun engem Serverprogramm lafen. Fir dëst ze maachen, funktionnéiert den Nginx Server mat de passenden Astellungen als Lastbalancer deen aus kënnt ab op eise Serverprozesser.
zerohttpd.unixism.net: Hei lafe mir eis Serverprogrammer op siwen verschidden Architekturen, eng gläichzäiteg.
redis.unixism.net: Dëse Server leeft de Redis Daemon, wou Gaaschtbuch Entréen a Visiteurenteller gespäichert ginn.

All Server lafen op de selwechte Prozessor Kär. D'Iddi ass déi maximal Leeschtung vun all Architektur ze evaluéieren. Zënter datt all Serverprogrammer op der selwechter Hardware getest ginn, ass dëst eng Basis fir de Verglach. Meng Testopstellung besteet aus virtuelle Servere gelount vum Digital Ocean.

Wat moosse mir?

Dir kënnt verschidden Indikatoren moossen. Mir evaluéieren d'Performance vun all Architektur an enger bestëmmter Konfiguratioun andeems d'Servere mat Ufroen op verschiddene Parallelismusniveauen lueden: d'Laascht wiisst vun 20 op 15 concurrent Benotzer.

Testresultater

Déi folgend Diagramm weist d'Performance vu Serveren op verschiddenen Architekturen op verschiddene Parallelismusniveauen. D'Y-Achs ass d'Zuel vun Ufroen pro Sekonn, d'X-Achs ass parallel Verbindungen.

Drënner ass eng Tabell mat de Resultater.

Ufroen pro Sekonn

Parallelismus
iterativ
Forschett
pre-gabel
streamen
Pre-Streaming
pollen
epoll

20
7
112
2100
1800
2250
1900
2050

50
7
190
2200
1700
2200
2000
2000

100
7
245
2200
1700
2200
2150
2100

200
7
330
2300
1750
2300
2200
2100

300
-
380
2200
1800
2400
2250
2150

400
-
410
2200
1750
2600
2000
2000

500
-
440
2300
1850
2700
1900
2212

600
-
460
2400
1800
2500
1700
2519

700
-
460
2400
1600
2490
1550
2607

800
-
460
2400
1600
2540
1400
2553

900
-
460
2300
1600
2472
1200
2567

1000
-
475
2300
1700
2485
1150
2439

1500
-
490
2400
1550
2620
900
2479

2000
-
350
2400
1400
2396
550
2200

2500
-
280
2100
1300
2453
490
2262

3000
-
280
1900
1250
2502
grouss Verbreedung
2138

5000
-
grouss Verbreedung
1600
1100
2519
-
2235

8000
-
-
1200
grouss Verbreedung
2451
-
2100

10
-
-
grouss Verbreedung
-
2200
-
2200

11
-
-
-
-
2200
-
2122

12
-
-
-
-
970
-
1958

13
-
-
-
-
730
-
1897

14
-
-
-
-
590
-
1466

15
-
-
-
-
532
-
1281

Vun der Grafik an der Tabell kann et gesi ginn datt iwwer 8000 simultan Ufroe mir nëmmen zwee Spiller hunn: Pre-Gabel an epoll. Wéi d'Laascht eropgeet, leeft e Poll-baséiert Server méi schlecht wéi e Streaming. D'Thread-Pre-Creation Architektur ass e wiirdege Konkurrent fir epoll, en Testament fir wéi gutt de Linux Kernel eng grouss Zuel vu Threads plangt.

ZeroHTTPd Quellcode

ZeroHTTPd Quellcode hei. Et gëtt eng separat Verzeechnes fir all Architektur.

ZeroHTTPd │ ├── 01_iterative │ ├── main.c ├── 02_forking │ ├── main.c ├── 03_preforking ├── ├ ├ ─ ─ ─ ─ │ _ threading │ ├── main.c ├── 04_prethreading │ ├── main.c ├── 05_poll │ ├── main.c ├── 06_epoll │ └─── main.c ├e ─ ëffentlech maachen ─ ├── Index .html │ └── tux . png └── Templates └── Gaaschtbuch └── index.html

Zousätzlech zu siwe Verzeichnisser fir all Architekturen, ginn et zwee méi am Top-Level Verzeechnes: ëffentlech a Schablounen. Déi éischt enthält d'index.html Datei an d'Bild vum éischte Screenshot. Dir kënnt aner Dateien an Ordner do setzen, an ZeroHTTPd sollt dës statesch Dateien ouni Probleemer servéieren. Wann de Wee am Browser de Wee am ëffentlechen Dossier entsprécht, da sicht ZeroHTTPd fir d'index.html Datei an dësem Verzeichnis. Den Inhalt fir d'Gäschtbuch gëtt dynamesch generéiert. Et huet nëmmen eng Homepage, a säin Inhalt baséiert op der Datei 'templates/guestbook/index.html'. ZeroHTTPd füügt einfach dynamesch Säiten fir Extensioun un. D'Iddi ass datt d'Benotzer Templates an dësem Verzeichnis kënne addéieren an ZeroHTTPd wéi néideg verlängeren.

Fir all siwen Serveren ze bauen, lafen make all aus dem Top-Level Verzeechnes - an all baut wäert an dësem Verzeechnes erschéngen. Ausféierbar Dateie sichen no den ëffentlechen a Template Verzeichnisser am Verzeichnis aus deem se lancéiert ginn.

Linux API

Dir musst net gutt beherrscht sinn an der Linux API fir d'Informatioun an dëser Artikelserie ze verstoen. Wéi och ëmmer, ech recommandéieren méi iwwer dëst Thema ze liesen; et gi vill Referenzressourcen um Internet. Och wa mir op verschidde Kategorien vu Linux APIs beréieren, wäert eise Fokus haaptsächlech op Prozesser, Threads, Eventer an den Netzwierkstack sinn. Zousätzlech zu Bicher an Artikelen iwwer d'Linux API, ech recommandéieren och Mana ze liesen fir Systemappellen a Bibliothéiksfunktiounen benotzt.

Leeschtung a Skalierbarkeet

Eng Notiz iwwer Leeschtung a Skalierbarkeet. Theoretesch gëtt et keng Verbindung tëscht hinnen. Dir kënnt e Webservice hunn, dee ganz gutt funktionnéiert, mat enger Äntwertzäit vun e puer Millisekonnen, awer e skaléiert guer net. Och kann et eng schlecht performant Webapplikatioun sinn, déi e puer Sekonnen dauert fir ze reagéieren, awer et skaléiert vun Zénger fir Zéngdausende vu gläichzäiteg Benotzer ze handhaben. Wéi och ëmmer, d'Kombinatioun vun héich Leeschtung a Skalierbarkeet ass eng ganz mächteg Kombinatioun. High-Performance Uwendungen benotzen allgemeng Ressourcen spuersam an doduerch effizient méi gläichzäiteg Benotzer um Server déngen, d'Käschte reduzéieren.

CPU an I / O Aufgaben

Endlech, am Informatik ginn et ëmmer zwou méiglech Aarte vun Aufgaben: fir I / O an CPU. Ufroen iwwer Internet kréien (Netzwierk I/O), Dateien servéieren (Netzwierk an Disk I/O), Kommunikatioun mat der Datebank (Netzwierk an Disk I/O) sinn all I/O Aktivitéiten. E puer Datebankufroe kënnen e bësse CPU-intensiv sinn (Sortéieren, duerchschnëttlech eng Millioun Resultater, etc.). Déi meescht Webapplikatioune si limitéiert duerch déi maximal méiglech I / O, an de Prozessor gëtt selten op voller Kapazitéit benotzt. Wann Dir gesitt datt e puer I / O Aufgab vill CPU benotzt, ass et héchstwahrscheinlech en Zeechen vun enger schlechter Applikatiounsarchitektur. Dëst kann heeschen datt CPU Ressourcen op Prozessmanagement a Kontextwiessel verschwenden - an dëst ass net ganz nëtzlech. Wann Dir eppes maacht wéi Bildveraarbechtung, Audiodateikonversioun oder Maschinnléieren, da brauch d'Applikatioun mächteg CPU Ressourcen. Awer fir déi meescht Uwendungen ass dëst net de Fall.

Léiert méi iwwer Serverarchitekturen

Source: will.com

Linux Reseau Applikatioun Leeschtung. Aféierung