Tokio 流处理:用 Stream trait 处理无限的异步数据序列的工程实践

OpenRaft完全指南:基于Rust的异步Raft算法实现与分布式系统实战 分布式共识算法是构建可靠分布式系统的核心技术基础,通过协调多个节点达成数据一致性状态。Raft算法将复杂的共识问题分解为领导选举、日志复制和安全性三个可理解模块,相比传统Paxos更易于工程实现。在Rust生态中,OpenRaft作为完全异步的Raft实现库,充分利用Rust的内存安全特性和高性能并发模型,为分布式数据库和协调服务提供坚实基础。其异步架构基于async/await语法,能够高效处理大量并发连接,避免线程阻塞,特别适合I/O密集型的日志复制场景。通过模块化设计将存储、网络传输等组件抽象为tra 阅读详情

Tokio 流处理:用 Stream trait 处理无限的异步数据序列的工程实践

一、场景引入:无限数据流

大家好,我是一铭。前段时间接了一个需求:实时消费 Kafka 的订单消息流,对每条消息做风控校验、数据增强、格式转换,然后写入 ClickHouse。

这个场景的特点是:数据是无限的、异步的、需要反压控制。你不能把所有数据先读到内存再处理,也不能用简单的 for 循环——因为数据在未来的某个时刻才会到来。

这时候,Tokio 的 Stream trait 就派上用场了。

二、Stream trait 基础

2.1 Stream 是什么

Stream 是异步版的 Iterator。普通迭代器的 next() 是同步的,而 Stream 的 poll_next() 返回 Poll<Option<Item>>,支持异步等待。

Rust 标准库目前还没有 Stream,但 futures 和 tokio-stream 提供了完整的实现:

// 引入 Stream 和 StreamExt
use futures::stream::{Stream, StreamExt};
use tokio_stream::StreamExt as TokioStreamExt;
use std::pin::Pin;
use std::task::{Context, Poll};

2.2 最简单的 Stream:interval

use tokio::time::{interval, Duration};
use tokio_stream::wrappers::IntervalStream;

#[tokio::main]
async fn main() {
    // 创建一个每隔 1 秒发射一次的 Stream
    let mut stream = IntervalStream::new(interval(Duration::from_secs(1)));

    // 取前 5 个事件
    while let Some(_) = stream.next().await {
        println!("⏰ tick!");
    }
}

三、实战:Kafka 到 ClickHouse 的数据管道

3.1 整体架构

我们要实现的数据管道包含以下几个阶段:

  1. Kafka Source:从 Kafka 消费消息,封装为 Stream
  2. 风控校验:对每条订单做规则检查
  3. 异步增强:调用外部 API 补充用户画像、商品信息
  4. 格式转换:转为 ClickHouse 需要的结构
  5. ClickHouse Sink:批量写入

3.2 构建 Kafka Stream

use rdkafka::consumer::{Consumer, StreamConsumer};
use rdkafka::Message;

/// 将 Kafka 消费者封装为 Stream
/// 每个元素是一条反序列化后的订单消息
fn kafka_stream(
    consumer: StreamConsumer,
) -> impl Stream<Item = Result<OrderMessage, PipelineError>> {
    // futures::stream::unfold 可以从一个异步函数构建 Stream
    futures::stream::unfold(consumer, |consumer| async move {
        loop {
            match consumer.recv().await {
                Ok(message) => {
                    // 尝试解析 Kafka 消息体为 OrderMessage
                    match message.payload() {
                        // payload() 返回 Option<&[u8]>,需要处理 None 情况
                        Some(payload) => {
                            match serde_json::from_slice::<OrderMessage>(payload) {
                                Ok(order) => {
                                    return Some((Ok(order), consumer));
                                }
                                Err(e) => {
                                    return Some((Err(PipelineError::Parse(e.to_string())), consumer));
                                }
                            }
                        }
                        None => continue, // 空消息,跳过
                    }
                }
                Err(e) => {
                    return Some((Err(PipelineError::Kafka(e.to_string())), consumer));
                }
            }
        }
    })
}

3.3 风控校验

/// 对订单做风控规则检查
/// 返回标记了风险等级的订单
async fn risk_check(order: OrderMessage) -> Result<CheckedOrder, PipelineError> {
    // 规则 1:单笔金额超过 10000 标记为高风险
    let risk_level = if order.amount > 10_000.0 {
        RiskLevel::High
    }
    // 规则 2:30 分钟内同一用户下单超过 5 次
    else if order.user_recent_count > 5 {
        RiskLevel::Medium
    } else {
        RiskLevel::Low
    };

    Ok(CheckedOrder {
        order,
        risk_level,
        checked_at: chrono::Utc::now(),
    })
}

3.4 异步数据增强(并发控制)

这里是关键——对每条订单调用外部 API 增强数据,需要控制并发数,防止打爆下游服务:

use futures::stream::StreamExt;

/// 并发调用外部 API 增强订单数据
/// 用 buffer_unordered 控制同时进行的请求数
async fn enrich_orders(
    stream: impl Stream<Item = Result<CheckedOrder, PipelineError>>,
) -> impl Stream<Item = Result<EnrichedOrder, PipelineError>> {
    stream
        // then:对每个元素做异步处理
        .then(|result| async {
            match result {
                Ok(checked) => {
                    // 并发调用两个外部 API
                    let user_future = fetch_user_profile(checked.order.user_id);
                    let product_future = fetch_product_info(checked.order.product_id);

                    // join! 同时发起两个请求,等两个都返回
                    let (user_result, product_result) =
                        tokio::join!(user_future, product_future);

                    match (user_result, product_result) {
                        (Ok(user), Ok(product)) => Ok(EnrichedOrder {
                            checked,
                            user_profile: Some(user),
                            product_info: Some(product),
                        }),
                        (user_err, prod_err) => {
                            // 任何一方失败就返回错误,但记录日志
                            eprintln!(
                                "数据增强失败: user={:?}, product={:?}",
                                user_err, prod_err
                            );
                            Err(PipelineError::Enrichment(
                                "外部 API 调用失败".into()
                            ))
                        }
                    }
                }
                Err(e) => Err(e),
            }
        })
        // 🔑 关键:最多 10 个并发请求,超过的排队等待
        .buffer_unordered(10)
}

3.5 批量写入 ClickHouse

use std::time::Duration;
use tokio::time;

/// 将订单流转为批量写入 ClickHouse
/// 使用 chunks_timeout 实现定时批量提交
async fn batch_write_to_clickhouse(
    stream: impl Stream<Item = Result<EnrichedOrder, PipelineError>>,
) {
    // 使用 chunks_timeout:
    // - 满了 500 条就提交
    // - 或者超过 5 秒还没满也提交
    let mut chunked = tokio_stream::StreamExt::chunks_timeout(
        stream,
        500,                           // 每批最多 500 条
        Duration::from_secs(5),        // 最多等 5 秒
    );

    while let Some(batch) = chunked.next().await {
        let orders: Vec<_> = batch
            .into_iter()
            .filter_map(|r| r.ok())    // 只保留成功的
            .collect();

        if !orders.is_empty() {
            // 实际写入 ClickHouse(这里简化)
            if let Err(e) = insert_into_clickhouse(&orders).await {
                eprintln!("写入 ClickHouse 失败: {}", e);
                // 可以考虑写入死信队列做后续重试
            }
        }
    }
}

3.6 组装管道

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 创建 Kafka 消费者
    let consumer: StreamConsumer = create_kafka_consumer()?;

    // 2. 构建完整管道
    let stream = kafka_stream(consumer);

    // 3. 风控校验
    let stream = stream.then(|r| async {
        match r {
            Ok(order) => risk_check(order).await,
            Err(e) => Err(e),
        }
    });

    // 4. 异步数据增强(最多 10 并发)
    let stream = enrich_orders(stream).await;

    // 5. 批量写入 ClickHouse
    batch_write_to_clickhouse(stream).await;

    Ok(())
}

3.7 实战踩坑:Stream 取消安全与内存泄漏

管道跑起来两天后,监控告警说内存使用一直在涨。排查发现是一个隐蔽的问题——buffer_unordered(10) 在流被提前取消时,已发出的 API 请求并没有被中止,连接资源持续泄漏。

// ❌ 问题代码:timeout 到后 stream 被 drop,飞行的请求泄漏
let stream = enrich_orders(stream).await;
let _ = tokio::time::timeout(
    Duration::from_secs(30),
    batch_write_to_clickhouse(stream),
).await;

修法:用 tokio::select! + AbortHandle 确保取消时所有子任务都被回收:

// ✅ 安全版本
let handle = tokio::spawn(batch_write_to_clickhouse(stream));
tokio::select! {
    result = handle => { /* 正常完成 */ }
    _ = tokio::time::sleep(Duration::from_secs(30)) => {
        handle.abort();
        eprintln!("管道超时,已取消所有飞行中的请求");
    }
}

另一个坑:如果下游 ClickHouse 写入慢于上游 Kafka 生产速度,buffer_unordered 的 10 个并发槽会一直占满,内部缓冲区无限增长。解决方法是根据实际吞吐加 throttle 限制流速。这个坑让我认识到:Stream 的反压是协作式的,需要你主动控制流速。 不能假设下游一定能消化所有数据。

四、反压机制详解

Stream 的反压是天然内建的。整个链条的流转逻辑:

当 buffer_unordered 的 10 个并发槽满了,poll_next() 会返回 Poll::Pending,上游(Kafka consumer)自然就不会被调用,实现了端到端的反压。不需要任何额外的队列或信号量。

4.1 实际项目里的反压失效:当 ClickHouse 宕机时

这里有一个容易被忽视的陷阱:chunks_timeout 本身不提供反压。如果 ClickHouse 宕机了,insert_into_clickhouse 超时报错,但 Kafka 消费者仍然在全速拉取消息。buffer_unordered(10) 的并发槽满了就阻塞,但 Kafka consumer 的 auto.offset.commit 还在提交 offset——宕机期间的批处理全部失败 + 丢消息。

解决方案:在 ClickHouse 写入失败时停止提交 Kafka offset,并暂停消费。通过 consumer.pause() 实现端到端的真反压。另外,给 chunks_timeout 的缓冲区设一个上限——如果积压超过 5000 条就报警,人为介入。

压测时建议用 tokio-console 看每个任务的 poll 延迟,一眼就能定位反压卡在哪个环节。

五、总结

这篇文章我们完整地走了一遍用 Tokio Stream 处理无限异步数据流的流程:

  1. Stream 是异步版的 Iterator,天然支持无限数据序列。
  2. buffer_unordered 是控制并发的最佳工具,一行代码搞定限流。
  3. chunks_timeout 实现定时批量提交,兼顾吞吐和延迟。
  4. 反压是内建的,当消费者处理不过来时,整个链条自动减速,不需要手工控制。
  5. futures::stream::unfold 可以从任何异步循环构建 Stream。

Stream 生态还在快速发展,StreamExt 提供的组合子已经非常丰富。掌握 Stream,你就掌握了 Rust 异步数据处理的核心能力。

Rust重写AI编程工具:Claw Code的工程实践与性能突破 AI编程辅助工具正从Python原型阶段迈向生产级落地,其核心挑战在于运行时性能、内存安全与可部署性。Rust凭借零成本抽象、所有权模型和异步生态,成为重构CLI类AI工具的理想选择。本文围绕Claw Code这一典型社区实践,解析其如何通过强类型CLI(clap)、无锁流式HTTP(tokio+reqwest)、内存映射上下文管理(memmap2)及编译时模板校验(tera),系统性规避Python在启动延迟、GIL阻塞、运行时字符串错误和内存泄漏等方面的固有缺陷。案例实测显示,Rust实现相较Pytho 阅读详情

相关推荐

精益六西格玛Python数字化应用开发-Day18 应用场景:家电企业生产效率优化

本文将重点介绍专门针对精益六西格玛黑带使用场景的 Python 库,这些库功能侧重于数据分析和流程优化,特别适用于 DMAIC 方法论和看板管理。考虑到读者具备中高级Python 使用经验,我们将深入探讨各库的高级功能和实际应用应用场景。 某家电企业生产线自动化程度高,数据量巨大,希望通过精益管理提升生产效率。企业借助 Python 脚本,打通各类数据源(MES、ERP、设备日志),自动归集生产数据,分析各工序的生产节拍、设备停机、效率损失,快速定位瓶颈环节

m0_56592100的博客 906

突破异步数据流瓶颈:Tokio Stream全解析与背压控制实战

在现代应用开发中,处理连续数据流已成为常态需求。无论是实时日志处理、高频交易数据传输还是物联网传感器数据流,开发者都面临着如何高效、可靠地处理异步数据序列的挑战。传统同步处理方式容易导致资源耗尽或响应延迟,而普通异步处理又常常忽略数据生产与消费速度不匹配的问题。 Tokio作为Rust生态中最成熟的异步运行时,提供了强大的Stream trait和完善的背压控制机制,帮助开发者构建高性能、弹性的...

gitblog_00443的博客 462

Hi3516CV610 YOLOv8模型转换与部署实战:从源码到板端推理全流程解析

本文详细解析了将YOLOv8模型部署到Hi3516CV610开发板的全流程。内容涵盖从Ubuntu环境搭建、模型获取与验证,到关键的PyTorch模型转换为ONNX格式,并利用海思工具链量化生成板端可执行的.wk文件。最后,指导开发者编写板端C程序,完成视频流处理、NNIE推理及结果后处理,并提供了部署调试与性能优化的实用技巧。

weixin_29215815的博客 271

tokio-stream 演进全解:从 0.1.0 到 0.1.19 的 API 成长史与 Stream 工具集实战指南

tokio-stream 是 Tokio 官方仓库中面向异步流式处理的工具 crate,它为 `futures_core::Stream` 提供了扩展 trait、适配器与大量包装类型,让开发者能够以接近同步 `Iterator` 的体验消费异步序列。本文以 [tokio-stream/CHANGELOG.md](https://link.gitcode.com/i/bf169e979a8c139

gitblog_00849的博客 720

计算机网络-自顶向下方法 第三章课后习题答案(第七版)

复习题 R1. a) 就叫这个协议为简单传输协议STP(Simple Transport Protocol)。在发送方,STP从发送进程接收不超过1196字节的数据块、目标主机地址和目标端口号。STP向每个块添加一个4字节的头,并将目标进程的端口号放在头中。STP然后将目标主机地址和结果段提供给网络层。网络层将段交付给目的地主机的STP。目的主机基于STP检查段中的端口号,从段中提取数据,并将数据传递给由端口号标识的进程。 b) 在发送方,STP从发送进程接收不超过1192字节的数据块、目标主机地址和目标端

Erekilu的博客 2万+

Air780E模组AT指令实战:5分钟搞定MQTT连接EMQX服务器(附完整代码)

本文详细介绍了如何使用Air780E 4G模组通过AT指令快速连接MQTT服务器。从硬件接线、网络注册到MQTT连接配置,提供了完整的实战步骤和代码示例,帮助开发者快速实现物联网设备的数据上报与远程通信。

wdx012345的博客 745

async-stream核心原理深度解析:从yield到Stream的魔法实现

你是否曾经想过,在Rust的异步编程中,如何像使用生成器一样优雅地创建流?今天,我将为你深入解析**async-stream**这个强大的异步流库的核心原理。通过本文,你将理解从简单的`yield`关键字到完整的`Stream`实现的魔法转换过程!🚀 ## 什么是async-stream? **async-stream**是一个Rust库,它允许你使用`async`和`await`语法来创建

gitblog_00596的博客 824

树莓派4B+WebRTC实现远程监控:5步搞定公网视频流传输(含Node.js配置)

本文详细介绍了如何利用树莓派4B和WebRTC技术,通过5个关键步骤搭建低延迟、高隐私的远程监控系统。重点阐述了WebRTC点对点传输相较于传统方案的优势,并提供了包含Node.js信令服务器配置、树莓派视频流捕获与推送、以及移动端自适应观看页面的完整实现方案,帮助用户实现公网视频流传输。

websocket5live的博客 293

async-stream:Rust异步流编程的终极指南与快速入门

**async-stream** 是 Rust 生态中一款强大的异步流处理库,它让开发者能够使用直观的 `async & await` 语法创建和操作异步流,极大简化了异步数据序列的处理逻辑。无论是处理网络连接、文件流还是实时数据,async-stream 都能提供简洁高效的解决方案,帮助开发者轻松构建响应式应用。 ## 🚀 为什么选择 async-stream?异步流编程的核心优势 在 R

gitblog_00474的博客 1038

代码实现 —— 基于 STM32 的可见光通信系统课程设计

基于STM32F103ZET6,源码如需移植,需要修改定时器捕获通道引脚,及定时器,如果你也有这个课设任务,希望对你有所帮助。

不善挽留 1万+

基于Simulink实现电动汽车电机驱动系统的建模与仿真

通过上述步骤,我们成功实现了基于Simulink的电动汽车电机驱动系统的建模与仿真。该系统能够全面评估电机驱动系统的性能,验证控制策略的有效性,并通过优化设计提高车辆的动力性和效率。引入智能预测:结合人工智能技术,实现更智能的控制策略。扩展功能:增加对多种电机类型的支持,提升系统通用性。实验验证:将仿真模型应用于实际硬件,进行实验验证,评估其在实际工况下的表现。

xiaoheshang_123的博客 319

Rust 之 `Stream` Trait 深度解析:异步迭代器、背压与 `pin-project` 工具

本文深度解析了 Rust 的 Stream Trait,它是 Future 在异步序列上的泛化,等同于异步世界的迭代器。文章首先剖析了 poll_next 方法的设计及其与同步迭代器的区别,介绍了使用 while let Some 消费流的模式。重点讨论了流的拉取模型如何天然实现背压机制,防止消费者过载。针对实现自定义流时的 Pin 难题,详细介绍了 pin-project 工具的解决方案,它能安全处理自引用结构体并自动生成正确的 Pin 投影。Stream 作为 Rust 异步生态处理数据序列的基础抽象,

AtomicVerse的博客 636

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

tokio-core UDP异步编程:UdpCodec编解码与UdpFramed分帧的完整实战指南

**tokio-core** 是 Rust 异步 I/O 领域的核心库,提供事件循环与网络原语,是众多异步生态的基石。本文围绕其中鲜少被展开的 UDP 能力,带你完整掌握 **UdpCodec 编解码** 与 **UdpFramed 分帧** 两大机制——从绑定一个 UDP 套接字,到用几行代码实现自定义协议的"乒乓"通信服务,全程实战、少废话。🎯 ## 一、为什么 UDP 也需要"分帧"?

gitblog_00279的博客 357

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

Rust 异步流(Streams)实战:从迭代器到异步序列的完整指南

本指南以《The Rust Programming Language》(下称《Rust 编程语言》书)第 17 章「异步与并发」中的 Streams 章节([src/ch17-04-streams.md](https://link.gitcode.com/i/715ac3670cb6bcbc4bb02c604176bcfc))为核心,系统讲解 Rust 异步编程中的**流(Stream)**概念:

gitblog_00803的博客 112

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

16、Rust程序设计语言——Async、Await、Future与Stream

Rust学习笔记

qq_51180928的博客 376

Scylla-Rust-Driver核心功能解析:异步查询、类型安全与自动分页

Scylla-Rust-Driver是一款专为ScyllaDB优化的异步CQL驱动,它通过异步查询处理、严格的类型安全验证和智能自动分页机制,为Rust开发者提供了高效、可靠的数据库交互体验。无论是构建高并发服务还是处理大规模数据集,该驱动都能显著提升应用性能与开发效率。 ## 🚀 异步查询:释放高并发潜力 异步查询是Scylla-Rust-Driver的核心优势之一,它基于Rust的异步运

gitblog_00659的博客 851

Tokio 官方示例完全指南:从 hello_world 到自定义执行器的实战入门

本文基于 Tokio 仓库的 [examples/README.md](https://link.gitcode.com/i/c4a4fc0feb51de6d2372de980a728214) 展开,系统讲解 `examples` 目录下数十个官方示例的组织方式、运行方法与核心设计意图。无论你是第一次接触 `#[tokio::main]` 的初学者,还是想深入理解 TCP/UDP 服务、Chann

gitblog_00943的博客 417

100-exercises-to-learn-rust 异步编程实战指南:async/.await、Future 与 tokio 运行时

Rust 的并发编程并不只有线程这一条路。本指南以《100-exercises-to-learn-rust》课程第 8 章(`book/src/08_futures/`)为骨架,系统讲解 `async`/`.await` 语法、`Future` trait、`tokio` 运行时以及协作式调度的底层原理,并结合仓库中的 [练习源码](https://link.gitcode.com/i/7e7a1

gitblog_00035的博客 975

100-exercises-to-learn-rust 异步编程全解析:从 async/await 到 tokio 实践与避坑指南

> 本指南基于 [100-exercises-to-learn-rust](https://link.gitcode.com/i/67e9896265667471159776b28d7eb949) 开源教程的 `book/src/08_futures/08_outro.md` 总结章,结合同章 `01_async_fn` 至 `07_cancellation` 各节及 [exercises/08_

gitblog_00603的博客 296

从ruflo入手:Rust流式管道架构、背压与实战全解析

数据流处理是现代后端系统应对高吞吐场景的核心技术,而Rust凭借无GC停顿和编译期并发安全,成为构建轻量级流式管道的理想选择。理解流式处理的本质,需要从节点抽象、数据传输、背压机制和执行调度四个维度切入。有界队列是实现背压的关键手段,通过限制队列容量让上游感知下游处理能力,避免内存溢出与任务堆积。Rust生态中的tokio和flume等库为异步管道提供了成熟支持,可在生产环境中高效落地。这类单体进程内的流式引擎,尤其适合资源受限但需要实时处理的团队,以极低内存占用替代重型大数据栈。本文将以ruflo为切入点

weixin_34242819的博客 303

为什么Nex-N2.5-Max权重分644片:拆解384专家MoE架构、FP8量化与1M上下文设计

下载 **Nex-N2.5-Max** 时,目录里会赫然出现 644 个 `model-00001-of-00644.safetensors` 权重文件。为什么一个模型的权重要拆成 644 片?答案藏在它的架构里:**1.6 万亿参数的 MoE(混合专家)模型、384 个路由专家、FP8 量化、1M 上下文长度**。本文带你读懂 [config.json](https://link.gitcode

gitblog_01200的博客 760

高效Rust数据序列化终极指南:Prost实战应用深度解析

Prost是Rust语言中一个高效的Protocol Buffers实现,它允许开发者在Rust应用中轻松实现数据的序列化与反序列化。作为Tokio生态系统的重要组成部分,Prost提供了简洁的API和优秀的性能表现,特别适合微服务通信、数据存储和网络传输等场景。 ## 实际应用场景:为什么选择Prost? 在现代分布式系统中,数据序列化是微服务间通信的核心技术。传统JSON虽然易用但性能较差

gitblog_00642的博客 379

TechEmpower 基准测试中的 Trillium:Rust 模块化异步 Web 框架实战解析

本篇技术指南以 [frameworks/Rust/trillium/README.md](https://link.gitcode.com/i/910485727ac597d237250b21850d291f) 为核心,围绕 TechEmpower Web Framework Benchmarks 项目中 Trillium 基准实现展开:从框架的模块化设计、tokio / async-std /

gitblog_00408的博客 419

Argus 进程页精通指南:3 种视图、40 列属性,快速揪出资源占用元凶

Argus 是一款用 Rust 编写的现代 Windows 任务管理器,它的进程页支持按应用、进程树、列表 3 种视图,提供 40 列可扩展属性,帮助新手快速定位 CPU、内存、磁盘、网络与 GPU 的资源占用元凶。掌握本页指南后,你无需翻看源码,几分钟内就能排查"电脑为什么突然变卡"。 ## 如何切换 3 种视图:按应用、进程树、列表 进程页左上角有 3 个一键切换的视图按钮,覆盖不同排查场

gitblog_00392的博客 684

组网第63课:安全域划分——Trust/Untrust/DMZ、区域模型、与 VLAN 的关系

一组接口 + 一组策略 + 一条默认拒绝。一组接口:这个域包含哪些物理口、VLAN、子接口;一组策略:这个域到别的域放行什么、拒绝什么;一条默认拒绝:没写进策略的,一律不通。第三条最关键。没有默认拒绝,前面划的域全是装饰。

qq_36765170的博客 572
上一篇: Rust 迭代器组合子:map、filter、fold 链式调用的性能陷阱分析
下一篇: WebAssembly AI 数据脱敏:在浏览器端先跑模型去隐私再上传的方案
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值