Mort

An S3-compatible image processing server written in Go. Still in active development.

Features

HTTP server
Resize, Rotate, SmartCrop
Convert (JPEG, PNG , BMP, Webp)
Multiple storage backends (disk, S3, http)
Fully modular
S3 API for listing and uploading files
Requests collapsing
Build in rate limiter
HTTP Range and Conditional requests
Compression (gzip, brotli)
Env variables driven configuration
Write you own transform parser using tengo
cloudinary image transformation and upload

And more see changelog for more info

Demo

Click on result image to see URL. More examples can be found in Image Operations list

Description	Result (to see result click on image)
preset: small (preserve aspect ratio) width: 75
preset: blur resize image (preserve aspect ratio) width: 700 blur image with sigma 5.0
preset: webp resize image (preserve aspect ratio) width: 1000 and change format to webp
preset: watermark resize image (preserve aspect ratio) width: 1300 and add watermark

Usage

Mort can be used directly from the Internet and behind any proxy.

Install

go get github.com/aldor007/mort/cmd/

Command line help

$ ./mort
Usage of  mort
  -config string
    	Path to configuration (default "/etc/mort/mort.yml")

Configuration

Example configuration used for providing demo images:

headers: #  add or overwrite all response headers of given status. This field is optional
  - statusCodes: [200]
    values:
      "cache-control": "max-age=84000, public"

buckets: # list of available buckets
    demo:    # bucket name
        keys: # list of S3 keys (optional)
          - accessKey: "access"
            secretAccessKey: "random"
        transform: # config for transforms
            path: "\\/(?P<presetName>[a-z0-9_]+)\\/(?P<parent>[a-z0-9-\\.]+)" # regexp for transform path
            kind: "presets-query" #  type of transform or "query"
            presets: # list of presets
                small:
                    quality: 75
                    filters:
                        thumbnail:
                            width: 150
                blur:
                    quality: 80
                    filters:
                        thumbnail:
                            width: 700
                        blur:
                          sigma: 5.0
                webp:
                    quality: 100
                    format: webp
                    filters:
                        thumbnail:
                            width: 1000
                watermark:
                    quality: 100
                    filters:
                        thumbnail:
                            width: 1300
                        watermark:
                            image: "https://i.imgur.com/uomkVIL.png"
                            position: "top-left"
                            opacity: 0.5
                smartcrop:
                    quality: 80
                    filters:
                      crop:
                        width: 200
                        height: 200
        storages:
             basic: # retrieve originals from s3
                 kind: "s3"
                 accessKey: "acc"
                 secretAccessKey: "sec"
                 region: ""
                 endpoint: "http://localhost:8080"
             transform: # and store it on disk
                 kind: "local-meta"
                 rootPath: "/var/www/domain/"
                 pathPrefix: "transform"

List of all image operations can be found in Image-Operations.md

More details about configuration can be found in Configuration.md

Write you own URL parser

Using golang (custom mort version needed) UrlParsers.md
Using tengo TengoUrlParser.md

Docker

See Dockerfile for image details.

Pull docker image

docker pull ghcr.io/aldor007/mort

Create you custom docker deployment

Create Dockerfile or use Dockerfile.service

# Dockerfile.service 
FROM ghcr.io/aldor007/mort:latest

# add your config
ADD config.yml /etc/mort/mort.yml

Build container

docker build -f Dockerfile.service -t myusername/mort

Run docker

docker run -p 8080:8080 myusername/mort

Full example you can find here

Development

Make sure you have a Go language compiler >= 1.9 (required) and git installed.
Install libvips like described on bimg page
Ensure your GOPATH is properly set.
Download it

git clone  https://github.com/aldor007/mort.git $GOPATH/src/github.com/aldor007/mort
cd $GOPATH/src/github.com/aldor007/mort

Install dependencies:

go mod vendor

Run unit tests:

make unit

Run integration tests:

make integrations

If you encounter following problem go build gopkg.in/h2non/bimg.v1: invalid flag in pkg-config --cflags: -Xpreprocessor while running tests in your IDE add this to your environment:

export CGO_CFLAGS_ALLOW="-Xpreprocessor"

Run tests using docker image

make docker-tests

Contributing

Please read CONTRIBUTING.md for details on our code of conduct, and the process for submitting pull requests.

License

This project is licensed under the MIT License - see the LICENSE.md file for details

📚 mort - Awesome Go Library for Images

Detailed Description of mort