本文分享了团队基于Rust语言改造Nginx组件的技术路径，旨在为超大规模流量调度场景提供更优解决方案。文章详细介绍了从Rust模块化探索到构建DLB 2.0流量调度平台的完整过程，包括FFI技术的应用、ngx_http_rust_module SDK的开发、Pingora框架的采用以及DLB 2.0产品的核心能力和技术细节。通过声明式配置管理、分层路由架构以及模块化Filter链设计，DLB 2.0实现了高性能、高可用和零迁移成本，为同类基础设施升级提供了可复用的工程经验。

🚀 通过FFI技术，将Rust核心业务逻辑与Nginx C模块集成，实现了Rust与C语言的交互，提升了系统的性能和稳定性。

🛠️ 开发ngx_http_rust_module SDK，为Rust模块开发提供了便利，实现了纯Rust编码的业务功能，提高了工程价值。

💡 采用Cloudflare的Pingora框架构建DLB 2.0流量调度平台，该平台具有云原生架构、高性能、协议生态、安全演进和扩展能力等优势。

⚙️ DLB 2.0采用声明式配置管理，通过YAML文件进行配置，支持热加载机制，实现了流量无损的配置更新，并与Nginx的server/path路由匹配逻辑完全兼容。

🛡️ DLB 2.0通过模块化Filter链设计，支持按需插拔流量处理组件，并采用线程安全的运行时结构和高效前缀树路由，确保了性能和可维护性。

原创 雷泽 2025-07-09 18:30 上海

在云原生架构高速迭代的背景下，基础设施的性能瓶颈与安全隐患成为技术演进的关键挑战。本文系统记录团队基于Rust语言改造Nginx组件的完整技术路径，为超大规模流量调度场景提供全新解决方案，也为同类基础设施升级提供可复用的工程经验。

- id: "hjob.shizhuang-inc.com"
  server_name: "hjob.shizhuang-inc.com"
  service_in:
  - "default_80"
  - "default_443"
  redirect: true
  location:
  - path: "/"
    access_rule_names:
    - "access_allow_d803a06f39ad4dcd8dfe517359a33a61"
    - "access_deny_all"
    client_max_body_size: "100M"
    proxy_headers:
    - "clientport:$remote_port"
    - "Upgrade:$http_upgrade"
    - "Connection:$http_connection"
    - "Host:$host"
    - "X-Forwarded-For:$proxy_add_x_forwarded_for"
    - "X-Forwarded-Proto:$scheme"
    proxy_pass: "http://hangzhou-csprd-hjob-8899"


 - name: "hangzhou-csprd-hjob-8899"
  peers:
  - server: "1.1.1.1:8899"
    weight: 100
    backup: false
    down: false
  - server: "2.2.2.2:8899"
    weight: 1
    backup: false
    down: false
  max_fails: 3
  fail_timeout: "10s"
  max_connections: 1000

/// A map of server names to their respective configurations.
#[serde(skip)]
pub servers: HashMap<String, Arc<Mutex<ServerConf>>>,
/// A map of upstream names to their respective configurations.
#[serde(skip)]
pub upstreams: HashMap<String, Arc<Mutex<UpstreamConf>>>,

impl TryFrom<&UpstreamConf> for RunTimeUpStream {
    type Error = Error;
    fn try_from(value: &UpstreamConf) -> std::result::Result<Self, Self::Error> {
    }
}

pub static GLOBAL_CONF: Lazy<RwLock<GlobalConf>> = Lazy::new(|| {
    RwLock::new(GlobalConf {
        main_conf: MainConf::default(),
        runtime_upstreams: HashMap::with_capacity(16),
        runtime_servers: HashMap::with_capacity(16),
        host_selectors: HashMap::with_capacity(16),
    })
});


#[derive(Default)]
pub struct GlobalConf {
    // main static configuration
    pub main_conf: MainConf,
    //one-to-one between upstreams and runtime_upstreams
    pub runtime_upstreams: HashMap<String, Arc<RunTimeUpStream>>,
    //one-to-one between servers and runtime_servers;
    pub runtime_servers: HashMap<String, Arc<RunTimeServer>>,
    //one service one host selector
    pub host_selectors: HashMap<String, Arc<HostSelector>>,
}

/// A struct to manage server selection based on host names.
///
/// This struct contains three fields: `equal`, `prefix`, and `regex`.
/// The `equal` field is a HashMap that stores server names and their corresponding IDs
/// when the server name exactly matches the host.
/// The `prefix` field is a Vec of tuples, where each tuple contains a prefix and its corresponding server ID.
/// The `regex` field is a Vec of tuples, where each tuple contains a Regex and its corresponding server ID.
///
/// The `HostSelector` struct provides methods to insert server names and IDs,
/// and to match a given host name with a server ID based on the rules defined in the struct.
#[derive(Clone)]
pub struct HostSelector {
    pub equal: HashMap<String, String>,
    pub prefixes: Vec<(String, String)>,  //原始前通配符数据
    pub prefix_nested_map: NestedHashMap, // 嵌套哈希结构优化匹配效率
    pub regex: Vec<(Regex, String)>,
}

#[derive(Debug, Clone)]
pub struct NestedHashMap {
    data: HashMap<String, NestedHashMap>, //层级域名节点
    value: Option<String>, // 终端节点关联服务器ID
}


impl NestedHashMap
{
    /// 基于域名分段实现高效检索（从右向左匹配）
    pub(crate) fn find(&self, key: &str) -> Option<String> {
        let tokens = key.split('.').collect::<Vec<&str>>();
        let mut current_map = self;
        let mut result = None;
        // 遍历域名层级（如 www.example.com → [com, example, www]）
        for token in tokens.iter().rev() {
            // 优先记录当前层级的有效值（实现最长匹配）
            if current_map.value.is_some() {
                result = Some(current_map.value.as_ref().unwrap());
            }
            // 向下一级域名跳转
            let child = current_map.data.get(*token);
            match child{
                Some(child) => {
                    current_map = child;
                }
                None => {
                    break;
                }
            }
        }
        result.map(|value| value.to_owned())
    }
}

Syntax:location [ = | ~ | ~* | ^~ ] uri { ... }
location @name { ... }
Default:—
Context:server, location

#[derive(Clone, Default)]
#[allow(unused)]
/// A struct representing a shared runtime server configuration.
pub struct RunTimeServer {
    /// Unique identifier for the server.
    pub id: String,
    /// Name of the server.
    pub server_name: String,
    /// Indicates whether the server should redirect requests.
    pub redirect: bool,
    /// A HashMap storing equal-matched locations, where the key is the path and the value is the location.
    pub equal_match: HashMap<String, Arc<RunTimeLocation>>,// 精确匹配字典
    /// A Vec storing regex-matched locations, where each tuple contains a Regex and the location.// 正则匹配队列
    pub regex_match: Vec<(Regex, Arc<RunTimeLocation>)>,
    /// The root node of the static location tree.
    pub prefix_root: Option<Arc<static_location_tree::TreeNode>>,
}

 pub fn find_location(path: &str, node: &Arc<TreeNode>) -> Option<(bool, Arc<RunTimeLocation>)> {
    let mut node = Some(node);
    let mut uri_len = 0;
    let mut search_node = None;


    while let Some(current) = node {
        let n = std::cmp::min(current.path.len(), path.len() - uri_len);
        let node_path = &current.path[..n];
        let temp_path = &path[uri_len..uri_len + n];


        match path_cmp(node_path, temp_path) {
            std::cmp::Ordering::Equal => {
                uri_len += n;
                search_node = Some((current.need_stop, current.val.clone()));
                node = current.tree.as_ref();
                if uri_len >= path.len() { break; }
            }
            std::cmp::Ordering::Greater => node = current.left.as_ref(),
            std::cmp::Ordering::Less => node = current.right.as_ref(),
        }
    }
    search_node
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RewriteFlags {
    Break,
    Last,
    Redirect,
    Permanent,
    NONE,
}


pub struct RewriteRule {
    pub reg_source: String,
    pub reg: Regex,
    pub target: String,
    pub flag: RewriteFlags,
}

#[async_trait]
pub trait ProxyFilter: Sync + Send {
    fn phase(&self) -> ProxyFilterPhase;
    
    fn name(&self) -> ProxyFilterName;
    
    fn order(&self) -> i32;
    
    async fn handle(&self, _session: &mut Session, _ctx: &mut ProxyContext) -> HandleResult {
        HandleResult::Continue
    }
}

#[derive(Debug, PartialEq, Clone, EnumString)]
pub enum HandleResult {
    /// 表示当前filter执行完成，继续执行下一个 filter。
    Continue,
    /// 表示当前filter操作被中断，停止filter chain 的执行动作。
    Break,
}

阅读原文

跳转微信打开

Fish AI Reader

Fish AI Reader

AI辅助创作，多种专业模板，深度分析，高质量内容生成。从观点提取到深度思考，FishAI为您提供全方位的创作支持。新版本引入自定义参数，让您的创作更加个性化和精准。

FishAI

鱼阅，AI 时代的下一个智能信息助手，助你摆脱信息焦虑

联系邮箱 441953276@qq.com