Gitpod一次性环境数据持久化方案：避免开发工作丢失的配置与策略

一、问题背景：为什么Gitpod的工作数据会丢失

用过Gitpod的开发者大概都遇到过这种情况：写了几十个文件，装了十几个依赖包，调好了各种环境变量，然后不小心关了工作区或者工作区超时了，再打开一看，所有东西都没了。这种体验确实让人崩溃，尤其是当你在本地还没来得及提交代码的时候。

Gitpod的工作区本质上是一个运行在云端容器里的Linux环境。这个容器在你关闭工作区之后，底层系统会把磁盘空间释放掉，下次再启动时，容器会从一个全新的基础镜像重新创建。这就好比你在公共电脑上写东西，每次关机后系统自动恢复了出厂设置。

那问题就很明显了：我们的代码、依赖包、配置文件、环境变量、甚至是临时产生的缓存文件，全都会丢失。对于习惯了本地开发环境的开发者来说，这种"一次性"特性确实不太友好。

这篇文章要解决的就是这个问题——怎么在Gitpod的一次性工作区里，把重要的数据保存下来，避免开发工作丢失。

二、数据持久化的核心原理

在聊具体方案之前，先搞明白Gitpod的存储机制。

Gitpod的工作区其实由几部分组成：容器本身、挂载的卷、以及云存储。容器本身是一次性的，用完就没了。但Gitpod提供了几种持久化存储的方式，我们可以利用这些方式来保存数据。

2.1 Gitpod的文件系统结构

Gitpod的工作区有几个关键目录需要理解：

# Gitpod工作区的典型目录结构
/home/user/          # 用户的家目录，工作区启动时会挂载
/workspace/          # 工作区的根目录，代码项目默认在这里
/tmp/                # 临时目录，工作区关闭后会被清理
/workspace/.git/     # Git仓库目录，代码提交后会推送到远程

关键点在于：只要数据保存在 /workspace 目录下并且通过Git提交推送，或者保存到了Gitpod提供的持久化卷中，数据就不会丢失。

2.2 持久化存储的类型

Gitpod提供了以下几种持久化存储方式，每种适合不同的场景：

# Gitpod支持的持久化存储类型说明

# 1. Git仓库（最基础的方式）
# 把代码提交推送到远程仓库，下次启动时自动拉取
git commit -m "保存当前进度"
git push origin main

# 2. 持久化卷（Persistent Volumes）
# Gitpod允许挂载持久化卷到工作区
# 配置在 .gitpod.yml 中

# 3. 云存储（Cloud Storage）
# 通过gitpod.yml配置外部存储，如AWS S3、Google Cloud Storage
# 数据保存在工作区之外的云服务中

三、持久化配置方案详解

接下来是重点部分，我会用完整的示例来说明几种常见的持久化配置方案。

技术栈：Gitpod .gitpod.yml + Bash + JSON 配置

3.1 方案一：通过Git提交实现基础持久化

这是最简单也最基础的方式。每次开发一段时间后，主动提交代码到远程仓库。

# .gitpod.yml
# 这是Gitpod工作区的配置文件，放在项目根目录
# 技术栈：Gitpod配置 + Bash脚本

# 工作区启动时自动执行的任务
tasks:
  - init: |
      # init任务在工作区第一次启动时执行
      # 用于安装依赖、初始化项目等
      echo "初始化Gitpod工作区..."
      echo "检查并安装项目依赖..."
      
      # 安装项目依赖
      npm install
      
      # 检查是否有未提交的变更，如果有则自动保存
      if [ -n "$(git status --porcelain)" ]; then
        echo "检测到未提交的变更，自动保存..."
        git add -A
        git commit -m "auto: Gitpod工作区自动保存 - $(date +%Y-%m-%d %H:%M:%S)"
        git push origin HEAD || echo "推送失败，请手动检查网络连接"
      fi

  - command: |
      # command任务在工作区每次启动时都会执行
      # 用于启动开发服务器等
      echo "启动开发服务器..."
      npm run dev -- --host 0.0.0.0

这个方案的好处是简单直观，不需要额外的配置。但缺点也很明显：如果你忘了提交，或者网络断了，数据照样会丢。

3.2 方案二：配置持久化卷（Persistent Volumes）

Gitpod支持在 .gitpod.yml 中配置持久化卷，这些卷会在多次工作区启动之间保留数据。

# .gitpod.yml
# 配置持久化卷来保存依赖包、缓存等数据
# 技术栈：Gitpod配置 + Bash脚本

# 工作区启动时自动执行的任务
tasks:
  - init: |
      echo "初始化工作区..."
      
      # 检查持久化卷是否已存在数据
      if [ ! -d "/mnt/data/node_modules" ]; then
        echo "持久化卷为空，执行首次依赖安装..."
        mkdir -p /mnt/data/node_modules
        npm install --prefix /workspace
      else
        echo "从持久化卷恢复依赖包..."
        # 从持久化卷复制依赖包到工作区
        cp -r /mnt/data/node_modules /workspace/
      fi
      
      # 检查持久化卷中是否有缓存数据
      if [ -d "/mnt/data/npm-cache" ]; then
        echo "恢复npm缓存..."
        mkdir -p ~/.npm
        cp -r /mnt/data/npm-cache/* ~/.npm/
      fi

  - command: |
      echo "启动开发环境..."
      npm run dev -- --host 0.0.0.0
      
      # 在后台启动数据同步脚本
      # 每隔5分钟自动将关键数据同步到持久化卷
      while true; do
        sleep 300
        echo "执行数据同步到持久化卷..."
        
        # 同步依赖包
        if [ -d "/workspace/node_modules" ]; then
          rsync -a /workspace/node_modules/ /mnt/data/node_modules/ 2>/dev/null
        fi
        
        # 同步npm缓存
        if [ -d "~/.npm" ]; then
          mkdir -p /mnt/data/npm-cache
          rsync -a ~/.npm/ /mnt/data/npm-cache/ 2>/dev/null
        fi
        
        # 同步自定义配置文件
        if [ -d "/workspace/.config" ]; then
          mkdir -p /mnt/data/config
          rsync -a /workspace/.config/ /mnt/data/config/ 2>/dev/null
        fi
      done &

# 持久化卷配置
# Gitpod会根据这些配置自动创建和挂载持久化卷
persistentVolume:
  enabled: true
  size: 5GB

持久化卷的好处是数据不会随着容器销毁而丢失，下次启动时可以直接恢复。但需要注意的是，持久化卷有大小限制，不能存太大的文件。

3.3 方案三：工作区关闭前自动保存

Gitpod支持配置工作区关闭时的钩子脚本，我们可以利用这个特性在关闭前自动保存所有数据。

# .gitpod.yml
# 配置工作区关闭前的自动保存
# 技术栈：Gitpod配置 + Bash脚本

tasks:
  - init: |
      # 初始化时创建保存脚本
      cat > /workspace/scripts/autosave.sh << 'SCRIPT_EOF'
#!/bin/bash
# ============================================
# Gitpod工作区自动保存脚本
# 功能：在工作区关闭前自动保存所有数据
# ============================================

echo "========== 执行自动保存 =========="
SAVE_TIME=$(date +%Y%m%d_%H%M%S)
LOG_FILE="/workspace/logs/autosave-${SAVE_TIME}.log"
mkdir -p /workspace/logs

# 第一步：保存Git变更
echo "[$SAVE_TIME] 步骤1: 保存Git变更..." | tee -a "$LOG_FILE"
cd /workspace
if [ -n "$(git status --porcelain)" ]; then
  git add -A
  git commit -m "autosave: 工作区关闭前自动保存 - ${SAVE_TIME}" 2>/dev/null | tee -a "$LOG_FILE"
  git push origin HEAD 2>/dev/null | tee -a "$LOG_FILE"
  echo "[$SAVE_TIME] Git变更已保存" | tee -a "$LOG_FILE"
else
  echo "[$SAVE_TIME] 没有未提交的Git变更" | tee -a "$LOG_FILE"
fi

# 第二步：保存环境变量
echo "[$SAVE_TIME] 步骤2: 保存环境变量..." | tee -a "$LOG_FILE"
# 导出关键环境变量，避免下次重新配置
env | grep -E '^(DB_|API_|AUTH_|CACHE_)' > /workspace/.env.saved 2>/dev/null
echo "[$SAVE_TIME] 环境变量已保存" | tee -a "$LOG_FILE"

# 第三步：保存IDE配置
echo "[$SAVE_TIME] 步骤3: 保存IDE配置..." | tee -a "$LOG_FILE"
# 保存VSCode的编辑器设置
if [ -d "/home/user/.config/Code/User" ]; then
  mkdir -p /workspace/.vscode
  cp /home/user/.config/Code/User/settings.json /workspace/.vscode/settings.json 2>/dev/null
  echo "[$SAVE_TIME] IDE配置已保存" | tee -a "$LOG_FILE"
fi

# 第四步：保存终端历史
echo "[$SAVE_TIME] 步骤4: 保存终端命令历史..." | tee -a "$LOG_FILE"
if [ -f "/home/user/.bash_history" ]; then
  cp /home/user/.bash_history /workspace/.terminal-history 2>/dev/null
  echo "[$SAVE_TIME] 终端历史已保存" | tee -a "$LOG_FILE"
fi

# 第五步：清理不必要的日志文件（保留最近30天）
echo "[$SAVE_TIME] 步骤5: 清理旧日志..." | tee -a "$LOG_FILE"
find /workspace/logs -name "autosave-*.log" -mtime +30 -delete 2>/dev/null

echo "========== 自动保存完成 ==========" | tee -a "$LOG_FILE"
SCRIPT_EOF
      
      # 赋予脚本执行权限
      chmod +x /workspace/scripts/autosave.sh
      
      # 注册工作区关闭钩子
      # Gitpod在关闭工作区前会执行这个脚本
      echo "/workspace/scripts/autosave.sh" > /workspace/scripts/.gitpod-stop-hook

  - command: |
      echo "开发环境已启动，请开始工作..."
      echo "提示：工作区关闭时会自动保存数据"
      echo "也可以手动运行: bash /workspace/scripts/autosave.sh"
      npm run dev -- --host 0.0.0.0

3.4 方案四：使用Gitpod Secrets保存敏感数据

开发过程中我们经常需要配置API密钥、数据库连接字符串等敏感信息。Gitpod提供了Secrets管理功能，可以安全地存储和使用这些敏感数据。

# .gitpod.yml
# 配置Gitpod Secrets来保存敏感数据
# 技术栈：Gitpod配置 + JSON配置 + Bash脚本

tasks:
  - init: |
      # 初始化时从Gitpod Secrets读取敏感配置
      # 将密钥注入到环境文件中
      echo "从Gitpod Secrets加载配置..."
      
      # 创建环境配置文件
      cat > /workspace/.env << EOF
      # ============================================
      # 从Gitpod Secrets自动生成的环境配置
      # 此文件不应被提交到Git仓库
      # ============================================
      
      # 数据库配置（从Gitpod Secrets读取）
      DATABASE_URL=$DATABASE_URL
      DATABASE_USERNAME=$DATABASE_USERNAME
      DATABASE_PASSWORD=$DATABASE_PASSWORD
      
      # API密钥配置（从Gitpod Secrets读取）
      API_SECRET_KEY=$API_SECRET_KEY
      API_BASE_URL=$API_BASE_URL
      
      # 认证配置（从Gitpod Secrets读取）
      AUTH_TOKEN=$AUTH_TOKEN
      AUTH_PROVIDER=$AUTH_PROVIDER
      
      # 缓存配置（从Gitpod Secrets读取）
      CACHE_URL=$CACHE_URL
      CACHE_EXPIRY=$CACHE_EXPIRY
      EOF
      
      echo "环境配置已生成，请检查 /workspace/.env"
      
      # 确保.env文件不被Git跟踪
      echo ".env" >> /workspace/.gitignore
      echo ".env.saved" >> /workspace/.gitignore
      echo "scripts/.gitpod-stop-hook" >> /workspace/.gitignore

# 定义Gitpod Secrets
# 这些值需要预先在Gitpod工作区设置中配置
# 配置路径：工作区设置 -> Secrets -> 添加新的Secret
secrets:
  - name: DATABASE_URL
    description: "数据库连接字符串，格式：postgres://user:pass@host:port/dbname"
  - name: DATABASE_USERNAME
    description: "数据库用户名"
  - name: DATABASE_PASSWORD
    description: "数据库密码"
  - name: API_SECRET_KEY
    description: "第三方API的密钥"
  - name: API_BASE_URL
    description: "第三方API的基础URL"
  - name: AUTH_TOKEN
    description: "认证令牌"
  - name: AUTH_PROVIDER
    description: "认证服务提供商，如github、google等"
  - name: CACHE_URL
    description: "缓存服务连接URL"
  - name: CACHE_EXPIRY
    description: "缓存过期时间，单位：秒"

3.5 方案五：配置云存储同步

对于需要长期保存的大型数据集或构建产物，可以使用Gitpod的云存储功能。

# .gitpod.yml
# 配置云存储同步
# 技术栈：Gitpod配置 + Bash脚本 + JSON配置

tasks:
  - init: |
      # 初始化云存储同步工具
      echo "配置云存储同步..."
      
      # 安装rsync（用于高效文件同步）
      which rsync || (sudo apt-get update && sudo apt-get install -y rsync)
      
      # 创建同步配置文件
      cat > /workspace/scripts/cloud-sync.sh << 'SYNC_EOF'
#!/bin/bash
# ============================================
# Gitpod云存储同步脚本
# 功能：将重要数据同步到云存储，确保数据持久化
# ============================================

# 配置同步目标
SYNC_TARGET="/mnt/data/cloud-sync"
LOG_DIR="/workspace/logs/sync"
mkdir -p "$LOG_DIR"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
LOG_FILE="${LOG_DIR}/sync-${TIMESTAMP}.log"

echo "[$TIMESTAMP] 开始云存储同步..." | tee -a "$LOG_FILE"

# 定义需要同步的目录列表
# 格式：源目录:目标目录:同步模式
SYNC_ITEMS=(
  "node_modules:deps:incremental"
  "build:build-output:full"
  ".config:ide-config:incremental"
  ".vscode:vscode-config:full"
)

for ITEM in "${SYNC_ITEMS[@]}"; do
  # 解析同步配置
  IFS=':' read -r SRC_NAME DST_NAME SYNC_MODE <<< "$ITEM"
  
  # 源目录的完整路径
  SRC="/workspace/${SRC_NAME}"
  
  # 目标目录的完整路径
  DST="${SYNC_TARGET}/${DST_NAME}"
  
  # 检查源目录是否存在
  if [ ! -d "$SRC" ]; then
    echo "[$TIMESTAMP] 跳过 ${SRC_NAME}，目录不存在" | tee -a "$LOG_FILE"
    continue
  fi
  
  # 创建目标目录
  mkdir -p "$DST"
  
  # 执行同步
  if [ "$SYNC_MODE" = "incremental" ]; then
    # 增量同步：只传输变化的文件，效率高
    rsync -av --delete "$SRC/" "$DST/" 2>&1 | tail -5 | tee -a "$LOG_FILE"
    echo "[$TIMESTAMP] 增量同步完成: ${SRC_NAME}" | tee -a "$LOG_FILE"
  else
    # 全量同步：传输所有文件，确保一致性
    rsync -av --delete "$SRC/" "$DST/" 2>&1 | tail -5 | tee -a "$LOG_FILE"
    echo "[$TIMESTAMP] 全量同步完成: ${SRC_NAME}" | tee -a "$LOG_FILE"
  fi
done

# 同步完成后清理30天前的同步日志
find "$LOG_DIR" -name "sync-*.log" -mtime +30 -delete 2>/dev/null

echo "[$TIMESTAMP] 云存储同步全部完成" | tee -a "$LOG_FILE"
SYNC_EOF
      
      chmod +x /workspace/scripts/cloud-sync.sh
      echo "云存储同步脚本已就绪"

  - command: |
      echo "开发环境启动完成"
      
      # 启动后台定时同步
      # 每10分钟同步一次重要数据
      (while true; do
        sleep 600
        echo "执行定时云存储同步..."
        bash /workspace/scripts/cloud-sync.sh
      done) &
      
      # 启动开发服务器
      npm run dev -- --host 0.0.0.0

四、应用场景分析

了解了各种持久化方案后，下面看看不同场景下应该选择哪种方案。

4.1 日常开发场景

日常开发中，代码变更是最主要的持久化需求。推荐组合方案：Git提交 + 自动保存脚本。

{
  "场景": "日常代码开发",
  "推荐方案": "Git自动提交 + 关闭前保存",
  "说明": "每次修改代码后自动提交到远程仓库，关闭工作区时执行完整的保存流程",
  "配置优先级": "高",
  "数据恢复时间": "秒级（从Git拉取）"
}

日常开发时，建议设置一个合理的自动提交频率，比如每15分钟检查一次是否有未提交的变更。

4.2 构建与部署场景

构建产物通常体积较大，不适合频繁提交到Git仓库。这种场景推荐使用持久化卷或云存储。

{
  "场景": "构建产物持久化",
  "推荐方案": "持久化卷 + 云存储同步",
  "说明": "构建产物保存到持久化卷，定期同步到云存储作为备份",
  "配置优先级": "中",
  "数据恢复时间": "分钟级（取决于数据量）"
}

构建产物的特点是体积大、更新频率相对低。持久化卷可以很好地满足需求，定期同步到云存储则提供了额外的安全保障。

4.3 多工作区协作场景

当多个开发者在同一个项目上协作时，数据持久化策略需要更加谨慎，避免数据冲突。

{
  "场景": "多开发者协作",
  "推荐方案": "Git分支 + 持久化卷隔离",
  "说明": "每个开发者使用独立的工作分支，各自的依赖包保存在独立的持久化卷中",
  "配置优先级": "高",
  "数据恢复时间": "秒级"
}

多工作区协作时，最关键的是避免相互覆盖。Git的分支机制天然支持这个需求，每个开发者在自己的分支上工作，持久化卷按开发者或工作区ID隔离存储。

4.4 依赖包缓存场景

Node.js、Python等项目安装依赖包通常需要较长时间。缓存依赖包可以显著减少工作区启动时间。

{
  "场景": "依赖包缓存",
  "推荐方案": "持久化卷缓存",
  "说明": "将node_modules等依赖包目录缓存到持久化卷，启动时直接恢复",
  "配置优先级": "中",
  "数据恢复时间": "秒级"
}

依赖包缓存是最常见的持久化需求之一。配置好之后，工作区启动时间可以从几分钟缩短到几秒钟，体验提升非常明显。

五、技术优缺点对比

5.1 Git提交方式

优点是简单、通用、有版本历史，所有Git用户都能理解。缺点是每次提交都有网络开销，不适合保存大文件和二进制文件，而且提交频率太高会产生大量无意义的提交记录。

5.2 持久化卷方式

优点是速度快，不需要网络传输，数据在本地直接可用。缺点是有大小限制，通常最多只能配到几十GB，而且持久化卷是跟工作区绑定的，切换工作区类型可能需要重新配置。

5.3 云存储同步方式

优点是灵活，可以同步到任何支持的云存储服务，适合大文件和长期保存。缺点是配置复杂，需要额外的同步脚本，而且同步过程本身有延迟，不是实时保存。

5.4 Gitpod Secrets方式

优点是安全，敏感数据不会暴露在代码仓库中，Gitpod有加密存储机制。缺点是有使用限制，Secrets的数量和大小都有上限，而且配置需要在工作区设置中手动完成。

六、注意事项与最佳实践

6.1 避免将所有数据都持久化

持久化不是越多越好。依赖包缓存、构建产物这些确实需要持久化，但临时文件、日志文件、调试数据这些不需要。保存太多无用数据会浪费存储空间，还可能因为同步大文件导致保存脚本执行缓慢。

# 建议在.gitignore中添加以下排除规则
# 这些文件不需要被持久化保存
*.log
tmp/
temp/
.cache/
node_modules/.cache/
dist/.temp/

6.2 设置合理的同步间隔

同步间隔太短会增加存储和网络开销，间隔太长则可能丢失数据。建议根据开发节奏来设置：

# 推荐的同步间隔配置
# 日常开发：每15分钟同步一次
SYNC_INTERVAL_NORMAL=900

# 频繁提交阶段：每5分钟同步一次
SYNC_INTERVAL_FREQUENT=300

# 稳定开发阶段：每30分钟同步一次
SYNC_INTERVAL_STABLE=1800

6.3 做好错误处理

持久化脚本中一定要做好错误处理，避免因为单个步骤失败导致整个保存流程中断。

#!/bin/bash
# ============================================
# 带错误处理的持久化脚本示例
# 功能：每一步都有错误检测，失败时记录日志并继续
# ============================================

ERROR_COUNT=0
LOG_FILE="/workspace/logs/persistence.log"
mkdir -p /workspace/logs

# 定义一个安全的执行函数
# 参数：步骤名称 执行命令
safe_execute() {
  local STEP_NAME="$1"
  shift
  local COMMAND="$*"
  
  echo "执行步骤: $STEP_NAME" | tee -a "$LOG_FILE"
  
  # 执行命令并捕获退出码
  if eval "$COMMAND" 2>&1 | tee -a "$LOG_FILE"; then
    echo "步骤 $STEP_NAME 执行成功" | tee -a "$LOG_FILE"
  else
    ERROR_COUNT=$((ERROR_COUNT + 1))
    echo "警告: 步骤 $STEP_NAME 执行失败，继续执行后续步骤" | tee -a "$LOG_FILE"
  fi
  
  # 每次失败后短暂等待，避免连续报错刷屏
  if [ $ERROR_COUNT -gt 0 ]; then
    sleep 1
  fi
}

# 使用安全执行函数来运行各个步骤
safe_execute "同步依赖包" "rsync -a /workspace/node_modules/ /mnt/data/node_modules/"
safe_execute "同步构建产物" "rsync -a /workspace/build/ /mnt/data/build/"
safe_execute "保存Git变更" "cd /workspace && git add -A && git commit -m 'auto save' && git push"
safe_execute "同步配置文件" "rsync -a /workspace/.config/ /mnt/data/config/"

# 最终汇总
if [ $ERROR_COUNT -eq 0 ]; then
  echo "所有步骤执行成功" | tee -a "$LOG_FILE"
else
  echo "共有 $ERROR_COUNT 个步骤执行失败，请检查日志" | tee -a "$LOG_FILE"
  # 返回非零退出码，通知Gitpod保存失败
  exit 1
fi

6.4 敏感数据不要写入持久化卷

虽然Gitpod的持久化卷是安全的，但最好的实践还是不要把API密钥、密码等敏感信息放在持久化卷里。这类数据应该使用Gitpod Secrets来管理，通过环境变量注入到工作区中。

6.5 定期测试数据恢复

配置好持久化方案之后，一定要定期测试数据恢复流程。最好的测试方法就是：主动关闭工作区，然后重新打开，检查数据是否完整恢复。如果发现有数据丢失，及时修复配置。

七、完整配置示例

下面给出一个综合所有方案的完整 .gitpod.yml 配置，可以直接参考使用。

# .gitpod.yml
# ============================================
# Gitpod工作区完整持久化配置
# 技术栈：Gitpod配置 + Bash脚本 + JSON
# 适用场景：Node.js项目的全方位数据持久化
# ============================================

# 工作区启动时自动执行的任务
tasks:
  - init: |
      echo "========================================="
      echo "Gitpod工作区初始化 - 持久化配置加载"
      echo "========================================="
      
      # 第一步：创建必要的目录结构
      echo "[初始化] 创建目录结构..."
      mkdir -p /workspace/scripts
      mkdir -p /workspace/logs
      mkdir -p /mnt/data/project-data
      
      # 第二步：检查并恢复依赖包缓存
      echo "[初始化] 恢复依赖包缓存..."
      if [ -d "/mnt/data/project-data/node_modules" ]; then
        echo "[恢复] 从持久化卷恢复node_modules..."
        cp -r /mnt/data/project-data/node_modules /workspace/
        echo "[恢复] 依赖包恢复完成"
      else
        echo "[安装] 持久化卷无缓存，执行依赖安装..."
        npm install
      fi
      
      # 第三步：恢复npm缓存
      if [ -d "/mnt/data/project-data/npm-cache" ]; then
        mkdir -p ~/.npm
        cp -r /mnt/data/project-data/npm-cache/* ~/.npm/ 2>/dev/null
        echo "[恢复] npm缓存恢复完成"
      fi
      
      # 第四步：生成环境配置文件
      echo "[初始化] 生成环境配置..."
      cat > /workspace/.env << EOF
      # 从Gitpod Secrets自动加载的环境变量
      DATABASE_URL=$DATABASE_URL
      API_KEY=$API_KEY
      NODE_ENV=development
      PORT=3000
      EOF
      
      # 第五步：创建自动保存脚本
      cat > /workspace/scripts/autosave.sh << 'AUTOSAVE_EOF'
#!/bin/bash
# 自动保存脚本 - 工作区关闭前执行
# 将所有重要数据持久化保存

SAVE_TIME=$(date +%Y%m%d_%H%M%S)
LOG="/workspace/logs/autosave-${SAVE_TIME}.log"
mkdir -p /workspace/logs

echo "[$SAVE_TIME] 自动保存开始" | tee -a "$LOG"

# 保存Git变更
cd /workspace
if [ -n "$(git status --porcelain)" ]; then
  git add -A
  git commit -m "autosave: 自动保存 ${SAVE_TIME}" 2>/dev/null | tee -a "$LOG"
  git push origin HEAD 2>/dev/null | tee -a "$LOG"
  echo "[$SAVE_TIME] Git变更已保存" | tee -a "$LOG"
fi

# 同步依赖包到持久化卷
if [ -d "/workspace/node_modules" ]; then
  rsync -a /workspace/node_modules/ /mnt/data/project-data/node_modules/ 2>/dev/null
  echo "[$SAVE_TIME] 依赖包已同步" | tee -a "$LOG"
fi

# 同步npm缓存到持久化卷
if [ -d "~/.npm" ]; then
  mkdir -p /mnt/data/project-data/npm-cache
  rsync -a ~/.npm/ /mnt/data/project-data/npm-cache/ 2>/dev/null
  echo "[$SAVE_TIME] npm缓存已同步" | tee -a "$LOG"
fi

# 同步配置文件
if [ -d "/workspace/.config" ]; then
  mkdir -p /mnt/data/project-data/config
  rsync -a /workspace/.config/ /mnt/data/project-data/config/ 2>/dev/null
  echo "[$SAVE_TIME] 配置文件已同步" | tee -a "$LOG"
fi

# 清理30天前的旧日志
find /workspace/logs -name "autosave-*.log" -mtime +30 -delete 2>/dev/null

echo "[$SAVE_TIME] 自动保存完成" | tee -a "$LOG"
AUTOSAVE_EOF
      
      chmod +x /workspace/scripts/autosave.sh
      
      # 第六步：注册关闭钩子
      # 工作区关闭前会自动执行自动保存脚本
      echo "/workspace/scripts/autosave.sh" > /workspace/scripts/.stop-hook
      
      # 第七步：配置Git忽略规则
      cat >> /workspace/.gitignore << GITIGNORE_EOF
      
      # ---- 持久化相关文件 ----
      # 环境配置文件（包含敏感信息）
      .env
      .env.saved
      
      # 持久化卷数据（不应提交到Git）
      /mnt/data/
      
      # 同步和保存脚本
      scripts/.stop-hook
      
      # 日志文件
      logs/
GITIGNORE_EOF
      
      echo "========================================="
      echo "初始化完成，请开始开发！"
      echo "========================================="

  - command: |
      echo "开发服务器启动中..."
      
      # 启动后台定时同步任务
      # 每10分钟将关键数据同步到持久化卷
      (while true; do
        sleep 600
        echo "[定时同步] $(date +%H:%M:%S) - 同步数据到持久化卷..."
        if [ -d "/workspace/node_modules" ]; then
          rsync -a --delete /workspace/node_modules/ /mnt/data/project-data/node_modules/ 2>/dev/null
        fi
        if [ -d "~/.npm" ]; then
          mkdir -p /mnt/data/project-data/npm-cache
          rsync -a --delete ~/.npm/ /mnt/data/project-data/npm-cache/ 2>/dev/null
        fi
      done) &
      
      # 启动开发服务器
      npm run dev -- --host 0.0.0.0

# 持久化卷配置
persistentVolume:
  enabled: true
  size: 10GB

# 需要预先配置的Secrets
# 在Gitpod工作区设置中配置这些密钥
# 路径：Settings -> Secrets -> 添加
secrets:
  - name: DATABASE_URL
    description: "数据库连接字符串"
  - name: API_KEY
    description: "第三方API密钥"

八、文章总结

Gitpod的一次性工作区虽然带来了便利，但也带来了数据丢失的风险。通过合理的持久化配置，我们可以完全避免这种风险。

回顾一下核心要点：第一，Git提交是最基础的持久化方式，每次代码修改后都应该及时提交推送；第二，持久化卷适合保存依赖包、缓存等体积较大的数据，能显著加快工作区启动速度；第三，关闭前自动保存脚本可以兜底，确保即使忘了手动提交，数据也不会丢失；第四，Gitpod Secrets是管理敏感数据的最佳方式，避免密钥泄露到代码仓库。

实际操作中，建议根据项目特点选择合适的组合方案。小型项目用Git提交就够了，中大型项目加上持久化卷会舒适很多，涉及敏感数据的项目一定要配合Gitpod Secrets使用。

配置持久化方案之后，别忘了定期测试恢复流程。最好的验证方式就是关掉工作区重新打开，看看数据是否完整。养成这个习惯，才能真正放心地在Gitpod上进行开发。