Implementation Overview (Kube)

ImageEngine Kube is ImageEngine's self-hosted image optimization engine for Kubernetes and Docker. It runs in your own cloud, works with any CDN, and uses WURFL device detection to automatically resize, compress, and convert images to AVIF, WebP, or JPEG XL, with up to 80% payload reduction. One flat monthly license, no per-request fees. Trusted by 100,000+ domains.

Existing ImageEngine SaaS customer? See Implementation Overview (SaaS).

ImageEngine Kube pulls images from your origin on demand and optimizes them, running in your own Kubernetes or Docker environment. Setup takes minutes and fits into your existing infrastructure.

Point ImageEngine at your existing image origin. On the first request for an image, ImageEngine fetches it, caches the result, and delivers an optimized version.

We do this through an "Engine," a relationship between the image origin and a Delivery Address.

Key Elements of an Engine

Delivery Address: A Delivery Address is where you direct requests for images. With ImageEngine Kube, this is a hostname you own (for example, images.foo.com) that points at your Kube deployment. You are responsible for creating its DNS record and provisioning its SSL certificate.

ImageEngine Address: Your engine also shows an ImageEngine Address on the imgeng.in domain in the control panel. With ImageEngine Kube, image traffic does not go through this address; your Delivery Address must point at your Kube deployment.

Origin: This is where your web content, such as images, is stored. You can store your images on a web server accessible via HTTP or HTTPS, S3, or cloud-based storage.
ImageEngine does not need you to move or upload images anywhere.

Putting the Pieces together

Diagram shows the general flow. With ImageEngine Kube, the optimizing server is your Kube deployment.

If an optimized version of the image tailored to the requesting device is already cached, ImageEngine will deliver it immediately. ImageEngine stores several optimized images based on the capabilities of the requesting devices or browsers, each with a unique cache key.

If an optimized image is not in ImageEngine’s cache (typically the very first time an image is requested), then ImageEngine will fetch the image from the origin. ImageEngine will resize, compress, and convert the image into its optimal format. During these first optimizations, ImageEngine will serve the original (unoptimized) image until the ImageEngine cache is “warmed” or “primed” to avoid any delays for users requesting images. Therefore, you should send a fair amount of traffic and monitor the cache hit rate in your Kube deployment’s metrics before evaluating the effectiveness of the image payload optimization and page load time.

If you use a CDN in front of Kube, the CDN serves cache hits and Kube handles only cache misses. See Configuring Kube with CDNs. ImageEngine typically reduces image payload by up to 80%.

Before You Begin

Make sure you:

• A running ImageEngine Kube deployment (see Getting Started with ImageEngine Kube)
• Have access to modify image URLs in your code or CMS
• Know your current image origin URL (e.g., `https://www.yoursite.com` or S3 bucket)
• A way to test changes (staging environment or test page)

Time to implement: Most customers complete basic integration in 15-30 minutes. 

Integration Methods

We have implementation guides and plugins available for many common platforms and technologies.  Please see them here: Integration Guides and Plugins

To implement ImageEngine on your website, you have two options for directing traffic to ImageEngine via updating img src tags: the Delivery Address Method and the Prefix Method. You can also keep your existing image URLs on your CDN and set Kube as the CDN's origin. See Configuring Kube with CDNs.

Which Integration Method Should I Use?

Choose Delivery Address Method if:
- ✓ You have one primary image origin
- ✓ You want clean, simple image URLs
- ✓ You're using a CMS with ImageEngine plugins available

Choose Prefix Method if:
- ✓ You have multiple image origins (CDN, S3, different servers)
- ✓ You want to test ImageEngine with different environments
- ✓ You need flexibility to switch origins without reconfiguring

Not sure? Start with Delivery Address Method—it's simpler and covers 99% of use cases.

1. Delivery Address Method

Diagram shows an ImageEngine SaaS setup. With Kube, images.foo.com points at your Kube deployment.

Use the Delivery Address you configured for your Kube deployment.

To optimize images, you must modify your img src attributes to direct requests to the Delivery Address. Copy the Delivery Address, and insert it into the img src attribute.

For example, the original image src attribute was  <img src="https://www.foo.com/image.jpg">
and your Delivery Address is images.foo.com,
then, you will modify your image src attribute to
<img src="https://images.foo.com/image.jpg">

Here is an animation of what this looks like: 

Animation shows an ImageEngine SaaS address. With Kube, use the hostname you point at your Kube deployment.

2. Prefix Method

You can prefix any image origin URL with a Delivery Address.
Please note, prefixing must first be enabled for your Delivery Address in the control panel.

This is a great option if you have multiple origins you want to serve through the same Delivery Address. It is also a great method for testing ImageEngine with different environments.
In the control panel, you may restrict which origins can be prefixed.

For example. if the original image src attribute was

<img src="https://www.foo.com/image.jpg">
and your Delivery Address with HTTPS is
images.foo.com
then you will modify your image src attribute to
<img src="https://images.foo.com/https://www.foo.com/image.jpg">

Optional: Manual resizing control, other directives, and Engine delivery options 

ImageEngine works automatically without any configuration. However, you can optionally use directives to manually override specific optimizations—such as forcing a particular width, format, or fit method.

For the complete list of available directives and examples, please see the Directives article. 

Adjust Engine delivery options

Each Engine can have settings for adjusting the delivery of large sets of images, please view our article on Customizing Engine Image delivery.  

Ready for Production?

Once you've tested your implementation, see our comprehensive Advice for Going Live with ImageEngine guide, which covers:
- Cache warming strategies
- Temporary Origin Image Fallback settings (serve original images while optimized versions are prepared)
- Verification and monitoring
- Preparing your origin servers for the transition
 

Next Steps

For a successful implementation:

1. Setup Kube with your CDN- Configuring Kube with CDNs
2. Test thoroughly- See Advice for Going Live for production deployment tips
3. Optimize performance- Review Best Practices with ImageEngine for advanced techniques
4. Use responsive images - Learn about Responsive Images Best Practices for optimal delivery
5. Need help? - Contact support at control.imageengine.io/support or check our Integration Guides

Quick verification

After implementation, verify ImageEngine is working:
1. Open browser DevTools → Network tab → reload page
2. Check image response headers for `server: ScientiaMobile ImageEngine`
3. Compare file sizes—you should see 40-80% reduction

For detailed verification steps, see How to Inspect Images.