云计算白嫖指南

Github Actions

GitHub 公共仓库托管的运行器，不限制使用时间，Private 仓库限制如下。

免费和专业账户
每月 2,000 分钟免费额度。
Ubuntu 运行器(2核虚拟CPU+7G内存+14G固态)：2,000 分钟。
macOS 运行器(3核虚拟CPU+14G内存+14G固态)：0 分钟。
Windows 运行器(2核虚拟CPU+7G内存+14G固态)：2,000 分钟。

团队账户
每月 3,000 分钟免费额度。
Ubuntu 运行器：3,000 分钟。
macOS 运行器：0 分钟。
Windows 运行器：3,000 分钟。

企业账户
每月 50,000 分钟免费额度。
Ubuntu 运行器：50,000 分钟。
macOS 运行器：50,000 分钟。
Windows 运行器：50,000 分钟。

Gitlab CI

每月免费 CI/CD 400分钟，包括公共和私有仓库，

免费版机器配置：
CPU: 2 核虚拟 CPU
内存: 4 GB
存储: 10 GB

Vercel Community Runtimes

Vercel Community Runtimes 文档

CloudFlare Workers

CloudFlare Workers 个人使用几乎免费，价格详情

支持的语言：

JavaScript 示例源码：点此查看
TypeScript 示例源码：点此查看
Python 示例源码：https://github.com/cloudflare/python-workers-examples
Rust

另外通过 WebAssembly，其他语言如 Rust、C、C++、Go 等也可以被间接支持。这些语言的代码需要编译为 WebAssembly，然后可以被 JavaScript 调用。

反向代理1

可反代一些被墙的站点，实现过墙功能

创建 Worker
worker.js

// @ts-nocheck
// 替换成你想镜像的站点
const upstream = 'linux-command-pi.vercel.app'
 
// 如果那个站点有专门的移动适配站点，否则保持和上面一致
const upstream_mobile = 'linux-command-pi.vercel.app'
 
const blocked_region = ['KP','RU']
 
const blocked_ip_address = ['0.0.0.0', '127.0.0.1']
 
const replace_dict = {
    '$upstream': '$custom_domain',
    '//linux-command-pi.vercel.app': ''
}
 
//以下内容都不用动
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;
    let upstream_domain = null;
 
    if (url.protocol == 'http:') {
        url.protocol = 'https:'
        response = Response.redirect(url.href);
        return response;
    }
 
    if (await device_status(user_agent)) {
        upstream_domain = upstream
    } else {
        upstream_domain = upstream_mobile
    }
 
    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 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', 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('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_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;
}
 
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;
}

自定义域名
worker测试域名被墙，绑定自定义域名才能正常访问，域名要托管在cloudflare，有两种绑定方法

(1).直接绑定
Workers>设置>触发器>自定义域名

(2).通过路由绑定
Workers>设置>触发器>路由
设置A记录，记录值随便填个IP，如2.2.2.2，开机黄色小云朵
然后切换到自定义域名的Workers 路由然后添加关联，Route 填写自定义域名 + /*（如： od.vircloud.net/*），Worker 选择需要自定义域名访问的 Worker
完成后就可以通过自定义的域名（如 https://od.vircloud.net）访问 Worker 服务了。

反向代理2

另一个更强大的反代 worker.js，项目地址

function logError(request, message) {
  console.error(
    `${message}, clientIp: ${request.headers.get(
      "cf-connecting-ip"
    )}, user-agent: ${request.headers.get("user-agent")}, url: ${request.url}`
  );
}

function createNewRequest(request, url, proxyHostname, originHostname) {
  const newRequestHeaders = new Headers(request.headers);
  for (const [key, value] of newRequestHeaders) {
    if (value.includes(originHostname)) {
      newRequestHeaders.set(
        key,
        value.replace(
          new RegExp(`(?<!\\.)\\b${originHostname}\\b`, "g"),
          proxyHostname
        )
      );
    }
  }
  return new Request(url.toString(), {
    method: request.method,
    headers: newRequestHeaders,
    body: request.body,
  });
}

function setResponseHeaders(
  originalResponse,
  proxyHostname,
  originHostname,
  DEBUG
) {
  const newResponseHeaders = new Headers(originalResponse.headers);
  for (const [key, value] of newResponseHeaders) {
    if (value.includes(proxyHostname)) {
      newResponseHeaders.set(
        key,
        value.replace(
          new RegExp(`(?<!\\.)\\b${proxyHostname}\\b`, "g"),
          originHostname
        )
      );
    }
  }
  if (DEBUG) {
    newResponseHeaders.delete("content-security-policy");
  }
  return newResponseHeaders;
}

/**
 * 替换内容
 * @param originalResponse 响应
 * @param proxyHostname 代理地址 hostname
 * @param pathnameRegex 代理地址路径匹配的正则表达式
 * @param originHostname 替换的字符串
 * @returns {Promise<*>}
 */
async function replaceResponseText(
  originalResponse,
  proxyHostname,
  pathnameRegex,
  originHostname
) {
  let text = await originalResponse.text();
  if (pathnameRegex) {
    pathnameRegex = pathnameRegex.replace(/^\^/, "");
    return text.replace(
      new RegExp(`((?<!\\.)\\b${proxyHostname}\\b)(${pathnameRegex})`, "g"),
      `${originHostname}$2`
    );
  } else {
    return text.replace(
      new RegExp(`(?<!\\.)\\b${proxyHostname}\\b`, "g"),
      originHostname
    );
  }
}

async function nginx() {
  return `<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>`;
}

export default {
  async fetch(request, env, ctx) {
    try {
      const {
        PROXY_HOSTNAME = "chatgpt.com", // 代理地址 hostname（必填）
        PROXY_PROTOCOL = "https", // 代理地址协议
        PATHNAME_REGEX,
        UA_WHITELIST_REGEX,
        UA_BLACKLIST_REGEX,
        URL302,
        IP_WHITELIST_REGEX,
        IP_BLACKLIST_REGEX,
        REGION_WHITELIST_REGEX,
        REGION_BLACKLIST_REGEX,
        DEBUG = false,
      } = env;
      const url = new URL(request.url);
      const originHostname = url.hostname;
      if (
        !PROXY_HOSTNAME ||
        (PATHNAME_REGEX && !new RegExp(PATHNAME_REGEX).test(url.pathname)) ||
        (UA_WHITELIST_REGEX &&
          !new RegExp(UA_WHITELIST_REGEX).test(
            request.headers.get("user-agent").toLowerCase()
          )) ||
        (UA_BLACKLIST_REGEX &&
          new RegExp(UA_BLACKLIST_REGEX).test(
            request.headers.get("user-agent").toLowerCase()
          )) ||
        (IP_WHITELIST_REGEX &&
          !new RegExp(IP_WHITELIST_REGEX).test(
            request.headers.get("cf-connecting-ip")
          )) ||
        (IP_BLACKLIST_REGEX &&
          new RegExp(IP_BLACKLIST_REGEX).test(
            request.headers.get("cf-connecting-ip")
          )) ||
        (REGION_WHITELIST_REGEX &&
          !new RegExp(REGION_WHITELIST_REGEX).test(
            request.headers.get("cf-ipcountry")
          )) ||
        (REGION_BLACKLIST_REGEX &&
          new RegExp(REGION_BLACKLIST_REGEX).test(
            request.headers.get("cf-ipcountry")
          ))
      ) {
        logError(request, "Invalid");
        return URL302
          ? Response.redirect(URL302, 302)
          : new Response(await nginx(), {
              headers: {
                "Content-Type": "text/html; charset=utf-8",
              },
            });
      }
      url.host = PROXY_HOSTNAME;
      url.protocol = PROXY_PROTOCOL;
      const newRequest = createNewRequest(
        request,
        url,
        PROXY_HOSTNAME,
        originHostname
      );
      const originalResponse = await fetch(newRequest);
      const newResponseHeaders = setResponseHeaders(
        originalResponse,
        PROXY_HOSTNAME,
        originHostname,
        DEBUG
      );
      const contentType = newResponseHeaders.get("content-type") || "";
      let body;
      if (contentType.includes("text/")) {
        body = await replaceResponseText(
          originalResponse,
          PROXY_HOSTNAME,
          PATHNAME_REGEX,
          originHostname
        );
      } else {
        body = originalResponse.body;
      }
      return new Response(body, {
        status: originalResponse.status,
        headers: newResponseHeaders,
      });
    } catch (error) {
      logError(request, `Fetch error: ${error.message}`);
      return new Response("Internal Server Error", { status: 500 });
    }
  },
};

环境变量

变量名	必填	默认值	示例	备注
PROXY_HOSTNAME	√		github.com	代理地址 hostname
PROXY_PROTOCOL	×	https	https	代理地址协议
PATHNAME_REGEX	×		^/jonssonyan/	代理地址路径正则表达式
UA_WHITELIST_REGEX	×		(curl)	User-Agent 白名单正则表达式
UA_BLACKLIST_REGEX	×		(curl)	User-Agent 黑名单正则表达式
IP_WHITELIST_REGEX	×		(192.168.1)	IP 白名单正则表达式
IP_BLACKLIST_REGEX	×		(192.168.1)	IP 黑名单正则表达式
REGION_WHITELIST_REGEX	×		(JP)	地区白名单正则表达式
REGION_BLACKLIST_REGEX	×		(JP)	地区黑名单正则表达式
URL302	×		https://github.com/jonssonyan/cf-workers-proxy	302 跳转地址
DEBUG	×	false	false	开启调试

镜像仓库加速

将环境变量 PROXY_HOSTNAME 设置为以镜像仓库地址即可

镜像仓库	地址
docker	registry-1.docker.io
k8s-gcr	k8s.gcr.io
k8s	registry.k8s.io
quay	quay.io
gcr	gcr.io
ghcr	ghcr.io
cloudsmith	docker.cloudsmith.io
ecr	public.ecr.aws

设置 Docker 镜像仓库加速
将 https://dockerhub.xxx.com 替换为你的 worker 自定义域名

mkdir -p /etc/docker
cat >/etc/docker/daemon.json <<EOF
{
  "registry-mirrors":["https://dockerhub.xxx.com"]
}
EOF
systemctl daemon-reload
systemctl restart docker

Replit

Repl.it免费给每个用户分配一台 1G 运存的虚拟主机，支持 50 多种语言的一键配置，不限流量，不限时间，主要用途是开发调试以及编程学习，所以 Replit 的应用在一段时间不使用后会自动休眠。

参考：replit 官方教程

类似的平台还有Koyeb、Render、Railway、Heroku、codesandbox

自定义环境

replit.nix

通过replit.nix文件可以安装Nix上可用的任何软件包，单个repl中可以支持任意数量的语言。可以在此处搜索可用软件包的列表。

示例：

{ pkgs }: {
    deps = [
        pkgs.cowsay
    ];
}

填写后 Ctrl + S 保存，即可更新 nix ，非常方便

.replit

.replit是主要的配置文件，其中最基本的是命令。通过.replitrun可以自动运行你设定的命令文件

.replit文件遵循toml配置格式，如下所示：

toml

# 单击“运行”按钮时执行的命令。
run = ["cargo", "run"]

# 编辑器中打开的默认文件。
entrypoint = "src/main.rs"

# 设置环境变量
[env]
FOO="foo"

# 通用软件包管理器的打包程序配置
# 请访问 https://github.com/replit/upm 了解支持的语言。
[packager]
language = "rust"

  [packager.features]
  # 启用包搜索侧栏
  packageSearch = true
  # 启用包自动联想
  guessImports = false

# 单独语言配置，格式: language.<lang name>
[languages.rust]
# 匹配该编程语言文件的 glob 模式（所有以 .rs 结尾的文件都被视为 Rust 文件）
pattern = "**/*.rs"

    # LSP configuration for code intelligence
    [languages.rust.languageServer]
    start = ["rust-analyzer"]

更多配置项参考：官方配置文档

在上面的代码中，每当您点击“run”按钮时，分配到的数组中的字符串都会在 shell 中按顺序执行。

网站保活

由于 Replit 的应用在一段时间不访问后会自动休眠，再次访问需要等一会才能进入程序，可以设置每 30 分种访问一次网站阻止其休眠

通过UptimeRobot对应用地址进行状态监控
使用curl命令配合定时任务
使用git actions定时任务

实例

部署 Alist 网盘（bash）

Alist是一款支持多种存储的目录文件列表程序，能让你或者其他人随时随地访问你的个人储存盘或者云盘。

类似的工具还有Nextcloud、可道云、filebrowser

搭建教程

创建一个 Bash 语言项目
下载最新版本alist-linux-amd64.tar.gz

1	wget https://github.com/Xhofe/alist/releases/latest/download/alist-linux-musl-amd64.tar.gz

解压解压至项目根目录

1	tar xvf alist-linux-musl-amd64.tar.gz

编写main.sh脚本

1 2	chmod +x alist-linux-musl-amd64.tar.gz ./alist-linux-musl-amd64

编写完成后直接点击主页的run即可

远程访问必须绑定域名，测试域名只能在 replit 后台访问

网站保活（每30分钟访问一次网页目录）

路由器等定时任务

1	/30 * * * curl -d '{"path":"/","password":"","page_num":1,"page_size":30}' -H "Content-Type: application/json" -X POST https://pan.pblood.com/api/public/path

Git actions 定时任务

name: cron

on:
  schedule:
    - cron:  '30 * * * *'

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout
        uses: actions/checkout@v3

      - name: 检索 Alist 目录
        run: |
          curl -d '{"path":"/","password":"","page_num":1,"page_size":30}' -H "Content-Type: application/json" -X POST https://pan.pblood.com/api/public/path

部署 Wordpress (PHP)

创建一个 PHP 语言环境（自动生成 PHP 环境默认的.replit配置文件）

1
2
3

run = "php -S 0.0.0.0:8000 -t ."

entrypoint = "index.php"

修改replit.nix文件

{ pkgs }: {
	deps = [
    pkgs.php74
    pkgs.less
    pkgs.wp-cli
	];
}

运行一键脚本，填写配置信息即可

1	bash <(curl -s https://raw.githubusercontent.com/ethanpil/wordpress-on-replit/master/install-wordpress-on-replit.sh)

注意此脚本采用的数据库是WP_SQLite_DB\PDOEngine，数据不稳定，有次我填写了好久的数据居然重置了！