Alexey Naidenov, CEO , ay nagsasalita tungkol sa pagbuo ng isang telecommunications platform para sa mga operator ng telecom sa programming language na Go (Golang). Ibinahagi rin ni Alexey ang kanyang karanasan sa pag-deploy at pagpapatakbo ng platform sa isa sa pinakamalaking Asian telecom operator, na ginamit ang platform upang magbigay ng voice mail (VoiceMail) at Virtual PBX (Cloud PBX) na mga serbisyo.
Alexey Naydenov (pagkatapos nito - AN): - Kamusta kayong lahat! Ang pangalan ko ay Alexey Naidenov. Ako ang direktor ng ITooLabs. Una sa lahat, gusto kong sagutin kung ano ang ginagawa ko dito at kung paano ako napunta dito.
Kung titingnan mo ang Bitrix24 Marketplace (seksyon na "Telephony"), kung gayon 14 na aplikasyon at 36 na naroroon (40%) ay kami:
Mas tiyak, ito ang aming mga partner na operator, ngunit sa likod ng lahat ng ito ay ang aming platform (Platform bilang isang Serbisyo) - kung ano ang ibinebenta namin sa kanila sa isang maliit na sentimos. Sa totoo lang, gusto kong pag-usapan ang tungkol sa pagbuo ng platform na ito at kung paano tayo napunta sa Go.
Ang mga numero para sa aming platform ngayon ay:
44 na kasosyong operator, kabilang ang MegaFon. Sa pangkalahatan, gusto naming pumunta sa mga pakikipagsapalaran, at talagang mayroon kaming access sa 100 milyong mga subscriber ng 44 na operator dito sa Russia. Samakatuwid, kung ang isang tao ay may ilang mga ideya sa negosyo, lagi kaming masaya na makinig sa kanila.
- 5000 mga kumpanya ng gumagamit.
- 20 subscriber sa kabuuan. Lahat ng ito ay b000b - nagtatrabaho lamang kami sa mga kumpanya.
- 300 tawag kada minuto sa araw.
- 100 milyong minuto ng tawag noong nakaraang taon (nagdiwang kami). Ito ay nang hindi isinasaalang-alang ang mga panloob na negosasyon na nasa aming plataporma.
Paano ito nagsimula?
Paano nagsisimula ang mga tamang dudes na gumawa ng sarili nilang plataporma? Dapat din nating isaalang-alang na mayroon tayong kasaysayan ng pag-unlad ng "hardcore enterprise", at kahit na sa pinakatumpak na oras ng taon para sa isang enterprise! Iyon ang masayang pagkakataong pumunta ka sa customer at sabihing: "Kailangan namin ng ilang server pa." At ang customer: "Oo, walang tanong! Mayroon kaming sampu sa rack.
Kaya ginawa namin ang Oracle, Java, WebSphere, Db2 at lahat ng iyon. Samakatuwid, kinuha namin, siyempre, ang pinakamahusay na mga solusyon sa vendor, isinama ang mga ito at sinubukang alisin ito. Naglaro sila sa kanilang sarili. Ito ay magiging isang panloob na startup.
Nagsimula ang lahat noong 2009. Mula noong 2006, malapit na kaming nasangkot sa mga desisyon ng operator, sa isang paraan o iba pa. Gumawa kami ng ilang custom na virtual na PBX (tulad ng mayroon kami ngayon sa order): tumingin kami, nagpasya na ito ay mabuti, at nagpasyang pukawin ang isang panloob na startup.
Kunin ang VMWare. Dahil mag-isa kaming naglalakad, kinailangan naming iwanan agad ang cool na vendor na Storage. Alam namin ang lahat tungkol sa mga ito: na ang mga pangako ay dapat na hatiin sa 3, at ang gastos ay dapat i-multiply sa 10. Samakatuwid, ginawa namin ang DirDB at iba pa.
Pagkatapos ay nagsimula itong lumaki. Ang serbisyo sa pagsingil ay idinagdag dito, dahil ang platform ay hindi na makayanan. Pagkatapos ang server ng pagsingil mula sa MySQL ay inilipat sa Mongo. Bilang resulta, nakakuha kami ng gumaganang solusyon na nagpoproseso ng lahat ng tawag na napupunta doon:
Ngunit sa isang lugar sa loob, ang parehong produkto ng vendor ay umiikot - ang pangunahing, nuclear, na minsan naming kinuha. Humigit-kumulang sa pagtatapos ng 2011, napagtanto namin sa aming sarili na ang pangunahing bottleneck para sa amin, siyempre, ay ang partikular na produktong ito - tatakbo kami dito. Nakita namin ang isang pader sa harap namin, kung saan kami tumakbo nang buong bilis, habang naglalakad ang mga customer, ay idinagdag.
Alinsunod dito, kailangan naming gawin ang isang bagay. Siyempre, marami kaming ginawang pananaliksik sa iba't ibang produkto - parehong open source at vendor. Hindi ko na ito tatalakayin ngayon - hindi iyon ang punto. Ang pinakahuling fallback na naisip namin ay ang paggawa ng sarili naming platform.
Sa huli, dumating kami sa pagpipiliang ito. Bakit? Dahil lahat ng vendor at open source na produkto ay ginawa para malutas ang mga problema 10 taon na ang nakakaraan. Well, kung isang 10 taong gulang, at ilan pa! Ang pagpili ay naging malinaw para sa amin: magpaalam kami sa aming magandang ideya ng isang perpektong serbisyo (para sa mga kasosyo, operator at sa aming sarili), o gumawa kami ng sarili naming bagay.
Nagpasya kaming gumawa ng isang bagay na naiiba!
Mga Kinakailangan sa Platform
Kung gumawa ka ng isang bagay sa loob ng mahabang panahon (pinagsasamantalahan mo ang produkto ng ibang tao), pagkatapos ay dahan-dahang nabuo ang pag-iisip sa iyong ulo: paano ko ito gagawin sa aking sarili? Dahil lahat tayo ay programmer sa kumpanya (maliban sa mga nagbebenta, walang mga hindi programmer), ang aming mga kinakailangan ay nabuo nang mahabang panahon, at malinaw ang mga ito:
- Mataas na bilis ng pag-unlad. Ang produkto ng vendor, na nagpahirap sa amin, ay hindi nababagay sa amin sa unang lugar dahil ang lahat ay gumana nang mahabang panahon at dahan-dahan. Gusto namin ng mabilis - marami kaming ideya! Marami pa kaming mga ideya, ngunit pagkatapos ay ang listahan ng mga ideya ay tulad na tila sampung taon sa hinaharap. Ngayon, isang taon na lang.
- Pinakamataas na paggamit ng multi-core na bakal. Mahalaga rin ito para sa amin, dahil nakita namin na dadami lang ang mga core.
- Mataas na pagiging maaasahan. Yung iniiyakan din namin.
- Mataas na fault tolerance.
- Nais naming tapusin ang isang pang-araw-araw na proseso ng paglabas. Para magawa ito, kailangan namin ng pagpili ng wika.
Alinsunod dito, mula sa mga kinakailangan para sa produkto na ipinakita namin para sa aming sarili, ang mga kinakailangan para sa wika ay lumalaki sa isang malinaw na lohikal na paraan.
- Kung gusto namin ng suporta para sa mga multi-core system, kailangan namin ng suporta para sa parallel execution.
- Kung kailangan namin ng bilis ng pag-unlad, kailangan namin ng isang wika na sumusuporta sa mapagkumpitensyang pag-unlad, mapagkumpitensyang programming. Kung ang sinuman ay hindi nakatagpo ng pagkakaiba, kung gayon ito ay napaka-simple:
- Ang parallel programming ay tungkol sa kung paano tumatakbo ang dalawang magkaibang thread sa magkaibang mga core;
- Ang sabay-sabay na pagpapatupad, mas partikular na suporta ng concurrency, ay tungkol sa kung paano nakakatulong ang wika (o runtime, anuman) na itago ang lahat ng pagiging kumplikado na nagmumula sa parallel execution.
- Mataas na katatagan. Malinaw, kailangan namin ng isang kumpol, at ito ay mas mahusay kaysa sa kung ano ang mayroon kami sa produkto ng vendor.
Wala talaga kaming maraming pagpipilian, kung naaalala mo. Una, Erlang - gustung-gusto namin ito at alam namin, ito ang aking personal, personal na paborito. Pangalawa, ang Java ay hindi kahit na Java, ngunit partikular na Scala. Pangatlo, ang lenggwahe na noong panahong iyon ay hindi natin alam - Go. Kakalabas lang noon, mas tiyak, mga dalawang taon na itong umiral, pero hindi pa nailalabas.
Natalo si Go!
Kasaysayan ng Go
Gumawa kami ng plataporma dito. Susubukan kong ipaliwanag kung bakit.
Isang Maikling Kasaysayan ng Go. Nagsimula noong 2007, binuksan noong 2009, ang unang bersyon ay inilabas noong 2012 (iyon ay, nagsimula kaming magtrabaho kahit bago ang unang paglabas). Ang nagpasimula ay ang Google, na gustong palitan, gaya ng hinala ko, ang Java.
Ang mga may-akda ay napaka sikat:
- Si Ken Thomson, na nasa likod ng Unix, ay nag-imbento ng UTF-8, ay nagtrabaho sa Plan 9 system;
- Si Rob Pike, na nagdisenyo ng UTF-8 kasama si Ken, ay nagtrabaho din sa Plan 9, Inferno, Limbo sa Bell Labs;
- Robert Gizmer, na kilala at mahal namin para sa pag-imbento ng Java HotSpot Compiler at para sa paggawa sa generator sa V8 (Javascript interpreter ng Google);
- At higit sa 700 na nag-ambag, kabilang ang ilan sa aming mga patch.
Pumunta sa isang sulyap
Nakikita natin na ang wika ay mas simple at naiintindihan. Mayroon kaming mga malinaw na uri: sa ilang mga kaso kailangan nilang ipahayag, sa iba ay hindi (ibig sabihin, ang mga uri ay hinuhulaan pa rin).
Ito ay makikita na ito ay sunod sa moda upang ilarawan ang mga istraktura. Makikita na mayroon tayong konsepto ng isang pointer (kung saan ang asterisk ay). Makikita na mayroong espesyal na suporta para sa pagdedeklara ng initialization ng arrays at associative arrays.
Medyo naiintindihan - maaari kang mabuhay. Sinusubukang magsulat ng Hello, world:
Ano ang nakikita natin? Ito ay tulad ng C syntax, ang semicolon ay opsyonal. Maaari itong maging isang separator para sa dalawang linya, ngunit kung ito ay dalawang konstruksyon na eksaktong nasa parehong linya.
Nakikita namin na ang mga bracket sa mga istruktura ng kontrol (sa ika-14 na linya) ay opsyonal, ngunit ang mga kulot ay palaging kinakailangan. Nakikita namin na ang pagta-type ay static. Si Tim sa karamihan ng mga kaso ay ipinapakita. Ang halimbawang ito ay bahagyang mas kumplikado kaysa sa karaniwang Hello, world - para lang ipakita na mayroong library.
Ano pa ang nakikita nating mahalaga? Ang code ay nakaayos sa mga pakete. At para magamit ang package sa sarili mong code, kailangan mong i-import ito gamit ang import directive - mahalaga din ito. Nagsisimula kami - ito ay gumagana. Malaki!
Subukan natin ang isang bagay na mas kumplikado: Kumusta, mundo, ngunit ngayon ito ay isang http server. Ano ang nakikita nating kawili-wili dito?
Una, ang function ay gumaganap bilang isang parameter. Nangangahulugan ito na ang function na mayroon kami ay isang "first-class citizen" at maaari kang gumawa ng maraming kawili-wiling bagay dito sa isang functional na istilo. Nakita namin ang hindi inaasahang susunod: ang direktiba sa pag-import ay direktang tumutukoy sa repositoryo ng GitHub. Ayun, ganyan - tsaka, ganyan dapat gawin.
Sa Go, ang universal identifier ng package ay ang url ng repository nito. Mayroong isang espesyal na utility ng Goget na napupunta para sa lahat ng mga dependency, dina-download ang mga ito, ini-install ang mga ito, kino-compile ang mga ito, at inihahanda ang mga ito para sa paggamit kung kinakailangan. Kasabay nito, alam ni Goget ang tungkol sa html-meta. Alinsunod dito, maaari kang magpanatili ng isang direktoryo ng http, na maglalaman ng mga link sa iyong partikular na imbakan (gaya ng ginagawa namin, halimbawa,).
Ano pa ang nakikita natin? Http at Json sa regular na aklatan. Mayroong, malinaw naman, introspection - reflection, na dapat gamitin sa pag-encode / json, dahil pinapalitan lang namin ang ilang arbitrary na bagay para dito.
Pinapatakbo namin ito at nakita namin na mayroon kaming 20 linya ng kapaki-pakinabang na code na nag-compile, nagpapatakbo at nagbibigay ng kasalukuyang average na pagkarga ng makina (sa makina kung saan ito tumatakbo).
Ano pa ba ang mahalaga sa makikita natin kaagad dito? Nag-compile ito sa isang static na binary (buinary). Ang binary na ito ay walang mga dependency, walang mga aklatan! Maaari itong kopyahin sa anumang system, tumakbo kaagad, at gagana ito.
Moving on.
Pumunta: mga pamamaraan at interface
May mga pamamaraan ang Go. Maaari kang magdeklara ng paraan para sa anumang pasadyang uri. Bukod dito, ito ay hindi kinakailangang isang istraktura, ngunit maaaring isang alyas ng ilang uri. Maaari kang magdeklara ng alyas para sa N32 at magsulat ng mga pamamaraan para makagawa ito ng isang bagay na kapaki-pakinabang.
At ito ay kung saan kami nahulog sa isang stupor sa unang pagkakataon ... Ito ay lumiliko na si Go ay walang klase tulad nito. Maaaring sabihin ng mga nakakakilala kay Go na mayroong uri ng pagsasama, ngunit ito ay ganap na naiiba. Kung mas maagang itinigil ng developer ang pag-iisip nito bilang mana, mas mabuti. Walang mga klase sa Go, at wala ring mana.
Tanong! Ano ang ibinigay sa amin ng kumpanya ng mga may-akda na pinamumunuan ng Google upang maipakita ang pagiging kumplikado ng mundo? Binigyan kami ng mga interface!
Ang isang interface ay isang espesyal na uri na nagpapahintulot sa iyo na magsulat ng mga simpleng pamamaraan, mga lagda ng pamamaraan. Dagdag pa, ang anumang uri kung saan umiiral ang mga pamamaraang ito (isinasagawa) ay tumutugma sa interface na ito. Nangangahulugan ito na maaari mo lamang isulat ang kaukulang function para sa isang uri, para sa isa pa (na tumutugma sa uri ng interface na iyon). Susunod, magdeklara ng variable ng uri ng interface na ito at magtalaga ng alinman sa mga bagay na ito dito.
Para sa mga hardcore na tagahanga, masasabi kong ang variable na ito ay talagang maglalaman ng dalawang pointer: ang isa sa data, ang isa sa isang espesyal na talahanayan ng descriptor na partikular sa partikular na uri na ito, sa interface ng ganitong uri. Iyon ay, ang compiler ay gumagawa ng mga naturang talahanayan ng mga descriptor sa oras ng pag-link.
At mayroong, siyempre, mga pointer na walang bisa sa Go. Ang salitang interface {} (na may dalawang kulot na brace) ay isang variable na nagbibigay-daan sa iyong tumuro sa anumang bagay sa prinsipyo.
Sa ngayon, maayos ang lahat, pamilyar ang lahat. Walang nakakagulat.
Pumunta: goroutines
Ngayon ay dumating tayo sa kung ano ang interesado tayo: magaan na mga proseso - goroutine (goroutine) sa terminolohiya ng Go.
- Una, ang mga ito ay talagang magaan (mas mababa sa 2 Kb).
- Pangalawa, ang halaga ng paglikha ng tulad ng isang goroutine ay bale-wala: maaari kang lumikha ng isang libo ng mga ito bawat segundo - walang mangyayari.
- Ang mga ito ay pinaglilingkuran ng kanilang sariling scheduler, na naglilipat lamang ng kontrol mula sa isang goroutine patungo sa isa pa.
- Sa kasong ito, inililipat ang kontrol sa mga sumusunod na kaso:
- kung ang isang go statement ay nakatagpo (kung ang goroutine ay magsisimula sa susunod na goroutine);
- kung ang isang blocking Input/Out na tawag ay pinagana;
- kung ang koleksyon ng basura ay na-trigger;
- kung magsisimula ang ilang operasyon na may mga channel.
Ibig sabihin, sa tuwing pinapatakbo ang isang Go program sa isang computer, nade-detect nito ang bilang ng mga core sa system, magsisimula ng maraming thread kung kinakailangan (kung gaano karaming mga core ang nasa system, o kung gaano karami ang sinabihan mo ito). Alinsunod dito, patakbuhin ng scheduler ang magaan na mga thread na ito ng pagpapatupad sa lahat ng mga thread ng operating system na ito sa bawat core.
Dapat tandaan na ito ang pinaka mahusay na paraan upang magamit ang bakal. Bilang karagdagan sa ipinakita namin, marami pa kaming ginagawa. Gumagawa kami, halimbawa, ng mga DPI system na nagbibigay-daan sa paghahatid ng 40 gigabits sa isang unit (depende sa kung ano ang mangyayari sa mga linyang ito).
Doon, kahit bago ang Go, ginamit namin ang eksaktong parehong pamamaraan para sa mismong kadahilanang ito: dahil pinapayagan ka nitong i-save ang lokalidad ng cache ng processor, makabuluhang bawasan ang bilang ng mga switch ng konteksto ng OS (na tumatagal din ng napakatagal). Uulitin ko: ito ang pinaka-epektibong paraan upang magamit ang bakal.
Ang simpleng 21-line na halimbawang ito ay isang halimbawa na simpleng gumagawa ng echo-server. Kasabay nito, tandaan na ang function ng serve ay sobrang simple, ito ay linear. Walang mga callback, hindi na kailangang mag-abala at mag-isip... Magbasa at magsulat ka lang!
Kasabay nito, kung magbabasa at magsusulat ka, dapat talaga itong i-block - ang goroutine na ito ay naka-queue lang at kinuha ng scheduler kapag naging posible muli ang execution. Iyon ay, ang simpleng code na ito ay maaaring kumilos bilang isang echo server para sa maraming koneksyon na papayagan ng OS sa makina na ito.
Itutuloy sa lalong madaling panahon...
Ilang ad π
Salamat sa pananatili sa amin. Gusto mo ba ang aming mga artikulo? Gustong makakita ng mas kawili-wiling nilalaman? Suportahan kami sa pamamagitan ng pag-order o pagrekomenda sa mga kaibigan, , isang natatanging analogue ng mga entry-level na server, na inimbento namin para sa iyo: (magagamit sa RAID1 at RAID10, hanggang 24 na core at hanggang 40GB DDR4).
Dell R730xd 2x na mas mura sa Equinix Tier IV data center sa Amsterdam? Dito lang sa Netherlands! Dell R420 - 2x E5-2430 2.2Ghz 6C 128GB DDR3 2x960GB SSD 1Gbps 100TB - mula $99! Basahin ang tungkol sa
Pinagmulan: www.habr.com