Design a Image Processing Service

Question

Design a multi-tenant image processing system that handles millions of requests. Discuss trade-offs in consistency, availability, and performance.

Codemia · Accepted Answer

### Functional Requirements:
1. **Image Upload**: Users can upload images in various formats (JPEG, PNG, GIF).
2. **Image Processing**: The system must support operations such as resize, crop, filter (e.g., grayscale, sepia), and format conversion.
3. **Multi-Tenancy**: The system should segregate data and processing for different tenants while ensuring data privacy.
4. **Image Retrieval**: Users can retrieve processed images via a unique URL.
5. **Batch Processing**: Ability to process multiple images in a single request.

### Non-Functional Requirements:
1. **Scalability**: The system should handle millions of requests per day with the ability to scale horizontally.
2. **Availability**: The system should have 99.9% uptime.
3. **Performance**: Image processing should be completed within 2 seconds for 95% of requests.
4. **Consistency**: Eventual consistency for processed images is acceptable but must guarantee that the latest version is served after processing.
5. **Security**: Ensure secure access control and data encryption during upload and retrieval.

Assuming Amazon's image processing service needs to handle:
- **10 million requests per day** (approx. 115 requests per second).
- Each image is, on average, **1 MB**, requiring a total of **10 TB** of storage per day.

### Storage Needs:
- If processed images are kept for 30 days, the total storage requirement becomes:
  - 10 TB/day * 30 days = **300 TB**.

### Processing Needs:
- If each image takes about 2 seconds to process, we need:
  - 115 requests/second * 2 seconds = **230 concurrent processing instances** at peak times.

### Load and Scaling:
- Each instance can handle 5 requests concurrently, thus requiring:
  - 230 / 5 = **46 processing servers** at peak times.

### Component Diagram:
- **API Gateway**: Handles incoming requests and routes them to the appropriate services.
- **Load Balancer**: Distributes requests across processing servers to ensure even load.
- **Image Processing Service**: A fleet of microservices (e.g., using AWS Lambda for serverless processing or EC2 instances) that perform the actual image processing tasks.
- **Message Queue (e.g., Amazon SQS)**: For decoupling image uploads from processing, ensuring that uploads don’t overwhelm the processing service.
- **Database (e.g., Amazon S3 for storage)**: Stores original and processed images. Metadata can be stored in a NoSQL database (e.g., DynamoDB) for quick access.
- **Monitoring Service (e.g., AWS CloudWatch)**: For logging, alerting, and monitoring system health.

### Schema Design:
1. **Images Table (DynamoDB)**:
   - **ImageID (PK)**: Unique identifier for each image.
   - **TenantID (SK)**: Identifier for multi-tenancy.
   - **OriginalURL**: S3 URL of the original image.
   - **ProcessedURL**: S3 URL of the processed image.
   - **Status**: Processing status (e.g., pending, processed).
   - **Timestamp**: Time of upload/processing.

2. **Metadata Storage**: Store additional image metadata (dimensions, format, processing history) in a separate NoSQL document structure that allows for quick retrieval and updates.

### Access Patterns:
- Fast lookups by ImageID and TenantID for retrieval and processing status checks.

1. **Consistency vs. Availability**: Opting for eventual consistency allows for better availability and scaling. Users may see processed images with slight delays, but the system remains responsive.
2. **Serverless vs. Managed Instances**: Using AWS Lambda for processing provides automatic scaling and less operational overhead but may have execution time limits. EC2 instances could allow longer processing times but require more management.
3. **Cost vs. Performance**: Using high-performance instances may reduce processing time but increase costs. A mix of instance types could balance performance and cost effectively.
4. **Direct Access vs. Message Queuing**: Direct processing of images could lead to bottlenecks under high load, while using a message queue adds latency but improves system resilience.

Design a Image Processing Service

Amazon

What the Interviewer Expects

Key Topics to Cover

How to Approach This

Possible Follow-up Questions

Practice a Similar Problem on Codemia

Sample Answer

Requirements

Functional Requirements:

Capacity Estimation

Submit Your Answer

Amazon Machine Learning Engineer Interview Guide

Related Questions

Design a high-throughput Inventory Management System

Design a low-latency Rate Limiting System

Design a fault-tolerant Payment System

Design a fault-tolerant Messaging System

Design Walmart Product Search