如何针对特定端口模拟低速网络环境？

Hey there! I totally get your situation—you’re building a Node.js/Express app locally on macOS, with Redis for caching and MySQL as your database, and you need to simulate slow network conditions to test how your app behaves under those constraints. The usual generic answers don’t cover your specific stack, so let’s dive into tailored solutions that work for your setup.

I’ll break this down into three key areas: client-to-server slowdowns, server-to-database/cache slowdowns, and code-level simulations (no system changes needed).

1. 模拟客户端 ↔ Express 服务器的低速网络 #

Since you’re developing locally, most traffic goes through your machine’s loopback interface (lo0). Here are two reliable ways to throttle this:

• Use macOS’s built-in pfctl (free, no extra tools)
  First, create a simple rules file (e.g., slownet.rules):

  dummynet-anchor "slownet" in on lo0
  anchor "slownet"
  

  Then apply a bandwidth limit and delay to the loopback interface—this mimics a slow client connection:

  sudo pfctl -f slownet.rules
  sudo dnctl pipe 1 config bw 1Mbit/s delay 200ms
  sudo pfctl -a slownet -f - <<EOF
  pass in on lo0 pipe 1
  pass out on lo0 pipe 1
  EOF
  

  To revert back to normal speeds:

  sudo pfctl -a slownet -F all
  sudo pfctl -f /etc/pf.conf
  

  Note: If you’re using Wi-Fi instead of loopback, replace lo0 with your network interface name (find it via ifconfig).

• Chrome DevTools (quick frontend-focused testing)
  If you just need to test how your frontend interacts with the Express server, skip system-level changes: open Chrome DevTools → go to the Network tab → use the dropdown menu to select "Slow 3G" or create a custom profile with your desired bandwidth/latency.

2. 模拟Express服务器 ↔ Redis/MySQL的低速网络 #

This is probably the most critical part for your stack—testing how slow database/cache calls impact your app’s performance. Here’s how to target specific services:

• Throttle specific ports with pfctl
  MySQL uses port 3306, Redis uses 6379. You can apply limits only to traffic on these ports:

  # Create a pipe with stricter limits (e.g., 500Kbps + 300ms delay)
  sudo dnctl pipe 2 config bw 500Kbit/s delay 300ms
  # Apply rules to MySQL and Redis ports
  sudo pfctl -a slownet -f - <<EOF
  pass in proto tcp from any to any port 3306 pipe 2
  pass out proto tcp from any to any port 3306 pipe 2
  pass in proto tcp from any to any port 6379 pipe 2
  pass out proto tcp from any to any port 6379 pipe 2
  EOF
  

  Revert using the same cleanup commands from section 1.

• Docker container-level throttling (if using Docker for Redis/MySQL)
  If you run your database/cache in Docker, you can restrict their network directly when starting the container:

  # Slow Redis container
  docker run -d --name redis-slow --cap-add NET_ADMIN redis:latest sh -c 'tc qdisc add dev eth0 root netem delay 300ms rate 500Kbit && redis-server'
  # Slow MySQL container
  docker run -d --name mysql-slow --cap-add NET_ADMIN -e MYSQL_ROOT_PASSWORD=your-password mysql:latest sh -c 'tc qdisc add dev eth0 root netem delay 300ms rate 500Kbit && mysqld'
  

  Update your Express app’s connection strings to point to these containers, and you’ll see the slowdown immediately.

3. Code-level simulation (no system changes) #

If you don’t want to mess with system network settings, you can add artificial delays directly to your database/cache clients:

• Add delay to Redis commands
  Using ioredis? Wrap the sendCommand method to inject random delays:

  const Redis = require('ioredis');
  const redis = new Redis();
  
  // Save the original method
  const originalSendCommand = redis.sendCommand;
  // Wrap it with a delay
  redis.sendCommand = async function(...args) {
    // Simulate 100-500ms of delay
    await new Promise(resolve => setTimeout(resolve, Math.random() * 400 + 100));
    return originalSendCommand.apply(this, args);
  };
  

• Add delay to MySQL queries
  For mysql2, wrap the pool’s query method:

  const mysql = require('mysql2/promise');
  const pool = mysql.createPool({
    host: 'localhost',
    user: 'root',
    password: 'your-password',
    database: 'your-db'
  });
  
  const originalQuery = pool.query;
  pool.query = async function(...args) {
    // Simulate 200-500ms of delay
    await new Promise(resolve => setTimeout(resolve, Math.random() * 300 + 200));
    return originalQuery.apply(this, args);
  };
  

Quick Tips #

• Don’t forget to revert network settings after testing—nothing’s worse than forgetting you throttled your entire system!
• To simulate packet loss, add plr 0.02 (2% loss rate) to your dnctl or tc commands.
• For mixed scenarios (client + server-to-db slowdowns), combine the system-level rules from sections 1 and 2.

内容的提问来源于stack exchange，提问作者Jochem Schulenklopper