อเล็กเซย์ ไนเดนอฟ ซีอีโอ พูดถึงการพัฒนาแพลตฟอร์มโทรคมนาคมสำหรับผู้ให้บริการโทรคมนาคมในภาษาโปรแกรม Go (Golang) Alexey ยังแบ่งปันประสบการณ์ของเขาในการปรับใช้และใช้งานแพลตฟอร์มกับหนึ่งในผู้ให้บริการโทรคมนาคมรายใหญ่ที่สุดในเอเชีย ซึ่งใช้แพลตฟอร์มเพื่อให้บริการวอยซ์เมล (VoiceMail) และบริการ Virtual PBX (Cloud PBX)
Alexey Naydenov (ต่อไปนี้ - AN): - สวัสดีทุกคน! ฉันชื่ออเล็กซี่ ไนเดนอฟ ฉันเป็นผู้อำนวยการของ ITooLabs ก่อนอื่นผมขอตอบก่อนว่าผมมาทำอะไรที่นี่และมาอยู่ที่นี่ได้อย่างไร
หากคุณดูที่ Bitrix24 Marketplace (ส่วน "โทรศัพท์") แสดงว่ามีแอปพลิเคชัน 14 รายการและ 36 รายการอยู่ที่นั่น (40%):
แม่นยำกว่านั้นคือผู้ให้บริการที่เป็นพันธมิตรของเรา แต่เบื้องหลังทั้งหมดนี้คือแพลตฟอร์มของเรา (แพลตฟอร์มเป็นบริการ) - สิ่งที่เราขายให้พวกเขาด้วยเงินเพียงเล็กน้อย ที่จริงฉันอยากจะพูดถึงการพัฒนาแพลตฟอร์มนี้และที่มาของ Go
ตัวเลขสำหรับแพลตฟอร์มของเราตอนนี้คือ:
ผู้ให้บริการพันธมิตร 44 ราย รวมถึง MegaFon โดยทั่วไปแล้ว เราชอบที่จะผจญภัย และเราสามารถเข้าถึงสมาชิก 100 ล้านคนจากผู้ให้บริการ 44 รายในรัสเซีย ดังนั้นหากใครมีไอเดียทางธุรกิจ เรายินดีรับฟังเสมอ
- บริษัท ผู้ใช้ 5000 ราย
- สมาชิกทั้งหมด 20 ราย มันคือ b000b ทั้งหมด - เราทำงานกับบริษัทเท่านั้น
- 300 โทรต่อนาทีในระหว่างวัน
- ปีที่แล้ว 100 ล้านนาทีการโทร (เราเฉลิมฉลอง) โดยไม่คำนึงถึงการเจรจาภายในที่อยู่บนแพลตฟอร์มของเรา
มันเริ่มต้นอย่างไร?
เพื่อนที่ใช่เริ่มสร้างแพลตฟอร์มของตัวเองได้อย่างไร เราต้องคำนึงถึงว่าเรามีประวัติของการพัฒนา "องค์กรที่ไม่ยอมใครง่ายๆ" และแม้แต่ในเวลาที่แม่นยำที่สุดของปีสำหรับองค์กร! มันเป็นช่วงเวลาที่มีความสุขเมื่อคุณไปหาลูกค้าและพูดว่า: "เราต้องการเซิร์ฟเวอร์เพิ่มอีกสองสามเครื่อง" และลูกค้า: “ใช่ ไม่มีปัญหา! เรามีสิบในชั้นวาง
ดังนั้นเราจึงทำ Oracle, Java, WebSphere, Db2 และทั้งหมดนั้น ดังนั้นเราจึงนำโซลูชันผู้ขายที่ดีที่สุดมารวมเข้าด้วยกันและพยายามนำออกมาใช้ พวกเขาเล่นด้วยตัวเอง มันจะเป็นการเริ่มต้นภายใน
ทุกอย่างเริ่มต้นในปี 2009 ตั้งแต่ปี 2006 เรามีส่วนร่วมอย่างใกล้ชิดในการตัดสินใจของผู้ปฏิบัติงานไม่ทางใดก็ทางหนึ่ง เราสร้าง PBX เสมือนที่กำหนดเองหลายรายการ (เช่นเดียวกับที่เราสั่งซื้อตอนนี้): เราดู ตัดสินใจว่ามันดี และตัดสินใจกระตุ้นการเริ่มต้นภายใน
ใช้ VMWare เนื่องจากเรากำลังเดินด้วยตัวเอง เราจึงต้องละทิ้งคลังเก็บผู้ขายที่ยอดเยี่ยมทันที เรารู้ทุกอย่างเกี่ยวกับพวกเขา: สัญญานั้นควรหารด้วย 3 และค่าใช้จ่ายควรคูณด้วย 10 ดังนั้นเราจึงทำ DirDB และอื่น ๆ
จากนั้นมันก็เริ่มเติบโต มีการเพิ่มบริการการเรียกเก็บเงินเนื่องจากแพลตฟอร์มนี้ไม่สามารถรับมือได้อีกต่อไป จากนั้นเซิร์ฟเวอร์การเรียกเก็บเงินจาก MySQL ก็ย้ายไปที่ Mongo ด้วยเหตุนี้ เราจึงมีโซลูชันที่ใช้งานได้ซึ่งประมวลผลการโทรทั้งหมดที่ไปที่นั่น:
แต่ที่ไหนสักแห่งข้างในผลิตภัณฑ์ของผู้ขายรายเดียวกันกำลังหมุนอยู่ - ผลิตภัณฑ์หลักคือนิวเคลียร์ซึ่งเราเคยเอามา ประมาณปลายปี 2011 เรารู้ด้วยตัวเองว่าคอขวดหลักสำหรับเราแน่นอนจะเป็นผลิตภัณฑ์นี้โดยเฉพาะ - เราจะเจอมัน เราเห็นกำแพงข้างหน้าเราซึ่งเราวิ่งเต็มกำลังในขณะที่ลูกค้าเดินถูกเพิ่มเข้ามา
ดังนั้นเราต้องทำอะไรบางอย่าง แน่นอนว่าเราได้ค้นคว้าเกี่ยวกับผลิตภัณฑ์ต่างๆ ค่อนข้างมาก ทั้งโอเพ่นซอร์สและผู้จำหน่าย ตอนนี้ฉันจะไม่พูดถึงเรื่องนี้ - นั่นไม่ใช่ประเด็น ทางเลือกสุดท้ายที่เรานึกถึงคือการสร้างแพลตฟอร์มของเราเอง
ในที่สุดเราก็มาถึงตัวเลือกนี้ ทำไม เนื่องจากผู้ขายและผลิตภัณฑ์โอเพ่นซอร์สทั้งหมดถูกสร้างขึ้นเพื่อแก้ปัญหาเมื่อ 10 ปีที่แล้ว ถ้าเด็กอายุ 10 ขวบขึ้นไป! ทางเลือกนั้นชัดเจนสำหรับเรา: ไม่ว่าเราจะบอกลาแนวคิดที่ยอดเยี่ยมของเราเกี่ยวกับบริการในอุดมคติ (สำหรับพันธมิตร ผู้ดำเนินการ และตัวเราเอง) หรือเราทำบางสิ่งด้วยตัวเราเอง
เราตัดสินใจที่จะทำสิ่งที่แตกต่างออกไป!
ข้อกำหนดของแพลตฟอร์ม
หากคุณทำอะไรเป็นเวลานาน (คุณใช้ประโยชน์จากผลิตภัณฑ์ของคนอื่น) ความคิดจะค่อยๆ ก่อตัวขึ้นในหัวของคุณ: ฉันจะทำมันเองได้อย่างไร? เนื่องจากเราทุกคนเป็นโปรแกรมเมอร์ในบริษัท (ยกเว้นผู้ขาย ไม่มีผู้ที่ไม่ใช่โปรแกรมเมอร์) ข้อกำหนดของเราจึงเกิดขึ้นเป็นเวลานานและมีความชัดเจน:
- ความเร็วในการพัฒนาสูง ผลิตภัณฑ์ของผู้ขายที่ทรมานเราไม่เหมาะกับเราตั้งแต่แรกเพราะทุกอย่างทำงานเป็นเวลานานและช้า เราต้องการอย่างรวดเร็ว – เรามีไอเดียมากมาย! เรายังมีความคิดมากมาย แต่แล้วรายการความคิดก็เป็นเช่นนั้นซึ่งดูเหมือนอีกสิบปีข้างหน้า ตอนนี้เพียงหนึ่งปี
- การใช้งานเตารีดแบบมัลติคอร์ให้เกิดประโยชน์สูงสุด สิ่งนี้สำคัญสำหรับเราเช่นกัน เพราะเราเห็นว่าจะมีจำนวนคอร์มากขึ้นเรื่อยๆ
- ความน่าเชื่อถือสูง คนที่เราร้องไห้ด้วย
- ความทนทานต่อความผิดพลาดสูง
- เราต้องการสิ้นสุดกระบวนการเผยแพร่รายวัน ในการทำเช่นนี้ เราต้องการตัวเลือกภาษา
ดังนั้นจากข้อกำหนดสำหรับผลิตภัณฑ์ที่เรานำเสนอสำหรับตัวเราเอง ข้อกำหนดสำหรับภาษาจึงเติบโตอย่างมีเหตุผลอย่างชัดเจน
- หากเราต้องการการสนับสนุนสำหรับระบบมัลติคอร์ เราก็ต้องการการสนับสนุนสำหรับการดำเนินการแบบขนาน
- ถ้าเราต้องการความเร็วในการพัฒนา เราต้องการภาษาที่สนับสนุนการพัฒนาการแข่งขัน การเขียนโปรแกรมการแข่งขัน ถ้าใครยังไม่เจอความแตกต่างก็ง่ายมาก:
- การเขียนโปรแกรมแบบขนานนั้นเกี่ยวกับการทำงานของเธรดที่แตกต่างกันสองเธรดบนคอร์ที่แตกต่างกัน
- การดำเนินการพร้อมกัน โดยเฉพาะอย่างยิ่งการสนับสนุนการทำงานพร้อมกันนั้นเกี่ยวกับวิธีที่ภาษา (หรือรันไทม์ อะไรก็ตาม) ช่วยซ่อนความซับซ้อนทั้งหมดที่มาจากการดำเนินการแบบขนาน
- ความเสถียรสูง เห็นได้ชัดว่าเราต้องการคลัสเตอร์ ซึ่งดีกว่าที่เรามีในผลิตภัณฑ์ของผู้จำหน่าย
เรามีทางเลือกไม่มากนัก ถ้าคุณจำได้ ประการแรก Erlang - เรารักมันและรู้ว่ามันเป็นของโปรดส่วนตัวของฉัน ประการที่สอง Java ไม่ใช่ Java แต่เป็น Scala โดยเฉพาะ ประการที่สาม ภาษาที่เราไม่รู้จักในเวลานั้น - ไป มันเพิ่งปรากฏขึ้นในตอนนั้น แม่นยำกว่านั้น มันมีอยู่ประมาณสองปีแล้ว แต่ยังไม่ได้รับการเผยแพร่
แพ้ไป!
ประวัติโก
เราทำแพลตฟอร์มบนนั้น ฉันจะพยายามอธิบายว่าทำไม
ประวัติโดยย่อของ Go เริ่มต้นในปี 2007 เปิดตัวในปี 2009 เวอร์ชันแรกเปิดตัวในปี 2012 (นั่นคือเราเริ่มทำงานก่อนการเปิดตัวครั้งแรกด้วยซ้ำ) ผู้ริเริ่มคือ Google ซึ่งต้องการแทนที่ Java อย่างที่ฉันสงสัย
ผู้เขียนมีชื่อเสียงมาก:
- Ken Thomson ผู้อยู่เบื้องหลัง Unix คิดค้น UTF-8 ทำงานบนระบบ Plan 9;
- Rob Pike ผู้ออกแบบ UTF-8 ร่วมกับ Ken ยังทำงานใน Plan 9, Inferno, Limbo ที่ Bell Labs;
- Robert Gizmer ผู้ที่เรารู้จักและชื่นชอบในการประดิษฐ์ Java HotSpot Compiler และทำงานเกี่ยวกับตัวสร้างใน V8 (ล่าม Javascript ของ Google);
- และผู้ร่วมให้ข้อมูลกว่า 700 ราย รวมถึงแพตช์บางส่วนของเรา
ได้อย่างรวดเร็ว
เราเห็นว่าภาษานั้นเรียบง่ายและเข้าใจได้ไม่มากก็น้อย เรามีประเภทที่ชัดเจน: ในบางกรณีจำเป็นต้องประกาศ แต่บางประเภทไม่ต้องประกาศ (หมายความว่าประเภทจะถูกอนุมานต่อไป)
จะเห็นได้ว่ามันเป็นแฟชั่นในการอธิบายโครงสร้าง จะเห็นได้ว่าเรามีแนวคิดของตัวชี้ จะเห็นได้ว่ามีการสนับสนุนพิเศษสำหรับการประกาศการเริ่มต้นของอาร์เรย์และอาร์เรย์ที่เชื่อมโยง
เข้าใจได้คร่าวๆ - คุณสามารถมีชีวิตอยู่ได้ กำลังพยายามเขียน Hello, world:
เราเห็นอะไร? นี่คือไวยากรณ์เหมือน C เครื่องหมายอัฒภาคเป็นตัวเลือก สามารถเป็นตัวคั่นสำหรับสองบรรทัดได้ แต่ถ้าเป็นสองโครงสร้างที่อยู่ในบรรทัดเดียวกัน
เราเห็นว่าวงเล็บปีกกาในโครงสร้างควบคุม (ในบรรทัดที่ 14) เป็นทางเลือก แต่ต้องใช้วงเล็บปีกกาเสมอ เราเห็นว่าการพิมพ์เป็นแบบคงที่ ทิมจะแสดงในกรณีส่วนใหญ่ ตัวอย่างนี้ซับซ้อนกว่า Hello, world เล็กน้อย - เพียงเพื่อแสดงว่ามีห้องสมุด
เราเห็นอะไรสำคัญอีกบ้าง? รหัสถูกจัดเป็นแพ็คเกจ และในการใช้แพ็คเกจในรหัสของคุณเอง คุณต้องนำเข้าโดยใช้คำสั่งนำเข้า - นี่เป็นสิ่งสำคัญเช่นกัน เราเริ่ม - ใช้งานได้ ยอดเยี่ยม!
มาลองอะไรที่ซับซ้อนกว่านี้กัน: สวัสดีชาวโลก แต่ตอนนี้มันเป็นเซิร์ฟเวอร์ http เราเห็นอะไรที่น่าสนใจที่นี่?
ประการแรก ฟังก์ชันทำหน้าที่เป็นพารามิเตอร์ ซึ่งหมายความว่าฟังก์ชั่นที่เรามีนั้นเป็น "พลเมืองชั้นหนึ่ง" และคุณสามารถทำสิ่งที่น่าสนใจได้มากมายในรูปแบบการใช้งาน เราเห็นสิ่งต่อไปที่ไม่คาดคิด: คำสั่งนำเข้าอ้างอิงโดยตรงไปยังที่เก็บ GitHub ถูกต้อง เป็นเช่นนั้น - ยิ่งกว่านั้น ควรทำเช่นไร
ใน Go ตัวระบุสากลของแพ็คเกจคือ URL ของที่เก็บ มียูทิลิตี Goget พิเศษที่ใช้สำหรับการอ้างอิงทั้งหมด ดาวน์โหลด ติดตั้ง คอมไพล์ และเตรียมสำหรับการใช้งานหากจำเป็น ในขณะเดียวกัน Goget ก็รู้เรื่อง html-meta ดังนั้น คุณสามารถเก็บไดเร็กทอรี http ซึ่งจะมีลิงก์ไปยังที่เก็บเฉพาะของคุณ (เช่น เราทำ)
เราเห็นอะไรอีกบ้าง? Http และ Json ในห้องสมุดปกติ เห็นได้ชัดว่ามีการวิปัสสนา - การสะท้อนซึ่งควรใช้ในการเข้ารหัส / json เพราะเราเพียงแค่แทนที่วัตถุตามอำเภอใจบางอย่างสำหรับมัน
เราเรียกใช้และเห็นว่าเรามีโค้ดที่เป็นประโยชน์ 20 บรรทัดที่คอมไพล์ รัน และให้โหลดเฉลี่ยปัจจุบันของเครื่อง (บนเครื่องที่กำลังทำงานอยู่)
มีอะไรอีกที่สำคัญจากสิ่งที่เราเห็นได้ทันทีที่นี่? มันรวบรวมเป็นหนึ่งไบนารีคงที่ (buinary) ไบนารีนี้ไม่มีการพึ่งพาเลย ไม่มีไลบรารี! สามารถคัดลอกไปยังระบบใดก็ได้ เรียกใช้ทันที และมันจะทำงาน
ย้ายที่
ไป: วิธีการและอินเทอร์เฟซ
โกมีวิธี คุณสามารถประกาศเมธอดสำหรับประเภทแบบกำหนดเองใดก็ได้ นอกจากนี้ ไม่จำเป็นต้องเป็นโครงสร้าง แต่อาจเป็นนามแฝงบางประเภท คุณสามารถประกาศนามแฝงสำหรับ N32 และเขียนเมธอดเพื่อทำสิ่งที่มีประโยชน์
และนี่คือที่เราตกอยู่ในอาการมึนงงเป็นครั้งแรก ... ปรากฎว่า Go ไม่มีชั้นเรียนเช่นนี้ ผู้ที่รู้จัก Go อาจกล่าวว่ามีการรวมประเภท แต่สิ่งนี้แตกต่างไปจากเดิมอย่างสิ้นเชิง ยิ่งนักพัฒนาหยุดคิดว่ามันเป็นมรดกได้เร็วเท่าไรก็ยิ่งดีเท่านั้น ไม่มีคลาสใน Go และไม่มีการสืบทอดเช่นกัน
คำถาม! บริษัทผู้เขียนที่นำโดย Google ให้อะไรแก่เราเพื่อแสดงความซับซ้อนของโลก เราได้รับอินเทอร์เฟซแล้ว!
อินเทอร์เฟซเป็นชนิดพิเศษที่ให้คุณเขียนเมธอดอย่างง่าย ลายเซ็นเมธอด นอกจากนี้ ประเภทใดก็ตามที่มีเมธอดเหล่านี้อยู่ (ถูกดำเนินการ) จะสอดคล้องกับอินเทอร์เฟซนี้ ซึ่งหมายความว่าคุณสามารถเขียนฟังก์ชันที่เกี่ยวข้องสำหรับประเภทหนึ่งสำหรับอีกประเภทหนึ่ง (ซึ่งสอดคล้องกับประเภทอินเทอร์เฟซนั้น) ถัดไป ประกาศตัวแปรประเภทอินเทอร์เฟซนี้และกำหนดออบเจกต์เหล่านี้ให้กับมัน
สำหรับแฟนๆ ฮาร์ดคอร์ ฉันสามารถพูดได้ว่าตัวแปรนี้จะมีพอยน์เตอร์สองตัว: ตัวชี้หนึ่งสำหรับข้อมูล อีกตัวสำหรับตารางคำอธิบายพิเศษเฉพาะสำหรับประเภทนี้โดยเฉพาะ ไปยังอินเทอร์เฟซของประเภทนี้ นั่นคือคอมไพเลอร์สร้างตารางคำอธิบายดังกล่าวในขณะที่ทำการเชื่อมโยง
และแน่นอนว่ามีตัวชี้ที่ทำให้เป็นโมฆะใน Go ส่วนต่อประสานคำ {} (ที่มีวงเล็บปีกกาสองตัว) เป็นตัวแปรที่อนุญาตให้คุณชี้ไปที่วัตถุใด ๆ ตามหลักการ
จนถึงตอนนี้ทุกอย่างเรียบร้อยทุกอย่างคุ้นเคย ไม่มีอะไรน่าแปลกใจ
ไป: goroutines
ตอนนี้เรามาถึงสิ่งที่เราสนใจ: กระบวนการที่มีน้ำหนักเบา - goroutines (goroutines) ในคำศัพท์ของ Go
- อย่างแรกคือน้ำหนักเบามาก (น้อยกว่า 2 Kb)
- ประการที่สองค่าใช้จ่ายในการสร้าง goroutine นั้นเล็กน้อย: คุณสามารถสร้างได้หนึ่งพันรายการต่อวินาที - จะไม่มีอะไรเกิดขึ้น
- โดยจะให้บริการโดยตัวกำหนดตารางเวลาของตนเอง ซึ่งเพียงแค่ถ่ายโอนการควบคุมจาก goroutine หนึ่งไปยังอีก goroutine
- ในกรณีนี้ การควบคุมจะถูกถ่ายโอนในกรณีต่อไปนี้:
- หากพบคำสั่ง go (หาก goroutine เริ่มต้น goroutine ถัดไป)
- หากเปิดใช้การบล็อกการโทรเข้า/ออก
- หากทริกเกอร์การรวบรวมขยะ
- หากเริ่มดำเนินการบางอย่างกับช่องสัญญาณ
นั่นคือ เมื่อใดก็ตามที่โปรแกรม Go ทำงานบนคอมพิวเตอร์ โปรแกรมจะตรวจจับจำนวนคอร์ในระบบ เริ่มเธรดได้มากเท่าที่จำเป็น (จำนวนคอร์ในระบบ ดังนั้นตัวกำหนดตารางเวลาจะเรียกใช้เธรดการดำเนินการที่มีน้ำหนักเบาบนเธรดของระบบปฏิบัติการเหล่านี้ทั้งหมดในแต่ละคอร์
ควรสังเกตว่านี่เป็นวิธีที่มีประสิทธิภาพสูงสุดในการใช้ธาตุเหล็ก นอกจากสิ่งที่เราได้แสดงให้เห็นแล้ว เรายังทำอะไรได้อีกมาก ตัวอย่างเช่น เราสร้างระบบ DPI ที่อนุญาตให้ให้บริการ 40 กิกะบิตในหนึ่งหน่วย (ขึ้นอยู่กับสิ่งที่เกิดขึ้นในบรรทัดเหล่านี้)
ที่นั่น แม้กระทั่งก่อน Go เราใช้โครงร่างเดียวกันทุกประการด้วยเหตุผลนี้: เนื่องจากช่วยให้คุณสามารถบันทึกตำแหน่งที่ตั้งของแคชโปรเซสเซอร์ ลดจำนวนสวิตช์บริบทระบบปฏิบัติการลงได้อย่างมาก (ซึ่งใช้เวลานานมากเช่นกัน) ฉันพูดซ้ำ: นี่เป็นวิธีที่มีประสิทธิภาพที่สุดในการใช้ธาตุเหล็ก
ตัวอย่างง่ายๆ 21 บรรทัดนี้เป็นตัวอย่างที่ใช้กับ echo-server ในขณะเดียวกัน โปรดทราบว่าฟังก์ชันเสิร์ฟนั้นง่ายมาก มันเป็นแบบเส้นตรง ไม่มีการโทรกลับ ไม่ต้องกังวลและคิดว่า... คุณแค่อ่านและเขียน!
ในเวลาเดียวกัน หากคุณอ่านและเขียน ควรบล็อกจริงๆ - goroutine นี้จะถูกจัดคิวและดำเนินการโดยตัวกำหนดตารางเวลาเมื่อการดำเนินการเป็นไปได้อีกครั้ง นั่นคือรหัสง่าย ๆ นี้สามารถทำหน้าที่เป็นเซิร์ฟเวอร์เสียงสะท้อนสำหรับการเชื่อมต่อได้มากเท่าที่ระบบปฏิบัติการบนเครื่องนี้จะอนุญาต
ต่อไปในเร็วๆ นี้...
โฆษณาบางส่วน🙂
ขอบคุณที่อยู่กับเรา คุณชอบบทความของเราหรือไม่? ต้องการดูเนื้อหาที่น่าสนใจเพิ่มเติมหรือไม่ สนับสนุนเราโดยการสั่งซื้อหรือแนะนำให้เพื่อน , อะนาล็อกที่ไม่เหมือนใครของเซิร์ฟเวอร์ระดับเริ่มต้นซึ่งเราคิดค้นขึ้นเพื่อคุณ: (ใช้ได้กับ RAID1 และ RAID10 สูงสุด 24 คอร์ และสูงสุด 40GB DDR4)
Dell R730xd ถูกกว่า 2 เท่าในศูนย์ข้อมูล Equinix Tier IV ในอัมสเตอร์ดัม? ที่นี่ที่เดียวเท่านั้น ในเนเธอร์แลนด์! Dell R420 - 2x E5-2430 2.2Ghz 6C 128GB DDR3 2x960GB SSD 1Gbps 100TB - จาก $99! อ่านเกี่ยวกับ
ที่มา: will.com