๐_๊ถ๊ทน์ ์ธ_Web_Framework_์๋_๋๊ฒฐ[20251230044123]
Source: Dev.to
๋ฒ์ญํ ํ ์คํธ๋ฅผ ์ ๊ณตํด ์ฃผ์๋ฉด ํ๊ตญ์ด๋ก ๋ฒ์ญํด ๋๋ฆฌ๊ฒ ์ต๋๋ค.
๐ก ํ ์คํธ ๋ฐฐ๊ฒฝ
2024๋ ์น ์ ํ๋ฆฌ์ผ์ด์ ์ฑ๋ฅ ๊ธฐ๋์น๋ ๋ฐ๋ฆฌ์ด ์์ค ์๋ต ์๊ฐ์ ๋ชฉํ๋ก ํ๊ณ ์์ต๋๋ค. ๋๋ ๊ฐ์ฅ ์ธ๊ธฐ ์๋ ์น ํ๋ ์์ํฌ๋ค์ ํ ๋ฌ ๋์ ๋ฒค์น๋งํนํ์ต๋๋ค:
| Framework | Category |
|---|---|
| Tokio | Rust ๋น๋๊ธฐ ๋ฐํ์ |
| Hyperlane | Rust ๊ณ ์ฑ๋ฅ ํ๋ ์์ํฌ |
| Rocket | Rust ์น ํ๋ ์์ํฌ |
| Rust Standard Library | ์ ์์ค Rust |
| Gin | Go ์น ํ๋ ์์ํฌ |
| Go Standard Library | Go net/http |
| Node Standard Library | Node.js http |
ํ ์คํธ ํ๊ฒฝ
- Server: Intel XeonโฏE5โ2686โฏv4โฏ@โฏ2.30โฏGHz
- Memory: 32โฏGB DDR4
- Network: Gigabit Ethernet
- OS: Ubuntuโฏ20.04โฏLTS
๐ ์ ์ฒด ์ฑ๋ฅ ๋น๊ต ๋ฐ์ดํฐ
๐ KeepโAlive ํ์ฑํ
wrk ์คํธ๋ ์ค ํ ์คํธ
๋์ ์ฐ๊ฒฐ 360๊ฐ, ์ง์ ์๊ฐ 60์ด
| Framework | QPS | Latency | Transfer Rate | Ranking |
|---|---|---|---|---|
| Tokio | 340,130.92 | 1.22โฏms | 30.17โฏMB/s | ๐ฅ |
| Hyperlane | 334,888.27 | 3.10โฏms | 33.21โฏMB/s | ๐ฅ |
| Rocket | 298,945.31 | 1.42โฏms | 68.14โฏMB/s | ๐ฅ |
| Rust StdโLib | 291,218.96 | 1.64โฏms | 25.83โฏMB/s | 4๏ธโฃ |
| Gin | 242,570.16 | 1.67โฏms | 33.54โฏMB/s | 5๏ธโฃ |
| Go StdโLib | 234,178.93 | 1.58โฏms | 32.38โฏMB/s | 6๏ธโฃ |
| Node StdโLib | 139,412.13 | 2.58โฏms | 19.81โฏMB/s | 7๏ธโฃ |
ab ์คํธ๋ ์ค ํ ์คํธ
๋์ ์ฐ๊ฒฐ 1000๊ฐ, 1โฏM ์์ฒญ
| Framework | QPS | Latency | Transfer Rate | Ranking |
|---|---|---|---|---|
| Hyperlane | 316,211.63 | 3.162โฏms | 32,115.24โฏKB/s | ๐ฅ |
| Tokio | 308,596.26 | 3.240โฏms | 28,026.81โฏKB/s | ๐ฅ |
| Rocket | 267,931.52 | 3.732โฏms | 70,907.66โฏKB/s | ๐ฅ |
| Rust StdโLib | 260,514.56 | 3.839โฏms | 23,660.01โฏKB/s | 4๏ธโฃ |
| Go StdโLib | 226,550.34 | 4.414โฏms | 34,071.05โฏKB/s | 5๏ธโฃ |
| Gin | 224,296.16 | 4.458โฏms | 31,760.69โฏKB/s | 6๏ธโฃ |
| Node StdโLib | 85,357.18 | 11.715โฏms | 4,961.70โฏKB/s | 7๏ธโฃ |
๐ KeepโAlive ๋นํ์ฑํ
wrk ์คํธ๋ ์ค ํ ์คํธ
๋์ ์ฐ๊ฒฐ 360๊ฐ, ์ง์ ์๊ฐ 60์ด
| Framework | QPS | Latency | Transfer Rate | Ranking |
|---|---|---|---|---|
| Hyperlane | 51,031.27 | 3.51โฏms | 4.96โฏMB/s | ๐ฅ |
| Tokio | 49,555.87 | 3.64โฏms | 4.16โฏMB/s | ๐ฅ |
| Rocket | 49,345.76 | 3.70โฏms | 12.14โฏMB/s | ๐ฅ |
| Gin | 40,149.75 | 4.69โฏms | 5.36โฏMB/s | 4๏ธโฃ |
| Go StdโLib | 38,364.06 | 4.96โฏms | 5.12โฏMB/s | 5๏ธโฃ |
| Rust StdโLib | 30,142.55 | 13.39โฏms | 2.53โฏMB/s | 6๏ธโฃ |
| Node StdโLib | 28,286.96 | 4.76โฏms | 3.88โฏMB/s | 7๏ธโฃ |
ab ์คํธ๋ ์ค ํ ์คํธ
๋์ ์ฐ๊ฒฐ 1000๊ฐ, 1โฏM ์์ฒญ
| Framework | QPS | Latency | Transfer Rate | Ranking |
|---|---|---|---|---|
| Tokio | 51,825.13 | 19.296โฏms | 4,453.72โฏKB/s | ๐ฅ |
| Hyperlane | 51,554.47 | 19.397โฏms | 5,387.04โฏKB/s | ๐ฅ |
| Rocket | 49,621.02 | 20.153โฏms | 11,969.13โฏKB/s | ๐ฅ |
| Go StdโLib | 47,915.20 | 20.870โฏms | 6,972.04โฏKB/s | 4๏ธโฃ |
| Gin | 47,081.05 | 21.240โฏms | 6,436.86โฏKB/s | 5๏ธโฃ |
| Node StdโLib | 44,763.11 | 22.340โฏms | 4,983.39โฏKB/s | 6๏ธโฃ |
| Rust StdโLib | 31,511.00 | 31.735โฏms | 2,707.98โฏKB/s | 7๏ธโฃ |
๐ฏ ๊น์ด ์๋ ์ฑ๋ฅ ๋ถ์
๐ KeepโAlive ํ์ฑํ
- Tokio๊ฐ wrk ํ ์คํธ์์ 340โฏkโฏQPS๋ก 1์๋ฅผ ์ฐจ์งํ์ง๋ง, Hyperlane์ 1.5โฏ% ๋ค์ ๋ถ๊ณผํ๋ฉฐ ์ ์ก ์๋์์๋ Tokio(30.17โฏMB/s)๋ณด๋ค ๋ ๋์ 33.21โฏMB/s๋ฅผ ๊ธฐ๋กํ์ต๋๋ค.
- ab ํ ์คํธ์์๋ Hyperlane์ด Tokio(308โฏkโฏQPS)๋ฅผ ์์ 316โฏkโฏQPS๋ฅผ ๋ฌ์ฑํ์ผ๋ฉฐ, ์ด๋ ์ง์์ ์ธ ๋ถํ ํ์์ ์์ ์์ฒญ ์ฒ๋ฆฌ ์ฒ๋ฆฌ๋์ด ๋ ์ฐ์ํจ์ ์์ฌํฉ๋๋ค.
๐ KeepโAlive ๋นํ์ฑํ
- ์งง์ ์ฐ๊ฒฐ ์๊ฐ์์๋ Hyperlane์ด ๋ค์ wrk ํ ์คํธ์์ 51โฏkโฏQPS๋ก ์ต๊ณ ์ ์ ๊ธฐ๋กํ๊ณ , Tokio๊ฐ ๊ทธ ๋ค๋ฅผ ๋ฐ์ง ๋ฐ๋์ต๋๋ค.
- ab ํ ์คํธ์์๋ ๊ฒฉ์ฐจ๊ฐ ๋์ฑ ์ข์์ ธ Tokio 51.8โฏkโฏQPS vs Hyperlane 51.5โฏkโฏQPS๋ก, ์ธก์ ์ค์ฐจ ๋ฒ์ ๋ด์ ๋จธ๋ฌผ๋ ์ต๋๋ค.
์์ฝ: Hyperlane์ ํนํ ๋ฐ์ดํฐ ์ ์ก ํจ์จ์ฑ ์ธก๋ฉด์์ ์ผ๊ด๋๊ฒ Tokio์ ๋๋ฑํ๊ฑฐ๋ ์ด๋ฅผ ๋ฅ๊ฐํ๋ฉฐ, ์ง์ฐ ์๊ฐ์ ๋ฏผ๊ฐํ ์๋น์ค์ ๊ฐ๋ ฅํ ํ๋ณด๊ฐ ๋ฉ๋๋ค.
๐ป ์ฝ๋ ๊ตฌํ ๋น๊ต
๐ข Node.js ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ
const http = require('http');
const server = http.createServer((req, res) => {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Hello');
});
server.listen(60000, '127.0.0.1');
๊ฐ๋จํ์ง๋ง, ๋จ์ผ ์ค๋ ๋ ์ด๋ฒคํธ ๋ฃจํ๊ฐ ๋๊ท๋ชจ ๋์์ฑ ํ์์ ๋น ๋ฅด๊ฒ ๋ณ๋ชฉ ํ์์ด ๋ฉ๋๋ค. ํ ์คํธ์์ Node.js๋ 811,908๊ฐ์ ์คํจ ์์ฒญ์ ๊ธฐ๋กํ์ต๋๋ค.
๐น Go ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ
package main
import (
"fmt"
"net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "Hello")
}
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":60000", nil)
}
Go์ goroutine ๋ชจ๋ธ์ ๋์์ฑ์ ํฅ์์ํค์ง๋ง, ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ์ GC ์ค๋ฒํค๋ ๋๋ฌธ์ QPS(~234โฏk)๊ฐ ์ต์์ Rust ํ๋ ์์ํฌ๋ณด๋ค ๋ค์ฒ์ง๋๋ค.
๐ Rust ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ (hyper)
use hyper::{Body, Request, Response, Server};
use hyper::service::{make_service_fn, service_fn};
async fn hello(_req: Request) -> Result, hyper::Error> {
Ok(Response::new(Body::from("Hello")))
}
#[tokio::main]
async fn main() -> Result> {
let make_svc = make_service_fn(|_conn| async {
Ok::(service_fn(hello))
});
let addr = ([127, 0, 0, 1], 60000).into();
let server = Server::bind(&addr).serve(make_svc);
println!("Listening on http://{}", addr);
server.await?;
Ok(())
}
hyper(์ฌ์ค์์ ๋น๋๊ธฐ HTTP ๋ผ์ด๋ธ๋ฌ๋ฆฌ)๋ฅผ ์ง์ ์ฌ์ฉํ๋ฉด ๊ฒฌ๊ณ ํ ๊ธฐ๋ณธ ์ฑ๋ฅ(โ291โฏkโฏQPS)์ ์ ๊ณตํ๋ฉฐ, Tokio, Rocket, Hyperlane๊ณผ ๊ฐ์ ๊ณ ์์ค ํ๋ ์์ํฌ์ ๊ธฐ๋ฐ์ด ๋ฉ๋๋ค.
๐ ์์ฝ
- Hyperlane์ ๋ชจ๋ ํ ์คํธ ์๋๋ฆฌ์ค์์ ์ผ๊ด๋๊ฒ ์ต๊ณ ํน์ ๋ฆฌ๋์ ๊ฑฐ์ ์ฐจ์ด๊ฐ ์๋ ์์ค์ ์์นํฉ๋๋ค.
- Tokio๋ ํนํ ๋ฐํ์์ ์ฅ๊ธฐ ์ฐ๊ฒฐ์ ๋ง๊ฒ ํ๋ํ์ ๋ ๊ฐ๋ ฅํ ์ฑ๋ฅ์ ์ ์งํฉ๋๋ค.
- Rocket๊ณผ Gin์ ๊ด์ฐฎ์ ์ฑ๋ฅ์ ๋ณด์ด์ง๋ง, ์์ ์ฒ๋ฆฌ๋ ์ธก๋ฉด์์๋ Rust ์ค์ฌ ์๋ฃจ์ ์ ๋ค์ฒ์ง๋๋ค.
- Node.js๋ ๊ณ ๋์์ฑ ํ๊ฒฝ์์ ์ฌ์ ํ ํฌ๊ฒ ๋ค์ฒ์ง๋ฉฐ, Go๋ ์ค๊ฐ ์ ๋์ ์ฑ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
์ต๊ณ ์ ์์ฒญ๋น ์ด๋น ์ฒ๋ฆฌ๋๊ณผ ํจ์จ์ ์ธ ๋ฐ์ดํฐ ์ ์ก์ด ํ์ํ๋ค๋ฉด, Hyperlane์ ๊ฐ์ฅ ๋จผ์ ํ๊ฐํด์ผ ํ ํ๋ ์์ํฌ์ ๋๋ค.
Rust ๊ตฌํ
use std::io::prelude::*;
use std::net::TcpListener;
use std::net::TcpStream;
fn handle_client(mut stream: TcpStream) {
let response = "HTTP/1.1 200 OK\r\n\r\nHello";
stream.write(response.as_bytes()).unwrap();
stream.flush().unwrap();
}
fn main() {
let listener = TcpListener::bind("127.0.0.1:60000").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_client(stream);
}
}
์ ์ฒด ํ๋ฉด ๋ชจ๋ ์ง์
์ ์ฒด ํ๋ฉด ๋ชจ๋ ์ข
๋ฃ
Rust์ ์์ ๊ถ ์์คํ ๊ณผ ์ ๋ก ์ฝ์คํธ ์ถ์ํ๋ ์ค์ ๋ก ๋ฐ์ด๋ ์ฑ๋ฅ์ ์ ๊ณตํฉ๋๋ค. ํ ์คํธ ๊ฒฐ๊ณผ Rust ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ 291,218.96โฏQPS๋ฅผ ๋ฌ์ฑํ์ผ๋ฉฐ, ์ด๋ ์ด๋ฏธ ๋งค์ฐ ์ธ์์ ์ ๋๋ค. ํ์ง๋ง ๊ณ ๋์์ฑ ์๋๋ฆฌ์ค์์๋ Rust์ ์ฐ๊ฒฐ ๊ด๋ฆฌ์ ์์ง ์ต์ ํ ์ฌ์ง๊ฐ ์์์ ๋ฐ๊ฒฌํ์ต๋๋ค.
๐ฏ ์ฑ๋ฅ ์ต์ ํ ์ ๋ต ๋ถ์
๐ง ์ฐ๊ฒฐ ๊ด๋ฆฌ ์ต์ ํ
๋น๊ต ํ
์คํธ๋ฅผ ํตํด ํต์ฌ ์ฑ๋ฅ ์ต์ ํ ํฌ์ธํธ์ธ ์ฐ๊ฒฐ ๊ด๋ฆฌ๋ฅผ ๋ฐ๊ฒฌํ์ต๋๋ค.
Hyperlane ํ๋ ์์ํฌ๋ ์ฐ๊ฒฐ ์ฌ์ฌ์ฉ์ ๋ฐ์ด๋๋ฉฐ, ์ด๋ KeepโAlive ํ
์คํธ์์ ์ฐ์ํ ์ฑ๋ฅ์ ๋ณด์ด๋ ์ด์ ๋ฅผ ์ค๋ช
ํฉ๋๋ค.
์ ํต์ ์ธ ์น ํ๋ ์์ํฌ๋ ์ฐ๊ฒฐ์ ์ฒ๋ฆฌํ ๋ ๋๋์ ์์ ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ GC ์๋ ฅ์ด ์ฆ๊ฐํฉ๋๋ค. Hyperlane์ ๊ฐ์ฒด ํ ๊ธฐ์ ์ ์ฑํํด ๋ฉ๋ชจ๋ฆฌ ํ ๋น ์ค๋ฒํค๋๋ฅผ ํฌ๊ฒ ์ค์ ๋๋ค.
๐ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ์ต์ ํ
๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ ์น ํ๋ ์์ํฌ ์ฑ๋ฅ์ ๋ ๋ค๋ฅธ ํต์ฌ ์์์ ๋๋ค. ํ ์คํธ์์ Rust์ ์์ ๊ถ ์์คํ ์ด ๋ฐ์ด๋ ์ฑ๋ฅ์ ์ ๊ณตํ๋ ๊ฒ์ ์ฌ์ค์ด์ง๋ง, ์ค์ ์ ํ๋ฆฌ์ผ์ด์ ์์๋ ๊ฐ๋ฐ์๊ฐ ๋ณต์กํ ์๋ช ๋ฌธ์ ๋ฅผ ๋ค๋ฃจ์ด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค.
Hyperlane์ Rust์ ์์ ๊ถ ๋ชจ๋ธ์ ๋ง์ถคํ ๋ฉ๋ชจ๋ฆฌ ํ์ ๊ฒฐํฉํด ์ ๋กโ๋ณต์ฌ ๋ฐ์ดํฐ ์ ์ก์ ๊ตฌํํฉ๋๋คโํนํ ๋์ฉ๋ ํ์ผ ์ ์ก์ ํจ๊ณผ์ ์ ๋๋ค.
โก ๋น๋๊ธฐ ์ฒ๋ฆฌ ์ต์ ํ
๋น๋๊ธฐ ์ฒ๋ฆฌ๋ ํ๋ ์น ํ๋ ์์ํฌ์ ํต์ฌ ๊ธฐ๋ฅ์ ๋๋ค. Tokio ํ๋ ์์ํฌ๋ ๋น๋๊ธฐ ์ฒ๋ฆฌ์์ ์ข์ ์ฑ๋ฅ์ ๋ณด์ด์ง๋ง, ๋์ ๋์์ฑ ์ํฉ์์๋ ์์ ์ค์ผ์ค๋ง ์๊ณ ๋ฆฌ์ฆ์ด ๋ณ๋ชฉ์ ์ง๋ฉดํฉ๋๋ค.
Hyperlane์ ์์คํ ๋ถํ์ ๋ฐ๋ผ ์์ ํ ๋น์ ๋์ ์ผ๋ก ์กฐ์ ํ ์ ์๋ ๋ณด๋ค ์ง๋ณด๋ ์์ ์ค์ผ์ค๋ง ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํด, ๊ธ์ฆํ๋ ํธ๋ํฝ์ ํนํ ํจ๊ณผ์ ์ ๋๋ค.
๐ฏ ์ค์ฉ์ ์ธ ์ ์ฉ ๊ถ์ฅ ์ฌํญ
๐ช ์ ์์๊ฑฐ๋ ์น์ฌ์ดํธ ์๋๋ฆฌ์ค
Performance is money. In my tests, Hyperlane excels in product listings, user authentication, and order processing.
- Recommendation: ํต์ฌ ๋น์ฆ๋์ค ์์คํ ์ Hyperlane์ ์ฌ์ฉํ์ธ์, ํนํ ์ ํ ๊ฒ์ ๋ฐ ์ถ์ฒ ์๊ณ ๋ฆฌ์ฆ๊ณผ ๊ฐ์ CPUโ์ง์ฝ์ ์ธ ์์ ์.
- Static resources: Nginx์ ๊ฐ์ ์ ์ฉ ์น ์๋ฒ๋ฅผ ๊ณ ๋ คํ์ธ์.
๐ฌ ์์ ํ๋ซํผ ์๋๋ฆฌ์ค
Social platforms involve numerous connections and frequent messages. Hyperlane shines in WebSocket connection management and can handle hundreds of thousands of concurrent connections.
- Recommendation: Hyperlane์ ์ฌ์ฉํด ๋ฉ์์งโํธ์ ์์คํ ์ ๊ตฌ์ถํ๊ณ , ์ค์๊ฐ ์ ๋ฌ์ ์ํด Redis์ ๊ฐ์ ์ธโ๋ฉ๋ชจ๋ฆฌ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๊ฒฐํฉํ์ธ์.
- Complex business logic (e.g., user relationships): GraphQL ์ฌ์ฉ์ ๊ณ ๋ คํ์ธ์.
๐ข ์ํฐํ๋ผ์ด์ฆ ์ ํ๋ฆฌ์ผ์ด์ ์๋๋ฆฌ์ค
Enterprise apps need to handle complex processes and data consistency. Hyperlane provides strong support for transaction processing, ensuring data integrity.
- Recommendation: ํต์ฌ ๋น์ฆ๋์ค ์์คํ ์ Hyperlane์ ์ฌ์ฉํ๊ณ , ์์์ฑ์ ์ํด PostgreSQL๊ณผ ๊ฐ์ ๊ด๊ณํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๊ฒฐํฉํ์ธ์.
- CPUโintensive tasks (e.g., report generation): ๋น๋๊ธฐ ์ฒ๋ฆฌ๋ฅผ ํ์ฉํ์ธ์.
๐ฎ ๋ฏธ๋ ๊ฐ๋ฐ ํธ๋ ๋
๐ ๊ทนํ ์ฑ๋ฅ
์ง์์ ์ธ ํ๋์จ์ด ๊ฐ์ ์ผ๋ก ์น ํ๋ ์์ํฌ ์ฑ๋ฅ์ ์๋ก์ด ์ ์ ์ ์ด๋ฅผ ๊ฒ์ ๋๋ค. ์์ผ๋ก์ ํ๋ ์์ํฌ๋ ๋ฐฑ๋ง ์์ค QPS๋ฅผ ๋ฌ์ฑํ๊ณ ์ง์ฐ ์๊ฐ์ ๋ง์ดํฌ๋ก์ด ์์ค์ผ๋ก ๋ฎ์ถ ๊ฒ์ผ๋ก ์์๋ฉ๋๋ค.
๐ง ๊ฐ๋ฐ์ ๊ฒฝํ ์ต์ ํ
์ฑ๋ฅ๋ ์ค์ํ์ง๋ง, ๊ฐ๋ฐ์ ๊ฒฝํ ์ญ์ ๋๋ฑํ๊ฒ ์ค์ํฉ๋๋ค. ๋ฏธ๋์ ํ๋ ์์ํฌ๋ ๋ ๋์ ๊ฐ๋ฐ ๋๊ตฌ, ๋๋ฒ๊น ์ ํธ๋ฆฌํฐ, ๋ชจ๋ํฐ๋ง ์๋ฃจ์ ์ ์ ๊ณตํ์ฌ ๊ณ ์ฑ๋ฅ ์ ํ๋ฆฌ์ผ์ด์ ๊ตฌ์ถ์ ๋ณด๋ค ์ฝ๊ฒ ๋ง๋ค ๊ฒ์ ๋๋ค.
๐ ํด๋ผ์ฐ๋โ๋ค์ดํฐ๋ธ ์ง์
ํด๋ผ์ฐ๋ ์ปดํจํ ์ด ๋ณดํธํ๋จ์ ๋ฐ๋ผ ํ๋ ์์ํฌ๋ ์ปจํ ์ด๋ํ์ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ ์ฒ๋ฅผ ๋์ฑ ์ ์ง์ํ ๊ฒ์ ๋๋ค. ์๋น์ค ๋์ค์ปค๋ฒ๋ฆฌ, ๋ก๋ ๋ฐธ๋ฐ์ฑ, ์ํท ๋ธ๋ ์ดํน ๋ฑ๊ณผ ๊ฐ์ ๋ด์ฅ ๊ธฐ๋ฅ์ ๊ธฐ๋ํด ๋ณด์ธ์.
๐ฏ Summary
์ด ์ฌ์ธต ํ ์คํธ๋ ์ต์ ์น ํ๋ ์์ํฌ์ ์ฑ๋ฅ ์ ์ฌ๋ ฅ์ ์ฌํ์ธํฉ๋๋ค. Hyperlane ํ๋ ์์ํฌ์ ๋ฑ์ฅ์ผ๋ก Rust๊ฐ ์น ๊ฐ๋ฐ์์ ์ ๊ณตํ ์ ์๋ ๋ฌดํํ ๊ฐ๋ฅ์ฑ์ด ๋ณด์ฌ์ง๋๋ค. Tokio๊ฐ ์ผ๋ถ ๋ฒค์น๋งํฌ์์ ๋ ๋์ ์ฑ๋ฅ์ ๋ณด์ด์ง๋ง, Hyperlane์ ์ ๋ฐ์ ์ธ ์ฑ๋ฅ๊ณผ ์์ ์ฑ์์ ๋ฐ์ด๋ ๊ฒฐ๊ณผ๋ฅผ ์ ๊ณตํฉ๋๋ค.
์๋์ด ๊ฐ๋ฐ์๋ก์, ํ๋ ์์ํฌ ์ ํ ์ ๋จ์ํ ์์ ์ฑ๋ฅ ์งํ๋ฟ๋ง ์๋๋ผ ๊ฐ๋ฐ ๊ฒฝํ, ์ํ๊ณ, ์ปค๋ฎค๋ํฐ ์ง์๋ ๊ณ ๋ คํด์ผ ํ๋ค๊ณ ์ ์ํฉ๋๋ค. Hyperlane์ ์ด๋ฌํ ์์ญ์์ ํ์ํ๋ฉฐ ๅฐ่ฏํ ๊ฐ์น๊ฐ ์์ต๋๋ค.
์น ๊ฐ๋ฐ์ ๋ฏธ๋๋ ์ฑ๋ฅ๊ณผ ํจ์จ์ฑ์ ๋ ์ง์คํ ๊ฒ์ ๋๋ค. ์ ๋ Hyperlane์ด ์ด ๋ถ์ผ์์ ์ ์ ๋ ์ค์ํ ์ญํ ์ ํ ๊ฒ์ด๋ผ๊ณ ๋ฏฟ์ต๋๋ค. ํจ๊ป ๊ทธ ์งํ๋ฅผ ์ง์ผ๋ด ์๋ค.
Forward to the next breakthrough in web development technology together!
[GitHub Homepage](https://github.com/hyperlane-dev/hyperlane)