从零打造极简高可用博客图床：海外大盘VPS + Go原生轻量后端 + EdgeOne边缘加速实践

折腾的出发点#

在运营基于 Astro / Hugo 等静态框架的独立博客时，图床选型始终是绕不开的话题：

公共图床/第三方免费托管：随时面临防盗链、被限流甚至跑路的风险；
商业对象存储（如 COS/OSS）+ 国内 CDN：按量计费虽然安全，但一旦遭遇恶意刷刷流量，容易产生高额账单；
Git 仓库内嵌媒体文件：随时间推移仓库体积快速膨胀，Clone 和 CI/CD 部署构建极度缓慢。

手头有一台闲置的大容量海外 VPS（1.5T 硬盘，Debian 12），既然硬盘空间充裕，将其改造成私有图床源站是极具性价比的选择。然而海外主机直连境内延迟高、且网络波动频繁，要达到商用级别的体验，必须解决三个关键需求：

资源极简：尽量避免引入重型面板或全家桶图床程序，内存占用控制在 10MB 以内；
边缘加速与回源保护：借助国内边缘加速节点接管大流量，海外源站仅作为物理存储底层；
闭环体验：支持前端自动 WebP 压缩、跨设备管理历史图片，并在博客后台（Decap CMS）实现像 Notion 一样截屏按 Ctrl + V 即可无感直传。

本文完整记录这一架构的搭建细节、踩坑经验与落地代码。

架构设计概览#

整体架构链路非常清晰：

1
[ 写作端 / Decap CMS ]
2
        │ (Ctrl+V 触发前端 Canvas 转码 WebP)
3
        ▼
4
[ EdgeOne 边缘加速 (Anycast) ]
5
   ├── 动态接口 (/upload, /list, /delete) ──(直接穿透 / 0缓存)──► [ 海外 VPS: Caddy:80 ]
6
   └── 静态图片 (*.webp, *.png, ...)   ──(强缓存 30 天 / 拦截)──► [ 边缘节点直接响应 ]
7
                                                                        │ (仅首次回源)
8
                                                                        ▼
9
                                                                 [ Go 原生服务 :3008 ]
10
                                                                        │ (磁盘读写)
11
                                                                        ▼
12
                                                                 [ /data/images ]

客户端（浏览器）：拦截上传前先通过 HTML5 Canvas 转码为 WebP，原图几 MB 瞬间压至数十 KB；
EdgeOne CDN：国内各省 Anycast 节点覆盖。针对上传与查询接口做 Bypass（不缓存），针对静态图片配置 30天节点强缓存 与 忽略 Query 参数；
反向代理（Caddy）：接收 EdgeOne 的 HTTP 回源，将动态接口反代至后端，将静态资源交由自身高性能静态引擎托管；
后端服务（Go 编译二进制）：仅使用 Go 原生标准库实现，无任何第三方框架，常驻内存仅 ~8MB，负责鉴权、写盘、按时间倒序扫盘及防越权删除。

一、后端实现：原生 Go 极简轻量服务#

不需要 Gin、Echo 等大型框架，Go 的 net/http、os、filepath 原生库足以支撑高并发的文件读写。

1. 源码编写与接口逻辑#

在 VPS 上创建目录 /opt/image-uploader，编写 main.go。核心接口包含：

/upload：校验 Header 中的 X-Upload-Token，以年月（2026/09）分目录落盘；
/list：校验 Token 后扫描存储目录，提取最新上传的文件列表返回前端；
/delete：校验 Token 并进行严格的路径清洗（防止 ../ 目录穿越攻击），物理删除指定文件。

1
package main
2

3
import (
4
  "encoding/json"
5
  "fmt"
6
  "io"
7
  "net/http"
8
  "net/url"
9
  "os"
10
  "path/filepath"
11
  "sort"
12
  "strings"
13
  "time"
14
)
15

16
// 配置项
17
const UploadSecret = "YOUR_CUSTOM_SECRET_KEY" // 替换为你的私有密钥
18
const StoragePath = "/data/images"
19
const PublicDomain = "https://img.example.com"
20

21
type Response struct {
22
  Success bool     `json:"success"`
23
  URL     string   `json:"url,omitempty"`
24
  Images  []string `json:"images,omitempty"`
25
  Error   string   `json:"error,omitempty"`
26
}
27

28
type DeleteRequest struct {
29
  URL string `json:"url"`
30
}
31

32
// 跨域处理与身份校验
33
func checkAuth(w http.ResponseWriter, r *http.Request) bool {
34
  w.Header().Set("Access-Control-Allow-Origin", "*")
35
  w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
36
  w.Header().Set("Access-Control-Allow-Headers", "Content-Type, X-Upload-Token")
37

38
  if r.Method == http.MethodOptions {
39
    w.WriteHeader(http.StatusOK)
40
    return false
41
  }
42

43
  w.Header().Set("Content-Type", "application/json")
44
  if r.Header.Get("X-Upload-Token") != UploadSecret {
45
    w.WriteHeader(http.StatusUnauthorized)
46
    json.NewEncoder(w).Encode(Response{Success: false, Error: "Unauthorized"})
47
    return false
48
  }
49
  return true
50
}
51

52
func uploadHandler(w http.ResponseWriter, r *http.Request) {
53
  if !checkAuth(w, r) {
54
    return
55
  }
56
  if r.Method != http.MethodPost {
57
    json.NewEncoder(w).Encode(Response{Success: false, Error: "Method not allowed"})
58
    return
59
  }
60

61
  // 限制请求体上限 30MB
62
  r.Body = http.MaxBytesReader(w, r.Body, 30<<20)
63

64
  now := time.Now()
65
  dateDir := now.Format("2006/01")
66
  fullDir := filepath.Join(StoragePath, dateDir)
67
  if err := os.MkdirAll(fullDir, 0755); err != nil {
68
    w.WriteHeader(http.StatusInternalServerError)
69
    json.NewEncoder(w).Encode(Response{Success: false, Error: "Failed to create directory"})
70
    return
71
  }
72

73
  ext := ".webp"
74
  contentType := r.Header.Get("Content-Type")
75
  if contentType == "image/png" {
76
    ext = ".png"
77
  } else if contentType == "image/jpeg" {
78
    ext = ".jpg"
79
  } else if contentType == "image/gif" {
80
    ext = ".gif"
81
  }
82

83
  fileName := fmt.Sprintf("img-%d%s", now.UnixNano(), ext)
84
  dstPath := filepath.Join(fullDir, fileName)
85

86
  dst, err := os.Create(dstPath)
87
  if err != nil {
88
    w.WriteHeader(http.StatusInternalServerError)
89
    json.NewEncoder(w).Encode(Response{Success: false, Error: "Failed to save file"})
90
    return
91
  }
92
  defer dst.Close()
93

94
  if _, err := io.Copy(dst, r.Body); err != nil {
95
    w.WriteHeader(http.StatusInternalServerError)
96
    json.NewEncoder(w).Encode(Response{Success: false, Error: "Failed to write content"})
97
    return
98
  }
99

100
  publicURL := fmt.Sprintf("%s/%s/%s", PublicDomain, dateDir, fileName)
101
  json.NewEncoder(w).Encode(Response{Success: true, URL: publicURL})
102
}
103

104
func listHandler(w http.ResponseWriter, r *http.Request) {
105
  if !checkAuth(w, r) {
106
    return
107
  }
108

109
  type fileItem struct {
110
    url     string
111
    modTime time.Time
112
  }
113
  var items []fileItem
114

115
  _ = filepath.Walk(StoragePath, func(path string, info os.FileInfo, err error) error {
116
    if err != nil || info.IsDir() {
117
      return nil
118
    }
119
    ext := strings.ToLower(filepath.Ext(path))
120
    if ext == ".webp" || ext == ".png" || ext == ".jpg" || ext == ".jpeg" || ext == ".gif" {
121
      rel, err := filepath.Rel(StoragePath, path)
122
      if err == nil {
123
        items = append(items, fileItem{
124
          url:     fmt.Sprintf("%s/%s", PublicDomain, filepath.ToSlash(rel)),
125
          modTime: info.ModTime(),
126
        })
127
      }
128
    }
129
    return nil
130
  })
131

132
  sort.Slice(items, func(i, j int) bool {
133
    return items[i].modTime.After(items[j].modTime)
134
  })
135

136
  var result []string
137
  limit := 80
138
  for i, it := range items {
139
    if i >= limit {
140
      break
141
    }
142
    result = append(result, it.url)
143
  }
144

145
  json.NewEncoder(w).Encode(Response{Success: true, Images: result})
146
}
147

148
func deleteHandler(w http.ResponseWriter, r *http.Request) {
149
  if !checkAuth(w, r) {
150
    return
151
  }
152

153
  var req DeleteRequest
154
  if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.URL == "" {
155
    w.WriteHeader(http.StatusBadRequest)
156
    json.NewEncoder(w).Encode(Response{Success: false, Error: "Invalid payload"})
157
    return
158
  }
159

160
  u, err := url.Parse(req.URL)
161
  if err != nil {
162
    w.WriteHeader(http.StatusBadRequest)
163
    json.NewEncoder(w).Encode(Response{Success: false, Error: "Invalid URL"})
164
    return
165
  }
166

167
  cleanPath := filepath.Clean(strings.TrimPrefix(u.Path, "/"))
168
  if strings.Contains(cleanPath, "..") || cleanPath == "index.html" || cleanPath == "" {
169
    w.WriteHeader(http.StatusForbidden)
170
    json.NewEncoder(w).Encode(Response{Success: false, Error: "Forbidden target"})
171
    return
172
  }
173

174
  targetFile := filepath.Join(StoragePath, cleanPath)
175
  if !strings.HasPrefix(targetFile, StoragePath) {
176
    w.WriteHeader(http.StatusForbidden)
177
    json.NewEncoder(w).Encode(Response{Success: false, Error: "Path traversal denied"})
178
    return
179
  }
180

181
  if err := os.Remove(targetFile); err != nil {
182
    w.WriteHeader(http.StatusInternalServerError)
183
    json.NewEncoder(w).Encode(Response{Success: false, Error: "File deletion failed"})
184
    return
185
  }
186

187
  json.NewEncoder(w).Encode(Response{Success: true})
188
}
189

190
func main() {
191
  http.HandleFunc("/upload", uploadHandler)
192
  http.HandleFunc("/list", listHandler)
193
  http.HandleFunc("/delete", deleteHandler)
194

195
  // 绑定内网避开常见端口
196
  fmt.Println("Image Uploader running at 127.0.0.1:3008")
197
  _ = http.ListenAndServe("127.0.0.1:3008", nil)
198
}

2. 编译与 Systemd 守护进程托管#

1
cd /opt/image-uploader
2
go build -o /opt/image-uploader/uploader main.go
3

4
# 创建 systemd 服务
5
cat << 'EOF' > /etc/systemd/system/image-uploader.service
6
[Unit]
7
Description=Lightweight Image Uploader Service
8
After=network.target
9

10
[Service]
11
Type=simple
12
User=root
13
WorkingDirectory=/opt/image-uploader
14
ExecStart=/opt/image-uploader/uploader
15
Restart=always
16
RestartSec=3
17

18
[Install]
19
WantedBy=multi-user.target
20
EOF
21

22
systemctl daemon-reload
23
systemctl enable --now image-uploader

二、 Caddy 网关与防重定向死循环配置#

在 CDN 加速架构中，一个极为经典的踩坑点是：CDN 到源站走 HTTP (80 端口)，而源站 Caddy 默认开启全自动 HTTPS 跳转（308），导致浏览器触发 ERR_TOO_MANY_REDIRECTS 死循环。

在 /etc/caddy/Caddyfile 中显式指定 http://，告知 Caddy 信任前置 CDN 代理，不再自动发起重定向：

1
http://img.example.com {
2
    # 1. 动态接口转发给 Go 本地后端
3
    @api path /upload /list /delete
4
    handle @api {
5
        reverse_proxy 127.0.0.1:3008
6
    }
7

8
    # 2. 静态图片直接由 Caddy 高性能响应，根目录访问工作台
9
    handle {
10
        root * /data/images
11
        file_server {
12
            index index.html
13
        }
14
        @images path *.webp *.png *.jpg *.jpeg *.gif
15
        header @images Cache-Control "public, max-age=2592000"
16
    }
17
}

执行 systemctl reload caddy 重载即可。

三、 EdgeOne 边缘规则引擎配置核心#

EdgeOne（或任意国内具备规则引擎的 CDN）的配置核心是两点：动态穿透 与 静态锁死。

1. 源站配置#

源站类型：IP
回源协议：HTTP（80 端口）
回源 Host：img.example.com
前端客户端：在 EdgeOne 后台申请免费证书并开启 强制 HTTPS

2. 规则引擎编排（自上而下按顺序匹配）#

分支一：动态接口不缓存（`IF₁`）#

匹配条件：URL path 正则匹配 ^/($|index\.html|upload|list|delete)
操作行为：
- 节点缓存 TTL：不缓存（Bypass）
效果：保证控制面板、上传、拉取列表与删除操作每次都能直通 VPS，绝不发生数据脏读。

分支二：静态媒体资源强缓存（`IF₂`）#

匹配条件：文件后缀 正则匹配 \.(webp|png|jpe?g|gif|svg)$
操作行为：
- 节点缓存 TTL：自定义 30 天
- 强制缓存：开启（忽略源站可能返回的私有头，全网节点直接固化）
- 自定义 Cache Key：查询字符串（Query String）选择 全部忽略
效果：图片仅在初次请求时回源海外 VPS 一次，随后 30 天内全部由境内边缘 Anycast 节点直接向读者分发，毫秒级加载。

四、客户端体验优化：前端 WebP 压缩与无缝接入#

1. 为什么在前端（浏览器）做图片压缩？#

传统方案往往由后端 Go/Python 借助 libvips 或 imagemagick 转码，这会给 1H1.5G 的廉价 VPS 带来巨大的 CPU 峰值压力。我们在前端通过 HTML5 Canvas 实现无感转码：

访客在粘贴或拖入截图瞬间，浏览器利用本地客户端算力直接完成 1920px 限制缩放与 85% 质量 WebP 编码；
原本 3~~5MB 的高清 PNG 截图瞬间压缩为 100~~300KB，传输带宽与 VPS 存储占用下降 90% 以上。

2. 博客管理端（Decap CMS）无感粘贴与凭证脱敏#

为了彻底避免将 Secret 密钥推送到公开/私有仓库的源码历史中，采用 localStorage 懒加载记忆方案：

1
// 从本地安全读取，首访自动弹窗询问并持久化
2
function getUploadSecret() {
3
  let secret = localStorage.getItem('site_image_token');
4
  if (!secret) {
5
    secret = prompt('【首次配置】请输入专属图床 Token（仅持久化保存在当前浏览器）：');
6
    if (secret && secret.trim()) {
7
      secret = secret.trim();
8
      localStorage.setItem('site_image_token', secret);
9
    } else {
10
      return null;
11
    }
12
  }
13
  return secret;
14
}
15

16
// 监听编辑区内粘贴
17
window.addEventListener('paste', async (e) => {
18
  const items = (e.clipboardData || e.originalEvent.clipboardData).items;
19
  let imageFile = null;
20
  for (const item of items) {
21
    if (item.type.indexOf('image') !== -1) {
22
      imageFile = item.getAsFile();
23
      break;
24
    }
25
  }
26

27
  if (imageFile) {
28
    e.preventDefault();
29
    const imgUrl = await uploadImageDirect(imageFile);
30
    if (imgUrl) {
31
      insertMarkdownAtCursor(`\n![](${imgUrl})\n`);
32
    }
33
  }
34
});

五、运维与安全思考小结#

权限隔离：虽然最终产出的图片外链是公网可读的（符合公开博客传播的本质需求），但通过 X-Upload-Token 与服务端绝对路径判断，彻底封死了未授权写盘与目录遍历；
CDN 缓存特性与删除机制：当在图床后台执行物理删除后，源站磁盘空间已即时释放。如果个别文件需要立即在全网失效，只需在 CDN 控制台提交单条“清除缓存”即可；
极轻量常驻：整套系统没有数据库依赖、无需 Redis，依靠原生文件系统结构自组织索引，不仅能在廉价配置的 VPS 上稳定自愈运行，还能兼作跨设备的通用贴图工具。