Mumamiriro ezvinhu ekukurumidza kusimudzira kwegore komputa uye microservice architecture, pane kuwedzera kuri kuda kupa kugona kuita zvine simba kodhi yemitauro yakasiyana-siyana yepurogiramu ine vimbiso yekuchengetedza, scalability uye kushanda kwepamusoro. Ichi chinyorwa chinotsanangura purojekiti inoshandisa kodhi kuuraya munzvimbo yakasarudzika, uye inokurukura zvakanakira sarudzo yakasarudzwa yekuvaka yemazuva ano WEB IDE. Iyo system inovakwa pamusoro Enda , inoshandisa gRPC kuitira kushanda kwe interservice kunoshanda, Redis semeseji broker uye Docker kuparadzanisa nzvimbo yekuuraya. A WebSocket server inoshandiswa kuratidza mhinduro munguva chaiyo.

Tichatsanangura zvakadzama kuti zvikamu zvikuru zvehurongwa zvakagadziriswa sei, zvakasiyana sei kubva kune dzimwe nzira dzekugadzirisa uye nei kusarudzwa kweiyi tekinoroji kuchibvumira kuwana kuita kwepamusoro uye kuchengetedzeka.

1. Architectural overview uye huru zvikamu

Iyo purojekiti yakavakirwa pamusimboti weiyo microservice architecture, iyo inokutendera iwe kugovera mashandiro kuita akazvimirira masevhisi. Chimwe nechimwe chikamu chine mutoro webasa rakasarudzika, iro rinovimbisa kuchinjika, scalability, uye kukanganisa kushivirira kwehurongwa.

Main components:

• gRPC inoshandiswa kune inter-service communication. Yakanakira kuendesa data pakati pemicroservices nekuda kwe:
  • Binary protocol (Protocol Buffers): inovimbisa kukurumidza uye compact data kutamiswa.
  • Yakasimba typing: inobatsira kudzivirira zvikanganiso mukufambiswa nekugadzirisa data.
  • Low latency: iyo yakakosha kune yemukati mafoni pakati pesevhisi (semuenzaniso, pakati pegRPC server uye Redis mutsara).
• WebSocket Server: Inopa nzira mbiri dzekutaurirana nemutengi kuendesa mhedzisiro yekuurayiwa munguva chaiyo. Iyo inonyorera kune mutsara nemhedzisiro uye inoendesa iyo data kune mutengi, ichipa ipapo kuratidzwa kwekuunganidza uye ekuuraya matanda.
• Mushandi: Sevhisi yakazvimirira inodhonza mabasa kubva pamutsetse, inogadzira nharaunda yekushanda kwenguva pfupi, inosimbisa uye inoisa kodhi mumudziyo wakasarudzika weDocker, uye wobva waburitsa mhedzisiro yekuurayiwa kudzokera kumutsara.
• Redis: Inoshandiswa semeseji broker kuendesa mabasa kubva kuGRPC server kuenda kuMushandi uye mhedzisiro kubva kuMushandi kuenda kuWebSocket server. Zvakanakira Redis zvinomhanya zvakanyanya, Pub/Sub rutsigiro uye nyore kuyera.
• Internal modules:
  • Compiler uye Docker Runner: Iyo module ine basa rekumhanyisa Docker mirairo ine rwizi matanda, ichibvumira chaiyo-nguva yekutarisa kwekuunganidza uye kuuraya maitiro.
  • Mutauro Vanomhanya: Sanganisa pfungwa yekusimbisa, kuunganidza, uye kuitisa kodhi yemitauro yakasiyana (C, C++, C #, Python, JavaScript, TypeScript). Mumhanyi wega wega anoshandisa imwe interface, iyo inorerutsa kuwedzera kwekushanda kwemitauro mitsva.

2. Tekinoroji uye chikonzero chekusarudza

Enda

Zvakanakira Go:

• Kuita uye scalability: Enda ine kukurumidza kuuraya kukuru, iyo inonyanya kukosha pakubata nhamba yakakura yezvikumbiro zvakafanana.

• Yakavakirwa-mukati concurrency tsigiro: Iyo nzira dzegoroutines uye chiteshi inobvumira kuita asynchronous kupindirana pakati pezvikamu pasina yakaoma multithreading mapatani.

  
  

gRPC

Zvakanakira zve gRPC:

• Kufambiswa kwedata kunoshanda: Kutenda kune bhinari yekufambisa protocol (Protocol Buffers), gRPC inopa yakaderera latency uye yakaderera network mutoro.
• Yakasimba typing: Izvi zvinoderedza huwandu hwezvikanganiso zvine chekuita nekududzirwa kusiri kwe data pakati pemicroservices.
• Tsigiro yebidirectional kutenderera: Izvi zvinonyanya kubatsira pakuchinjanisa matanda uye mhedzisiro mhedzisiro munguva chaiyo.

Kuenzanisa: Kusiyana neREST API, gRPC inopa kutaurirana kwakanaka uye kwakavimbika pakati pemasevhisi, izvo zvakakosha kune zvakanyanya kuwirirana masisitimu.

Redis

Sei Redis?

• Kuita kwepamusoro: Redis inogona kubata huwandu hukuru hwekushanda pasekondi, izvo zvinoita kuti ive yakanakira basa uye mhedzisiro mitsetse.

• Pub/Sub uye Rondedzero Rutsigiro: Iko kureruka kwekushandisa mitsetse uye nzira dzekunyorera kunoita kuti zvive nyore kuronga asynchronous kupindirana pakati pemasevhisi.

• Kuenzanisa nemamwe mabroker meseji: Kusiyana neRabbitMQ kana Kafka, Redis inoda kushomeka kurongeka uye inopa kuita kwakakwana kune chaiyo-nguva masisitimu.

  
  

Docker

Basa reDocker:

• Kusarudzika kwezvakatipoteredza: Docker midziyo inobvumidza iwe kuti umhanye kodhi munzvimbo yakasarudzika, iyo inowedzera kuchengetedzwa kwekuuraya uye inoderedza njodzi yekukonana neiyo huru system.

• Manageability uye kuenderana: Kushandisa Docker kunopa iyo yakafanana nharaunda yekunyora nekuita kodhi, zvisinei neiyo host system.

• Kuenzanisa: Kumhanya kodhi yakananga pamugamuchiri kunogona kuunza njodzi yekuchengetedza uye kutungamirira kumakakatanwa ekutsamira, nepo Docker inobvumidza iwe kugadzirisa aya matambudziko.

  
  

WebSocket

• Chaiyo-nguva: Kuramba kwakabatana nemutengi kunobvumira data (matanda, mhedzisiro mhedzisiro) kutamiswa ipapo.
• Yakavandudzwa mushandisi ruzivo: NeWebSocket, iyo IDE inogona kuratidza zvine simba mhedzisiro yekodhi.

3. Zvakanakira Microservice Architecture

Iyi purojekiti inoshandisa microservice nzira, ine akati wandei akakosha mabhenefiti:

• Kuzvimiririra kuyera: Sevhisi yega yega (gRPC server, Mushandi, WebSocket server, Redis) inogona kuyerwa zvakasiyana zvichienderana nemutoro. Izvi zvinobvumira kushandiswa kwakanaka kwezvinhu uye kukurumidza kugadzirisa kukura kwenhamba yezvikumbiro.
• Mhosva kushivirira: Kupatsanura sisitimu mumamodule akazvimirira zvinoreva kuti kutadza kweimwe microservice hakutungamiri mukukundikana kwehurongwa hwese. Izvi zvinowedzera kugadzikana kwese uye zvinorerutsa kupora kubva mukukanganisa.
• Kuchinjika kwekusimudzira uye kutumira: Microservices inogadzirwa uye inoiswa yakazvimirira, iyo inorerutsa kuunzwa kwezvinhu zvitsva uye zvigadziriso. Izvi zvinokutendera kuti ushandise matekinoroji akakodzera kune yega yega sevhisi.
• Kureruka kwekubatanidza: Nzvimbo dzakanyatsotsanangurwa (semuenzaniso kuburikidza negRPC) inoita kuti zvive nyore kubatanidza masevhisi matsva pasina shanduko huru kune iripo zvivakwa.
• Kuzviparadzanisa nevamwe uye kuchengetedzeka: Imwe neimwe microservice inogona kumhanya mumudziyo wayo, izvo zvinoderedza njodzi dzine chekuita nekuita kodhi isina kuchengetedzeka uye inopa imwezve chengetedzo.

4. Kuenzanisa kuongororwa kwemaitiro ekugadzira

Paunenge uchivaka emazuva ano WEB IDE ekuita kure kure kodhi, akasiyana ezvivakwa mhinduro anowanzo kuenzaniswa. Ngatitarisei nzira mbiri:

Nzira A: Microservice architecture (gRPC + Redis + Docker)

• Latency: 40 ms
• Kubuda: 90 zvikamu
• Chengetedzo: 85 zvikamu
• Scalability: 90 zvikamu

Features:
Iyi nzira inopa nekukurumidza uye yakavimbika kutaurirana kwepakati-sevhisi, kuparadzaniswa kwakanyanya kwekodhi kuuraya, uye kuchinjika kuyera nekuda kwekuiswa kwemidziyo. Yakakwana kune azvino WEB IDE, uko kupindura uye kuchengetedzeka kwakakosha.

Nzira B: Traditional Monolithic Architecture (HTTP REST + Centralized Execution)

• Latency: 70 ms
• Kubuda: 65 zvikamu
• Chengetedzo: 60 zvikamu
• Scalability: 70 zvikamu

Features:
Monolithic mhinduro, dzinowanzo shandiswa mumavhezheni ekutanga ewebhu IDE, dzakavakirwa paHTTP REST uye yepakati kodhi kuuraya. Masisitimu akadai anotarisana nenyaya dzekuyera, kuwedzera latency, uye kuomerwa kwekuchengetedza chengetedzo paunenge uchiita kodhi yemumwe munhu.

Ongorora: Mumamiriro ezvinhu emazuva ano eWEB IDE kusimudzira, iyo HTTP REST uye yepakati kuuraya nzira yakaderera kune zvakanakira ye microservices architecture, sezvo isingape inodiwa kuchinjika uye scalability.

Kuona kwekuenzanisa metrics

Girafu inoratidza zvakajeka kuti iyo microservices architecture (Nzira A) inopa yakaderera latency, yakakwirira throughput, chengetedzo iri nani uye scalability zvichienzaniswa neiyo monolithic mhinduro (Nzira B).

5. Docker architecture: kuparadzaniswa uye scalability

Chimwe chezvinhu zvakakosha zvekuchengetedza system uye kugadzikana ndiko kushandiswa kweDocker. Mumhinduro yedu, masevhisi ese anoiswa mumidziyo yakasiyana, ayo anovimbisa:

• Kusarudzika kwenzvimbo yekuuraya: Sevhisi yega yega (gRPC server, Mushandi, WebSocket server) uye meseji broker (Redis) inomhanya mumudziyo wayo, izvo zvinoderedza njodzi yekodhi isina kuchengetedzeka inokanganisa sisitimu huru. Panguva imwecheteyo, iyo kodhi iyo mushandisi anomhanyisa mubrowser (semuenzaniso, kuburikidza neWEB IDE) inogadzirwa uye inoitwa mune yakaparadzana Docker mudziyo webasa rega rega. Iyi nzira inovimbisa kuti inogona kunge isina kuchengetedzeka kana kukanganisa kodhi haigone kukanganisa kushanda kweiyo main infrastructure.
• Kusagadzikana kwezvakatipoteredza: Kushandisa Docker kunovimbisa kuti marongero anoramba akafanana mukusimudzira, kuyedza, uye kugadzirwa nharaunda, iyo inorerutsa zvakanyanya kugadzirisa uye inovimbisa kufanotaura kwekodhi kuuraya.
• Scalability flexibility: Chikamu chega chega chinogona kuyerwa chakazvimirira, icho chinokutendera kuti unyatso kujairana nekuchinja mitoro. Semuyenzaniso, sezvo huwandu hwezvikumbiro huchiwedzera, unogona kuvhura mamwe midziyo yeVashandi, imwe neimwe inozogadzira midziyo yakaparadzana yekuita kodhi yemushandisi.

• 
  

6. Zvikamu zviduku zvekodhi

Pazasi pane minified vhezheni yezvikamu zvikuru zvekodhi inoratidza maitiro ehurongwa:

1. Inotara kuti ndeupi mutauro wekumhanya uchishandisa global runner registry.
2. Inotanga mudziyo weDocker kumhanyisa mushandisi kodhi uchishandisa iyo RunInDockerStreaming basa.

1. Kuonekwa kwemutauro kuburikidza nekunyoresa mumhanyi

Iyo sisitimu inoshandisa registry yepasirese, uko mutauro wega wega une mumhanyi wayo. Izvi zvinokutendera kuti uwedzere nyore tsigiro yemitauro mitsva, zvakakwana kushandisa iyo inomhanya interface uye kuinyoresa:

 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") }

Muenzaniso wekunyoresa mutauro mutsva:

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

Saka, kana uchigamuchira chikumbiro, iyo system inodaidza:

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

uye inogamuchira mumhanyi anoenderana kuti aite iyo kodhi.

2. Kutangisa mudziyo weDocker kuti uite kodhi

Kune yega yega mushandisi kodhi chikumbiro, yakaparadzana Docker mudziyo unogadzirwa. Izvi zvinoitwa mukati memumhanyi nzira (semuenzaniso, muRun). Iyo huru pfungwa yekumhanyisa mudziyo iri muRunInDockerStreaming basa:

 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") } }

Iri basa rinogadzira iyo docker run command, uko:

• mufananidzo ndiwo mufananidzo weDocker wakasarudzwa kune mumwe mutauro (unotsanangurwa nemumhanyi kumisikidzwa).
• dir ndiyo dhairekitori ine kodhi yakagadzirwa yechikumbiro ichi.
• cmdStr ndiwo murairo wekunyora kana kuita kodhi.

Saka, pakudaidza iyo Run nzira yemumhanyi, zvinotevera zvinoitika:

• Iyo RunInDockerStreaming basa rinotanga iyo Docker mudziyo uko iyo kodhi inoitiswa.
• Iwo matanda ekuuraya anofambiswa kune iyo logCh chiteshi, iyo inokutendera iwe kuendesa ruzivo nezve maitiro ekuuraya munguva chaiyo.

3. Integrated execution process

Yakaderedzwa chidimbu cheiyo huru logic yekodhi kuuraya (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 } }

Mumuenzaniso uyu mudiki:

• Kuonekwa kwemutauro kunoitwa pachishandiswa runhare kumitauro.GetRunner(req.Language), zvinoita kuti zvive nyore kuwedzera rutsigiro rwemutauro mutsva.
• Docker mudziyo kuvhurwa unoitwa mukati meCompile/Run nzira, dzinoshandisa RunInDockerStreaming kuita kodhi uri wega.

Izvi zvimedu zvakakosha zvinoratidza kuti sisitimu inotsigira sei kuwedzera (kuwedzera nyore kwemitauro mitsva) uye inopa kuzviparadzanisa nekugadzira yakaparadzana Docker mudziyo wechikumbiro chega chega. Iyi nzira inovandudza kuchengetedzwa, kugadzikana uye scalability yepuratifomu, iyo inonyanya kukosha kune yemazuva ano WEB IDE.

7. Mhedziso

Ichi chinyorwa chinokurukura chikuva chekure kure kodhi kuuraya yakavakirwa pane microservice architecture uchishandisa gRPC + Redis + Docker stack. Iyi nzira inokubvumira kuti:

• Deredza latency uye ive nechokwadi chekufambisa kwepamusoro nekuda kwekuita interservice kutaurirana.
• Ita shuwa chengetedzo nekuparadzanisa kodhi kuuraya mune yakaparadzana Docker midziyo, uko yakaparadzana mudziyo unogadzirwa kune yega yega mushandisi chikumbiro.
• Kuyera sisitimu inochinjika nekuda kwekuzvimiririra kuyera kwema microservices.
• Nunura mhedzisiro munguva chaiyo kuburikidza neWebSocket, iyo inonyanya kukosha kune azvino WEB IDE.

Ongororo yekuenzanisa inoratidza kuti iyo microservice architecture inodarika echinyakare monolithic mhinduro mune ese akakosha metrics. Zvakanakira nzira iyi inosimbiswa ne data chaiyo, iyo inoita kuti ive mhinduro inoyevedza yekugadzira yakakwirira-yekuita uye inoshivirira masisitimu.

Munyori: Oleksii Bondar
Date: 2025–02–07