ალექსეი ნაიდენოვი. ITooLabs. განვითარების ქეისი Go (Golang) სატელეფონო პლატფორმაზე. Ნაწილი 1

ალექსეი ნაიდენოვი, აღმასრულებელი დირექტორი ITooLabs, საუბრობს ტელეკომის ოპერატორებისთვის სატელეკომუნიკაციო პლატფორმის შემუშავებაზე პროგრამირების ენაზე Go (გოლანგი). ალექსეი ასევე იზიარებს თავის გამოცდილებას პლატფორმის განლაგებისა და ექსპლუატაციის შესახებ ერთ-ერთ უმსხვილეს აზიურ ტელეკომის ოპერატორში, რომელიც იყენებდა პლატფორმას ხმოვანი ფოსტის (VoiceMail) და ვირტუალური PBX (Cloud PBX) სერვისების უზრუნველსაყოფად.

ალექსეი ნაიდენოვი (შემდგომში - 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. ვინაიდან ჩვენ დამოუკიდებლად მივდიოდით, სასწრაფოდ მოგვიწია მიგვეტოვებინა მაგარი გამყიდველი Storage. ჩვენ ყველაფერი ვიცით მათ შესახებ: რომ დაპირებები უნდა გაიყოს 3-ზე, ხოლო ღირებულება უნდა გავამრავლოთ 10-ზე. ამიტომ გავაკეთეთ DirDB და ა.შ.

მერე დაიწყო ზრდა. ამას დაემატა ბილინგის სერვისი, რადგან პლატფორმა ვეღარ უმკლავდებოდა. შემდეგ ბილინგის სერვერი MySQL-დან გადავიდა მონგოში. შედეგად, ჩვენ მივიღეთ სამუშაო გადაწყვეტა, რომელიც ამუშავებს ყველა ზარს, რომელიც მიდის იქ:

მაგრამ სადღაც შიგნით, იგივე გამყიდველი პროდუქტი ტრიალებს - მთავარი, ბირთვული, რომელიც ჩვენ ერთხელ ავიღეთ. დაახლოებით 2011 წლის ბოლოსთვის ჩვენ თვითონ მივხვდით, რომ ჩვენთვის მთავარი დაბრკოლება, რა თქმა უნდა, სწორედ ეს პროდუქტი იქნება - ჩვენ მას გადავაწყდებით. ჩვენ თვალწინ კედელი დავინახეთ, რომელშიც სრული გალოპებით შევრბოდით, როცა კლიენტები დადიოდნენ, დაემატა.
შესაბამისად, რაღაც უნდა გაგვეკეთებინა. რა თქმა უნდა, ჩვენ საკმაოდ ბევრი კვლევა ჩავატარეთ სხვადასხვა პროდუქტებზე - როგორც ღია კოდის, ასევე გამყიდველის. ახლა ამაზე არ შევჩერდები - ეს არ არის მთავარი. ბოლო სარეზერვო საშუალება, რაზეც ვფიქრობდით, იყო ჩვენი საკუთარი პლატფორმის შექმნა.

საბოლოოდ, ჩვენ მივედით ამ ვარიანტამდე. რატომ? რადგან ყველა გამყიდველი და ღია კოდის პროდუქტი შეიქმნა პრობლემების გადასაჭრელად 10 წლის წინ. ისე, თუ 10 წლის, და კიდევ რამდენიმე! არჩევანი ჩვენთვის აშკარა გახდა: ან დავემშვიდობებით ჩვენს იდეალურ იდეას იდეალური სერვისის შესახებ (პარტნიორებისთვის, ოპერატორებისთვის და საკუთარი თავისთვის), ან ვაკეთებთ რაიმეს საკუთარ თავს.

ჩვენ გადავწყვიტეთ რაღაც განსხვავებული გაგვეკეთებინა!

პლატფორმის მოთხოვნები

თუ რაიმეს დიდხანს აკეთებ (სხვის პროდუქტს იყენებ), მაშინ ნელ-ნელა შენს თავში წარმოიქმნება აზრი: როგორ გავაკეთო ეს მე თვითონ? ვინაიდან ჩვენ ყველა ვართ პროგრამისტები კომპანიაში (გარდა გამყიდველებისა, არ არიან არაპროგრამისტები), ჩვენი მოთხოვნები დიდი ხანია ჩამოყალიბდა და ისინი აშკარა იყო:

1. განვითარების მაღალი სიჩქარე. გამყიდველის პროდუქცია, რომელიც გვტანჯავდა, პირველ რიგში არ გვიწყობდა ხელს, რადგან ყველაფერი დიდხანს და ნელა აეწყო. გვინდოდა სწრაფად - ბევრი იდეა გვქონდა! ჯერ კიდევ ბევრი იდეა გვაქვს, მაგრამ მაშინ იდეების სია ისეთი იყო, რომ თითქოს ათი წელი იყო წინ. ახლა მხოლოდ ერთი წლით.
2. მრავალბირთვიანი რკინის მაქსიმალური გამოყენება. ეს ასევე მნიშვნელოვანი იყო ჩვენთვის, რადგან დავინახეთ, რომ მხოლოდ უფრო და უფრო მეტი ბირთვი იქნებოდა.
3. მაღალი საიმედოობა. ის ჩვენც ვიტირეთ.
4. ხარვეზების მაღალი ტოლერანტობა.
5. გვინდოდა დასრულებულიყო ყოველდღიური გამოშვების პროცესი. ამისათვის დაგვჭირდა ენის არჩევანი.

შესაბამისად, პროდუქტის მოთხოვნებიდან, რომელიც ჩვენ თვითონ წარმოვადგინეთ, ენის მიმართ მოთხოვნები აშკარად ლოგიკურად იზრდება.

1. თუ ჩვენ გვინდა მხარდაჭერა მრავალბირთვიანი სისტემებისთვის, მაშინ გვჭირდება მხარდაჭერა პარალელური შესრულებისთვის.
2. თუ ჩვენ გვჭირდება განვითარების სიჩქარე, გვჭირდება ენა, რომელიც მხარს უჭერს კონკურენტულ განვითარებას, კონკურენტულ პროგრამირებას. თუ ვინმეს არ შეხვედრია განსხვავება, მაშინ ეს ძალიან მარტივია:
   • პარალელური პროგრამირება არის იმის შესახებ, თუ როგორ მუშაობს ორი განსხვავებული თემა სხვადასხვა ბირთვზე;
   • კონკურენტული შესრულება, უფრო კონკრეტულად კონკურენტული მხარდაჭერა, არის იმის შესახებ, თუ როგორ ეხმარება ენა (ან გაშვების დრო, რაც არ უნდა იყოს) დაფაროს მთელი სირთულის პარალელური შესრულება.
3. მაღალი სტაბილურობა. ცხადია, ჩვენ გვჭირდებოდა კლასტერი და ის უკეთესი იყო ვიდრე ის, რაც გვქონდა გამყიდველის პროდუქტზე.

ბევრი ვარიანტი ნამდვილად არ გვქონდა, თუ გახსოვთ. ჯერ ერთი, Erlang - ჩვენ გვიყვარს და ვიცით, ეს იყო ჩემი პირადი, პირადი ფავორიტი. მეორეც, ჯავა კი არ არის ჯავა, არამედ კონკრეტულად სკალა. მესამე, ენა, რომელიც მაშინ ჩვენ საერთოდ არ ვიცოდით - წადი. ის ახლახან გამოჩნდა, უფრო სწორედ, უკვე არსებობდა დაახლოებით ორი წელი, მაგრამ ჯერ არ იყო გამოშვებული.

დამარცხებული წადი!

Go-ის ისტორია

ჩვენ მასზე პლატფორმა გავაკეთეთ. შევეცდები აგიხსნათ რატომ.

Go-ს მოკლე ისტორია. დაიწყო 2007 წელს, გაიხსნა 2009 წელს, პირველი ვერსია გამოვიდა 2012 წელს (ანუ ჩვენ დავიწყეთ მუშაობა ჯერ კიდევ პირველ გამოშვებამდე). ინიციატორი იყო Google, რომელსაც სურდა ჩაენაცვლებინა, როგორც მე ვეჭვობ, Java.

ძალიან ცნობილი ავტორები არიან:

• კენ ტომსონმა, რომელიც Unix-ის უკან იდგა, გამოიგონა UTF-8, მუშაობდა Plan 9 სისტემაზე;
• რობ პაიკი, რომელმაც შექმნა UTF-8 კენთან ერთად, ასევე მუშაობდა Plan 9, Inferno, Limbo-ზე Bell Labs-ში;
• რობერტ გიზმერი, რომელსაც ვიცნობთ და გვიყვარს Java HotSpot შემდგენელის გამოგონებით და V8-ში გენერატორზე მუშაობისთვის (Google-ის Javascript თარჯიმანი);
• და 700-ზე მეტი კონტრიბუტორი, მათ შორის ზოგიერთი ჩვენი პატჩი.

წადი ერთი შეხედვით

ჩვენ ვხედავთ, რომ ენა მეტ-ნაკლებად მარტივი და გასაგებია. ჩვენ გვაქვს აშკარა ტიპები: ზოგ შემთხვევაში საჭიროა მათი დეკლარირება, ზოგში არა (იგულისხმება, რომ ტიპები მაინც დასკვნაა).

ჩანს, რომ მოდურია სტრუქტურების აღწერა. ჩანს, რომ ჩვენ გვაქვს მაჩვენებლის ცნება (სადაც ვარსკვლავია). ჩანს, რომ არსებობს სპეციალური მხარდაჭერა მასივების და ასოციაციური მასივების ინიციალიზაციის გამოცხადებისთვის.

უხეშად გასაგებია - შეგიძლია იცხოვრო. ვცდილობ დავწერო გამარჯობა, სამყარო:

რას ვხედავთ? ეს არის C-ის მსგავსი სინტაქსი, მძიმით არჩევითია. ეს შეიძლება იყოს ორი ხაზის გამყოფი, მაგრამ მხოლოდ იმ შემთხვევაში, თუ ეს არის ორი კონსტრუქცია, რომლებიც ზუსტად იმავე ხაზზეა.

ჩვენ ვხედავთ, რომ საკონტროლო სტრუქტურებში (მე-14 ხაზზე) ფრჩხილები არჩევითია, მაგრამ ხვეული ყოველთვის საჭიროა. ჩვენ ვხედავთ, რომ აკრეფა სტატიკურია. დრო უმეტეს შემთხვევაში ნაჩვენებია. ეს მაგალითი ოდნავ უფრო რთულია, ვიდრე ჩვეულებრივი Hello, world - მხოლოდ იმის საჩვენებლად, რომ არსებობს ბიბლიოთეკა.

კიდევ რას ვხედავთ მნიშვნელოვანს? კოდი ორგანიზებულია პაკეტებად. და იმისათვის, რომ გამოიყენოთ პაკეტი საკუთარ კოდში, საჭიროა მისი იმპორტი იმპორტის დირექტივის გამოყენებით - ეს ასევე მნიშვნელოვანია. ჩვენ ვიწყებთ - მუშაობს. დიდი!

მოდით ვცადოთ რაღაც უფრო რთული: გამარჯობა, მსოფლიო, მაგრამ ახლა ეს არის http სერვერი. რას ვხედავთ აქ საინტერესო?

პირველ რიგში, ფუნქცია მოქმედებს როგორც პარამეტრი. ეს ნიშნავს, რომ ფუნქცია, რომელიც ჩვენ გვაქვს, არის „პირველი კლასის მოქალაქე“ და ამით შეგიძლიათ ბევრი საინტერესო რამ გააკეთოთ ფუნქციონალურ სტილში. ჩვენ ვხედავთ მოულოდნელს შემდეგს: იმპორტის დირექტივა პირდაპირ ეხება GitHub საცავს. ასეა, ასეა – უფრო მეტიც, ასეც უნდა მოხდეს.

Go-ში პაკეტის უნივერსალური იდენტიფიკატორი არის მისი საცავის url. არსებობს სპეციალური Goget უტილიტა, რომელიც მიდის ყველა დამოკიდებულებაზე, ჩამოტვირთავს მათ, დააინსტალირებს, აწყობს და საჭიროების შემთხვევაში ამზადებს გამოსაყენებლად. ამავდროულად, გოგეტმა იცის html-meta-ს შესახებ. შესაბამისად, შეგიძლიათ შეინახოთ http დირექტორია, რომელიც შეიცავს ბმულებს თქვენს კონკრეტულ საცავთან (როგორც ჩვენ, მაგალითად, ვაკეთებთ).

კიდევ რას ვხედავთ? Http და Json ჩვეულებრივ ბიბლიოთეკაში. არსებობს, ცხადია, ინტროსპექცია - ასახვა, რომელიც უნდა გამოვიყენოთ კოდირების / json-ში, რადგან ჩვენ უბრალოდ ვცვლით მას რაიმე თვითნებურ ობიექტს.

ჩვენ ვაწარმოებთ მას და ვხედავთ, რომ გვაქვს 20 სტრიქონი სასარგებლო კოდი, რომელიც ადგენს, აწარმოებს და იძლევა აპარატის მიმდინარე საშუალო დატვირთვას (მანქანაზე, რომელზეც ის მუშაობს).
კიდევ რა არის მნიშვნელოვანი იმისგან, რაც ჩვენ დაუყოვნებლივ ვხედავთ აქ? იგი იკრიბება ერთ სტატიკურ ბინარში (ბუინარი). ამ ბინარს საერთოდ არ აქვს დამოკიდებულებები, არც ბიბლიოთეკები! მისი კოპირება შესაძლებელია ნებისმიერ სისტემაში, დაუყოვნებლივ გაშვება და იმუშავებს.

გადაადგილება.

გადასვლა: მეთოდები და ინტერფეისები

Go აქვს მეთოდები. თქვენ შეგიძლიათ გამოაცხადოთ მეთოდი ნებისმიერი მორგებული ტიპისთვის. უფრო მეტიც, ეს სულაც არ არის სტრუქტურა, მაგრამ შეიძლება იყოს რაიმე სახის მეტსახელი. თქვენ შეგიძლიათ გამოაცხადოთ მეტსახელი N32-ისთვის და დაწეროთ მეთოდები, რომ გააკეთოს რაიმე სასარგებლო.

და აქ ჩვენ პირველად ჩავვარდებით სისულელეში... თურმე გო-ს არ აქვს კლასები, როგორც ასეთი. ვინც იცის Go შეიძლება თქვას, რომ არსებობს ტიპის ჩართვა, მაგრამ ეს სრულიად განსხვავებულია. რაც უფრო ადრე შეწყვეტს დეველოპერი მასზე ფიქრს, როგორც მემკვიდრეობით, მით უკეთესი. Go-ში კლასები არ არის და არც მემკვიდრეობაა.

Კითხვა! რა მოგვცა Google-ის ხელმძღვანელობით ავტორთა კომპანიამ სამყაროს სირთულის ჩვენების მიზნით? ჩვენ მოგვცეს ინტერფეისები!

ინტერფეისი არის სპეციალური ტიპი, რომელიც საშუალებას გაძლევთ დაწეროთ მარტივი მეთოდები, მეთოდის ხელმოწერები. გარდა ამისა, ნებისმიერი ტიპი, რომლისთვისაც ეს მეთოდები არსებობს (შესრულებულია) შეესაბამება ამ ინტერფეისს. ეს ნიშნავს, რომ თქვენ შეგიძლიათ უბრალოდ დაწეროთ შესაბამისი ფუნქცია ერთი ტიპისთვის, მეორესთვის (რომელიც შეესაბამება ამ ინტერფეისის ტიპს). შემდეგი, გამოაცხადეთ ამ ინტერფეისის ტიპის ცვლადი და მიაკუთვნეთ მას რომელიმე ამ ობიექტს.

ჰარდკორის გულშემატკივრებისთვის შემიძლია ვთქვა, რომ ეს ცვლადი რეალურად შეიცავს ორ მაჩვენებელს: ერთი მონაცემებისკენ, მეორე სპეციალური აღწერის ცხრილისკენ, რომელიც სპეციფიკურია ამ კონკრეტული ტიპისთვის, ამ ტიპის ინტერფეისისთვის. ანუ შემდგენელი აკეთებს აღწერების ასეთ ცხრილებს დაკავშირების დროს.

და, რა თქმა უნდა, არის მინიშნებები, რომ გააუქმოს Go-ში. სიტყვა ინტერფეისი {} (ორი ხვეული ბრეკეტით) არის ცვლადი, რომელიც საშუალებას გაძლევთ პრინციპში მიუთითოთ ნებისმიერი ობიექტი.
ჯერჯერობით ყველაფერი რიგზეა, ყველაფერი ნაცნობია. არაფერია გასაკვირი.

წადი: გორუტინები

ახლა მივედით იმაზე, რაც გვაინტერესებს: მსუბუქი პროცესები - გორუტინები (გოროტინები) Go ტერმინოლოგიაში.

1. პირველი, ისინი მართლაც მსუბუქი წონაა (2 კბ-ზე ნაკლები).
2. მეორეც, ასეთი გორუტინის შექმნის ღირებულება უმნიშვნელოა: თქვენ შეგიძლიათ შექმნათ ათასი მათგანი წამში - არაფერი მოხდება.
3. მათ ემსახურება საკუთარი გრაფიკი, რომელიც უბრალოდ გადასცემს კონტროლს ერთი გორუტინიდან მეორეზე.
4. ამ შემთხვევაში, კონტროლი გადადის შემდეგ შემთხვევებში:
   • თუ წავა განცხადება წავა (თუ გორუტინი იწყებს შემდეგ გორუტინს);
   • თუ ჩართულია დაბლოკვის შეყვანის/გასვლის ზარი;
   • თუ ნაგვის შეგროვება გამოიწვია;
   • თუ დაიწყება რაიმე ოპერაცია არხებთან.

ანუ, როდესაც Go პროგრამა გაშვებულია კომპიუტერზე, ის ამოიცნობს სისტემაში ბირთვების რაოდენობას, იწყებს იმდენ თემას, რამდენიც საჭიროა (რამდენი ბირთვი აქვს სისტემას ან რამდენი უთხარით მას). შესაბამისად, დამგეგმავი განახორციელებს შესრულების ამ მსუბუქ ძაფებს ოპერაციული სისტემის ყველა ამ ძაფზე თითოეულ ბირთვში.

უნდა აღინიშნოს, რომ ეს არის ყველაზე ეფექტური გზა რკინის გამოსაყენებლად. გარდა იმისა, რაც ვაჩვენეთ, კიდევ ბევრს ვაკეთებთ. ჩვენ ვაკეთებთ, მაგალითად, DPI სისტემებს, რომლებიც საშუალებას იძლევა ერთ ერთეულში 40 გიგაბიტი მოემსახუროს (დამოკიდებულია იმაზე, თუ რა ხდება ამ ხაზებში).

იქ, Go-მდეც კი, ჩვენ ვიყენებდით ზუსტად იმავე სქემას სწორედ ამ მიზეზით: რადგან ის საშუალებას გაძლევთ შეინახოთ პროცესორის ქეშის ადგილმდებარეობა, მნიშვნელოვნად შეამციროთ OS კონტექსტური გადამრთველების რაოდენობა (რასაც ასევე ძალიან დიდი დრო სჭირდება). ვიმეორებ: ეს არის ყველაზე ეფექტური გზა რკინის გამოსაყენებლად.

ეს მარტივი 21 სტრიქონიანი მაგალითი არის მაგალითი, რომელიც უბრალოდ აკეთებს ექო-სერვერს. ამავე დროს, გაითვალისწინეთ, რომ სერვისის ფუნქცია ძალიან მარტივია, ის ხაზოვანია. არ არის გამოძახება, არ არის საჭირო შეწუხება და ფიქრი... თქვენ უბრალოდ კითხულობთ და წერთ!

ამავდროულად, თუ კითხულობთ და წერთ, ის რეალურად უნდა დაბლოკოს - ეს გორუტინი უბრალოდ რიგში დგას და გადაიღებს განრიგის მიერ, როდესაც შესრულება ხელახლა გახდება შესაძლებელი. ანუ, ამ მარტივ კოდს შეუძლია იმოქმედოს როგორც ექო სერვერი იმდენი კავშირისთვის, რამდენსაც ამ აპარატის ოპერაციული სისტემა საშუალებას მისცემს.

გაგრძელება ძალიან მალე...

რამდენიმე რეკლამა 🙂

გმადლობთ, რომ დარჩით ჩვენთან. მოგწონთ ჩვენი სტატიები? გსურთ ნახოთ უფრო საინტერესო შინაარსი? მხარი დაგვიჭირეთ შეკვეთის განთავსებით ან მეგობრებისთვის რეკომენდაციით, ღრუბელი VPS დეველოპერებისთვის 4.99 დოლარიდან, საწყისი დონის სერვერების უნიკალური ანალოგი, რომელიც ჩვენ მიერ გამოგონილია თქვენთვის: მთელი სიმართლე VPS (KVM) E5-2697 v3 (6 Cores) 10GB DDR4 480GB SSD 1Gbps 19$-დან ან როგორ გავაზიარო სერვერი? (ხელმისაწვდომია RAID1 და RAID10-ით, 24 ბირთვამდე და 40 გბ-მდე DDR4).

Dell R730xd 2-ჯერ იაფია Equinix Tier IV მონაცემთა ცენტრში ამსტერდამში? Მხოლოდ აქ 2 x Intel TetraDeca-Core Xeon 2x E5-2697v3 2.6GHz 14C 64GB DDR4 4x960GB SSD 1Gbps 100 ტელევიზორი $199-დან ნიდერლანდებში! Dell R420 - 2x E5-2430 2.2Ghz 6C 128GB DDR3 2x960GB SSD 1Gbps 100TB - $99-დან! Წაიკითხო რაღაცის შესახებ როგორ ავაშენოთ ინფრასტრუქტურის კორპუსი. კლასი Dell R730xd E5-2650 v4 სერვერების გამოყენებით 9000 ევროს ღირებულების პენი?

წყარო: www.habr.com