Golang存储与图像处理服务插件库Mort的使用

Mort是一个用Go编写的S3兼容图像处理服务器，目前仍在积极开发中。

主要特性

HTTP服务器
图像处理功能：调整大小、旋转、智能裁剪
格式转换：支持JPEG、PNG、BMP、Webp
多种存储后端：磁盘、S3、HTTP
完全模块化设计
S3 API用于列出和上传文件
请求合并
内置速率限制器
支持HTTP Range和条件请求
压缩：gzip、brotli
基于环境变量的配置
可使用tengo编写自定义转换解析器
支持Cloudinary图像转换和上传

示例演示

以下是Mort的一些图像处理示例：

描述	结果(点击图片查看)
预设: small (保持宽高比，宽度: 75)
预设: blur (调整大小并模糊处理)
预设: webp (调整大小并转换为webp格式)
预设: watermark (调整大小并添加水印)

安装与使用

安装

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

命令行帮助

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

配置示例

以下是一个配置示例，用于提供演示图像：

headers: # 添加或覆盖给定状态的所有响应头。此字段是可选的
  - statusCodes: [200]
    values:
      "cache-control": "max-age=84000, public"

buckets: # 可用存储桶列表
    demo:    # 存储桶名称
        keys: # S3密钥列表(可选)
          - accessKey: "access"
            secretAccessKey: "random"
        transform: # 转换配置
            path: "\/(?P<presetName>[a-z0-9_]+)\/(?P<parent>[a-z0-9\-\.]+)" # 转换路径的正则表达式
            kind: "presets-query" #  转换类型或"query"
            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: # 从s3检索原始文件
                 kind: "s3"
                 accessKey: "acc"
                 secretAccessKey: "sec"
                 region: ""
                 endpoint: "http://localhost:8080"
             transform: # 存储在磁盘上
                 kind: "local-meta"
                 rootPath: "/var/www/domain/"
                 pathPrefix: "transform"

Docker使用

拉取Docker镜像

docker pull ghcr.io/aldor007/mort

创建自定义Docker部署

创建Dockerfile或使用Dockerfile.service:

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

# 添加你的配置
ADD config.yml /etc/mort/mort.yml

构建容器:

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

运行Docker:

docker run -p 8080:8080 myusername/mort

开发指南

确保安装了Go语言编译器(>=1.9)和git
按照bimg页面描述安装libvips
确保GOPATH设置正确
下载代码:

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

安装依赖:

go mod vendor

运行单元测试:

make unit

运行集成测试:

make integrations

如果在IDE中运行测试时遇到问题go build gopkg.in/h2non/bimg.v1: invalid flag in pkg-config --cflags: -Xpreprocessor，可以添加以下环境变量:

export CGO_CFLAGS_ALLOW="-Xpreprocessor"

使用Docker镜像运行测试:

make docker-tests

完整示例代码

以下是一个使用Mort进行图像处理的完整示例:

package main

import (
	"fmt"
	"github.com/aldor007/mort/pkg/config"
	"github.com/aldor007/mort/pkg/server"
	"log"
	"net/http"
)

func main() {
	// 创建配置
	cfg := config.Config{
		Headers: []config.HeadersCfg{
			{
				StatusCodes: []int{200},
				Values: map[string]string{
					"cache-control": "max-age=84000, public",
				},
			},
		},
		Buckets: map[string]config.Bucket{
			"demo": {
				Transform: config.Transform{
					Path: `\/(?P<presetName>[a-z0-9_]+)\/(?P<parent>[a-z0-9\-\.]+)`,
					Kind: "presets-query",
					Presets: map[string]config.Preset{
						"small": {
							Quality: 75,
							Filters: map[string]interface{}{
								"thumbnail": map[string]interface{}{
									"width": 150,
								},
							},
						},
						"blur": {
							Quality: 80,
							Filters: map[string]interface{}{
								"thumbnail": map[string]interface{}{
									"width": 700,
								},
								"blur": map[string]interface{}{
									"sigma": 5.0,
								},
							},
						},
					},
				},
				Storages: map[string]config.Storage{
					"basic": {
						Kind:            "s3",
						AccessKey:       "acc",
						SecretAccessKey: "sec",
						Endpoint:        "http://localhost:8080",
					},
					"transform": {
						Kind:       "local-meta",
						RootPath:   "/var/www/domain/",
						PathPrefix: "transform",
					},
				},
			},
		},
	}

	// 创建服务器
	srv, err := server.New(&cfg)
	if err != nil {
		log.Fatal(err)
	}

	// 启动HTTP服务器
	fmt.Println("Starting server on :8080")
	log.Fatal(http.ListenAndServe(":8080", srv.Router()))
}

这个示例展示了如何:

创建Mort配置
设置图像处理预设
配置存储后端
启动HTTP服务器

你可以根据需要修改配置中的预设和存储设置。

更多关于golang存储与图像处理服务插件库mort的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

htzhanglong 1楼

更多关于golang存储与图像处理服务插件库mort的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html

Mort - Go语言图像处理服务插件库

Mort是一个用Go语言编写的图像处理服务插件库，它提供了简单易用的API来处理图像转换、缩放、裁剪等操作。下面我将详细介绍Mort的使用方法。

安装Mort

首先，使用go get命令安装Mort：

go get github.com/aldor007/mort

基本使用

1. 初始化Mort服务

package main

import (
	"log"
	"net/http"
	
	"github.com/aldor007/mort"
	"github.com/aldor007/mort/pkg/config"
	"github.com/aldor007/mort/pkg/response"
)

func main() {
	// 创建Mort配置
	cfg := config.Config{}
	
	// 初始化Mort实例
	m, err := mort.NewMort(cfg)
	if err != nil {
		log.Fatal(err)
	}
	
	// 设置HTTP处理器
	http.Handle("/", m.GetHTTPHandler())
	
	// 启动服务
	log.Println("Starting server on :8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

2. 基本图像处理

Mort支持通过URL参数进行图像处理。例如：

http://localhost:8080/image.jpg?width=200&height=150&quality=80

3. 编程方式处理图像

package main

import (
	"bytes"
	"image/jpeg"
	"log"
	"os"
	
	"github.com/aldor007/mort/pkg/processor"
	"github.com/aldor007/mort/pkg/transforms"
)

func main() {
	// 打开原始图像文件
	file, err := os.Open("input.jpg")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()
	
	// 创建图像处理器
	proc := processor.NewProcessor()
	
	// 设置转换参数
	trans := transforms.Transforms{
		Width:   200,
		Height:  150,
		Quality: 80,
	}
	
	// 处理图像
	var buf bytes.Buffer
	err = proc.Process(file, &buf, trans)
	if err != nil {
		log.Fatal(err)
	}
	
	// 将结果保存为新文件
	outFile, err := os.Create("output.jpg")
	if err != nil {
		log.Fatal(err)
	}
	defer outFile.Close()
	
	// 解码处理后的图像以确保有效性
	img, err := jpeg.Decode(&buf)
	if err != nil {
		log.Fatal(err)
	}
	
	// 保存图像
	err = jpeg.Encode(outFile, img, &jpeg.Options{Quality: 80})
	if err != nil {
		log.Fatal(err)
	}
}

高级功能

1. 自定义存储后端

Mort支持多种存储后端，包括本地文件系统、S3等：

cfg := config.Config{
	Buckets: map[string]config.Bucket{
		"default": {
			Storage: config.Storage{
				Kind: "local",
				Local: config.Local{
					Path: "/path/to/images",
				},
			},
		},
	},
}

2. 使用S3存储

cfg := config.Config{
	Buckets: map[string]config.Bucket{
		"default": {
			Storage: config.Storage{
				Kind: "s3",
				S3: config.S3{
					Bucket:   "my-bucket",
					Region:   "us-east-1",
					Key:      "AWS_ACCESS_KEY",
					Secret:   "AWS_SECRET_KEY",
					Endpoint: "s3.amazonaws.com",
				},
			},
		},
	},
}

3. 缓存配置

cfg := config.Config{
	Cache: config.Cache{
		Kind: "memory",
		Memory: config.MemoryCache{
			Size: 100, // MB
		},
	},
}

4. 自定义转换

Mort支持自定义转换管道：

trans := transforms.Transforms{
	Width:  200,
	Height: 150,
	Operations: []transforms.Operation{
		{
			Name: "resize",
			Args: map[string]interface{}{
				"width":  200,
				"height": 150,
			},
		},
		{
			Name: "grayscale",
			Args: map[string]interface{}{},
		},
	},
}

性能优化建议

启用缓存以减少重复处理
对于高流量场景，考虑使用Redis作为缓存后端
合理设置并发处理限制
使用CDN来分发处理后的图像

错误处理

Mort提供了详细的错误处理机制：

err := proc.Process(file, &buf, trans)
if err != nil {
	switch e := err.(type) {
	case *processor.ImageError:
		log.Printf("Image processing error: %s", e.Message)
	case *processor.TransformError:
		log.Printf("Transform error: %s", e.Message)
	default:
		log.Printf("Unknown error: %v", err)
	}
}

Mort是一个功能强大且灵活的图像处理库，适合构建各种规模的图像处理服务。通过合理配置，它可以满足从简单图像转换到复杂处理管道的各种需求。