Explain how to implement a serverless image resizing solution using S3 and Lambda.

Question

Accepted Answer

A serverless image resizing solution using S3 and Lambda creates an automated event-driven pipeline. When a user uploads an image to a source S3 bucket, it triggers a Lambda function that processes the image (resizing, compressing) and saves the result to a destination bucket or folder. This architecture scales automatically, costs only when files are processed, and requires zero server management . The core architectural pattern uses two separate S3 buckets or folders to prevent infinite loops. If the Lambda function wrote resized images back to the same bucket that triggered it, each new output would trigger the function again, causing an endless cycle. Therefore, best practice is to maintain an 'original' bucket for uploads and a separate 'resized' bucket for processed images . For even more flexibility, you can enable EventBridge for advanced filtering and routing of events to multiple Lambda functions . The Lambda function needs appropriate IAM permissions to read from the source bucket and write to the destination bucket. It also requires the AWSLambdaBasicExecutionRole policy to write logs to CloudWatch for monitoring and troubleshooting. The function code typically uses image processing libraries like Pillow (PIL) for Python or Sharp for Node.js, which must be included in the deployment package or added via Lambda Layers . import boto3
import os
import uuid
from urllib.parse import unquote_plus
from PIL import Image

DEST_BUCKET = 'your-resized-bucket-name'
s3_client = boto3.client('s3')

def resize_image(image_path, resized_path):
    with Image.open(image_path) as image:
        image.thumbnail((128, 128))
        image.save(resized_path)

def lambda_handler(event, context):
    for record in event['Records']:
        bucket = record['s3']['bucket']['name']
        key = unquote_plus(record['s3']['object']['key'])
        
        download_path = '/tmp/{}{}'.format(uuid.uuid4(), key)
        upload_path = '/tmp/resized-{}'.format(key)
        
        try:
            s3_client.download_file(bucket, key, download_path)
            resize_image(download_path, upload_path)
            s3_client.upload_file(upload_path, DEST_BUCKET, key)
        except Exception as e:
            print(f"Error processing {key}: {e}")
            raise e
    
    return {'statusCode': 200, 'body': 'Images processed successfully'} const AWS = require('aws-sdk');
const S3 = new AWS.S3();
const sharp = require('sharp');

exports.handler = async (event) => {
    const bucket = event.Records[0].s3.bucket.name;
    const key = decodeURIComponent(event.Records[0].s3.object.key);
    const outputKey = key.replace('original/', 'compressed/');
    
    try {
        const image = await S3.getObject({ Bucket: bucket, Key: key }).promise();
        
        const compressed = await sharp(image.Body)
            .resize({ width: 1200 })
            .webp({ quality: 70 })
            .toBuffer();
        
        await S3.putObject({
            Bucket: bucket,
            Key: outputKey,
            Body: compressed,
            ContentType: 'image/webp'
        }).promise();
        
        return { statusCode: 200, body: 'Image processed successfully' };
    } catch (error) {
        console.error('Error:', error);
        throw error;
    }
}; To set up the S3 trigger, navigate to your source bucket's properties, configure an event notification for 'All object create events' (or specific suffixes like .jpg, .png), and select your Lambda function as the destination . Alternatively, you can enable EventBridge for the bucket and create rules that provide richer filtering capabilities, such as triggering only for files above a certain size or with specific metadata tags . For production deployments, consider several optimizations: implement proper error handling with try/catch blocks, set appropriate Lambda timeouts (10-30 seconds for image processing), use temporary /tmp storage for intermediate files (limited to 512MB-10GB depending on configuration), and monitor CloudWatch logs for troubleshooting . You can also implement multiple resize configurations to generate several image sizes from a single upload, creating thumbnails, medium-sized images, and full-resolution optimized versions . Always use separate source and destination buckets or folders to prevent infinite processing loops  Package image processing libraries (Pillow, Sharp, ImageMagick) via Lambda Layers or container images  Configure minimum IAM permissions: s3:GetObject on source bucket, s3:PutObject on destination bucket, and CloudWatch logs access  Set memory allocation appropriately (512MB-1GB) for image processing performance  Consider S3 Object Lambda as an alternative for on-the-fly transformations without storing multiple versions  Use CloudFront to serve resized images with caching for better performance

Explain how to implement a serverless image resizing solution using S3 and Lambda.

A serverless image resizing solution can be implemented by triggering an AWS Lambda function on S3 upload events to automatically process and resize images without managing servers.

Explain how to implement a serverless image resizing solution using S3 and Lambda.

A serverless image resizing solution can be implemented by triggering an AWS Lambda function on S3 upload events to automatically process and resize images without managing servers.

Scenario Questions

Follow-up Questions