Serverless Architecture: De Voor- en Nadelen

Serverless is een buzzword dat de laatste jaren enorm populair is geworden. Maar wat betekent het eigenlijk, en wanneer moet je het wel of niet gebruiken? In deze post duik ik in de realiteit van serverless architectuur, met concrete voorbeelden en praktische adviezen.

Wat Is Serverless Eigenlijk?

Ondanks de naam draait serverless nog steeds op servers - je hoeft ze alleen niet zelf te beheren. In plaats van een VM of container 24/7 draaiend te houden, betaal je alleen voor de daadwerkelijke compute time die je gebruikt.

Belangrijkste eigenschappen:

• Event-driven: Code wordt getriggerd door events (HTTP requests, database changes, file uploads)
• Auto-scaling: Schaalt automatisch van 0 tot duizenden instances
• Pay-per-use: Betaal alleen voor daadwerkelijke executions
• Managed infrastructure: Cloud provider regelt servers, patching, scaling

Populaire Serverless Platforms

AWS Lambda

De pionier en marktleider. Ondersteunt Python, Node.js, Go, Java, .NET, Ruby.

// AWS Lambda function (Node.js)
export const handler = async (event) => {
  const body = JSON.parse(event.body);
  
  // Business logic here
  const result = await processData(body);
  
  return {
    statusCode: 200,
    body: JSON.stringify({ success: true, data: result })
  };
};

Azure Functions

Microsoft's serverless platform, naadloze .NET integratie.

// Azure Function (C#)
[FunctionName("ProcessOrder")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req,
    ILogger log)
{
    var body = await new StreamReader(req.Body).ReadToEndAsync();
    var order = JsonConvert.DeserializeObject<Order>(body);
    
    await ProcessOrderAsync(order);
    
    return new OkObjectResult(new { success = true });
}

Google Cloud Functions

Google's variant, sterk in data processing en ML workflows.

Wanneer Is Serverless De Juiste Keuze?

✅ Perfecte Use Cases

1. Event-driven workflows

• Webhook endpoints
• File processing (upload → resize image → save)
• Background jobs triggered by queue messages

2. Variabele workloads

• Traffic pieken (bijv. ticketverkoop events)
• Periodieke batch jobs (1x per nacht data processing)
• Onvoorspelbare usage patterns

3. Rapid prototyping

• MVPs en proof of concepts
• Experimenten zonder infrastructure overhead
• Quick integrations tussen services

4. Backend voor mobiele apps

• REST API endpoints
• Push notification handlers
• Authentication flows

❌ Wanneer NIET Serverless Te Gebruiken

1. Lang-lopende processen

• Lambda heeft een max execution time van 15 minuten
• Video encoding, machine learning training → gebruik containers

2. Constant high throughput

• Als je 24/7 traffic hebt, wordt serverless duurder dan dedicated infrastructure
• Break-even point ligt vaak rond 30-40% constant CPU utilization

3. Low latency requirements

• Cold starts kunnen 1-3 seconden duren
• Kritieke real-time apps → gebruik always-on instances

4. Complexe state management

• Serverless functions zijn stateless
• Voor stateful apps heb je externe storage nodig (databases, Redis)

Real-World Voorbeeld: Image Processing Pipeline

Een praktisch voorbeeld van waar serverless excelleert:

# Architecture
User uploads image → S3 bucket → triggers Lambda → 
  → Resize image (3 sizes) →
  → Generate thumbnails →
  → Extract metadata →
  → Save to database →
  → Send notification

# AWS SAM template
Resources:
  ImageBucket:
    Type: AWS::S3::Bucket
    Properties:
      NotificationConfiguration:
        LambdaConfigurations:
          - Event: s3:ObjectCreated:*
            Function: !GetAtt ProcessImageFunction.Arn

  ProcessImageFunction:
    Type: AWS::Serverless::Function
    Properties:
      Runtime: nodejs18.x
      Handler: index.handler
      Timeout: 60
      MemorySize: 1024
      Environment:
        Variables:
          THUMBNAIL_SIZES: "150,300,600"

Voordelen hier:

• Schaalt automatisch met upload volume
• Geen idle costs wanneer geen uploads
• Geen server management

Kosten: De Waarheid

Serverless marketing zegt "super goedkoop", maar dat klopt niet altijd.

AWS Lambda pricing (voorbeeld):

• $0.20 per 1 miljoen requests
• $0.0000166667 per GB-second compute

Scenario 1: Low traffic API (startup)

• 100,000 requests/maand
• Gem. 200ms duration, 512MB memory
• Kosten: ~$1/maand → ✅ Zeer goedkoop

Scenario 2: High traffic app (scale-up)

• 50 miljoen requests/maand
• Gem. 500ms duration, 1GB memory
• Kosten: ~$400/maand → ⚠️ Dedicated server kan goedkoper

Best Practices

1. Minimize cold starts

// Keep dependencies minimal
// Reuse connections outside handler
const db = require('./db'); // Initialized once

exports.handler = async (event) => {
  // Handler stays lean
  return db.query(event.query);
};

2. Use environment variables

# Don't hardcode configs
DATABASE_URL=postgres://...
API_KEY=secret123
STAGE=production

3. Implement proper error handling

exports.handler = async (event) => {
  try {
    return await processEvent(event);
  } catch (error) {
    console.error('Error:', error);
    // Send to error tracking (Sentry, etc.)
    throw error; // Let Lambda retry
  }
};

4. Monitor en optimize

• Watch CloudWatch metrics (duration, errors, throttles)
• Optimize memory allocation (more memory = faster CPU)
• Use distributed tracing (X-Ray)

Conclusie

Serverless is geen silver bullet, maar een krachtig tool in je architectuur toolkit. Het schittert bij event-driven workloads met variabele traffic, maar is niet altijd de goedkoopste of snelste optie voor constant high-traffic scenarios.

Mijn advies:

• Start serverless voor nieuwe projects (snelle iteration)
• Monitor kosten en performance vanaf dag 1
• Migreer naar dedicated infrastructure als dat economisch zinvol wordt
• Gebruik hybrid: serverless voor peaks, containers voor baseline

English summary: This article explores serverless architecture's pros and cons, covering when to use AWS Lambda, Azure Functions, or Google Cloud Functions versus traditional infrastructure. It includes practical examples, cost analysis, and best practices for production serverless deployments.