Building a Scalable API Proxy with Node.js

API proxies are essential for managing, securing, and optimizing API traffic in modern applications. This tutorial walks through building a production-ready proxy service from scratch.

Architecture Overview

Our proxy service will include:

• Request/response transformation
• Rate limiting and authentication
• Caching layer
• Load balancing
• Comprehensive logging

Core Implementation

Setting Up the Express Server

import express from 'express';
import { createProxyMiddleware } from 'http-proxy-middleware';
import rateLimit from 'express-rate-limit';

const app = express();

// Rate limiting
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100 // limit each IP to 100 requests per windowMs
});

app.use(limiter);

Request Authentication

const authenticateApiKey = async (req: Request, res: Response, next: NextFunction) => {
  const apiKey = req.headers.authorization?.replace('Bearer ', '');
  
  if (!apiKey) {
    return res.status(401).json({ error: 'API key required' });
  }

  // Validate API key against database
  const isValid = await validateApiKey(apiKey);
  if (!isValid) {
    return res.status(401).json({ error: 'Invalid API key' });
  }

  next();
};

Scaling Considerations

Horizontal Scaling

Use a process manager like PM2 for clustering:

pm2 start ecosystem.config.js

// ecosystem.config.js
module.exports = {
  apps: [{
    name: 'api-proxy',
    script: './dist/server.js',
    instances: 'max',
    exec_mode: 'cluster',
    env: {
      NODE_ENV: 'production',
      PORT: 3000
    }
  }]
};

Database Connection Pooling

import { Pool } from 'pg';

const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
  max: 20, // Maximum number of connections
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000,
});

Monitoring and Observability

Implement comprehensive monitoring:

import prometheus from 'prom-client';

const requestCounter = new prometheus.Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'route', 'status']
});

const responseTime = new prometheus.Histogram({
  name: 'http_request_duration_seconds',
  help: 'HTTP request duration in seconds',
  labelNames: ['method', 'route']
});

Conclusion

Building a scalable API proxy requires careful attention to architecture, performance, and monitoring. The patterns shown here will help you create a robust foundation for your API infrastructure.