本文章没有找到对应的语言版本

起因：我需要一个「跨设备剪贴板」📋

日常中总有这样的场景：刷手机看到一篇好文章、一个有用的链接、一段代码片段，想先存下来回头在电脑上细看。

我之前的方案：微信「文件传输助手」或者大号发小号。简单粗暴，但用久了问题就来了：

痛点具体表现
🔒 设备限制电脑端微信只能登录一个账号，想用小号存东西得先退出大号
💨 数据易丢换手机、清缓存、重装微信，聊天记录说没就没
🔍 检索困难几百条消息里翻一个链接？大海捞针
📝 格式混乱纯聊天记录，没有分类、没有标签，全靠记忆

我想要的其实很简单：一个自己掌控的「记录本」，手机电脑都能秒开，支持搜索和分类，数据永远不会丢。

搜了一圈，发现 flomo 挺火的，但它是商业产品，高级功能要付费，数据也存在别人服务器上。作为一个有服务器的人，当然要找开源自托管的方案——于是就遇到了 Memos。

Memos 是什么？🤔

Memos 是一款开源的自托管备忘录服务，可以理解为「开源版 flomo」或「私有化微博」。

💡 官方 Slogan：Your thoughts, your data, your control — no tracking, no ads, no subscription fees. （你的想法，你的数据，你的控制权——无追踪，无广告，无订阅费）

技术架构

组件技术选型
后端Go（高性能、低资源占用）
前端React + TypeScript
数据库SQLite（默认）/ PostgreSQL / MySQL
部署Docker 一行命令启动

核心特性

特性说明
🪶 极致轻量单容器部署，内存占用约 50MB，树莓派都能跑
✍️ Markdown原生支持，纯文本存储，数据迁移无压力
🏷️ 标签系统#标签 语法，支持多级标签，快速分类检索
📅 热力图GitHub 风格的活动日历，记录你的输出频率
🔗 开放 API完整的 RESTful + gRPC 接口，可对接微信机器人、Telegram Bot 等
👥 多用户支持多账户，可设置内容为私有/工作区可见/完全公开
📱 响应式手机、平板、电脑自适应，支持 PWA 安装
🌙 深色模式护眼党福音

项目数据

部署方案：Docker Compose + PostgreSQL 🐳

Memos 默认使用 SQLite 作为数据库（零配置，开箱即用），但如果你对数据可靠性有更高要求，或者想要更好的备份恢复体验，推荐使用 PostgreSQL。

docker-compose.yml 配置（当前最新版本v0.25.3）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

services:
  postgres:
    image: postgres:15
    restart: unless-stopped
    environment:
      POSTGRES_DB: memos_db
      POSTGRES_USER: memos_user
      POSTGRES_PASSWORD: your_strong_password_here
    volumes:
      - postgres_data:/var/lib/postgresql/data

  memos:
    image: neosmemo/memos:stable
    depends_on:
      - postgres
    environment:
      - MEMOS_MODE=prod
      - MEMOS_PORT=5230
      - MEMOS_DRIVER=postgres
      - MEMOS_DSN=postgresql://memos_user:your_strong_password_here@postgres:5432/memos_db?sslmode=disable
    ports:
      - "5230:5230"
    restart: always

volumes:
  postgres_data:

参数详解

PostgreSQL 服务配置

参数说明示例值
imagePostgreSQL 镜像版本，推荐使用 15 或更高版本postgres:15
POSTGRES_DB数据库名称，Memos 会在这个库中创建表memos_db
POSTGRES_USER数据库用户名，用于连接认证memos_user
POSTGRES_PASSWORD数据库密码，请务必修改为强密码！your_strong_password
volumes数据持久化路径，使用命名卷更方便管理postgres_data:/var/lib/postgresql/data

Memos 服务配置

环境变量说明可选值
MEMOS_MODE运行模式prod（生产）/ dev（开发）/ demo（演示）
MEMOS_PORT监听端口默认 5230，可自定义
MEMOS_DRIVER数据库驱动sqlite（默认）/ postgres / mysql
MEMOS_DSN数据库连接字符串PostgreSQL 格式见下方说明

PostgreSQL DSN 格式：

1

postgresql://用户名:密码@主机:端口/数据库名?sslmode=disable

⚠️ 安全提示：

  • 生产环境请使用强密码（16位以上，包含大小写字母、数字和特殊字符）
  • 如果通过公网访问，建议配置 sslmode=require
  • 可以使用 Docker secrets 或环境变量文件来管理敏感信息

文件存储机制 📁

不同数据库驱动下，Memos 的文件存储方式不同：

SQLite 模式：上传的图片、附件存储在 /var/opt/memos 目录，必须挂载数据卷，否则容器重启后文件丢失！

SQLite 存储位置

PostgreSQL 模式：文件会以二进制形式存入数据库表中（我从备份的 SQL 里确认的）。官方不推荐存储大文件到数据库，但好处是备份数据库就等于备份了所有内容。

文件存储位置

自定义存储：如果想把文件存到其他地方（本地路径、S3、外部存储），需要在 Web 管理界面中配置，不能通过环境变量设置。

存储配置界面

启动服务

1
2
3
4
5
6
7
8

# 启动所有服务（后台运行）
docker compose up -d

# 查看运行状态
docker compose ps

# 查看日志
docker compose logs -f memos

启动成功后，访问 http://你的服务器IP:5230 即可看到 Memos 界面！🎉

首次访问会提示你创建管理员账户，设置好用户名和密码就可以开始记录你的想法了。

版本升级：两行命令搞定 🔄

1
2

docker compose pull
docker compose up -d

💡 提示：升级前建议瞅一眼官方文档，了解新版本的变更和注意事项～

Nginx 反向代理：给 Memos 加上 HTTPS 🔐

直接用 IP + 端口访问不够优雅，也不安全。配置 Nginx 反向代理，让 Memos 拥有自己的域名和 HTTPS 加密！

配置文件

创建 Nginx 配置文件（如 /etc/nginx/conf.d/memos.conf）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

server {
    listen 443 ssl;
    http2 on;

    server_name memos.yourdomain.com;

    # SSL 证书配置（推荐使用 Let's Encrypt）
    ssl_certificate /etc/letsencrypt/live/memos.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/memos.yourdomain.com/privkey.pem;

    # 日志配置
    access_log /var/log/nginx/memos.access.log main;
    error_log /var/log/nginx/memos.error.log warn;

    location / {
        # 反向代理到 Memos 服务
        proxy_pass http://127.0.0.1:5230;

        # 传递真实客户端信息
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # 关闭缓冲，实时传输响应
        proxy_buffering off;
        proxy_request_buffering off;

        # CORS 跨域配置（可选，我是从其他的服务直接复制的一份，懒得改了）
        add_header 'Access-Control-Allow-Origin' '*';
        add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
        add_header 'Access-Control-Allow-Headers' 'DNT, X-CustomHeader, Keep-Alive, User-Agent, X-Requested-With, If-Modified-Since, Cache-Control, Content-Type';

        # WebSocket 支持（可选，我是从其他的服务直接复制的一份，懒得改了）
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";

        # 超时配置
        proxy_connect_timeout 30s;
        proxy_send_timeout 30s;
        proxy_read_timeout 300s;
    }
}

# HTTP 自动跳转 HTTPS
server {
    listen 80;
    server_name memos.yourdomain.com;
    return 301 https://$server_name$request_uri;
}

配置参数说明

基础配置

指令说明
listen 443 ssl监听 443 端口，启用 SSL
http2 on启用 HTTP/2 协议，提升性能
server_name绑定的域名，需要替换为你自己的

代理头配置

Header作用
Host保持原始请求的 Host 头
X-Real-IP传递客户端真实 IP
X-Forwarded-For记录代理链路中的所有 IP
X-Forwarded-Proto告知后端当前使用的协议（http/https）

性能与超时配置

参数说明建议值
proxy_buffering off关闭响应缓冲，数据实时传输适合小响应
proxy_request_buffering off关闭请求缓冲，适合上传文件按需开启
proxy_connect_timeout与后端建立连接的超时30s
proxy_send_timeout发送请求到后端的超时30s
proxy_read_timeout等待后端响应的超时300s（5分钟）

生效配置

1
2
3
4
5
6
7
8

# 测试配置语法
sudo nginx -t

# 重载配置（不中断服务）
sudo nginx -s reload

# 或者使用 systemctl
sudo systemctl reload nginx

配置完成后，访问 https://memos.yourdomain.com 即可通过 HTTPS 安全访问你的 Memos！🎉

数据备份：未雨绸缪才能高枕无忧 💾

数据是无价的！虽然 PostgreSQL 久经考验，但谁也不能保证硬盘不会突然罢工、手抖不会误删数据库、或者哪天心血来潮想换台服务器。定期备份，是每个运维人的基本修养（认真脸）。

下面这个脚本堪称「懒人福音」—— 自动从 docker-compose.yaml 读取数据库配置，执行 pg_dump 备份，还会自动清理过期文件，完全不用操心。

backup.sh 备份脚本

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290

#!/bin/bash
set -euo pipefail

# ============================================
# Memos PostgreSQL 自动备份脚本
# ============================================

# 脚本所在目录
REPO_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# ============================================
# 可配置参数（可通过环境变量覆盖）
# ============================================
BACKUP_DIR="${BACKUP_DIR:-$REPO_DIR/backups}"    # 备份文件保存目录
RETENTION_DAYS="${RETENTION_DAYS:-7}"             # 备份保留天数
COMPOSE_FILE="${COMPOSE_FILE:-$REPO_DIR/docker-compose.yaml}"  # compose 文件路径
SERVICE_NAME="${SERVICE_NAME:-postgres}"          # PostgreSQL 服务名
BACKUP_PREFIX="${BACKUP_PREFIX:-memos}"           # 备份文件前缀

# ============================================
# 日志输出（带颜色）
# ============================================
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'

log_info()  { echo -e "${GREEN}[INFO]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1"; }
log_warn()  { echo -e "${YELLOW}[WARN]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1"; }
log_error() { echo -e "${RED}[ERROR]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1" >&2; }
log_debug() { [[ "${DEBUG:-false}" == "true" ]] && echo -e "${BLUE}[DEBUG]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1" || true; }

# ============================================
# 依赖检查
# ============================================
check_dependencies() {
    local deps=("docker" "gzip")
    for dep in "${deps[@]}"; do
        if ! command -v "$dep" >/dev/null 2>&1; then
            log_error "$dep 未安装，请先安装后再运行此脚本"
            exit 1
        fi
    done
}

# ============================================
# 从 docker-compose.yaml 解析数据库配置
# ============================================
parse_compose_config() {
    local compose_file="$1"

    if [[ ! -f "$compose_file" ]]; then
        log_error "找不到 Docker Compose 文件: $compose_file"
        exit 1
    fi

    log_info "正在解析配置文件: $compose_file"

    # 从 postgres 服务的环境变量中提取配置
    local db_name db_user db_password
    db_name=$(grep -A 10 "services:" "$compose_file" | grep -A 10 "^  postgres:" | grep "POSTGRES_DB" | head -1 | sed -E 's/.*POSTGRES_DB[=:][[:space:]]*([^[:space:]]+).*/\1/' | tr -d ' \"')
    db_user=$(grep -A 10 "services:" "$compose_file" | grep -A 10 "^  postgres:" | grep "POSTGRES_USER" | head -1 | sed -E 's/.*POSTGRES_USER[=:][[:space:]]*([^[:space:]]+).*/\1/' | tr -d ' \"')
    db_password=$(grep -A 10 "services:" "$compose_file" | grep -A 10 "^  postgres:" | grep "POSTGRES_PASSWORD" | head -1 | sed -E 's/.*POSTGRES_PASSWORD[=:][[:space:]]*([^[:space:]]+).*/\1/' | tr -d ' \"')

    # 如果从 postgres 服务未找到，尝试从 MEMOS_DSN 解析
    if [[ -z "$db_name" || -z "$db_user" || -z "$db_password" ]]; then
        log_debug "尝试从 MEMOS_DSN 解析配置..."
        local memos_dsn
        memos_dsn=$(grep -A 20 "services:" "$compose_file" | grep -A 20 "^  memos:" | grep "MEMOS_DSN" | head -1 | sed -E 's/.*MEMOS_DSN[=:][[:space:]]*([^[:space:]]+).*/\1/' | tr -d ' \"')

        if [[ -n "$memos_dsn" ]]; then
            parse_memos_dsn "$memos_dsn"
            return
        fi
    fi

    DB_NAME="${db_name:-memos_db}"
    DB_USER="${db_user:-memos_user}"

    if [[ -n "$db_password" ]]; then
        COMPOSE_POSTGRES_PASSWORD="$db_password"
        log_debug "已找到数据库配置 - 库名: $DB_NAME, 用户: $DB_USER"
    else
        log_warn "未在配置文件中找到 POSTGRES_PASSWORD"
    fi
}

# 解析 MEMOS_DSN 连接字符串
parse_memos_dsn() {
    local dsn="$1"
    log_debug "正在解析 MEMOS_DSN: $dsn"

    # 格式: postgresql://user:password@host:port/dbname?options
    if [[ "$dsn" =~ postgresql://([^:]+):([^@]+)@[^/]+/([^?]+) ]]; then
        DB_USER="${BASH_REMATCH[1]}"
        COMPOSE_POSTGRES_PASSWORD="${BASH_REMATCH[2]}"
        DB_NAME="${BASH_REMATCH[3]}"
        log_info "已从 MEMOS_DSN 解析数据库配置"
    else
        log_error "无法解析 MEMOS_DSN: $dsn"
        log_error "期望格式: postgresql://user:password@host:port/dbname"
        exit 1
    fi
}

# ============================================
# 验证环境配置
# ============================================
validate_environment() {
    if [[ -n "${COMPOSE_POSTGRES_PASSWORD:-}" ]]; then
        POSTGRES_PASSWORD="$COMPOSE_POSTGRES_PASSWORD"
        log_info "使用配置文件中的数据库密码"
    elif [[ -n "${POSTGRES_PASSWORD:-}" ]]; then
        log_info "使用环境变量中的数据库密码"
    else
        log_error "未找到 POSTGRES_PASSWORD"
        log_error "请确保 docker-compose.yaml 中设置了 POSTGRES_PASSWORD"
        exit 1
    fi

    if [[ -z "$DB_NAME" || -z "$DB_USER" || -z "$POSTGRES_PASSWORD" ]]; then
        log_error "数据库配置不完整"
        exit 1
    fi

    log_info "数据库配置验证通过: 库名=$DB_NAME, 用户=$DB_USER"
}

# ============================================
# 检查服务是否运行
# ============================================
check_service_running() {
    log_info "检查服务 '$SERVICE_NAME' 运行状态..."

    local container_id
    container_id="$(docker compose -f "$COMPOSE_FILE" ps -q "$SERVICE_NAME" 2>/dev/null || true)"

    if [[ -z "$container_id" ]]; then
        log_error "服务 '$SERVICE_NAME' 未运行"
        log_error "请先执行: docker compose -f \"$COMPOSE_FILE\" up -d"
        return 1
    fi

    local status
    status="$(docker inspect --format='{{.State.Status}}' "$container_id" 2>/dev/null || echo "none")"

    if [[ "$status" != "running" ]]; then
        log_error "服务 '$SERVICE_NAME' 状态异常: $status"
        return 1
    fi

    log_info "服务 '$SERVICE_NAME' 运行正常 (容器ID: ${container_id:0:12})"
    return 0
}

# ============================================
# 创建备份目录
# ============================================
create_backup_dir() {
    if ! mkdir -p "$BACKUP_DIR"; then
        log_error "无法创建备份目录: $BACKUP_DIR"
        exit 1
    fi
    log_info "备份目录: $BACKUP_DIR"
}

# ============================================
# 执行数据库备份
# ============================================
perform_backup() {
    local timestamp backup_path
    timestamp="$(date +%Y%m%d_%H%M%S)"
    backup_path="$BACKUP_DIR/${BACKUP_PREFIX}_${timestamp}.sql.gz"

    log_info "开始备份数据库..."
    log_info "目标: $DB_NAME@$SERVICE_NAME (用户: $DB_USER)"

    export PGPASSWORD="$POSTGRES_PASSWORD"

    if docker compose -f "$COMPOSE_FILE" exec -T "$SERVICE_NAME" \
        pg_dump --verbose -U "$DB_USER" "$DB_NAME" | gzip > "$backup_path"; then

        if [[ ! -f "$backup_path" ]]; then
            log_error "备份文件未创建: $backup_path"
            return 1
        fi

        local backup_size
        backup_size=$(du -h "$backup_path" | cut -f1)
        local backup_lines
        backup_lines=$(zcat "$backup_path" | wc -l 2>/dev/null || echo "0")

        log_info "✅ 备份成功: $backup_path"
        log_info "   文件大小: $backup_size, SQL行数: $backup_lines"
        echo "$backup_path"
    else
        local exit_code=$?
        log_error "备份失败，退出码: $exit_code"
        [[ -f "$backup_path" ]] && rm -f "$backup_path"
        return 1
    fi
}

# ============================================
# 清理过期备份
# ============================================
cleanup_old_backups() {
    if [[ "$RETENTION_DAYS" =~ ^[0-9]+$ ]] && [[ "$RETENTION_DAYS" -gt 0 ]]; then
        log_info "清理 $RETENTION_DAYS 天前的备份..."

        local old_backups
        old_backups=$(find "$BACKUP_DIR" -name "${BACKUP_PREFIX}_*.sql.gz" -type f -mtime "+$((RETENTION_DAYS - 1))" 2>/dev/null)

        if [[ -n "$old_backups" ]]; then
            local deleted_count=0
            echo "$old_backups" | while read -r file; do
                log_info "删除: $(basename "$file")"
                rm -f "$file"
                ((deleted_count++))
            done
            log_info "已删除 $deleted_count 个过期备份"
        else
            log_info "无过期备份需要清理"
        fi
    fi
}

# ============================================
# 列出当前备份
# ============================================
list_backups() {
    log_info "当前备份列表:"
    local backup_list
    backup_list=$(find "$BACKUP_DIR" -name "${BACKUP_PREFIX}_*.sql.gz" -type f -exec ls -lh {} \; 2>/dev/null | sort -k6,7)

    if [[ -n "$backup_list" ]]; then
        echo "$backup_list" | while read -r line; do
            echo "  $line"
        done
        local total_size
        total_size=$(find "$BACKUP_DIR" -name "${BACKUP_PREFIX}_*.sql.gz" -type f -exec du -ch {} + 2>/dev/null | grep total | cut -f1)
        log_info "总大小: $total_size"
    else
        log_warn "暂无备份文件"
    fi
}

# ============================================
# 显示配置摘要
# ============================================
show_config() {
    log_info "=== 备份配置 ==="
    log_info "Compose 文件:  $COMPOSE_FILE"
    log_info "服务名称:      $SERVICE_NAME"
    log_info "数据库名:      $DB_NAME"
    log_info "数据库用户:    $DB_USER"
    log_info "备份目录:      $BACKUP_DIR"
    log_info "保留天数:      $RETENTION_DAYS"
    log_info "文件前缀:      $BACKUP_PREFIX"
    log_info "================"
}

# ============================================
# 主函数
# ============================================
main() {
    log_info "🚀 开始 Memos 数据库备份..."

    parse_compose_config "$COMPOSE_FILE"
    check_dependencies
    validate_environment
    show_config
    create_backup_dir
    check_service_running

    if backup_file=$(perform_backup); then
        cleanup_old_backups
        list_backups
        log_info "✅ 备份流程完成"
    else
        log_error "❌ 备份失败"
        exit 1
    fi
}

# 处理中断信号
trap 'log_warn "备份被用户中断"; exit 1' INT TERM

main "$@"

脚本参数说明

环境变量说明默认值
BACKUP_DIR备份文件保存目录脚本同目录下的 backups/
RETENTION_DAYS备份保留天数，超过后自动删除7 天
COMPOSE_FILEdocker-compose.yaml 文件路径脚本同目录
SERVICE_NAMEPostgreSQL 服务名称postgres
BACKUP_PREFIX备份文件名前缀memos
DEBUG是否启用调试日志false

脚本特性：

  • ✅ 自动从 docker-compose.yaml 读取数据库配置
  • ✅ 支持从 MEMOS_DSN 连接字符串解析配置
  • ✅ 使用 gzip 压缩备份，节省存储空间
  • ✅ 自动清理过期备份
  • ✅ 彩色日志输出，状态一目了然
  • ✅ 完善的错误处理和依赖检查

数据恢复：关键时刻救命用 🔄

备份做了，万一真出事了怎么恢复？别慌，用这个脚本一键搞定！（希望你永远用不上它 🙏）

restore.sh 恢复脚本

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

#!/usr/bin/env bash
set -euo pipefail

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

log_info()  { echo -e "${GREEN}[INFO]${NC} $1"; }
log_warn()  { echo -e "${YELLOW}[WARN]${NC} $1"; }
log_error() { echo -e "${RED}[ERROR]${NC} $1"; }

# ============================================
# 可配置参数（默认值需与 docker-compose.yml 一致）
# ============================================
COMPOSE_FILE="${COMPOSE_FILE:-docker-compose.yaml}"
SERVICE_NAME="${SERVICE_NAME:-postgres}"
DB_NAME="${DB_NAME:-memos_db}"
DB_USER="${DB_USER:-memos_user}"

# ============================================
# 参数检查
# ============================================
if [[ $# -eq 0 ]]; then
    log_error "用法: $0 <备份文件.sql.gz>"
    log_info "可用的备份文件:"
    find . -name "*.sql.gz" -type f 2>/dev/null | head -10 || echo "  (无)"
    exit 1
fi

BACKUP_FILE="$1"

# 验证备份文件
if [[ ! -f "$BACKUP_FILE" ]]; then
    log_error "备份文件不存在: $BACKUP_FILE"
    exit 1
fi

# 检查依赖
if ! command -v docker >/dev/null 2>&1; then
    log_error "未安装 docker"
    exit 1
fi

# 检查服务状态
if ! docker compose -f "$COMPOSE_FILE" ps -q "$SERVICE_NAME" >/dev/null 2>&1; then
    log_error "服务 '$SERVICE_NAME' 未运行"
    exit 1
fi

# 获取数据库密码
POSTGRES_PASSWORD=$(grep -A 10 "services:" "$COMPOSE_FILE" | grep -A 10 "^  postgres:" | grep "POSTGRES_PASSWORD" | head -1 | sed -E 's/.*POSTGRES_PASSWORD[=:][[:space:]]*([^[:space:]]+).*/\1/' | tr -d ' \"')

if [[ -z "$POSTGRES_PASSWORD" ]]; then
    log_error "未在 docker-compose.yaml 中找到 POSTGRES_PASSWORD"
    exit 1
fi

# ============================================
# 确认恢复操作
# ============================================
log_warn "⚠️  警告：此操作将覆盖数据库 $DB_NAME 中的所有数据！"
log_info "备份文件: $BACKUP_FILE"
read -p "确定要继续吗？(y/N): " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
    log_info "已取消恢复操作"
    exit 0
fi

# ============================================
# 执行恢复
# ============================================
log_info "正在恢复数据库..."
export PGPASSWORD="$POSTGRES_PASSWORD"

if gunzip -c "$BACKUP_FILE" | docker compose -f "$COMPOSE_FILE" exec -T "$SERVICE_NAME" psql -U "$DB_USER" -d "$DB_NAME"; then
    log_info "✅ 数据库恢复成功！"
else
    log_error "❌ 数据库恢复失败"
    exit 1
fi

恢复脚本参数说明

环境变量说明默认值
COMPOSE_FILEdocker-compose.yaml 文件路径docker-compose.yaml
SERVICE_NAMEPostgreSQL 服务名称postgres
DB_NAME目标数据库名称memos_db
DB_USER数据库用户名memos_user

💡 提示：默认值要和你的 docker-compose.yml 保持一致，不然恢复的时候会找不到数据库哦！

使用方法：

1
2
3
4
5

# 恢复指定的备份文件
./restore.sh backups/memos_20251220_030015.sql.gz

# 使用自定义配置
COMPOSE_FILE=./my-compose.yaml ./restore.sh backup.sql.gz

⚠️ 注意：恢复操作会覆盖当前数据库中的所有数据，请确认后再操作！

定时自动备份：让服务器替你操心 ⏰

每天手动跑一次备份脚本？那也太不 geek 了！设置个 cron 定时任务，让服务器在你睡觉的时候默默干活～

配置 Crontab

1
2
3
4
5

# 编辑系统级 crontab
sudo vim /etc/crontab

# 添加以下内容（每天凌晨3:15执行备份）
15 3 * * * root cd /home/user-home/memos && /home/user-home/memos/backup.sh >> /home/user-home/memos/backup.log 2>&1

💡 提示：把 user-home 替换成你的实际用户名，或者直接改成你喜欢的任意路径～

Cron 表达式说明

1
2
3
4
5
6
7
8

分 时 日 月 周 用户 命令
15 3  *  *  *  root ...
│  │  │  │  │
│  │  │  │  └── 星期几（0-7，0和7都是周日）
│  │  │  └───── 月份（1-12）
│  │  └──────── 日期（1-31）
│  └─────────── 小时（0-23）
└────────────── 分钟（0-59）

常用时间设置示例：

表达式含义
0 3 * * *每天凌晨3:00
0 */6 * * *每6小时
0 3 * * 0每周日凌晨3:00
0 3 1 * *每月1号凌晨3:00

验证定时任务

1
2
3
4
5

# 查看当前的定时任务
sudo crontab -l

# 查看备份日志
tail -f /home/user-home/memos/backup.log

写在最后 📝

折腾了这么多，终于可以愉快地记笔记了！回顾一下我们做了什么：

步骤搞定的事情安心指数
Docker 部署Memos + PostgreSQL 跑起来了⭐⭐⭐
Nginx 反代HTTPS 加密 + 自定义域名⭐⭐⭐⭐
自动备份定时备份 + 自动清理⭐⭐⭐⭐⭐
恢复脚本关键时刻一键救命⭐⭐⭐⭐⭐

现在你可以放心地把那些灵感、链接、代码片段统统丢进 Memos 了——再也不用担心微信聊天记录丢失的噩梦！✨

如果你觉得 Memos 不错，别忘了去 GitHub 给它点个 Star ⭐（顺便也可以给本文点个赞？😏）

🐛 发现问题？ 如果你在部署过程中遇到了文章中未提及的错误，或者发现哪里写得不对，欢迎在评论区留言邮箱告诉我！我会及时补充和修正，帮助更多小伙伴少踩坑～