When to Use Serverless

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

// Parallel Run Pattern Implementation
// Route traffic to both systems, compare results
 
interface ParallelRunConfig {
    legacyUrl: string;
    serverlessUrl: string;
    compareResponses: boolean;
    logDifferences: boolean;
    useServerlessResponse: boolean; // false = legacy is primary
    sampleRate: number; // 0-1, what % of traffic to parallel run
}
 
export const parallelRunHandler: APIGatewayProxyHandler = async (event) => {
    const config = getConfig();
    
    // Should we parallel run this request?
    const shouldParallel = Math.random() < config.sampleRate;
    
    if (!shouldParallel) {
        // Just use the primary system
        return config.useServerlessResponse 
            ? invokeServerless(event) 
            : invokeLegacy(event);
    }
    
    // Parallel execution
    const startTime = Date.now();
    const [legacyResult, serverlessResult] = await Promise.allSettled([
        invokeLegacy(event),
        invokeServerless(event),
    ]);
    
    // Log comparison metrics
    const metrics = {
        requestId: event.requestContext.requestId,
        legacyDuration: legacyResult.status === 'fulfilled' 
            ? legacyResult.value.duration : null,
        serverlessDuration: serverlessResult.status === 'fulfilled' 
            ? serverlessResult.value.duration : null,
        legacyStatus: legacyResult.status === 'fulfilled' 
            ? legacyResult.value.statusCode : 'error',
        serverlessStatus: serverlessResult.status === 'fulfilled' 
            ? serverlessResult.value.statusCode : 'error',
        responsesMatch: false,
    };
    
    // Compare responses if both succeeded
    if (config.compareResponses && 
        legacyResult.status === 'fulfilled' && 
        serverlessResult.status === 'fulfilled') {
        
        metrics.responsesMatch = compareResponses(
            legacyResult.value.body,
            serverlessResult.value.body,
        );
        
        if (!metrics.responsesMatch && config.logDifferences) {
            await logDifference({
                requestId: event.requestContext.requestId,
                request: event,
                legacyResponse: legacyResult.value.body,
                serverlessResponse: serverlessResult.value.body,
            });
        }
    }
    
    await publishMetrics(metrics);
    
    // Return primary system's response
    const primary = config.useServerlessResponse ? serverlessResult : legacyResult;
    if (primary.status === 'fulfilled') {
        return primary.value.response;
    } else {
        // Primary failed, try secondary
        const secondary = config.useServerlessResponse ? legacyResult : serverlessResult;
        if (secondary.status === 'fulfilled') {
            return secondary.value.response;
        }
        throw new Error('Both systems failed');
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

// Migration Canary: Validates infrastructure before real migration
// This function does almost nothing but proves everything works
 
export const canaryHandler: APIGatewayProxyHandler = async (event) => {
    const healthChecks = {
        lambda: true,
        timestamp: new Date().toISOString(),
        region: process.env.AWS_REGION,
        functionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
        checks: {} as Record<string, boolean>,
    };
    
    // Test database connectivity
    try {
        await db.query('SELECT 1');
        healthChecks.checks.database = true;
    } catch (error) {
        healthChecks.checks.database = false;
        console.error('Database check failed:', error);
    }
    
    // Test cache connectivity
    try {
        await redis.ping();
        healthChecks.checks.cache = true;
    } catch (error) {
        healthChecks.checks.cache = false;
        console.error('Cache check failed:', error);
    }
    
    // Test external service (if applicable)
    try {
        await fetch(process.env.LEGACY_SERVICE_URL + '/health');
        healthChecks.checks.legacyService = true;
    } catch (error) {
        healthChecks.checks.legacyService = false;
        console.error('Legacy service check failed:', error);
    }
    
    // Emit custom metric
    await cloudwatch.putMetricData({
        Namespace: 'Migration',
        MetricData: [{
            MetricName: 'CanaryHealthy',
            Value: Object.values(healthChecks.checks).every(Boolean) ? 1 : 0,
            Unit: 'Count',
        }],
    });
    
    return {
        statusCode: 200,
        body: JSON.stringify(healthChecks),
    };
};
 
// Deploy this first and validate:
// - Lambda execution works
// - VPC networking is correct (can reach database)
// - IAM permissions are sufficient
// - Logging and metrics flow correctly
// - Deployment pipeline functions end-to-end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

// Dual Write Pattern for Zero-Downtime Database Migration
 
interface DualWriteConfig {
    primaryDb: Database;  // Initially legacy, switches to new
    secondaryDb: Database;  // Initially new, switches to legacy
    writeToBoth: boolean;
    readFromPrimary: boolean;
    validateWrites: boolean;
}
 
class DualWriteRepository {
    constructor(private config: DualWriteConfig) {}
    
    async create(entity: Entity): Promise<Entity> {
        // Always write to primary
        const result = await this.config.primaryDb.insert(entity);
        
        if (this.config.writeToBoth) {
            try {
                // Write to secondary asynchronously
                await this.config.secondaryDb.insert(entity);
                
                if (this.config.validateWrites) {
                    // Validate data matches
                    const secondary = await this.config.secondaryDb.findById(result.id);
                    if (!deepEqual(result, secondary)) {
                        await this.logDiscrepancy('create', result, secondary);
                    }
                }
            } catch (error) {
                // Secondary write failed - log but don't fail the request
                await this.logSecondaryFailure('create', entity, error);
            }
        }
        
        return result;
    }
    
    async findById(id: string): Promise<Entity | null> {
        const primary = await this.config.primaryDb.findById(id);
        
        // Optionally validate secondary has same data
        if (this.config.validateWrites && primary) {
            const secondary = await this.config.secondaryDb.findById(id);
            if (!deepEqual(primary, secondary)) {
                await this.logDiscrepancy('read', primary, secondary);
            }
        }
        
        return primary;
    }
    
    // Migration phases:
    // 1. writeToBoth=true, primaryDb=legacy (build up new DB)
    // 2. Validate: compare all data between DBs
    // 3. readFromPrimary switches to new DB
    // 4. primaryDb switches to new DB  
    // 5. writeToBoth=false (stop writing to legacy)
    // 6. Decommission legacy DB
}