Rolling Updates: Implementing Continuous Deployment with Zero Downtime

AWS Connection Draining Configuration

# CloudFormation template for ELB with connection draining
Resources:
  MyLoadBalancer:
    Type: AWS::ElasticLoadBalancing::LoadBalancer
    Properties:
      Listeners:
        - LoadBalancerPort: '80'
          InstancePort: '80'
          Protocol: HTTP
      HealthCheck:
        Target: HTTP:80/health
        HealthyThreshold: '3'
        UnhealthyThreshold: '5'
        Interval: '30'
        Timeout: '5'
      ConnectionDrainingPolicy:
        Enabled: true
        Timeout: 300  # 5 minutes to allow connections to complete

Nginx Connection Draining Example

# Nginx configuration for graceful shutdown
events {
    worker_connections 1024;
}

http {
    upstream backend {
        server backend1.example.com;
        server backend2.example.com;
        server backend3.example.com;
    }
    
    server {
        listen 80;
        
        location / {
            proxy_pass http://backend;
            proxy_http_version 1.1;
            proxy_set_header Connection "";  # Enable keepalive connections
            
            # Proper headers for connection draining
            proxy_next_upstream error timeout http_502 http_503 http_504;
            proxy_connect_timeout 5s;
            proxy_read_timeout 60s;
            proxy_send_timeout 60s;
        }
    }
}

# Graceful shutdown script
#!/bin/bash
# Signal Nginx to stop accepting new connections but finish processing existing ones
nginx -s quit

# Wait for connections to drain (adjust timeout as needed)
timeout=300  # 5 minutes
interval=5   # Check every 5 seconds
elapsed=0

while [ $elapsed -lt $timeout ]; do
    # Check if Nginx still has active connections
    active_connections=$(ss -tn | grep -c ":80")
    
    if [ $active_connections -eq 0 ]; then
        echo "All connections drained, proceeding with update"
        break
    fi
    
    echo "Waiting for $active_connections connections to complete..."
    sleep $interval
    elapsed=$((elapsed + interval))
done

# Continue with the update process

External Session Store Implementation

// Node.js with Express and Redis Session Store
const express = require('express');
const session = require('express-session');
const RedisStore = require('connect-redis').default;
const { createClient } = require('redis');

const app = express();

// Create Redis client
const redisClient = createClient({
  url: process.env.REDIS_URL || 'redis://localhost:6379'
});

redisClient.connect().catch(console.error);

// Configure session middleware with Redis store
app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: process.env.SESSION_SECRET || 'your-secret-key',
  resave: false,
  saveUninitialized: false,
  cookie: {
    secure: process.env.NODE_ENV === 'production',
    maxAge: 1000 * 60 * 60 * 24 // 1 day
  }
}));

// Session usage in application
app.get('/profile', (req, res) => {
  if (!req.session.user) {
    return res.redirect('/login');
  }
  
  res.render('profile', { user: req.session.user });
});

app.post('/login', (req, res) => {
  // Authenticate user
  const user = authenticateUser(req.body.username, req.body.password);
  
  if (user) {
    // Store user in session
    req.session.user = {
      id: user.id,
      username: user.username,
      email: user.email,
      preferences: user.preferences
    };
    
    res.redirect('/dashboard');
  } else {
    res.render('login', { error: 'Invalid credentials' });
  }
});

// Graceful shutdown handling
process.on('SIGTERM', async () => {
  console.log('Received SIGTERM signal, shutting down gracefully');
  
  // Close Redis connection
  await redisClient.quit();
  
  // Close Express server
  server.close(() => {
    console.log('HTTP server closed');
    process.exit(0);
  });
});