Cloudflare + Backblaze + PicList 搭建博客图床（无需自有域名）

export default {

  async fetch(request, env) {

    const API_KEY_ID = env.API_KEY_ID; // Application Key ID
    const API_KEY = env.API_KEY; // Application Key
    const BUCKET_NAME = env.BUCKET_NAME; // Bucket Name
    const KV_NAMESPACE = env.KV_NAMESPACE; // KV namespace for rate limiting
    
    const ALLOWED_REFERERS = ["https://site1/",
                              "https://site2/",
                              "https://site3/",
                              "https://localhost:1313/"
                            ]; // List of allowed referers

    const MAX_REQUESTS_PER_DAY = 1000; // Limit to 1000 requests per day
    const url = new URL(request.url);
    const filePath = url.pathname.slice(1); // Extract file path from URL

    if (!filePath) {
      return new Response("File path not provided", { status: 400 });
    }

    // Step 1: Validate Referer Header

    const referer = request.headers.get("Referer");
    const isAllowedReferer =
      !referer || ALLOWED_REFERERS.some((allowed) => referer.includes(allowed));

    if (!isAllowedReferer) {
      return new Response("Invalid referer", { status: 403 });
    }

    // Access Cloudflare Cache API
    const cache = caches.default;

    // Check if the response is already in cache

    const cachedResponse = await cache.match(request);
    if (cachedResponse) {
      console.log(`Cache hit for: ${filePath}`);
      return cachedResponse; // Serve from cache
    }

    // Step 2: Rate Limiting using KV
    const currentDate = new Date().toISOString().split("T")[0]; // YYYY-MM-DD
    const requestCountKey = `${currentDate}:${filePath}`;
    let requestCount = (await KV_NAMESPACE.get(requestCountKey)) || 0;

    if (requestCount >= MAX_REQUESTS_PER_DAY) {
      return new Response("Daily limit reached for this file", { status: 429 });
    }

    requestCount = parseInt(requestCount) + 1;
    await KV_NAMESPACE.put(requestCountKey, requestCount, { expirationTtl: 86400 }); // Reset every 24 hours

    console.log(`Request count for ${filePath}: ${requestCount}`);

    console.log(`Cache miss for: ${filePath}. Fetching from Backblaze.`);

    // Step 3: Authenticate with Backblaze

    const authResponse = await fetch("https://api.backblazeb2.com/b2api/v2/b2_authorize_account", {
      headers: {
        Authorization: `Basic ${btoa(`${API_KEY_ID}:${API_KEY}`)}`,
      },
    });

    const authResponseText = await authResponse.text();

    if (!authResponse.ok) {
      return new Response(`Authorization failed: ${authResponseText}`, { status: 500 });
    }

    const authData = JSON.parse(authResponseText);
    const authToken = authData.authorizationToken;
    const downloadUrl = authData.downloadUrl; // Base URL for the bucket

    // Step 4: Construct the file URL

    const b2FileUrl = `${downloadUrl}/file/${BUCKET_NAME}/${filePath}`;

    // Step 5: Fetch the file from Backblaze

    const fileResponse = await fetch(b2FileUrl, {
      headers: {
        Authorization: authToken,
      },
    });

    if (!fileResponse.ok) {
      const errorText = await fileResponse.text();
      return new Response(`Failed to fetch file from Backblaze: ${errorText}`, { status: 404 });
    }

    // Clone the response to store in cache
    const responseToCache = new Response(fileResponse.body, {
      headers: {
        "Content-Type": fileResponse.headers.get("Content-Type"),
        "Cache-Control": "public, max-age=31536000", // Cache for 1 year
      },
    });

    // Store the response in cache

    await cache.put(request, responseToCache.clone());
    // Return the fetched response to the client
    return responseToCache;
  },
};

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression

cd C:\

scoop bucket add lemon https://github.com/hoilc/scoop-lemon
scoop install lemon/piclist