使用CF Workers and Pages搭建各种项目（更新中》》》）

今天依旧更新一下关于我们赛博大善人的教程。

首先，Workers是Cloud flare免费提供的一项无服务器部署JavaScript代码到CF的边缘网络上的技术，免费版每天限制100k个请求（10万个），应该是够用了。

准备步骤：一枚CF和Github账号，一个能绑定在CF的域名，一个聪明的大脑，还有你勤劳的小手

一.使用CF Pages搭建Vless节点
第一种方法（较推荐）：

1.使用注册时所用的邮箱和密码登录进面板之后点击左侧侧边栏里的

1.登录进CF仪表盘后，右上角Language更改语言为简体中文后点击右侧的“Workers and Pages”，点击创建

2选Pages，上传资产

3.命名一下，创建项目，把这个包传上去，上传完成后点击部署站点，https://tutt.lanzouh.com/iNuzw227k25e　　无密码

4.点击自定义域，设置一下域名，点击设置，环境变量，在制作那里添加变量

5.变量名称为UUID（大写），值的话可以在这个网站里生成：https://1024tools.com/uuid
默认生成了5个随便找一个复制就好，填进去，保存

6.点击部署，创建新部署，再把那个文件重新传一次就好

7.点击你刚才给Worker绑定的域名，加上/你设置的UUID即可，复制节点配置，添加到V2rayNG里，右键编辑服务器，
地址可以替换，我这里贴两个：www.gov.se，www.visa.com.sg，198.41.221.170，端口为443即可

二.使用Cloudflare和Telegraph搭建图床

1.Fork Telegraph-Image 仓库
访问 Telegraph-Image 仓库地址（https://github.com/cf-pages/Telegraph-Image），fork 到个人仓库：

2.同样点击右侧的“Workers and Pages”，点击创建，选Pages，连接到Git，绑定账号后选择相应仓库开始安装

3.安装完成后同样点击自定义域，设置一下域名，绑定好以后就可以用这个地址访问了，可以测试一下图片上传

4.配置高级点的功能
4-1.开启图片管理后台
Telegraph-Image 的图片管理功能默认是关闭的，我们需要绑定 KV 命名空间才能使用。

首先，依次点击 Workers 和 Pages ， KV ， 创建命名空间，添加一个名为image-hosting的命名空间

然后，依次点击 Workers 和 Pages，你刚才创建的那个Pages，设置，函数，绑定刚刚创建的命名空间image-hosting
变量名称设置为img_url，KV 命名空间设置为image-hosting，回到部署页面重试部署即可

4-2.后台登录验证：
要开启它，需要新增BASIC_USER（管理员登录名称）和BASIC_PASS（登录密码）环境变量，在你自定义的域名后面加上/admin即可访问。

三.使用Workers搭建Google镜像站

1.点击Workers和Pagers，创建，选Worker，创建一个Worker，命名一下，点击部署

２.部署完成后点击编辑代码，删掉原来的代码，粘贴下面的：

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
// 反代目标网站
const upstream = 'ipv6.google.com.hk'
const upstream_v4 = 'www.google.com.hk'

// 访问区域黑名单（按需设置）.
const blocked_region = ['TK']

//资源重定向
const replace_dict = {
  $upstream: '$custom_domain',
  'www.google.com/': 'ｔｕ．ｔｕｊｉ．ｃｌｏｕｄｎｓ．ｂｅ/', //填入你的子域名（你之后要自定义的那个域名，不是CF默认的）
  'gstatic.com': 'gstatic.cn',
  'ajax.googleapis.com': 'ajax.lug.ustc.edu.cn',
  'fonts.googleapis.com': 'fonts.googleapis.cn',
  'themes.googleusercontent.com': 'google-themes.lug.ustc.edu.cn',
  'www.gravatar.com/avatar': 'dn-qiniu-avatar.qbox.me/avatar',
  'www.google.co.jp': '$custom_domain',
  'www.google.com.sg': '$custom_domain',
  'books.google.com.hk': '$custom_domain',
  'books.google.co.jp': '$custom_domain',
  'books.google.com.sg': '$custom_domain',
  'maps.google.com.hk': '$custom_domain',
  'maps.google.co.jp': '$custom_domain',
  'maps.google.com.sg': '$custom_domain',
  'maps.google.com': '$custom_domain',
  'books.google.com': '$custom_domain',
}

addEventListener('fetch', (event) => {
  event.respondWith(fetchAndApply(event.request))
})

async function fetchAndApply(request) {
  const region = request.headers.get('cf-ipcountry').toUpperCase()
//   const ip_address = request.headers.get('cf-connecting-ip')
//   const user_agent = request.headers.get('user-agent')

  let response = null
  let url = new URL(request.url)
  let url_host = url.host

  if (url.protocol == 'http:') {
    url.protocol = 'https:'
    response = Response.redirect(url.href)
    return response
  }

  //检查是否为图片搜索
  var key = url.href
  var ikey1 = 'tbm=isch'
  var ikey2 = '/img'
  if ((key.search(ikey1) == -1) && (key.search(ikey2) == -1)) {
    var upstream_domain = upstream
  } else {
    var upstream_domain = upstream_v4
  }

  url.host = upstream_domain

  if (blocked_region.includes(region)) {
    response = new Response(
      'Access denied: WorkersProxy is not available in your region yet.',
      {
        status: 403,
      }
    )
  } else {
    let method = request.method
    let request_headers = request.headers
    let new_request_headers = new Headers(request_headers)

    new_request_headers.set('Host', upstream_domain)
    new_request_headers.set('Referer', url.href)

    let original_response = await fetch(url.href, {
      method: method,
      headers: new_request_headers,
    })

    let original_response_clone = original_response.clone()
    let original_text = null
    let response_headers = original_response.headers
    let new_response_headers = new Headers(response_headers)
    let status = original_response.status

    new_response_headers.set('cache-control', 'public, max-age=14400')
    new_response_headers.set('access-control-allow-origin', '*')
    new_response_headers.set('access-control-allow-credentials', true)
    new_response_headers.delete('content-security-policy')
    new_response_headers.delete('content-security-policy-report-only')
    new_response_headers.delete('clear-site-data')

    const content_type = new_response_headers.get('content-type')
    if (content_type.includes('text/html') && content_type.includes('UTF-8')) {
      // && content_type.includes('UTF-8')
      original_text = await replace_response_text(
        original_response_clone,
        upstream_domain,
        url_host
      )
    } else {
      original_text = original_response_clone.body
    }

    response = new Response(original_text, {
      status,
      headers: new_response_headers,
    })
  }
  return response
}

async function replace_response_text(response, upstream_domain, host_name) {
  let text = await response.text()

  var i, j
  for (i in replace_dict) {
    j = replace_dict[i]
    if (i == '$upstream') {
      i = upstream_domain
    } else if (i == '$custom_domain') {
      i = host_name
    }

    if (j == '$upstream') {
      j = upstream_domain
    } else if (j == '$custom_domain') {
      j = host_name
    }

    let re = new RegExp(i, 'g')
    text = text.replace(re, j)
  }

  return text
}

注意：记得把 ‘www.google.com/‘: ‘ｔｕ．ｔｕｊｉ．ｃｌｏｕｄｎｓ．ｂｅ/‘, 此处的ｔｕ．ｔｕｊｉ．ｃｌｏｕｄｎｓ．ｂｅ替换为你的子域名（你之后要自定义的那个域名，不是CF默认的）

３.回到设置，触发器，绑定自定义域名，，等待DNS解析生效后即可访问

四．使用Workers镜像Github

1.点击Workers和Pagers，创建，选Worker，创建一个Worker，命名一下，点击部署

２.部署完成后点击编辑代码，删掉原来的代码，粘贴下面的：

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
// 你要镜像的网站.
const upstream = 'github.com'

// 镜像网站的目录，比如你想镜像某个网站的二级目录则填写二级目录的目录名，镜像 google 用不到，默认即可.
const upstream_path = '/'

// 镜像站是否有手机访问专用网址，没有则填一样的.
const upstream_mobile = 'github.com'

// 屏蔽国家和地区.
const blocked_region = ['KP', 'SY', 'PK', 'CU']

// 屏蔽 IP 地址.
const blocked_ip_address = ['0.0.0.0', '127.0.0.1']

// 镜像站是否开启 HTTPS.
const https = true

// 文本替换.
const replace_dict = {'$upstream': '$custom_domain', '//github.com': ''}

// 以下保持默认，不要动
addEventListener('fetch', event => {
  event.respondWith(fetchAndApply(event.request))
})

async function fetchAndApply(request) {
  const region = request.headers.get('cf-ipcountry').toUpperCase()
  const ip_address = request.headers.get('cf-connecting-ip')
  const user_agent = request.headers.get('user-agent')

  let response = null
  let url = new URL(request.url)
  let url_hostname = url.hostname

  if (https == true) {
    url.protocol = 'https:'
  } else {
    url.protocol = 'http:'
  }

  if (await device_status(user_agent)) {
    var upstream_domain = upstream
  } else {
    var upstream_domain = upstream_mobile
  }

  url.host = upstream_domain
  if (url.pathname == '/') {
    url.pathname = upstream_path
  } else {
    url.pathname = upstream_path + url.pathname
  }

  if (blocked_region.includes(region)) {
    response = new Response('Access denied: WorkersProxy is not available in your region yet.', {
      status: 403
    })
  } else if (blocked_ip_address.includes(ip_address)) {
    response = new Response('Access denied: Your IP address is blocked by WorkersProxy.', {
      status: 403
    })
  } else {
    let method = request.method
    let request_headers = request.headers
    let new_request_headers = new Headers(request_headers)

    new_request_headers.set('Host', url.hostname)
    new_request_headers.set('Referer', url.hostname)

    let original_response = await fetch(url.href, {
            method: method,
            headers: new_request_headers
    })

    let original_response_clone = original_response.clone()
    let original_text = null
    let response_headers = original_response.headers
    let new_response_headers = new Headers(response_headers)
    let status = original_response.status

    new_response_headers.set('access-control-allow-origin', '*')
    new_response_headers.set('access-control-allow-credentials', true)
    new_response_headers.delete('content-security-policy')
    new_response_headers.delete('content-security-policy-report-only')
    new_response_headers.delete('clear-site-data')
    
    const content_type = new_response_headers.get('content-type')
    if (content_type.includes('text/html') && content_type.includes('UTF-8')) {
      original_text = await replace_response_text(original_response_clone, upstream_domain, url_hostname)
    } else {
      original_text = original_response_clone.body
    }

    response = new Response(original_text, {
      status,
      headers: new_response_headers
    })
  }
  return response
}

async function replace_response_text(response, upstream_domain, host_name) {
  let text = await response.text()

  var i, j
  for (i in replace_dict) {
    j = replace_dict[i]

    if (i == '$upstream') {
      i = upstream_domain
    } else if (i == '$custom_domain') {
      i = host_name
    }

    if (j == '$upstream') {
      j = upstream_domain
    } else if (j == '$custom_domain') {
      j = host_name
    }

    let re = new RegExp(i, 'g')
    text = text.replace(re, j)
  }
  return text
}

async function device_status(user_agent_info) {
  var agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"]
  var flag = true
  for (var v = 0; v < agents.length; v++) {
    if (user_agent_info.indexOf(agents[v]) > 0) {
      flag = false
      break
    }
  }
  return flag
}

３.回到设置，触发器，绑定自定义域名，，等待DNS解析生效后即可访问
注意！如果是使用CloudNS提供的免费域名，不要用来绑定类似于Github这种有关人家版权的网站，会被封号，整不好你绑在Github镜像站上的域名会被举报认定为是在钓鱼！别问我咋知道的，问就是我自个已经踩过坑了，给你们避个雷

待更新》》》

#CloudFlare,白嫖
使用CF Workers and Pages搭建各种项目（更新中》》》）
http://example.com/2024/06/15/CF Worker搭建各种项目/
作者
图酱的老粉
发布于
2024年6月15日
更新于
2024年8月25日
许可协议