Lust is an auto-optimising image server, designed for high throughput and low latency handling of images, now that is lustful.
Re-encode uploaded images into png, jpeg, webp or even into gif based formats!
Resize them to your liking automatically with sizing presets, instantly create small, medium and large variants with just a few line in a config file. Now that's the spirit of lust
And much more like caching, on the fly resizing and diffrent processing modes to name a few.
It's highly advised to take a look at some example config files to get an idea of what a general config file would look like.
Full documentation in markdown form can also be found here, this is also served directly by the server as part of the documentation ui endpoint.
To building from source, just clone this repo via git clone https://github.com/chillfish8/lust.git and then run cargo build --release.
You can install lust directly via cargo and the git flag:
cargo install lust --git https://github.com/ChillFish8/lust.gitLust has a set of pre-built, optimised docker images ready to go. Just run it with
docker run -v "my_configs:/var/lust/" chillfish8/lust:latest --config-file "/var/lust/config.yaml"Note: Assuming there is a folder called my_configs with a config.yaml file in it.
Once you're up and running navigate to http://127.0.0.1:8000/ui or /ui of what ever port your server is running on
to see the full OpenAPI docs.
Lust makes use of a Least Recently Used in-memory cache which can be adjusted for your needs via the cache_size key in the configuration file.
The larger the number the more images it will cache at once and vice versa.
NOTE: With bigger images this can create much higher RAM usage
Lust's ability to scale is purely down to the backend you use, so it is worth noting that the file system backend is only really designed for testing. For full scale deployment consider using Scylla or a s3 compatible blob store to serve data from.
If your goal is high-end performance, Scylla DB will be the most performant by a large margin, but this will come with a higher operating cost.
Lust supports any of the following formats:
- Png
- JPEG
- GIF
- Webp
Any uploaded images will be given a unique uuid and be re-encoded into all the other enabled formats in all presets. This is especially useful when you want to serve several variants of the same image with different formats.
You can also adjust this based on the processing mode, aot/Ahead of time encoding will follow the old
lust behavour by encoding and resizing each image at upload time.
jit/Just in time encoding will only resize and re-encode at request time, storing a base copy
of the file to generate new images. This can save on a considerable amount of CPU time and disk space
depending on your requirements.
Finally, we have the realtime encoder, this will only store an original copy like the jit encoder
but instead will never save the resized and encoded image, this does also enable the ability to
do on the fly resizing and is recommended for situations where you're not expecting to serve image
to the public network.
The server can take several sizing presets which can be targeted via the size
query parameter when getting an image.
These presets will mean every image at upload time will be resized to
fit the width and height bounds using the configured resizing filter
(defaults to nearest neighbour).
Regardless of presets an original image is always stored and can be accessed via the size=original query.
The default preset when served without a size parameter can be set in the configuration file via default_serving_preset key.
Lust's data storage efficiency is roughly the same as storing on a plain file system outside any system the database backend employs when storing the data.