Esimweni sokuthuthuka okusheshayo kwe-cloud computing kanye ne-microservice architecture, kunesidingo esandayo sokuhlinzeka ngamakhono okusebenzisa ikhodi yezilimi ezihlukahlukene zokuhlela ngesiqinisekiso sokuphepha, ukuqina nokusebenza okuphezulu. Lesi sihloko sichaza iphrojekthi esebenzisa ukusetshenziswa kwekhodi endaweni engayodwa, futhi ixoxa ngezinzuzo zesixazululo sezakhiwo esikhethiwe se-WEB IDE yesimanje. Isistimu yakhelwe phezu kwayo Hamba , isebenzisa gRPC ukuxhumana okusebenzayo kwe-interservice, I-Redis njengomthengisi wemiyalezo futhi I-Docker ukuhlukanisa imvelo yokwenza. A I-WebSocket iseva isetshenziselwa ukubonisa imiphumela ngesikhathi sangempela.

Sizochaza ngokuningiliziwe ukuthi izingxenye eziyinhloko zesistimu zakhiwe kanjani, ukuthi zihluke kanjani kwezinye izixazululo nokuthi kungani ukukhethwa kwalobu buchwepheshe kuvumela ukufeza ukusebenza okuphezulu nokuphepha.

1. Uhlolojikelele lwezakhiwo kanye nezingxenye eziyinhloko

Iphrojekthi yakhelwe kumgomo we-microservice architecture, okuvumela ukuthi uhlukanise ukusebenza kumasevisi azimele. Ingxenye ngayinye inesibopho somsebenzi okhethekile kakhulu, oqinisekisa ukuguquguquka, ukulinganisa, nokubekezelela amaphutha kwesistimu.

Izingxenye eziyinhloko:

• I-gRPC isetshenziselwa ukuxhumana phakathi kwezinsizakalo. Ilungele ukudlulisa idatha phakathi kwama-microservices ngenxa:
  • Iphrothokholi kanambambili (Amabhafa weProtokholi): iqinisekisa ukudluliswa kwedatha okusheshayo nokuhlangene.
  • Ukuthayipha okuqinile: kusiza ukugwema amaphutha ekudluliselweni kwedatha nasekucutshungulweni.
  • Ukubambezeleka okuphansi: okubalulekile ezicingweni zangaphakathi phakathi kwamasevisi (isibonelo, phakathi kweseva ye-gRPC kanye nomugqa we-Redis).
• Iseva yeWebSocket: Inikeza ukuxhumana okubili neklayenti ukuze kudluliselwe imiphumela yokubulawa ngesikhathi sangempela. Ibhalisela ulayini onemiphumela futhi idlulisele idatha kuklayenti, inikeze ukuboniswa okusheshayo kwamalogi okuhlanganiswa nawokwenza.
• Isisebenzi: Isevisi ezimele edonsa imisebenzi emgqeni, edala indawo yokusebenza yesikhashana, eqinisekisa futhi ikhiphe ikhodi kusiqukathi se-Docker esingasodwa, bese ishicilela imiphumela yokwenziwa ibuyele kulayini.
• I-Redis: Isetshenziswa njengomthengisi womlayezo ukudlulisa imisebenzi isuka kuseva ye-gRPC iye Kumsebenzi kanye nemiphumela isuka kuMsebenzi iye kuseva ye-WebSocket. Izinzuzo zeRedis ijubane eliphezulu, ukwesekwa kwe-Pub/Sub kanye nokukala okulula.
• Amamojula angaphakathi:
  • I-Compiler ne-Docker Runner: Imojula enesibopho sokusebenzisa imiyalo ye-Docker ngokugawulwa kokusakaza, okuvumela ukuqapha kwesikhathi sangempela kwenqubo yokuhlanganisa nokwenza.
  • Abagijimi Bolimi: Hlanganisa ingqondo ukuze kuqinisekiswe, kuhlanganiswe, futhi kwenziwe ikhodi yezilimi ezihlukahlukene (C, C++, C#, Python, JavaScript, TypeScript). Umgijimi ngamunye usebenzisa isixhumi esibonakalayo esisodwa, esenza kube lula ukunwetshwa kokusebenza kwezilimi ezintsha.

2. Ubuchwepheshe kanye nezizathu zokukhetha

Hamba

Izinzuzo ze-Go:

• Ukusebenza nokulinganisa: I-Go inesivinini esikhulu sokwenza, esibaluleke kakhulu ekuphatheni inombolo enkulu yezicelo ezifanayo.

• Ukusekelwa okwakhelwe ngaphakathi kwe-concurrency: Izinqubo zama-goroutines namashaneli zivumela ukusebenzisa ukusebenzisana okuvumelanayo phakathi kwezingxenye ngaphandle kwamaphethini okufunda amaningi ayinkimbinkimbi.

  
  

gRPC

Izinzuzo ze-gRPC:

• Ukudluliswa kwedatha okuphumelelayo: Ngenxa yephrothokholi yokudluliswa kanambambili (I-Protocol Buffers), i-gRPC inikeza ukubambezeleka okuphansi nomthwalo wenethiwekhi ophansi.
• Ukuthayipha okuqinile: Lokhu kunciphisa inani lamaphutha ahlobene nokuchazwa okungalungile kwedatha phakathi kwama-microservices.
• Ukusekelwa kokusakazwa kwe-bidirectional: Lokhu kuwusizo ikakhulukazi ekushintshisaneni ngamalogi nemiphumela yokusabalalisa ngesikhathi sangempela.

Ukuqhathanisa: Ngokungafani ne-REST API, i-gRPC inikeza ukuxhumana okusebenza kahle nokuthembekile phakathi kwezinsizakalo, okubalulekile ezinhlelweni ezihambisana kakhulu.

I-Redis

Kungani Redis?

• Ukusebenza okuphezulu: I-Redis ingakwazi ukuphatha inani elikhulu lemisebenzi ngomzuzwana, okuyenza ilungele umsebenzi nemigqa yemiphumela.

• I-Pub/Sub and List Support: Ubulula bokusebenzisa imigqa nezindlela zokubhalisa kwenza kube lula ukuhlela ukusebenzisana okuvumelanayo phakathi kwezinsizakalo.

• Ukuqhathaniswa nabanye abadayisi bemilayezo: Ngokungafani ne-RabbitMQ noma i-Kafka, i-Redis idinga ukulungiselelwa okuncane futhi inikeza ukusebenza okwanele kumasistimu esikhathi sangempela.

  
  

I-Docker

Indima kaDocker:

• Ukuhlukaniswa kwemvelo: Iziqukathi ze-Docker zikuvumela ukuthi usebenzise ikhodi endaweni engayodwa, okwandisa ukuphepha kokubulawa futhi kunciphisa ubungozi bokungqubuzana nohlelo oluyinhloko.

• Ukuphatha nokungaguquguquki: Ukusebenzisa i-Docker kunikeza indawo efanayo yokuhlanganisa nokusebenzisa ikhodi, kungakhathalekile ukuthi iluphi uhlelo lomsingathi.

• Ukuqhathanisa: Ikhodi egijima ngqo kumsingathi ingaba sengozini yezokuphepha futhi iholele ezingxabanweni zokuncika, kuyilapho i-Docker ikuvumela ukuthi uxazulule lezi zinkinga.

  
  

I-WebSocket

• Isikhathi sangempela: Ukuxhumana okuqhubekayo neklayenti kuvumela idatha (amalogi, imiphumela yokubulawa) ukuthi idluliswe khona manjalo.
• Umuzwa othuthukisiwe womsebenzisi: Nge-WebSocket, i-IDE ingabonisa imiphumela yekhodi.

3. Izinzuzo ze-Microservice Architecture

Le phrojekthi isebenzisa indlela ye-microservice, enezinzuzo eziningi ezibalulekile:

• Ukukala okuzimele: Isevisi ngayinye (iseva ye-gRPC, Isisebenzi, iseva ye-WebSocket, i-Redis) ingakalwa ngokuhlukile kuye ngomthwalo. Lokhu kuvumela ukusetshenziswa kahle kwezinsiza kanye nokuzivumelanisa ngokushesha nokukhula kwenani lezicelo.
• Ukubekezelela iphutha: Ukwehlukanisa isistimu ibe amamojula azimele kusho ukuthi ukwehluleka kwe-microservice eyodwa akuholeli ekuhlulekeni kwalo lonke uhlelo. Lokhu kukhulisa ukuzinza futhi kwenza lula ukutholakala kwamaphutha.
• Ukuvumelana nezimo kokuthuthukiswa nokusatshalaliswa: Ama-Microservices athuthukiswa futhi asetshenziswe ngokuzimela, okwenza kube lula ukwethulwa kwezici ezintsha nezibuyekezo. Lokhu futhi kukuvumela ukuthi usebenzise ubuchwepheshe obufaneleka kakhulu kusevisi ngayinye ethile.
• Ukuhlanganisa kalula: Izixhumanisi zokusebenzelana ezichazwe ngokucacile (isb nge-gRPC) zikwenza kube lula ukuxhuma izinsiza ezintsha ngaphandle kwezinguquko ezinkulu ekwakhiweni okukhona.
• Ukuhlukaniswa nokuphepha: Isevisi encane ngayinye ingasebenza esitsheni sayo, esinciphisa ubungozi obuhlobene nokusebenzisa ikhodi engaphephile futhi inikeze isendlalelo esengeziwe sokuvikela.

4. Ukuhlaziya okuqhathanisayo kwezindlela zezakhiwo

Lapho kwakhiwa ama-WEB IDE esimanje okwenziwa kwekhodi ekude, izixazululo ezihlukahlukene zezakhiwo zivame ukuqhathaniswa. Ake sicabangele izindlela ezimbili:

Indlela A: I-Microservice architecture (gRPC + Redis + Docker)

• Ukubambezeleka: 40 ms
• Ukukhiqiza: amayunithi angama-90
• Ukuphepha: amayunithi angama-85
• I-Scalability: amayunithi angama-90

Izici:
Le ndlela ihlinzeka ngokuxhumana okusheshayo nokuthembekile kwezinsizakusebenza, ukuhlukaniswa okuphezulu kokwenziwa kwekhodi, kanye nokukala okuguquguqukayo ngenxa yokufakwa kweziqukathi. Ilungele ama-WEB IDE esimanje, lapho ukuphendula nokuphepha kubalulekile.

Indlela B: I-Traditional Monolithic Architecture (HTTP REST + Centralised Execution)

• Ukubambezeleka: 70 ms
• Ukukhiqiza: amayunithi angama-65
• Ukuphepha: amayunithi angama-60
• I-Scalability: amayunithi angama-70

Izici:
Izixazululo ze-Monolithic, ezivame ukusetshenziswa ezinguqulweni zangaphambili zama-IDE ewebhu, zisekelwe ku-HTTP REST kanye nokwenziwa kwekhodi okumaphakathi. Amasistimu anjalo abhekana nezinkinga zokukala, ukubambezeleka okwandisiwe, nobunzima ekuqinisekiseni ukuphepha lapho kusetshenziswa ikhodi yomunye umuntu.

Yazi: Esimeni samanje sokuthuthukiswa kwe-WEB IDE, i-HTTP REST kanye nendlela yokwenza emaphakathi ingaphansi kwezinzuzo zezakhiwo ze-microservices, njengoba inganikezi ukuguquguquka okudingekayo kanye nokulinganisa.

Ukubona ngeso lengqondo amamethrikhi okuqhathanisa

Igrafu ibonisa ngokucacile ukuthi i-microservices architecture (I-Approach A) inikeza ukubambezeleka okuphansi, ukuphuma okuphakeme, ukuvikeleka okungcono nokuqina uma kuqhathaniswa nesixazululo se-monolithic (I-Approach B).

5. I-Docker Architecture: ukuhlukaniswa kanye nokulinganisa

Enye yezinto ezibalulekile zokuvikela nokuqina kwesistimu ukusetshenziswa kwe-Docker. Esixazululweni sethu, zonke izinsizakalo zisatshalaliswa ezitsheni ezihlukene, eziqinisekisa:

• Ukuhlukaniswa kwendawo yokusebenza: Isevisi ngayinye (iseva ye-gRPC, Isisebenzi, iseva ye-WebSocket) kanye nomthengisi wemiyalezo (i-Redis) isebenza esitsheni sayo, esinciphisa ubungozi bekhodi engaphephile ethinta isistimu enkulu. Ngesikhathi esifanayo, ikhodi esetshenziswa umsebenzisi esipheqululini (isibonelo, nge-WEB IDE) iyakhiwa futhi ifakwe esitsheni esihlukile se-Docker somsebenzi ngamunye. Le ndlela iqinisekisa ukuthi ikhodi okungenzeka ingaphephile noma enephutha ayikwazi ukuthikameza ukusebenza kwengqalasizinda eyinhloko.
• Ukungaguquguquki kwemvelo: Ukusebenzisa i-Docker kuqinisekisa ukuthi izilungiselelo zihlala zifana ekuthuthukisweni, ekuhlolweni, nasezindaweni zokukhiqiza, okwenza kube lula ukulungisa amaphutha futhi iqinisekise ukubikezelwa kokwenziwa kwekhodi.
• Ukuguquguquka kwe-scalability: Ingxenye ngayinye ingalinganiswa ngokuzimela, okukuvumela ukuthi uvumelane ngokuphumelelayo nokushintsha imithwalo. Isibonelo, njengoba inani lezicelo likhula, ungaqalisa iziqukathi ezengeziwe Zabasebenzi, ngasinye sazo esizodala iziqukathi ezihlukene zokwenza ikhodi yomsebenzisi.

• 
  

6. Izingxenye ezincane zekhodi

Ngezansi inguqulo emincane yezigaba eziyinhloko zekhodi ebonisa ukuthi isistimu:

1. Inquma ukuthi yiluphi ulimi okufanele lusetshenziswe kusetshenziswa ukubhaliswa komgijimi womhlaba.
2. Iqala isiqukathi se-Docker ukusebenzisa ikhodi yomsebenzisi isebenzisa umsebenzi we-RunInDockerStreaming.

1. Ukutholwa kolimi ngokubhaliswa komgijimi

Uhlelo lusebenzisa ukubhaliswa komhlaba wonke, lapho ulimi ngalunye lunomgijimi walo. Lokhu kukuvumela ukuthi ungeze kalula ukusekelwa kwezilimi ezintsha, kwanele ukusebenzisa isixhumi esibonakalayo sokugijima bese usibhalisa:

 package languages import ( "errors" "sync" ) var ( registry = make(map[string]Runner) registryMu sync.RWMutex ) type Runner interface { Validate(projectDir string) error Compile(ctx context.Context, projectDir string) (<-chan string, error) Run(ctx context.Context, projectDir string) (<-chan string, error) } func Register(language string, runner Runner) { registryMu.Lock() defer registryMu.Unlock() registry[language] = runner } func GetRunner(language string) (Runner, error) { registryMu.RLock() defer registryMu.RUnlock() if runner, exists := registry[language]; exists { return runner, nil } return nil, errors.New("unsupported language") }

Isibonelo sokubhalisa ulimi olusha:

 func init() { languages.Register("python", NewGenericRunner("python")) languages.Register("javascript", NewGenericRunner("javascript")) }

Ngakho-ke, lapho uthola isicelo, uhlelo lubiza:

 runner, err := languages.GetRunner(req.Language)

futhi ithola umgijimi ohambisanayo ukuze akhiphe ikhodi.

2. Kwethulwa isiqukathi se-Docker ukuze sikhiphe ikhodi

Ngesicelo ngasinye sekhodi yomsebenzisi, kwakhiwa isitsha se-Docker esihlukile. Lokhu kwenziwa ngaphakathi kwezindlela zokugijima (isibonelo, ku-Run). I-logic eyinhloko yokusebenzisa isiqukathi ikumsebenzi we-RunInDockerStreaming:

 package compiler import ( "bufio" "fmt" "io" "log" "os/exec" "time" ) func RunInDockerStreaming(image, dir, cmdStr string, logCh chan < -string) error { timeout: = 50 * time.Second cmd: = exec.Command("docker", "run", "--memory=256m", "--cpus=0.5", "--network=none", "-v", fmt.Sprintf("%s:/app", dir), "-w", "/app", image, "sh", "-c", cmdStr) cmd.Stdin = nil stdoutPipe, err: = cmd.StdoutPipe() if err != nil { return fmt.Errorf("error getting stdout: %v", err) } stderrPipe, err: = cmd.StderrPipe() if err != nil { return fmt.Errorf("error getting stderr: %v", err) } if err: = cmd.Start();err != nil { return fmt.Errorf("Error starting command: %v", err) } // Reading logs from the container go func() { reader: = bufio.NewReader(io.MultiReader(stdoutPipe, stderrPipe)) for { line, isPrefix, err: = reader.ReadLine() if err != nil { if err != io.EOF { logCh < -fmt.Sprintf("[Error reading logs: %v]", err) } break } msg: = string(line) for isPrefix { more, morePrefix, err: = reader.ReadLine() if err != nil { break } msg += string(more) isPrefix = morePrefix } logCh < -msg } close(logCh) }() doneCh: = make(chan error, 1) go func() { doneCh < -cmd.Wait() }() select { case err: = < -doneCh: return err case <-time.After(timeout): if cmd.Process != nil { cmd.Process.Kill() } return fmt.Errorf("Execution timed out") } }

Lo msebenzi ukhiqiza umyalo we-docker run, lapho:

• isithombe isithombe se-Docker esikhethelwe ulimi oluthile (okuchazwe ukucushwa komgijimi).
• I-dir iyinkomba enekhodi edalelwe lesi sicelo.
• I-cmdStr iwumyalo wokuhlanganisa noma wokwenza ikhodi.

Ngakho-ke, lapho ubiza indlela ye-Run yomgijimi, okulandelayo kwenzeka:

• Umsebenzi we-RunInDockerStreaming uqala isiqukathi se-Docker lapho kukhishwa khona ikhodi.
• Amalogi okubulala asakazwa esiteshini se-logCh, esikuvumela ukuthi udlulise ulwazi mayelana nenqubo yokusabalalisa ngesikhathi sangempela.

3. Inqubo yokukhipha ehlanganisiwe

Isiqephu esincishisiwe se-logic eyinhloko yokusebenzisa ikhodi (i-executor.ExecuteCode):

 func ExecuteCode(ctx context.Context, req CodeRequest, logCh chan string) CodeResponse { // Create a temporary directory and write files projectDir, err: = util.CreateTempProjectDir() if err != nil { return CodeResponse { "", fmt.Sprintf("Error: %v", err) } } defer os.RemoveAll(projectDir) for fileName, content: = range req.Files { util.WriteFileRecursive(filepath.Join(projectDir, fileName), [] byte(content)) } // Get a runner for the selected language runner, err: = languages.GetRunner(req.Language) if err != nil { return CodeResponse { "", err.Error() } } if err: = runner.Validate(projectDir); err != nil { return CodeResponse { "", fmt.Sprintf("Validation error: %v", err) } } // Compile (if needed) and run code in Docker container compileCh, _: = runner.Compile(ctx, projectDir) for msg: = range compileCh { logCh < -"[Compilation]: " + msg } runCh, _: = runner.Run(ctx, projectDir) var output string for msg: = range runCh​​ { logCh < -"[Run]: " + msg output += msg + "\n" } return CodeResponse { Output: output } }

Kulesi sibonelo esincane:

• Ukutholwa kolimi kwenziwa ngokushayela izilimi.GetRunner(req.Language), okuvumela ukwengezwa okulula kosekelo lolimi olusha.
• Ukwethulwa kwesiqukathi se-Docker kusetshenziswa ngaphakathi kwezindlela ze-Compile/Run, ezisebenzisa i-RunInDockerStreaming ukuze ikhiphe ikhodi iyodwa.

Lezi zingcezu ezibalulekile zibonisa ukuthi isistimu isekela kanjani ukwandiswa (ukwengezwa okulula kwezilimi ezintsha) futhi ihlinzeka ngokuhlukaniswa ngokwakha isitsha se-Docker esihlukile sesicelo ngasinye. Le ndlela ithuthukisa ukuvikeleka, ukuzinza nokuqina kwenkundla, okubaluleke kakhulu kuma-WEB IDE esimanje.

7. Isiphetho

Lesi sihloko sidingida inkundla yokwenza ikhodi ekude eyakhelwe ekwakhiweni kwe-microservice kusetshenziswa isitaki se-gRPC + Redis + Docker. Le ndlela ikuvumela ukuthi:

• Yehlisa ukubambezeleka futhi uqinisekise ukusebenza okuphezulu ngenxa yokuxhumana okusebenzayo kwe-interservice.
• Qinisekisa ukuphepha ngokuhlukanisa ukusetshenziswa kwekhodi ezitsheni ezihlukene ze-Docker, lapho kwakhiwa khona isiqukathi esihlukile sesicelo ngasinye somsebenzisi.
• Ukukala isistimu ngokuguquguquka ngenxa yokukala okuzimele kwama-microservices.
• Letha imiphumela ngesikhathi sangempela nge-WebSocket, ebaluleke kakhulu kuma-WEB IDE esimanjemanje.

Ukuhlaziywa okuqhathanisayo kubonisa ukuthi i-microservice architecture idlula kakhulu izixazululo zendabuko ze-monolithic kuwo wonke amamethrikhi angukhiye. Izinzuzo zale ndlela ziqinisekiswa idatha yangempela, okwenza kube yisixazululo esikhangayo sokudala izinhlelo zokusebenza eziphezulu nezingabekezeleli amaphutha.

Umbhali: Oleksii Bondar
Idethi: 2025–02–07