Serverless Architecture: Pros, Cons, and Use Cases

# AWS Lambda event mapping example
{
  "Records": [
    {
      "eventVersion": "2.1",
      "eventSource": "aws:s3",
      "eventName": "ObjectCreated:Put",
      "s3": {
        "bucket": {
          "name": "my-bucket"
        },
        "object": {
          "key": "uploads/image.jpg"
        }
      }
    }
  ]
}

# Function handler
exports.handler = async (event) => {
  for (const record of event.Records) {
    if (record.eventName === 'ObjectCreated:Put') {
      const bucket = record.s3.bucket.name;
      const key = record.s3.object.key;
      
      // Process the uploaded file
      await processImage(bucket, key);
    }
  }
  
  return { statusCode: 200, body: 'Success' };
};

# package.json - Only include production dependencies
{
  "name": "my-lambda-function",
  "version": "1.0.0",
  "dependencies": {
    "aws-sdk": "^2.1000.0",
    "lodash": "^4.17.21"
  },
  "devDependencies": {
    "jest": "^27.0.0",
    "eslint": "^8.0.0"
  }
}

# webpack.config.js - Tree shaking and minification
const path = require('path');

module.exports = {
  entry: './src/index.js',
  target: 'node',
  mode: 'production',
  optimization: {
    minimize: true,
    usedExports: true,
    sideEffects: false
  },
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: 'index.js',
    libraryTarget: 'commonjs2'
  }
};

# AWS Kinesis Data Streams processing
exports.handler = async (event) => {
  const records = event.Records;
  
  for (const record of records) {
    const payload = Buffer.from(record.kinesis.data, 'base64').toString();
    const data = JSON.parse(payload);
    
    // Process the data
    const processedData = await transformData(data);
    
    // Store results
    await storeResults(processedData);
  }
  
  return { statusCode: 200 };
};

# Google Cloud Pub/Sub processing
exports.processMessage = async (message) => {
  const data = JSON.parse(message.data.toString());
  
  // Process the message
  const result = await processData(data);
  
  // Acknowledge the message
  message.ack();
  
  return result;
};

# RESTful API with AWS Lambda
exports.handler = async (event) => {
  const { httpMethod, path, pathParameters, queryStringParameters, body } = event;
  
  try {
    switch (httpMethod) {
      case 'GET':
        if (path === '/users') {
          return await getUsers(queryStringParameters);
        } else if (path === '/users/{id}') {
          return await getUser(pathParameters.id);
        }
        break;
        
      case 'POST':
        if (path === '/users') {
          return await createUser(JSON.parse(body));
        }
        break;
        
      case 'PUT':
        if (path === '/users/{id}') {
          return await updateUser(pathParameters.id, JSON.parse(body));
        }
        break;
        
      case 'DELETE':
        if (path === '/users/{id}') {
          return await deleteUser(pathParameters.id);
        }
        break;
        
      default:
        return {
          statusCode: 405,
          body: JSON.stringify({ error: 'Method not allowed' })
        };
    }
  } catch (error) {
    return {
      statusCode: 500,
      body: JSON.stringify({ error: error.message })
    };
  }
};