Rust网络编程实战:用Tokio手写一个迷你TCP反向代理(minginx)Nginx作为强大的反向代理服务器,是我们日常开发中的得力助手。但你是否想过,它的核心原理——TCP流量转发,究竟是如何实现的?我们能否用Rust和Tokio亲手构建一个迷你版的Nginx呢?
Nginx 作为强大的反向代理服务器,是我们日常开发中的得力助手。但你是否想过,它的核心原理——TCP流量转发,究竟是如何实现的?我们能否用 Rust 和 Tokio 亲手构建一个迷你版的 Nginx 呢?
本文旨在通过一个名为 minginx
的实战项目,带领读者从零开始,用不到100行代码实现一个功能完备的异步TCP反向代理。我们将深入探讨如何利用 tokio::spawn
处理并发连接,以及如何通过 tokio::io::copy
高效地在客户端和上游服务器之间建立双向数据流。为了验证我们的代理,我们还会搭建一个基于 axum
的后端Web服务。
读完本文,你不仅能理解TCP反向代理的本质,还能掌握一套使用Rust构建高性能网络服务的实用技能。
use std::sync::Arc;
use anyhow::Result;
use serde::{Deserialize, Serialize};
use tokio::{
io,
net::{TcpListener, TcpStream},
};
use tracing::{info, level_filters::LevelFilter, warn};
use tracing_subscriber::{Layer as _, fmt::Layer, layer::SubscriberExt, util::SubscriberInitExt};
#[derive(Debug, Deserialize, Serialize)]
struct Config {
listen_addr: String,
upstream_addr: String,
}
#[tokio::main]
async fn main() -> Result<()> {
// proxy client traffic to upstream
let layer = Layer::new().pretty().with_filter(LevelFilter::INFO);
tracing_subscriber::registry().with(layer).init();
let config = resolve_config();
let config = Arc::new(config);
info!("Upstream: {}", config.upstream_addr);
info!("Listen: {}", config.listen_addr);
let listener = TcpListener::bind(&config.listen_addr).await?;
loop {
let (client, addr) = listener.accept().await?;
// let cloned_config = config.clone(); 阅读代码 方便使用 Arc::clone
let cloned_config = Arc::clone(&config);
info!("Accept connection from {}", addr);
tokio::spawn(async move {
let upstream = TcpStream::connect(&cloned_config.upstream_addr).await?;
proxy(client, upstream).await?;
Ok::<(), anyhow::Error>(())
});
}
}
async fn proxy(mut client: TcpStream, mut upstream: TcpStream) -> Result<()> {
let (mut client_rd, mut client_wr) = client.split();
let (mut upstream_rd, mut upstream_wr) = upstream.split();
let client_to_upstream = io::copy(&mut client_rd, &mut upstream_wr);
let upstream_to_client = io::copy(&mut upstream_rd, &mut client_wr);
if let Err(e) = tokio::try_join!(client_to_upstream, upstream_to_client) {
warn!("Error in proxy: {}", e)
}
Ok(())
}
fn resolve_config() -> Config {
Config {
listen_addr: "127.0.0.1:8081".to_string(),
upstream_addr: "127.0.0.1:8080".to_string(),
}
}
这段 Rust 代码实现了一个简单的 TCP 代理服务器 (TCP proxy)。
程序首先在本地 127.0.0.1:8081
地址上监听传入的 TCP 连接,当接收到一个新的客户端连接后,它会立即为该连接创建一个新的异步任务(tokio::spawn
)。在这个新任务中,程序会连接到预设的上游服务器地址(127.0.0.1:8081
),然后调用 proxy
函数。proxy
函数的核心功能是使用 io::copy
在客户端和上游服务器之间建立一个双向数据流,将从客户端收到的数据原封不动地转发给上游服务器,同时也将上游服务器返回的数据转发给客户端,从而完成代理的功能。
rust-ecosystem-learning on main [!?] is 📦 0.1.0 via 🦀 1.88.0 took 2m 4.9s
➜ cargo run --example minginx
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.17s
Running `target/debug/examples/minginx`
2025-07-03T15:02:50.964166Z INFO minginx: Upstream: 0.0.0.0:8080
at examples/minginx.rs:26
2025-07-03T15:02:50.964204Z INFO minginx: Listen: 0.0.0.0:8081
at examples/minginx.rs:27
use std::sync::{Arc, Mutex};
use anyhow::Result;
use axum::{
Json, Router,
extract::State,
routing::{get, patch},
};
use serde::{Deserialize, Serialize};
use tokio::net::TcpListener;
use tracing::{info, instrument, level_filters::LevelFilter};
use tracing_subscriber::{
Layer as _,
fm...
如果觉得我的文章对您有用,请随意打赏。你的支持将鼓励我继续创作!