如何用脚本模拟网络延迟

本文目录导读：

1. Linux 系统（使用 tc 命令）
2. Python 代理脚本（模拟客户端-服务器延迟）
3. Node.js 延迟中间件
4. 使用 iptables 模拟延迟
5. Charles/Fiddler 等工具脚本
6. 高级：模拟真实网络条件
7. 持续监控和脚本化
8. 建议用途

我可以为您提供几种模拟网络延迟的方法,包括使用脚本和现有工具：

Linux 系统（使用 tc 命令）

# 在 eth0 网卡上添加 100ms 延迟
sudo tc qdisc add dev eth0 root netem delay 100ms
# 添加延迟和丢包
sudo tc qdisc add dev eth0 root netem delay 100ms 10ms loss 5%
# 模拟特定目标IP的延迟
sudo tc qdisc add dev eth0 root netem delay 200ms
# 或者使用 iptables 配合 tc
# 清除规则
sudo tc qdisc del dev eth0 root

Python 代理脚本（模拟客户端-服务器延迟）

import socket
import time
import threading
class DelayProxy:
    def __init__(self, listen_port, target_host, target_port, delay_ms=100):
        self.listen_port = listen_port
        self.target_host = target_host
        self.target_port = target_port
        self.delay = delay_ms / 1000
    def handle_client(self, client_socket, addr):
        # 连接到目标服务器
        target = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        target.connect((self.target_host, self.target_port))
        # 创建双向转发线程
        def forward(src, dst):
            while True:
                data = src.recv(4096)
                if not data:
                    break
                time.sleep(self.delay)  # 模拟延迟
                dst.send(data)
        t1 = threading.Thread(target=forward, args=(client_socket, target))
        t2 = threading.Thread(target=forward, args=(target, client_socket))
        t1.start()
        t2.start()
        t1.join()
        t2.join()
        client_socket.close()
        target.close()
    def start(self):
        server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server.bind(('localhost', self.listen_port))
        server.listen(10)
        while True:
            client, addr = server.accept()
            threading.Thread(target=self.handle_client, args=(client, addr)).start()
# 使用示例
if __name__ == '__main__':
    proxy = DelayProxy(8080, 'example.com', 80, delay_ms=200)
    print("启动代理在端口 8080")
    proxy.start()

Node.js 延迟中间件

const express = require('express');
const app = express();
// 添加延迟中间件
app.use((req, res, next) => {
    const delay = 500; // 延迟500ms
    setTimeout(next, delay);
});
// 添加可变延迟（模拟网络波动）
app.use((req, res, next) => {
    const minDelay = 100;
    const maxDelay = 1000;
    const delay = Math.random() * (maxDelay - minDelay) + minDelay;
    setTimeout(next, delay);
});
// 或者模拟特定类型的请求延迟
app.use((req, res, next) => {
    if (req.path.includes('/api')) {
        setTimeout(next, 300); // API请求延迟300ms
    } else {
        next(); // 静态资源不延迟
    }
});

使用 iptables 模拟延迟

# 使用 iptables 将流量转发到模拟延迟的端口
sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8080
# 配合 tc 规则
sudo tc qdisc add dev lo root netem delay 150ms 20ms distribution normal
# 使用 iptables DAM 模块（如果有）
sudo modprobe ipt-DELAY

Charles/Fiddler 等工具脚本

Charles 脚本示例：

// 在 Charles 中编辑请求/响应
function onResponse(session) {
    // 仅对特定域名的请求添加延迟
    if (session.hostname.includes('target-api.com')) {
        java.lang.Thread.sleep(1000); // 延迟1秒
    }
    return session;
}

高级：模拟真实网络条件

# 模拟移动网络（高延迟、丢包、抖动）
sudo tc qdisc add dev eth0 root netem delay 200ms 50ms loss 3% duplicate 1% corrupt 0.1%
# 模拟不同网络类型
# 3G: delay 150ms 50ms loss 2%
# 4G: delay 50ms 10ms loss 0.5%
# WiFi: delay 20ms 5ms loss 0.1%

持续监控和脚本化

#!/bin/bash
# network_latency_simulator.sh
while true; do
    echo "模拟 2 秒延迟..."
    sudo tc qdisc add dev eth0 root netem delay 2000ms
    sleep 30  # 模拟30秒
    echo "恢复正常..."
    sudo tc qdisc del dev eth0 root
    sleep 60  # 等待60秒再次模拟
done

建议用途

• 开发测试：验证应用的网络鲁棒性
• 性能调优：测试不同网络条件下的响应时间
• 故障模拟：模拟网络不稳定的场景
• 用户体验：测试移动网络下的使用体验

选择哪种方法取决于您的具体场景：

• Linux 直接使用 tc 命令最方便
• Python/Node.js 适合应用级模拟
• 代理工具适合调试和测试

请记住在生产环境使用时要格外小心,确保在测试环境验证后再使用。