Angus-fw🥝

Cloudflare部署Snippets项目教程

2026-03-27T02:00:00.000Z

Cloudflare部署Snippets项目教程

本教程将详细介绍如何在Cloudflare中使用Snippets功能部署GitHub反代、Docker反代以及随机图项目。

准备工作

拥有一个已添加到Cloudflare的域名
登录Cloudflare账户

步骤一：进入Cloudflare Snippets页面

登录Cloudflare账户
选择你要使用的域名
在左侧菜单中找到”规则”选项并点击
在规则页面中选择”Snippets”选项卡

步骤二：创建Snippets片段

代码由于2x.nz博客提供的，感谢2x.nz博客的贡献

1. 创建GitHub反代片段

点击”创建片段”按钮
在名称输入框中输入一个描述性名称，例如”GitHub反代”
在编辑框中粘贴以下代码：

// 域名白名单配置（仅保留需要的原生域名）
const domain_whitelist = [
  'github.com',
  'avatars.githubusercontent.com',
  'github.githubassets.com',
  'collector.github.com',
  'api.github.com',
  'raw.githubusercontent.com',
  'gist.githubusercontent.com',
  'github.io',
  'assets-cdn.github.com',
  'cdn.jsdelivr.net',
  'securitylab.github.com',
  'www.githubstatus.com',
  'npmjs.com',
  'git-lfs.github.com',
  'githubusercontent.com',
  'github.global.ssl.fastly.net',
  'api.npms.io',
  'github.community',
  'desktop.github.com',
  'central.github.com'
];

// 由白名单自动生成映射
const domain_mappings = Object.fromEntries(
  domain_whitelist.map(domain => [domain, domain.replace(/\./g, '-') + '-'])
);

// 需要重定向的路径（屏蔽海外后可以不填写）
const redirect_paths = [];

// 中国大陆以外的地区重定向到原始GitHub域名
const enable_geo_redirect = true;

export default {
  async fetch(request, env, ctx) {
    return handleRequest(request);
  }
};

async function handleRequest(request) {
  const url = new URL(request.url);
  // 统一转小写
  const current_host = url.host.toLowerCase();
  const host_header = request.headers.get('Host');
  const effective_host = (host_header || current_host).toLowerCase();
  
  // 检查是否需要重定向到原始GitHub（非中国用户）
  if (enable_geo_redirect) {
    const country = request.headers.get('CF-IPCountry') || '';
    if (country && country !== 'CN') {
      const host_prefix = getProxyPrefix(effective_host);
      if (host_prefix) {
        let target_host = null;
        if (host_prefix && host_prefix.endsWith('-gh.')) {
          const prefix_part = host_prefix.slice(0, -4);
          for (const original of Object.keys(domain_mappings)) {
            const normalized_original = original.trim().toLowerCase();
            if (normalized_original.replace(/\./g, '-') === prefix_part) {
              target_host = original;
              break;
            }
          }
        }
        if (target_host) {
          const domain_suffix = effective_host.substring(host_prefix.length);
          const original_url = new URL(request.url);
          original_url.host = target_host;
          original_url.protocol = 'https:';
          return Response.redirect(original_url.href, 302);
        }
      }
    }
  }
  
  // 检查特殊路径，返回正常错误
  if (redirect_paths.includes(url.pathname)) {
    return new Response('Not Found', { status: 404 });
  }

  // 强制使用 HTTPS
  if (url.protocol === 'http:') {
    url.protocol = 'https:';
    return Response.redirect(url.href);
  }

  // 从有效主机名中提取前缀
  const host_prefix = getProxyPrefix(effective_host);
  if (!host_prefix) {
    return new Response(`Domain not configured for proxy. Host: ${effective_host}, Prefix check failed`, { status: 404 });
  }

  // 根据前缀找到对应的原始域名
  let target_host = null;
  
  // 解析 *-gh. 模式
  if (host_prefix && host_prefix.endsWith('-gh.')) {
    const prefix_part = host_prefix.slice(0, -4); // 移除 -gh.
    // 尝试找到对应的原始域名
    for (const original of Object.keys(domain_mappings)) {
      const normalized_original = original.trim().toLowerCase();
      if (normalized_original.replace(/\./g, '-') === prefix_part) {
        target_host = original;
        break;
      }
    }
  }

  if (!target_host) {
    return new Response(`Domain not configured for proxy. Host: ${effective_host}, Prefix: ${host_prefix}, Target lookup failed`, { status: 404 });
  }

  // 直接使用正则表达式处理最常见的嵌套URL问题
  let pathname = url.pathname;
  
  // 修复特定的嵌套URL模式 - 直接移除嵌套URL部分
  // 匹配 /xxx/xxx/latest-commit/main/https%3A//gh.xxx.xxx/ 或 /xxx/xxx/tree-commit-info/main/https%3A//gh.xxx.xxx/
  pathname = pathname.replace(/(\/[^\/]+\/[^\/]+\/(?:latest-commit|tree-commit-info)\/[^\/]+)\/https%3A\/\/[^\/]+\/.*/, '$1');
  
  // 同样处理非编码版本
  pathname = pathname.replace(/(\/[^\/]+\/[^\/]+\/(?:latest-commit|tree-commit-info)\/[^\/]+)\/https:\/\/[^\/]+\/.*/, '$1');

  // 构建新的请求URL
  const new_url = new URL(url);
  new_url.host = target_host;
  new_url.pathname = pathname;
  new_url.protocol = 'https:';

  // 设置新的请求头
  const new_headers = new Headers(request.headers);
  new_headers.set('Host', target_host);
  new_headers.set('Referer', new_url.href);
  // 强制要求源站返回未压缩的内容，确保我们可以正常修改文本
  new_headers.delete('accept-encoding');
  
  try {
    // 发起请求
    const response = await fetch(new_url.href, {
      method: request.method,
      headers: new_headers,
      body: request.method !== 'GET' ? request.body : undefined,
      redirect: 'manual' // 处理重定向，避免自动跟随导致的问题
    });

    // 处理重定向
    if ([301, 302, 303, 307, 308].includes(response.status)) {
      const location = response.headers.get('location');
      if (location) {
        const modified_location = modifyUrl(location, host_prefix, effective_host);
        const new_res_headers = new Headers(response.headers);
        new_res_headers.set('location', modified_location);
        return new Response(null, {
          status: response.status,
          headers: new_res_headers
        });
      }
    }

    // 设置新的响应头
    const new_response_headers = new Headers(response.headers);
    new_response_headers.set('access-control-allow-origin', '*');
    new_response_headers.set('access-control-allow-credentials', 'true');
    new_response_headers.set('cache-control', 'public, max-age=14400');
    new_response_headers.delete('content-security-policy');
    new_response_headers.delete('content-security-policy-report-only');
    new_response_headers.delete('clear-site-data');

    // 只处理 200 OK 且是文本类型的响应内容
    const content_type = response.headers.get('content-type') || '';
    const is_text = content_type.includes('text/') || 
                    content_type.includes('application/json') || 
                    content_type.includes('application/javascript') || 
                    content_type.includes('application/xml');

    if (response.status === 200 && is_text) {
      // 如果要修改内容，必须移除这些头，因为内容会被解压且长度会变化
      new_response_headers.delete('content-encoding');
      new_response_headers.delete('content-length');
      
      let text = await response.text();
      text = await modifyText(text, host_prefix, effective_host);
      
      // 注入统计脚本
      if (content_type.includes('text/html')) {
        const inject_script = '';
        if (text.includes('')) {
          text = text.replace('', `${inject_script}`);
        } else if (text.includes('')) {
          text = text.replace('', `${inject_script}`);
        } else {
          text = text + inject_script;
        }
      }
      
      return new Response(text, {
        status: response.status,
        headers: new_response_headers
      });
    }

    // 对于非文本或非 200 响应，直接返回原始流
    return new Response(response.body, {
      status: response.status,
      headers: new_response_headers
    });
  } catch (err) {
    return new Response(`Proxy Error: ${err.message}`, { status: 502 });
  }
}

// 获取当前主机名的前缀，用于匹配反向映射
function getProxyPrefix(host) {
  // 检查 *-gh. 模式
  const ghMatch = host.match(/^([a-z0-9-]+-gh\.)/);
  if (ghMatch) {
    return ghMatch[1];
  }

  return null;
}

// 修改文本中的域名引用
async function modifyText(text, host_prefix, effective_hostname) {
  // 使用有效主机名获取域名后缀部分（用于构建完整的代理域名）
  const domain_suffix = effective_hostname.substring(host_prefix.length);
  
  // 替换所有域名引用
  for (const [original_domain, _] of Object.entries(domain_mappings)) {
    const escaped_domain = original_domain.replace(/\./g, '\\.');
    
    // 统一为 [原生域名]-github.com
    const current_prefix = original_domain.replace(/\./g, '-') + '-gh.';
    const full_proxy_domain = `${current_prefix}${domain_suffix}`;
    
    // 替换完整URLs
    text = text.replace(
      new RegExp(`https?://${escaped_domain}(?=/|"|'|\\s|$)`, 'g'),
      `https://${full_proxy_domain}`
    );
    
    // 替换协议相对URLs
    text = text.replace(
      new RegExp(`//${escaped_domain}(?=/|"|'|\\s|$)`, 'g'),
      `//${full_proxy_domain}`
    );
  }

  return text;
}

// 修改 URL（用于重定向等）
function modifyUrl(url_str, host_prefix, effective_hostname) {
  try {
    const url = new URL(url_str);
    const domain_suffix = effective_hostname.substring(host_prefix.length);
    
    for (const [original_domain, _] of Object.entries(domain_mappings)) {
      if (url.host === original_domain) {
        const current_prefix = original_domain.replace(/\./g, '-') + '-gh.';
        url.host = `${current_prefix}${domain_suffix}`;
        break;
      }
    }
    return url.href;
  } catch (e) {
    return url_str;
  }
}

点击”保存”按钮、

2. 创建Docker反代片段

点击”创建片段”按钮
在名称输入框中输入一个描述性名称，例如”Docker反代”
在编辑框中粘贴以下代码：

const DEFAULT_HUB_HOST = 'registry-1.docker.io'
const AUTH_URL = 'https://auth.docker.io'
const DEFAULT_BLOCKED_UA = ['netcraft']

const SNIPPET_CONFIG = {
  URL302: '',
  URL: '',
  UA: ''
}

function routeByHosts(host, defaultHubHost) {
  const routes = {
    quay: 'quay.io',
    gcr: 'gcr.io',
    'k8s-gcr': 'k8s.gcr.io',
    k8s: 'registry.k8s.io',
    ghcr: 'ghcr.io',
    cloudsmith: 'docker.cloudsmith.io',
    nvcr: 'nvcr.io',
    test: 'registry-1.docker.io'
  }
  if (host in routes) return [routes[host], false]
  return [defaultHubHost, true]
}

const PREFLIGHT_INIT = {
  headers: new Headers({
    'access-control-allow-origin': '*',
    'access-control-allow-methods': 'GET,POST,PUT,PATCH,TRACE,DELETE,HEAD,OPTIONS',
    'access-control-max-age': '1728000'
  })
}

function makeRes(body, status = 200, headers = {}) {
  headers['access-control-allow-origin'] = '*'
  return new Response(body, { status, headers })
}

function newUrl(urlStr, base) {
  try {
    return new URL(urlStr, base)
  } catch {
    return null
  }
}

async function nginx() {
  return `
  
  
  
  Welcome to nginx!
  
  
  
  Welcome to nginx!
  If you see this page, the nginx web server is successfully installed and
  working. Further configuration is required.
  For online documentation and support please refer to
  nginx.org.

  Commercial support is available at
  nginx.com.
  Thank you for using nginx.
  
  
  `
}

async function searchInterface() {
  return `
  
  
  
    Docker Hub 镜像搜索
    
    
    
  
  
    
      
        
        
        
      
    
    
      
        
          
          
        
      
      Docker Hub 镜像搜索
      快速查找、下载和部署 Docker 容器镜像
      
        
        
      
      基于 Cloudflare Workers / Pages 构建，利用全球边缘网络实现毫秒级响应。
    
    
  
  
  `
}

async function httpHandler(req, pathname, baseHost) {
  const reqHdrRaw = req.headers
  if (req.method === 'OPTIONS' && reqHdrRaw.has('access-control-request-headers')) {
    return new Response(null, PREFLIGHT_INIT)
  }
  const reqHdrNew = new Headers(reqHdrRaw)
  reqHdrNew.delete('Authorization')
  const urlObj = newUrl(pathname, `https://${baseHost}`)
  const reqInit = {
    method: req.method,
    headers: reqHdrNew,
    redirect: 'follow',
    body: req.body
  }
  return proxy(urlObj, reqInit, '')
}

async function proxy(urlObj, reqInit, rawLen) {
  const res = await fetch(urlObj.href, reqInit)
  const resHdrOld = res.headers
  const resHdrNew = new Headers(resHdrOld)
  if (rawLen) {
    const newLen = resHdrOld.get('content-length') || ''
    if (rawLen !== newLen) {
      return makeRes(res.body, 400, {
        '--error': `bad len: ${newLen}, except: ${rawLen}`,
        'access-control-expose-headers': '--error'
      })
    }
  }
  resHdrNew.set('access-control-expose-headers', '*')
  resHdrNew.set('access-control-allow-origin', '*')
  resHdrNew.set('Cache-Control', 'max-age=1500')
  resHdrNew.delete('content-security-policy')
  resHdrNew.delete('content-security-policy-report-only')
  resHdrNew.delete('clear-site-data')
  return new Response(res.body, {
    status: res.status,
    headers: resHdrNew
  })
}

function parseCsvInput(input) {
  let text = input.replace(/[\t |"'\r\n]+/g, ',').replace(/,+/g, ',')
  if (text.charAt(0) === ',') text = text.slice(1)
  if (text.charAt(text.length - 1) === ',') text = text.slice(0, text.length - 1)
  return text ? text.split(',') : []
}

export default {
  async fetch(request) {
    const getReqHeader = (key) => request.headers.get(key)
    const originalUrl = new URL(request.url)
    let url = new URL(request.url)
    const userAgentHeader = request.headers.get('User-Agent')
    const userAgent = userAgentHeader ? userAgentHeader.toLowerCase() : 'null'
    const workersUrl = `https://${originalUrl.hostname}`
    const ns = url.searchParams.get('ns')
    const hostname = url.searchParams.get('hubhost') || originalUrl.hostname
    const hostTop = hostname.split('.')[0]
    let blockedUA = [...DEFAULT_BLOCKED_UA]
    if (SNIPPET_CONFIG.UA) blockedUA = blockedUA.concat(parseCsvInput(SNIPPET_CONFIG.UA))
    let checkHost
    let hubHost = DEFAULT_HUB_HOST

    if (ns) {
      hubHost = ns === 'docker.io' ? 'registry-1.docker.io' : ns
    } else {
      checkHost = routeByHosts(hostTop, DEFAULT_HUB_HOST)
      hubHost = checkHost[0]
    }

    const fakePage = checkHost ? checkHost[1] : false
    url.hostname = hubHost
    const hubParams = ['/v1/search', '/v1/repositories']

    if (blockedUA.some((ua) => userAgent.includes(ua)) && blockedUA.length > 0) {
      return new Response(await nginx(), {
        headers: { 'Content-Type': 'text/html; charset=UTF-8' }
      })
    }

    if ((userAgent && userAgent.includes('mozilla')) || hubParams.some((param) => url.pathname.includes(param))) {
      if (url.pathname === '/') {
        if (SNIPPET_CONFIG.URL302) return Response.redirect(SNIPPET_CONFIG.URL302, 302)
        if (SNIPPET_CONFIG.URL) {
          if (SNIPPET_CONFIG.URL.toLowerCase() === 'nginx') {
            return new Response(await nginx(), {
              headers: { 'Content-Type': 'text/html; charset=UTF-8' }
            })
          }
          return fetch(new Request(SNIPPET_CONFIG.URL, request))
        }
        if (fakePage) {
          return new Response(await searchInterface(), {
            headers: { 'Content-Type': 'text/html; charset=UTF-8' }
          })
        }
      } else {
        if (url.pathname.startsWith('/v1/')) url.hostname = 'index.docker.io'
        else if (fakePage) url.hostname = 'hub.docker.com'
        if (url.searchParams.get('q')?.includes('library/') && url.searchParams.get('q') !== 'library/') {
          const search = url.searchParams.get('q')
          url.searchParams.set('q', search.replace('library/', ''))
        }
        return fetch(new Request(url, request))
      }
    }

    if (!/%2F/.test(url.search) && /%3A/.test(url.toString())) {
      const modifiedUrl = url.toString().replace(/%3A(?=.*?&)/, '%3Alibrary%2F')
      url = new URL(modifiedUrl)
    }

    if (url.pathname.includes('/token')) {
      const tokenParameter = {
        headers: {
          Host: 'auth.docker.io',
          'User-Agent': getReqHeader('User-Agent'),
          Accept: getReqHeader('Accept'),
          'Accept-Language': getReqHeader('Accept-Language'),
          'Accept-Encoding': getReqHeader('Accept-Encoding'),
          Connection: 'keep-alive',
          'Cache-Control': 'max-age=0'
        }
      }
      const tokenUrl = AUTH_URL + url.pathname + url.search
      return fetch(new Request(tokenUrl, request), tokenParameter)
    }

    if (hubHost === 'registry-1.docker.io' && /^\/v2\/[^/]+\/[^/]+\/[^/]+$/.test(url.pathname) && !/^\/v2\/library/.test(url.pathname)) {
      url.pathname = '/v2/library/' + url.pathname.split('/v2/')[1]
    }

    if (
      url.pathname.startsWith('/v2/') &&
      (url.pathname.includes('/manifests/') ||
        url.pathname.includes('/blobs/') ||
        url.pathname.includes('/tags/') ||
        url.pathname.endsWith('/tags/list'))
    ) {
      let repo = ''
      const v2Match = url.pathname.match(/^\/v2\/(.+?)(?:\/(manifests|blobs|tags)\/)/)
      if (v2Match) repo = v2Match[1]
      if (repo) {
        const tokenUrl = `${AUTH_URL}/token?service=registry.docker.io&scope=repository:${repo}:pull`
        const tokenRes = await fetch(tokenUrl, {
          headers: {
            'User-Agent': getReqHeader('User-Agent'),
            Accept: getReqHeader('Accept'),
            'Accept-Language': getReqHeader('Accept-Language'),
            'Accept-Encoding': getReqHeader('Accept-Encoding'),
            Connection: 'keep-alive',
            'Cache-Control': 'max-age=0'
          }
        })
        const tokenData = await tokenRes.json()
        const parameter = {
          headers: {
            Host: hubHost,
            'User-Agent': getReqHeader('User-Agent'),
            Accept: getReqHeader('Accept'),
            'Accept-Language': getReqHeader('Accept-Language'),
            'Accept-Encoding': getReqHeader('Accept-Encoding'),
            Connection: 'keep-alive',
            'Cache-Control': 'max-age=0',
            Authorization: `Bearer ${tokenData.token}`
          },
          cacheTtl: 3600
        }
        if (request.headers.has('X-Amz-Content-Sha256')) {
          parameter.headers['X-Amz-Content-Sha256'] = getReqHeader('X-Amz-Content-Sha256')
        }
        const originalResponse = await fetch(new Request(url, request), parameter)
        const newResponseHeaders = new Headers(originalResponse.headers)
        if (newResponseHeaders.get('Www-Authenticate')) {
          const re = new RegExp(AUTH_URL, 'g')
          newResponseHeaders.set(
            'Www-Authenticate',
            originalResponse.headers.get('Www-Authenticate').replace(re, workersUrl)
          )
        }
        if (newResponseHeaders.get('Location')) {
          const location = newResponseHeaders.get('Location')
          return httpHandler(request, location, hubHost)
        }
        return new Response(originalResponse.clone().body, {
          status: originalResponse.status,
          headers: newResponseHeaders
        })
      }
    }

    const parameter = {
      headers: {
        Host: hubHost,
        'User-Agent': getReqHeader('User-Agent'),
        Accept: getReqHeader('Accept'),
        'Accept-Language': getReqHeader('Accept-Language'),
        'Accept-Encoding': getReqHeader('Accept-Encoding'),
        Connection: 'keep-alive',
        'Cache-Control': 'max-age=0'
      },
      cacheTtl: 3600
    }
    if (request.headers.has('Authorization')) {
      parameter.headers.Authorization = getReqHeader('Authorization')
    }
    if (request.headers.has('X-Amz-Content-Sha256')) {
      parameter.headers['X-Amz-Content-Sha256'] = getReqHeader('X-Amz-Content-Sha256')
    }

    const originalResponse = await fetch(new Request(url, request), parameter)
    const newResponseHeaders = new Headers(originalResponse.headers)
    if (newResponseHeaders.get('Www-Authenticate')) {
      const re = new RegExp(AUTH_URL, 'g')
      newResponseHeaders.set(
        'Www-Authenticate',
        originalResponse.headers.get('Www-Authenticate').replace(re, workersUrl)
      )
    }
    if (newResponseHeaders.get('Location')) {
      const location = newResponseHeaders.get('Location')
      return httpHandler(request, location, hubHost)
    }
    return new Response(originalResponse.clone().body, {
      status: originalResponse.status,
      headers: newResponseHeaders
    })
  }
}

点击”保存”按钮

3. 创建随机图项目片段

点击”创建片段”按钮
在名称输入框中输入一个描述性名称，例如”随机图”
在编辑框中粘贴以下代码：

let countsCache = null;
let lastFetch = 0;
const CACHE_TTL = 10 * 60 * 1000; // 10分钟缓存

async function getCounts() {
    // 简单缓存，避免每次请求都 fetch
    if (countsCache && (Date.now() - lastFetch < CACHE_TTL)) {
        return countsCache;
    }

    const resp = await fetch('https://p.域名/random.js');
    const text = await resp.text();

    // 提取 {"h":1124,"v":4382}
    const match = text.match(/counts\s*=\s*(\{[^}]+\})/);

    if (!match) {
        throw new Error('无法解析 counts');
    }

    countsCache = JSON.parse(match[1]);
    lastFetch = Date.now();

    return countsCache;
}

function randomInt(max) {
    return Math.floor(Math.random() * max) + 1;
}

export default {
    async fetch(request) {
        const url = new URL(request.url);
        const path = url.pathname;

        try {
            const counts = await getCounts();

            if (path === '/h') {
                const n = randomInt(counts.h);
                const location = `https://p.域名/ri/h/${n}.webp`;

                return new Response(null, {
                    status: 302,
                    headers: {
                        Location: location
                    }
                });
            }

            if (path === '/v') {
                const n = randomInt(counts.v);
                const location = `https://p.域名/ri/v/${n}.webp`;

                return new Response(null, {
                    status: 302,
                    headers: {
                        Location: location
                    }
                });
            }

            return new Response('Not Found', { status: 404 });

        } catch (e) {
            return new Response('Error: ' + e.message, { status: 500 });
        }
    }
};

点击”保存”按钮

步骤三：配置片段规则

1. 为GitHub反代配置规则

找到刚创建的”GitHub反代”片段
点击”添加规则”按钮
在规则配置页面中：
- 选择”自定义筛选表达式”
- 字段选择”主机名”
- 运算符选择”通配符”
- 值输入*-gh.域名（或者你想要使用的具体子域名，例如github.com）
点击”保存”按钮

2. 为Docker反代配置规则

找到刚创建的”Docker反代”片段
点击”添加规则”按钮
在规则配置页面中：
- 选择”自定义筛选表达式”
- 字段选择”主机名”
- 运算符选择”通配符”
- 值输入docker.域名（或者你想要使用的具体子域名，例如docker.yourdomain.com）
点击”保存”按钮

3. 为随机图项目配置规则

找到刚创建的”随机图”片段
点击”添加规则”按钮
在规则配置页面中：
- 选择”自定义筛选表达式”
- 字段选择”主机名”
- 运算符选择”通配符”
- 值输入c-p.域名（或者你想要使用的具体子域名，例如c-p.yourdomain.com）
点击”保存”按钮

步骤四：部署和测试

确保所有片段和规则都已保存
等待Cloudflare生效（通常需要几分钟时间）
测试访问：
- GitHub反代：访问github.com（替换为你的实际域名）
- Docker反代：访问docker.yourdomain.com（替换为你的实际域名）
- 随机图：访问c-p.yourdomain.com（替换为你的实际域名）

注意事项

确保你的域名已经正确配置了DNS记录，指向Cloudflare
如果你使用的是子域名，确保已经在DNS中添加了相应的A记录或CNAME记录
某些地区可能无法访问GitHub或Docker Hub，即使使用反代也可能受到影响
随机图服务可能会受到外部API的限制，建议使用多个备用API以提高可靠性

故障排除

如果访问时出现错误，请检查片段代码是否正确
确认规则配置中的主机名是否与你的实际域名匹配
检查Cloudflare的安全设置，确保没有阻止请求
尝试清除浏览器缓存后再次访问

通过以上步骤，你应该已经成功在Cloudflare上部署了GitHub反代、Docker反代和随机图项目。如果遇到任何问题，请参考Cloudflare的官方文档或寻求社区支持。

Cloudflare Pages 国内访问优化 -- 利用「优选 IP」加速

2026-01-12T16:00:00.000Z

🌟 核心方案

Cloudflare Pages + 华为云国际站 + 第三方 CNAME 优选 IP

🧠 优化思路

核心逻辑

通过 DNS 层分流实现国内外访问优化：

🌍 国外访问：继续使用 Cloudflare 官方线路
🇨🇳 国内访问：通过优选 IP 线路提高访问速度

技术实现

实现这个效果需要三个关键步骤：

Cloudflare 子域名 NS 下沉：将特定子域名的解析权下放
华为云国际站线路解析：实现智能地区分流
第三方 Cloudflare 优选 IP/CNAME：使用稳定快速的国内访问节点

预期效果

✅ 国内访问速度显著提升
✅ 国外访问保持原有稳定性
✅ Pages 项目无需任何代码修改
✅ 架构清晰，配置简单

🗺️ 架构示意图

用户访问  
  │  
  ├─ 国外 → Cloudflare DNS → CF Pages  
  │  
  └─ 国内 → 华为云 DNS → 优选 IP → CF Pages

架构特点：

仅在 DNS 层进行智能分流，不影响 Pages 项目本身
国内流量通过优选 IP 直达 Cloudflare Pages
国外流量保持原有 Cloudflare 官方路径
对用户完全透明，无需修改访问方式

� 准备条件

在开始配置之前，请确保你已经准备好以下资源：

✅ Cloudflare Pages 项目：已部署的项目（如 logo 库、静态网站等）
✅ 自定义二级域名：已绑定到 Pages 项目的域名
✅ 第三方 Cloudflare 优选 IP/CNAME：稳定的国内加速节点
✅ 华为云国际站账号：无需实名，仅需邮箱注册即可

🔗 步骤一：确保 Cloudflare Pages 已绑定域名

查看 Pages 分配的 CNAME

部署 Cloudflare Pages 后，系统会分配一个默认的 CNAME 地址：

1	xxx.pages.dev

注意：这个 CNAME 地址非常重要，后续配置会用到。

绑定自定义域名（如已完成可跳过）

登录 Cloudflare Pages 控制台
选择目标项目，进入「Settings」→「Custom domains」
输入自定义二级域名（如 logo.example.com）
点击「Activate domain」完成绑定

测试初始访问速度

使用 itdog 等工具测试未优化前的访问效果：

☁️ 步骤二：注册并使用华为云国际站

注册华为云国际站

重要提示：请确保注册的是国际站，而非国内站。

访问注册地址：https://www.huaweicloud.com/intl/zh-cn/
邮箱注册：使用任意邮箱即可注册，无需实名认证
无需手机绑定：注册过程简单快捷，不需要绑定海外手机号

进入 DNS 管理控制台

注册完成后：

登录华为云国际站控制台
在「服务列表」中找到并进入 云解析服务 DNS

🧩 步骤三：在华为云添加子域名解析

📋 3.1 创建公网域名

登录华为云 DNS 控制台
点击「创建公网域名」
输入你的二级域名（如 logo.example.com）

注意：这里只需要添加二级域名，不需要添加主域名（因为主域名仍托管在 Cloudflare）。

⚙️ 3.2 添加关键 DNS 记录（核心步骤）

� 记录一：默认线路（非大陆访问）

用于处理海外用户的访问请求：

类型：CNAME
主机记录：留空（表示直接使用域名）
线路类型：全网默认
解析值：填写 Cloudflare Pages 分配的 xxx.pages.dev

这条记录确保海外用户继续使用 Cloudflare 官方线路访问。

� 记录二：中国大陆线路（国内访问）

用于优化国内用户的访问速度：

类型：CNAME
主机记录：留空
线路类型：地域解析 → 中国大陆
解析值：填写第三方提供的 Cloudflare 优选 IP CNAME
例如：logo.cf.090227.xyz

这条记录是国内加速的核心，所有中国大陆用户的请求都会通过优选 IP 访问你的 Pages 项目。

📝 3.3 记录华为云分配的 NS 服务器

完成域名添加后，华为云会自动为这个子域名分配一组 NS 服务器地址，类似这样：

ns1.huaweicloud-dns.com
ns1.huaweicloud-dns.cn
ns1.huaweicloud-dns.net
ns1.huaweicloud-dns.org

请将这些 NS 地址完整记录下来，后续配置需要使用。

� 步骤四：在 Cloudflare 设置 NS 下沉

🎯 核心操作：将子域名解析权下放给华为云

登录 Cloudflare 控制台，进入「域名管理 → DNS」
点击「添加记录」
配置以下参数：
- 类型：NS
- 名称：输入二级域名的前缀（如 logo）
- 名称服务器：输入华为云分配的 NS 地址
- TTL：保持默认自动
重复上述步骤，添加华为云分配的所有 NS 服务器记录

📌 操作含义

通过 NS 下沉设置，我们将 logo.example.com 这个子域名的 DNS 解析权完全下放给华为云，而主域名 example.com 仍然由 Cloudflare 管理。这样华为云就能根据用户地域智能分配解析结果了。

📊 步骤五：验证优化效果

⏳ 生效时间

配置完成后，DNS 记录一般需要 5-30分钟 生效，具体时间取决于网络环境和 DNS 缓存情况。

🧪 验证方法

你可以通过以下方式验证优化效果：

网络测试工具：使用 itdog、ping.pe 等工具测试域名访问速度
浏览器访问：直接在浏览器中访问优化后的域名
实际应用场景：在播放器中测试台标加载速度
跨网络测试：使用不同网络环境（大陆/非大陆）测试访问效果

✨ 预期效果

优化成功后，你应该能观察到：

✅ 国内访问速度显著提升（通常可提升 30%-70%）
✅ 台标等静态资源加载更快
✅ 海外用户访问不受影响
✅ Pages 项目无需任何代码修改

🎯 方案总结

� 核心优势

通过 Cloudflare Pages + 华为云国际站 + 第三方 CNAME 优选 IP 方案，你可以获得：

🚀 显著的国内访问加速：解决 Cloudflare 国内访问慢的问题
🌍 全球访问优化：海外用户继续享受 Cloudflare 全球 CDN 服务
�️ 零代码修改：无需修改 Pages 项目代码，配置即可生效
🔒 安全稳定：利用华为云国际站的可靠解析服务
💡 低成本高效益：无需额外服务器成本，仅需 DNS 配置

📈 适用场景

这个优化方案特别适合：

🌐 Logo 图库托管
📺 直播源订阅服务
📁 静态资源分发
🌍 全球访问的个人/企业网站

⚠️ 注意事项与经验分享

📌 优选 IP 选择建议

质量优先：优先选择稳定可靠的优选 IP，而非数量
定期更新：优选 IP 可能会失效，建议定期检查和更新
测试验证：使用前先测试优选 IP 的稳定性和速度

�️ 风险控制

优选 IP 失效不会影响海外线路访问
子域名 NS 下沉仅影响单个子域名，不会影响主域名
保持 Cloudflare 主域名配置不变，确保整体稳定性

� 避免常见错误

不要在 Cloudflare 再为同一子域名添加额外的 CNAME 记录
确保华为云的 NS 记录完整添加到 Cloudflare
配置后耐心等待 DNS 记录生效（通常需要 5-30 分钟）

uptime-kuma 搭建教程和美化教程

2026-01-11T16:00:00.000Z

什么是 uptime-kuma？
uptime-kuma 是一个自托管的监控工具，用于监控网站、服务器和其他在线服务的可用性。它提供了直观的 Web 界面，支持多种监控方式，如 HTTP、TCP、Ping、DNS 等，并且可以自定义通知方式。

效果展示

🚀 安装 uptime-kuma

方法一：使用 Docker 安装（推荐）

Docker 安装是最简单和推荐的方式：

# 创建数据目录
mkdir uptime-kuma

# 运行容器
cd uptime-kuma
curl -o compose.yaml https://raw.githubusercontent.com/louislam/uptime-kuma/master/compose.yaml
docker compose up -d

🎨 基础配置

访问 Web 界面：打开浏览器访问 http://服务器IP:3001
创建管理员账户：首次访问需要设置用户名和密码
添加监控项：点击「Add New Monitor」按钮添加需要监控的服务

🌟 美化代码和自定义

自用美化配置代码

飞牛NAS远程访问设置教程

2025-12-22T16:00:00.000Z

前段时间，在一台工作近20年的老笔记本上安装了飞牛NAS系统，跑得速度还挺快，装了1T的硬盘，平时可自动把手机里的照片视频都备份上去，还能远程离线下载电影，非常不错。

如何在外面远程访问家里的NAS，这是个难题。现在找宽带运营商要免费的IPV4基本上是不可能的，但是好在各个宽带运营商都提供了免费的IPV6，关键是如何使用。

一、IPV6查看与检测

1. Windows电脑查看IPV6

如果是Windows电脑，依次点击”控制面板”→”网络和 Internet”→”网络和共享中心”→”更改适配器设置”，找到对应的网卡，点击鼠标右键，选择”状态”，点击”详细信息”，即可查看当前网卡的IPV6地址。

也可以通过cmd的命令行查看，在cmd窗口中输入ipconfig /all，回车

向下滚动，找到对应的网卡，即可看到IPV6地址：

两种方法，我更倾向于使用cmd，因为cmd里面的地址可以直接复制出来。

另外，每个网卡会有2个IPV6地址，其中：FE80开头的比较短，是局域网的IPV6地址，只能在局域网内部使用；24开头的比较长，是外网可用的地址。

2. Linux系统查看IPV6

在shell中输入命令ip -6 addr show即可。

3. 飞牛NAS中查看IPV6

使用手机APP或者是网页登录飞牛NAS，在”系统设置”→”网络设置”中可查看。

4. 判断IPV6能否在外网访问

关闭手机的wifi，然后把飞牛NAS的IPV6复制出来，比如说是：240e:401::691e::a14:**:81b1

打开手机浏览器，在地址栏中输入[240e:401:****:691e:****:a14:****:81b1]，看能否打开网页，即可判断该IPV6能否在外网访问。此处要注意，在浏览器中，IPV6地址要使用[]包裹起来。

如果打不开网页，说明光猫拦截了该外网访问，剩下的就是去光猫中设置。

二、移动光猫开启IPV6

之前使用的是移动的宽带，移动的光猫带有路由器和WIFI功能，所以就没有再购买路由器，直接使用光猫的WIFI。

移动光猫使用管理员用户登录（管理员密码可以找宽带运维工程师要，一般都会给），找到”安全”→”防火墙”，如下图所示，拉到最下面，找到”IPV6防火墙开关”，这个默认是开着的，把它关闭，点击”保存”。

操作完以后，就可以在外网通过IPV6访问家里的设备了。

三、电信光猫开启IPV6

电信的光猫同样带有路由和WIFI功能。

使用电信光猫的普通用户登录（用户名和密码都在光猫背面印着）。

用户名是useradmin，密码是2*。

1. 开启Telnet

找宽带运维工程师要管理员密码（用户名是useradmin），然后使用管理员密码登录光猫后台，网址是192.168.1.1，登录后的界面如下：

登陆后再打开如下网址：

http://192.168.1.1:8080/enableTelnet.html，启用telnet。（一定要先使用管理员密码登录光猫后台）

在这个网页上，能发现Telnet的开关是关着的，把开关打开，然后点击”保存/应用”即可。

2. 连接Telnet，关闭IPV6防火墙

Win10电脑上默认没有安装Telnet，因此需要去下载一下，就几十KB，下载地址：https://xiazai.zol.com.cn/detail/45/446440.shtml

把下载后的exe放在windows目录下，然后，打开cmd窗口，输入：

1	telnet 192.168.1.1

输入用户名telnetadmin，密码2**

然后依次把以下命令粘贴进去即可：

ip6tables -F
ip6tables -P INPUT ACCEPT
ip6tables -P FORWARD ACCEPT
ip6tables -P OUTPUT ACCEPT

以上命令可以关闭ipv6防火墙，但是重启光猫后配置会丢失，只要光猫不重启就可以一直用。

H96MAX系统重装教程

2024-01-16T16:00:00.000Z

🛠️ 系统重装准备工作

准备工具：

准备>=8g的U盘一个(也许不止一个，有些U盘识别不好时请更换U盘试下)
局域网 IP扫描工具
电脑SSH连接服务器工具 SecureCRT | MobaXterm
镜像烧录工具 usbit | Win32磁盘映像工具 | balenaEtcher (推荐使用balenaEtcher)

以上所有文件下载地址: 【软件库 -> 系统重装准备工具】

💿 U盘启动盘镜像下载

两种镜像都可以制作U盘启动盘，与你想要恢复的系统无关，随便选择一个即可
下载文件后，请提前解压出img镜像文件备用

Ubuntu镜像
下载地址: 【软件库 -> U盘启动盘镜像】

📥 下载系统镜像

下载的系统镜像无需解压

下载相对应的系统镜像，下载地址: 【软件库 -> 系统盘镜像】

💽 制作U盘启动盘

使用usbit(USB Image Tool)制作启动盘步骤

如何安装AList系统

2024-01-16T16:00:00.000Z

什么是AList?
一个支持多种存储，支持网页浏览和 WebDAV 的文件列表程序，由 gin 和 Solidjs 驱动。

📥 获取 AList

下载说明

泰山派使用教程

2024-01-16T16:00:00.000Z

如果需要安装docker就得用内核5.0以上的镜像，不需要用docker就用官方给的镜像刷入就可以了

🖥️ 镜像下载

官方刷入链接：点击下载

可用docker镜像：点击下载

📶 连接WiFi并使用ssh连接设备

WiFi相关命令

泰山派使用docker安装Home Assistant经验

2024-01-16T16:00:00.000Z

前置要求
请确保已经完成Docker的安装和配置

🔄 修改Docker镜像源

1	vi /etc/docker/daemon.json

{
    "registry-mirrors": [
        "https://docker.1panelproxy.com",
        "https://docker-proxy.741001.xyz", 
        "https://registry.docker-cn.com"
    ]
}

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": [
    "https://docker.m.daocloud.io",
    "https://docker.1panel.live",
    "https://hub.rat.dev"
  ]
}
EOF

修改后需要重启Docker服务：

1	systemctl restart docker

📦 Home Assistant安装

详细安装步骤

玩客云装宝塔（无需焊接）0基础教程

2024-01-16T16:00:00.000Z

🛠️ 准备工具

USB公对公（没有的可以自己DIY）
金属线一段或镊子
如果你的宽带支持IPV6建议关闭（路由器禁用即可）

最新提示：固件用5.9的（2022-12-18）
刷机工具安装时关闭杀毒软件避免驱动装不上

📥 刷机步骤

详细刷机步骤