Resize Images at Scale without breaking a sweat!

Introduction

Handling images at scale can be challenging — especially when you need to serve them in different resolutions and formats. Traditional methods often involve batch processing to asynchronously process and store the images, which is time-consuming and inefficient. But there’s a better way, which saves a lot of time and is massively scalable as well. 

Problem Statement

Many development teams face the challenge of serving images in multiple resolutions and formats. 

For example, a single image might need to be available in various sizes such as:

• Thumbnail: /images/photo.png?w=150&h=150
• Medium: /images/photo.png?w=300&h=300
• Large: /images/photo.png?w=600&h=600

The typical approach involves running batch jobs that process uploaded images and stores them in various formats. This process works fine but can cause various issues — like

• High Storage Requirements: Storing multiple versions of each image consumes significant storage space.
• Long Processing Times: Batch processing can take a long time, delaying the availability of images.
• Manual Intervention: Managing and updating the batch processing scripts requires continuous manual effort.
• Poor Scalability: As the number of images grows, the system becomes harder to scale and maintain.

AWS Serverless Image Handler

AWS Serverless Image Handler offers a solution that overcomes these challenges by leveraging AWS’s serverless technologies. Here’s how it works and why it’s better:

1. Client Request: The client sends an HTTP request for an image with specific dimensions (e.g., /image.png?w=300).
2. AWS WAF Protection: The request is filtered through AWS WAF (Web Application Firewall) to protect against common web exploits.
3. CloudFront Distribution: The request is then directed to CloudFront, AWS’s Content Delivery Network (CDN), which caches images to reduce latency and improve load times.
4. Viewer Request Lambda@Edge: Triggered by the CloudFront “viewer request” event. Reformats the requested URI into a valid S3 key expected by the S3 bucket (e.g., /image.png?w=300 to /300/image.avif).
5. S3 Bucket Access: CloudFront uses an Origin Access Identity to securely access the S3 bucket, which stores both original and resized images.
6. Image Retrieval: CloudFront attempts to fetch the image from the S3 bucket. If the resized image exists, it is retrieved and sent to the client.
7. Origin Response Lambda@Edge: If the resized image is not found, this Lambda function is triggered. Checks if the original image is available in the S3 bucket. If found, it resizes the image, stores it back in the S3 bucket, and returns it to the client. If not found, returns a 404 error.
8. Image Processing: The Lambda function processes and saves the resized image back to the S3 bucket for future requests.
9. Image Delivery: The resized image is delivered to the client.

This architecture ensures that images are processed efficiently and delivered quickly, with minimal manual intervention and maximum scalability.

Benefits

• Dynamic Image Handling: Automatically resize, crop, and edit images at the edge, reducing manual effort and processing time.
• Cost-Effective and Scalable: Pay only for what you use, and easily scale with your needs without additional infrastructure management.
• Quick Implementation: Get up and running in days with AWS’s pre-built CloudFormation template.

Conclusion and Next Steps

AWS’s Serverless Image Handler provides a seamless, scalable, and cost-effective solution for dynamic image resizing. It simplifies the process, reduces manual effort, and enhances performance.

Ready to simplify your image management workflow? Try out the Serverless Image Handler CloudFormation template today.

For personalized assistance and expert consulting, reach out to KubeNine. We’re here to help you optimize your cloud infrastructure and streamline your operations.