使用 R2 构建高性能对象存储服务

      # Cloudflare R2 配置
R2_ACCOUNT_ID="455ff61978adea5b200403729a6d5188"
R2_ACCESS_KEY_ID="d587ee662c66917d9276531fb0954171"
R2_SECRET_ACCESS_KEY="11119104484a173ec4575f282b47d906d858d9c5ad1c911f0887f64e767fd52c"
R2_BUCKET_NAME="zetar-mold-production"
R2_PUBLIC_URL="https://imgs.zetar.ai"

# 迁移控制标志（双写模式）
ENABLE_DUAL_WRITE=true        # 启用双写（R2+OSS）
USE_OSS_FOR_WRITES=false      # 是否只写 OSS
    

      // R2 Storage (optional - only if R2 is configured)
R2_ACCOUNT_ID: z.string().optional(),
R2_ACCESS_KEY_ID: z.string().optional(),
R2_SECRET_ACCESS_KEY: z.string().optional(),
R2_BUCKET_NAME: z.string().optional(),
R2_PUBLIC_URL: z.string().optional(),

// Migration flags
ENABLE_DUAL_WRITE: z.string().optional(),
USE_OSS_FOR_WRITES: z.string().optional(),
    

      import { S3Client, PutObjectCommand, DeleteObjectCommand, ListObjectsV2Command } from "@aws-sdk/client-s3";
import { env } from "@/env";

let s3Client: S3Client | null = null;

/**
 * 获取 S3 客户端实例（懒加载）
 */
function getS3Client(): S3Client | null {
  if (!env.R2_ACCOUNT_ID || !env.R2_ACCESS_KEY_ID || !env.R2_SECRET_ACCESS_KEY || !env.R2_BUCKET_NAME) {
    return null;
  }

  if (!s3Client) {
    s3Client = new S3Client({
      endpoint: `https://${env.R2_ACCOUNT_ID}.r2.cloudflarestorage.com`,
      region: "auto",
      credentials: {
        accessKeyId: env.R2_ACCESS_KEY_ID,
        secretAccessKey: env.R2_SECRET_ACCESS_KEY,
      },
    });
  }

  return s3Client;
}

/**
 * 检查 R2 存储是否已配置
 */
export function isR2Configured(): boolean {
  return !!(
    env.R2_ACCOUNT_ID &&
    env.R2_ACCESS_KEY_ID &&
    env.R2_SECRET_ACCESS_KEY &&
    env.R2_BUCKET_NAME
  );
}

/**
 * 上传文件到 R2
 */
export async function uploadToR2(
  key: string,
  buffer: Buffer,
  contentType: string,
  metadata?: Record<string, string>
): Promise<string> {
  const client = getS3Client();
  if (!client) {
    throw new Error("R2 storage is not configured");
  }

  await client.send(new PutObjectCommand({
    Bucket: env.R2_BUCKET_NAME,
    Key: key,
    Body: buffer,
    ContentType: contentType,
    Metadata: metadata,
  }));

  return getR2PublicUrl(key);
}

/**
 * 从 R2 删除文件
 */
export async function deleteFromR2(key: string): Promise<void> {
  const client = getS3Client();
  if (!client) {
    throw new Error("R2 storage is not configured");
  }

  await client.send(new DeleteObjectCommand({
    Bucket: env.R2_BUCKET_NAME,
    Key: key,
  }));
}

/**
 * 获取 R2 文件的公共 URL
 */
export function getR2PublicUrl(key: string): string {
  // 返回相对路径，前端会处理完整 URL
  return `/${key.replace(/^\//, "")}`;
}

/**
 * 列出 R2 中的对象
 */
export async function listR2Objects(prefix: string): Promise<Array<{ key: string; uploaded?: Date }>> {
  const client = getS3Client();
  if (!client) {
    throw new Error("R2 storage is not configured");
  }

  const response = await client.send(new ListObjectsV2Command({
    Bucket: env.R2_BUCKET_NAME,
    Prefix: prefix,
  }));

  return (response.Contents || []).map((obj) => ({
    key: obj.Key || "",
    uploaded: obj.LastModified,
  }));
}

/**
 * 获取内容类型
 */
export function getContentTypeFromExtension(filename: string): string {
  const ext = filename.split('.').pop()?.toLowerCase();
  const contentTypes: Record<string, string> = {
    'jpg': 'image/jpeg',
    'jpeg': 'image/jpeg',
    'png': 'image/png',
    'gif': 'image/gif',
    'webp': 'image/webp',
    'svg': 'image/svg+xml',
    'mp4': 'video/mp4',
    'webm': 'video/webm',
    'mov': 'video/quicktime',
    'pdf': 'application/pdf',
    'doc': 'application/msword',
    'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
    'txt': 'text/plain',
  };
  return contentTypes[ext || ''] || 'application/octet-stream';
}
    

      // 双写模式实现
if (enableDualWrite && r2Configured && ossConfigured) {
  // 双写模式 - 同时上传到 R2 和 OSS
  console.log(`[Dual Write] Uploading ${key} to both R2 and OSS`);
  
  try {
    // OSS 优先（上海用户更快）
    publicUrl = await Promise.race([
      uploadToOSS(key, bufferToUpload, contentType, metadata),
      new Promise<never>((_, reject) =>
        setTimeout(() => reject(new Error("OSS upload timeout")), uploadTimeout)
      ),
    ]);
    console.log(`[Dual Write] OSS upload successful for ${key}`);
    
    // R2 后台异步上传（不阻塞响应）
    uploadToR2(key, bufferToUpload, contentType, metadata)
      .then(() => console.log(`[Dual Write] R2 upload successful for ${key} (background)`))
      .catch((error) => console.error(`[Dual Write] R2 upload failed for ${key}:`, error));
      
  } catch (ossError) {
    console.error(`[Dual Write] OSS upload failed for ${key}:`, ossError);
    
    // OSS 失败时回退到 R2
    try {
      publicUrl = await Promise.race([
        uploadToR2(key, bufferToUpload, contentType, metadata),
        new Promise<never>((_, reject) =>
          setTimeout(() => reject(new Error("R2 upload timeout")), uploadTimeout)
        ),
      ]);
      console.log(`[Dual Write] R2 upload successful for ${key} (fallback)`);
    } catch (r2Error) {
      console.error(`[Dual Write] R2 upload also failed for ${key}:`, r2Error);
      throw new Error("Both OSS and R2 uploads failed");
    }
  }
} else if (r2Configured) {
  // 仅 R2 模式
  console.log(`[R2 Write] Uploading ${key} to R2`);
  publicUrl = await uploadToR2(key, bufferToUpload, contentType, metadata);
}
    

      /**
 * 获取 R2 存储路径
 */
export function getR2KeyPath(
  type: ImageUploadType,
  id: number,
  subtype: ImageSubtype
): string {
  const typePath = type === "mold" ? "molds" : "projects";
  return `uploads/${typePath}/${id}/${subtype}`;
}

/**
 * 生成唯一文件名
 */
export function generateImageFilename(userId: string, originalName: string): string {
  const timestamp = Date.now();
  const randomString = Math.random().toString(36).substring(2, 15);
  const extension = originalName.split('.').pop() || 'jpg';
  const sanitizedName = originalName
    .replace(/\.[^/.]+$/, '') // 移除扩展名
    .replace(/[^a-zA-Z0-9-_]/g, '-') // 替换特殊字符
    .slice(0, 50); // 限制长度
  
  return `${timestamp}-${randomString}-${sanitizedName}.${extension}`;
}
    

      import { copyOSSObject, deleteFromOSS, listOSSObjects } from "@/lib/oss-storage";
import { deleteFromR2, listR2Objects } from "@/lib/r2-storage";

export class FileMigrationService {
  /**
   * 迁移临时文件到正式位置（R2）
   */
  async migrateR2TempFiles(
    userId: string,
    tempId: string,
    targetPath: string
  ): Promise<string[]> {
    const tempPrefix = `uploads/temp/${userId}/${tempId}/`;
    const files = await listR2Objects(tempPrefix);
    const migratedUrls: string[] = [];

    for (const file of files) {
      if (file.key) {
        const filename = file.key.split('/').pop();
        if (filename) {
          const newKey = `${targetPath}/${filename}`;
          
          // R2 不支持直接 copy，需要下载再上传
          // 这里简化处理，实际项目中返回临时 URL
          migratedUrls.push(`/${newKey}`);
          
          // 删除临时文件
          await deleteFromR2(file.key);
        }
      }
    }

    return migratedUrls;
  }

  /**
   * 清理过期的临时文件（R2）
   */
  async cleanupR2ExpiredTempFiles(hoursOld: number = 24): Promise<number> {
    const tempPrefix = 'uploads/temp/';
    const files = await listR2Objects(tempPrefix);
    const cutoffTime = new Date(Date.now() - hoursOld * 60 * 60 * 1000);
    let deletedCount = 0;

    for (const file of files) {
      if (file.key && file.uploaded && file.uploaded < cutoffTime) {
        await deleteFromR2(file.key);
        deletedCount++;
        console.log(`[Cleanup] Deleted expired temp file: ${file.key}`);
      }
    }

    return deletedCount;
  }
}
    

      #!/usr/bin/env bun
import { S3Client, ListObjectsV2Command, GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";

// 配置
const config = {
  r2: {
    endpoint: `https://${process.env.R2_ACCOUNT_ID}.r2.cloudflarestorage.com`,
    credentials: {
      accessKeyId: process.env.R2_ACCESS_KEY_ID!,
      secretAccessKey: process.env.R2_SECRET_ACCESS_KEY!,
    },
    bucket: process.env.R2_BUCKET_NAME!,
  },
  oss: {
    endpoint: `https://${process.env.OSS_ENDPOINT}`,
    credentials: {
      accessKeyId: process.env.OSS_ACCESS_KEY_ID!,
      secretAccessKey: process.env.OSS_SECRET_ACCESS_KEY!,
    },
    bucket: process.env.OSS_BUCKET_NAME!,
  },
};

async function syncR2ToOSS(minutesAgo: number = 10) {
  const r2Client = new S3Client(config.r2);
  const ossClient = new S3Client(config.oss);
  
  // 获取最近更新的文件
  const cutoffTime = new Date(Date.now() - minutesAgo * 60 * 1000);
  
  // 列出 R2 文件
  const listResponse = await r2Client.send(new ListObjectsV2Command({
    Bucket: config.r2.bucket,
  }));
  
  const filesToSync = (listResponse.Contents || [])
    .filter(obj => obj.LastModified && obj.LastModified > cutoffTime);
  
  console.log(`Found ${filesToSync.length} files to sync`);
  
  // 同步每个文件
  for (const file of filesToSync) {
    if (!file.Key) continue;
    
    try {
      // 从 R2 下载
      const getResponse = await r2Client.send(new GetObjectCommand({
        Bucket: config.r2.bucket,
        Key: file.Key,
      }));
      
      const body = await getResponse.Body?.transformToByteArray();
      if (!body) continue;
      
      // 上传到 OSS
      await ossClient.send(new PutObjectCommand({
        Bucket: config.oss.bucket,
        Key: file.Key,
        Body: body,
        ContentType: getResponse.ContentType,
      }));
      
      console.log(`✅ Synced: ${file.Key}`);
    } catch (error) {
      console.error(`❌ Failed to sync ${file.Key}:`, error);
    }
  }
}

// 执行同步
const minutes = parseInt(process.argv[2] || "10");
await syncR2ToOSS(minutes);
    

      #!/usr/bin/env bun

async function compareStorages() {
  const r2Files = await listR2Objects("");
  const ossFiles = await listOSSObjects("");
  
  const r2Keys = new Set(r2Files.map(f => f.key));
  const ossKeys = new Set(ossFiles.map(f => f.key));
  
  // 找出差异
  const onlyInR2 = [...r2Keys].filter(key => !ossKeys.has(key));
  const onlyInOSS = [...ossKeys].filter(key => !r2Keys.has(key));
  
  console.log(`Total files in R2: ${r2Keys.size}`);
  console.log(`Total files in OSS: ${ossKeys.size}`);
  console.log(`Files only in R2: ${onlyInR2.length}`);
  console.log(`Files only in OSS: ${onlyInOSS.length}`);
  
  if (onlyInR2.length > 0) {
    console.log("\nFiles missing in OSS:");
    onlyInR2.forEach(key => console.log(`  - ${key}`));
  }
  
  return {
    r2Count: r2Keys.size,
    ossCount: ossKeys.size,
    missingInOSS: onlyInR2,
    missingInR2: onlyInOSS,
  };
}
    

      用户上传 → API 接收
         ↓
    文件压缩（如果需要）
         ↓
    ┌─────────────┐
    │  双写判断   │
    └─────────────┘
         ↓
    双写模式启用？
    ├─ 是 → OSS 上传（主）
    │      ├─ 成功 → 返回 URL
    │      │        → R2 后台上传（备）
    │      └─ 失败 → R2 上传（回退）
    └─ 否 → 单存储上传
    

      // 对于大于 10MB 的文件使用分块上传
if (buffer.length > 10 * 1024 * 1024) {
  return await multipartUpload(key, buffer);
}
    

      // 限制并发上传数量
const CONCURRENT_UPLOADS = 5;
const uploadQueue = [];

for (let i = 0; i < files.length; i += CONCURRENT_UPLOADS) {
  const batch = files.slice(i, i + CONCURRENT_UPLOADS);
  await Promise.all(batch.map(file => uploadFile(file)));
}
    

      // 缓存 S3 客户端实例
let s3Client: S3Client | null = null;

function getS3Client() {
  if (!s3Client) {
    s3Client = new S3Client(config);
  }
  return s3Client;
}
    

      // 增加超时时间
const uploadTimeout = file.size > 50 * 1024 * 1024 ? 300000 : 60000;
    

      {
  "AllowedOrigins": ["*"],
  "AllowedMethods": ["GET", "PUT", "POST", "DELETE"],
  "AllowedHeaders": ["*"],
  "MaxAgeSeconds": 3600
}
    

      // 启用详细日志
console.log(`[R2] Uploading ${key} (${buffer.length} bytes)`);
console.log(`[R2] Upload successful: ${publicUrl}`);
console.error(`[R2] Upload failed:`, error);