Network performance optimization

Understanding the Core Objectives of Network Performance Optimization

The core of network performance optimization lies in reducing latency, increasing throughput, and minimizing resource consumption. For Node.js applications, this means optimizing I/O operations, reducing CPU-intensive tasks, and leveraging caching effectively. A typical example is that synchronous blocking operations can stall the entire event loop when handling HTTP requests, while asynchronous non-blocking patterns maintain high concurrency.

// Bad synchronous code example
const fs = require('fs');
const data = fs.readFileSync('/path/to/file'); // Blocks the event loop

// Optimized asynchronous version
fs.readFile('/path/to/file', (err, data) => {
  // Non-blocking processing
});

Optimizing HTTP Server Configuration

Node.js's built-in http module is simple, but its default configuration may not be suitable for production environments. Adjusting TCP parameters and HTTP headers can significantly improve performance:

const http = require('http');
const server = http.createServer((req, res) => {
  res.setHeader('Connection', 'keep-alive');
  res.setHeader('Keep-Alive', 'timeout=30');
  // Business logic
});

server.listen(3000);
server.keepAliveTimeout = 30000; // 30 seconds

Key configuration items include:

• keepAliveTimeout: Time to keep TCP connections alive
• headersTimeout: Timeout for waiting for HTTP headers to complete
• maxHeadersCount: Limit the number of request headers to prevent DDoS

Efficient Static Resource Handling

Poor handling of static resources can consume significant CPU and I/O resources. Recommended practices include:

1. Using CDNs to distribute static content
2. Implementing strong and negotiated caching
3. Enabling gzip/brotli compression

const zlib = require('zlib');
const fs = require('fs');
const http = require('http');

http.createServer((req, res) => {
  const raw = fs.createReadStream('./static/image.png');
  res.setHeader('Content-Encoding', 'gzip');
  raw.pipe(zlib.createGzip()).pipe(res);
}).listen(3000);

Example caching strategy:

Cache-Control: public, max-age=31536000, immutable
ETag: "33a64df551425fcc55e4d42a148795d9f25f89d4"

Database Query Optimization

Databases are often performance bottlenecks. Optimization recommendations for MongoDB:

// Avoid full table scans
db.collection.find({ indexField: value }).explain("executionStats");

// Use projections to reduce data transfer
db.collection.find({}, { name: 1, age: 1 });

// Use batch operations instead of loops
await Model.insertMany([...array]);

MySQL optimization tips:

• Add appropriate indexes
• Use connection pools to manage connections
• Use prepared statements to prevent SQL injection

const pool = mysql.createPool({
  connectionLimit: 10,
  host: 'localhost',
  user: 'root',
  password: 'password',
  database: 'test'
});

Cluster Mode and Load Balancing

To utilize multi-core CPUs, start a cluster:

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  const cpuCount = os.cpus().length;
  for (let i = 0; i < cpuCount; i++) {
    cluster.fork();
  }
} else {
  require('./server'); // Start the application
}

A more advanced solution is to use the PM2 process manager:

pm2 start app.js -i max --watch

Real-Time Monitoring and Performance Analysis

Performance optimization requires data support. Key tools include:

1. Node.js built-in performance hooks

const { PerformanceObserver, performance } = require('perf_hooks');

const obs = new PerformanceObserver((items) => {
  console.log(items.getEntries()[0].duration);
  performance.clearMarks();
});
obs.observe({ entryTypes: ['measure'] });

performance.mark('A');
// Code to measure
performance.mark('B');
performance.measure('A to B', 'A', 'B');

2. Clinic.js diagnostic tool

clinic doctor -- node server.js

3. APM tools like New Relic or Datadog

Stream Processing and Backpressure Control

When handling large files or data streams, backpressure must be managed correctly:

const fs = require('fs');
const zlib = require('zlib');

// Correct stream handling
fs.createReadStream('input.txt')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('output.txt.gz'))
  .on('finish', () => console.log('Done'));

Error handling example:

stream.on('error', (err) => {
  console.error('Stream error:', err);
  // Implement retry or fallback logic
});

Memory Management and Garbage Collection

Common causes of Node.js memory leaks:

• Accumulation of global variables
• Uncleared timers
• Closure references

Use heapdump to analyze memory:

const heapdump = require('heapdump');

setInterval(() => {
  if (process.memoryUsage().heapUsed > 500 * 1024 * 1024) {
    heapdump.writeSnapshot();
  }
}, 5000);

Optimization recommendations:

• Use Buffer pools to reuse memory
• Limit log file sizes
• Monitor heap memory usage

Network Optimization in Microservice Architectures

In microservice scenarios, pay special attention to:

1. Using gRPC instead of REST APIs

syntax = "proto3";

service ProductService {
  rpc GetProduct (ProductRequest) returns (ProductResponse);
}

message ProductRequest {
  int32 id = 1;
}

message ProductResponse {
  int32 id = 1;
  string name = 2;
  double price = 3;
}

2. Intelligent routing in service meshes

# Istio VirtualService example
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: product-service
spec:
  hosts:
  - products
  http:
  - route:
    - destination:
        host: products
        subset: v1
      weight: 90
    - destination:
        host: products
        subset: v2
      weight: 10

Frontend and Node.js Collaborative Optimization

Optimization points for frontend-backend collaboration:

1. Server-Side Rendering (SSR) caching strategy

const renderCache = new LRU({
  max: 100,
  maxAge: 1000 * 60 * 15 // 15 minutes
});

app.get('*', (req, res) => {
  const cacheKey = req.url;
  if (renderCache.has(cacheKey)) {
    return res.send(renderCache.get(cacheKey));
  }
  
  renderToString(app).then(html => {
    renderCache.set(cacheKey, html);
    res.send(html);
  });
});

2. GraphQL query optimization

query {
  user(id: 123) {
    name
    email
    posts(limit: 5) {
      title
      comments(limit: 3) {
        content
      }
    }
  }
}

Balancing Security and Performance

Security measures may impact performance; balance is needed:

1. Reasonable HTTPS configuration

const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('server.key'),
  cert: fs.readFileSync('server.crt'),
  ciphers: [
    'ECDHE-ECDSA-AES256-GCM-SHA384',
    'ECDHE-RSA-AES256-GCM-SHA384'
  ].join(':'),
  honorCipherOrder: true,
  minVersion: 'TLSv1.2'
};

https.createServer(options, app).listen(443);

2. Rate limiting implementation

const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100 // Limit 100 requests per IP
});

app.use('/api/', limiter);

Leveraging Modern JavaScript Features

ES6+ features can improve execution efficiency:

1. Using Promise.all to optimize I/O waits

async function fetchAllData() {
  const [users, products] = await Promise.all([
    fetch('/api/users'),
    fetch('/api/products')
  ]);
  // Parallel processing
}

2. Worker threads for CPU-intensive tasks

const { Worker } = require('worker_threads');

function runService(workerData) {
  return new Promise((resolve, reject) => {
    const worker = new Worker('./worker.js', { workerData });
    worker.on('message', resolve);
    worker.on('error', reject);
  });
}

Deployment Environment Best Practices

Production environment configuration recommendations:

1. Adjust Linux system parameters

# Increase file descriptor limit
ulimit -n 100000

# Adjust TCP parameters
sysctl -w net.ipv4.tcp_tw_reuse=1
sysctl -w net.core.somaxconn=65535

2. Docker optimization configuration

FROM node:16-alpine

WORKDIR /app
COPY package*.json ./
RUN npm ci --production

COPY . .

USER node
EXPOSE 3000
CMD ["node", "--max-old-space-size=4096", "server.js"]

Performance Optimization Patterns and Anti-Patterns

Common optimization patterns:

• Connection pooling for database connections
• Precompiling regular expressions
• Using object pools to avoid frequent GC

Anti-patterns to avoid:

// Anti-pattern: Using synchronous operations in hot paths
app.get('/data', (req, res) => {
  const data = JSON.parse(fs.readFileSync('data.json'));
  res.json(data);
});

// Anti-pattern: Unhandled Promise rejections
app.get('/async', async (req, res) => {
  const result = await someAsyncOp(); // No try-catch
  res.send(result);
});