Andy的百宝箱

URL=https://www.aapanel.com/script/install_7.0_en.sh && if [ -f /usr/bin/curl ];then curl -ksSO "$URL" ;else wget --no-check-certificate -O install_7.0_en.sh "$URL";fi;bash install_7.0_en.sh aapanel

5、域名购买

6、Cloudflare

2025年3月29日星期六

2025年搭建Vless+TCP+Reality协议节点教程，使用3X-UI面板！！

2025年3月22日星期六

2025年最新vmess、vless节点搭建教程，使用3x-ui面板，谷歌云GCP机器搭建，开启BBR加速！！

前期准备：

1、一个域名

2、Cloudflare账号

3、一个VPS

4、订阅链接转换

防火墙设置：

1、设置防火墙规则

允许http 和 https流量

点击【创建】

2、入站，出站 0.0.0.0/0

3、获取root权限:

1）回到实例界面，点击SSH

2）在命令行界面输入：sudo -i

4、编辑sshd配置文件：

vim /etc/ssh/sshd_config

输入键盘 i 键，切换成输入模式

把PermitRootLogin 和 PasswordAuthentication 改成yes

之后按ESC建，输入:wq

5、重启sshd服务

service sshd restart

6、为root账户设置密码

passwd

7、关闭对话框，用ssh工具连接

部署步骤（使用谷歌云，Debian12操作系统）：

1、更新软件包

apt update -y && apt install -y curl && apt install -y socat

2、下载3x-ui面板

bash <(curl -Ls https://raw.githubusercontent.com/mhsanaei/3x-ui/master/install.sh)

3、申请证书

4、节点配置

vless-ws(有域名)

Vmess（无域名）

5、开启BBR加速

6、检验BBR加速是否已开启

sysctl net.ipv4.tcp_available_congestion_control

返回中带有bbr即为成功

2025年2月16日星期日

一键搭建多个协议节点教程---甬哥脚本

脚本安装命令：

bash <(wget -qO- https://raw.githubusercontent.com/yonggekkk/sing-box-yg/main/sb.sh)

安装完成后，输入sb可进入管理页面。

安装过程：

1、命令粘贴到VPS中

2、输入1

3、剩余操作可以都用回车，保持默认即可

注意：

如果选择的是CentOS系统，还需要关闭vps防火墙来开放端口，相关命令如下：

查看防火墙状态命令：

firewall-cmd --state

停止firewall命令：

systemctl stop firewalld.service

禁止firewall开机启动命令：

systemctl disable firewalld.service

一键加速脚本教程：点此访问

2025VPS推荐：DCI 鸭一云日本 IIJ 三网优化实例介绍，25刀一年，1T流量/月，1C，0.5G内存，3 次免费更换 IPv4 （月），无限次免费更换 IPv6 （月）

鸭一云注册：点此访问

充值优惠码：760F9FDB210

购买的时候点击这里充值对应价格的余额，使用优惠码

日本 IIJ 三网优化实例-购买链接：点此进入

IIJ 是代表一种对中国大陆三网优化的线路，其延迟，速度十分出色。

实例优点：

1. 可以每个月换IPv4(对于累计充值不满20USD的是每月1次)(对于累计充值满20USD的是每月5次）

2. 这是IIJ优化线路小鸡，对于移动和电信非常友好，联通一般

3. 机器稳定

4. 支持流媒体DNS解锁(免费)

「DNS解锁地址」

HK: 154.83.83.84

JP: 154.83.83.85

TW: 154.83.83.86

SG: 154.83.83.87

US: 154.83.83.88

UK: 154.83.83.89

DE: 154.83.83.90

默认可使用154.83.83.83

如需更改为其他地区的Netflix/Disney等可选择其他DNS

「关闭IPv6」

sudo sysctl -w net.ipv6.conf.all.disable_ipv6=1

sudo sysctl -w net.ipv6.conf.default.disable_ipv6=1

「检查解锁情况」（仅供参考）

wget -O dns_check.sh https://github.com/1-stream/RegionRestrictionCheck/raw/main/check.sh && bash dns_check.sh -M 4

任何问题让他们加入群组 @DuckyGroup，支持人员是 @DCISupportBot

2025年1月29日星期三

使用AutoDL算力云，低成本租用4090显卡，部署高参数量DeepSeek模型，并利用Ollama，达到低成本本地使用DeepSeek模型的目的！

核心：在本地和远程服务器之间建立一个安全的隧道，实现端口转发

autoDL官网

需要用到的命令：

#建立隧道

ssh -CNg -L 11434:127.0.0.1:11434 root@【audodl机器IP】 -p 【autodl ssh端口】

#linux安装ollama

curl -fsSL https://ollama.com/install.sh | sh

注意事项：

1、autoDL的机器在下载ollama的时候，会有warning，需要解决

apt update #更新安装源

apt install pciutils lshw #确保GPU支持

2、手动启动Ollama

ollama serve

或者让它在后台运行：

ollama serve &

3、隧道建立后，手动修改应用到的模型

2025最简单本地部署使用DeepSeek-R1模型教程，支持命令行、浏览器插件使用，支持与图片对话！！

Ollma官网：访问

浏览器插件：下载界面

下载并载入模型：

DeepSeek-R1-Distill-Qwen-1.5B

ollama run deepseek-r1:1.5b

DeepSeek-R1-Distill-Qwen-7B

ollama run deepseek-r1:7b

DeepSeek-R1-Distill-Llama-8B

ollama run deepseek-r1:8b

DeepSeek-R1-Distill-Qwen-14B

ollama run deepseek-r1:14b

DeepSeek-R1-Distill-Qwen-32B

ollama run deepseek-r1:32b

DeepSeek-R1-Distill-Llama-70B

ollama run deepseek-r1:70b

2024年9月7日星期六

使用AutoDL算力云低成本使用4090显卡！部署LangChain-Chatchat 0.3.x项目，按量付费2元一小时，无需科学上网本地使用大模型智能对话！构建本地知识库！媲美ChatGPT！

chatchat项目地址：访问

AutoDL地址：访问

部署文档和必要的包：下载

2024年8月31日星期六

使用CloudFlare Worker 搭建永久免费的节点订阅链接！！晚高峰4K无压力，解锁流媒体，解锁ChatGPT！！永久免费VPN、永久免费科学上网！！

项目地址：大佬项目地址

注册CloudFlare

2024年8月17日星期六

HiN VPN: 永久免费的多协议订阅链接，完全免费科学上网、VPN，部分节点支持4k、8k视频，大部分支持解锁流媒体、与ChatGPT，免费翻墙！！

网站地址：

https://itsyebekhe.github.io/HiN-VPN/

2024年5月5日星期日

永久免费翻墙，永久免费节点，使用Cloudflare Worker 搭建免费Trojan协议节点！

大佬项目：https://github.com/ca110us/epeius

worker.js

// src/worker.js
import { connect } from "cloudflare:sockets";
const proxyIPs = ['cdn.xn--b6gac.eu.org', 'cdn-all.xn--b6gac.eu.org', 'workers.cloudflare.cyou'];
let proxyIP = proxyIPs[Math.floor(Math.random() * proxyIPs.length)];
let sha224Password = 'xxxx';
const worker_default = {
/**
* @param {import("@cloudflare/workers-types").Request} request
* @param {{UUID: string, PROXYIP: string}} env
* @param {import("@cloudflare/workers-types").ExecutionContext} ctx
* @returns {Promise<Response>}
*/
async fetch(request, env, ctx) {
try {
proxyIP = env.PROXYIP || proxyIP;
const upgradeHeader = request.headers.get("Upgrade");
if (!upgradeHeader || upgradeHeader !== "websocket") {
const url = new URL(request.url);
switch (url.pathname) {
case "/link":
const host = request.headers.get('Host');
return new Response(`trojan://ca110us@${host}:443/?type=ws&host=${host}&security=tls`, {
status: 200,
headers: {
"Content-Type": "text/plain;charset=utf-8",
}
});
default:
return new Response("404 Not found", { status: 404 });
}
} else {
return await trojanOverWSHandler(request);
}
} catch (err) {
let e = err;
return new Response(e.toString());
}
}
};
async function trojanOverWSHandler(request) {
const webSocketPair = new WebSocketPair();
const [client, webSocket] = Object.values(webSocketPair);
webSocket.accept();
let address = "";
let portWithRandomLog = "";
const log = (info, event) => {
console.log(`[${address}:${portWithRandomLog}] ${info}`, event || "");
};
const earlyDataHeader = request.headers.get("sec-websocket-protocol") || "";
const readableWebSocketStream = makeReadableWebSocketStream(webSocket, earlyDataHeader, log);
let remoteSocketWapper = {
value: null
};
let udpStreamWrite = null;
readableWebSocketStream.pipeTo(new WritableStream({
async write(chunk, controller) {
if (udpStreamWrite) {
return udpStreamWrite(chunk);
}
if (remoteSocketWapper.value) {
const writer = remoteSocketWapper.value.writable.getWriter();
await writer.write(chunk);
writer.releaseLock();
return;
}
const {
hasError,
message,
portRemote = 443,
addressRemote = "",
rawClientData
} = await parseTrojanHeader(chunk);
address = addressRemote;
portWithRandomLog = `${portRemote}--${Math.random()} tcp`;
if (hasError) {
throw new Error(message);
return;
}
handleTCPOutBound(remoteSocketWapper, addressRemote, portRemote, rawClientData, webSocket, log);
},
close() {
log(`readableWebSocketStream is closed`);
},
abort(reason) {
log(`readableWebSocketStream is aborted`, JSON.stringify(reason));
}
})).catch((err) => {
log("readableWebSocketStream pipeTo error", err);
});
return new Response(null, {
status: 101,
// @ts-ignore
webSocket: client
});
}
async function parseTrojanHeader(buffer) {
if (buffer.byteLength < 56) {
return {
hasError: true,
message: "invalid data"
};
}
let crLfIndex = 56;
if (new Uint8Array(buffer.slice(56, 57))[0] !== 0x0d || new Uint8Array(buffer.slice(57, 58))[0] !== 0x0a) {
return {
hasError: true,
message: "invalid header format (missing CR LF)"
};
}
const password = new TextDecoder().decode(buffer.slice(0, crLfIndex));
if (password !== sha224Password) {
return {
hasError: true,
message: "invalid password"
};
}
const socks5DataBuffer = buffer.slice(crLfIndex + 2);
if (socks5DataBuffer.byteLength < 6) {
return {
hasError: true,
message: "invalid SOCKS5 request data"
};
}
const view = new DataView(socks5DataBuffer);
const cmd = view.getUint8(0);
if (cmd !== 1) {
return {
hasError: true,
message: "unsupported command, only TCP (CONNECT) is allowed"
};
}
const atype = view.getUint8(1);
// 0x01: IPv4 address
// 0x03: Domain name
// 0x04: IPv6 address
let addressLength = 0;
let addressIndex = 2;
let address = "";
switch (atype) {
case 1:
addressLength = 4;
address = new Uint8Array(
socks5DataBuffer.slice(addressIndex, addressIndex + addressLength)
).join(".");
break;
case 3:
addressLength = new Uint8Array(
socks5DataBuffer.slice(addressIndex, addressIndex + 1)
)[0];
addressIndex += 1;
address = new TextDecoder().decode(
socks5DataBuffer.slice(addressIndex, addressIndex + addressLength)
);
break;
case 4:
addressLength = 16;
const dataView = new DataView(socks5DataBuffer.slice(addressIndex, addressIndex + addressLength));
const ipv6 = [];
for (let i = 0; i < 8; i++) {
ipv6.push(dataView.getUint16(i * 2).toString(16));
}
address = ipv6.join(":");
break;
default:
return {
hasError: true,
message: `invalid addressType is ${atype}`
};
}
if (!address) {
return {
hasError: true,
message: `address is empty, addressType is ${atype}`
};
}
const portIndex = addressIndex + addressLength;
const portBuffer = socks5DataBuffer.slice(portIndex, portIndex + 2);
const portRemote = new DataView(portBuffer).getUint16(0);
return {
hasError: false,
addressRemote: address,
portRemote,
rawClientData: socks5DataBuffer.slice(portIndex + 4)
};
}
async function handleTCPOutBound(remoteSocket, addressRemote, portRemote, rawClientData, webSocket, log) {
async function connectAndWrite(address, port) {
const tcpSocket2 = connect({
hostname: address,
port
});
remoteSocket.value = tcpSocket2;
log(`connected to ${address}:${port}`);
const writer = tcpSocket2.writable.getWriter();
await writer.write(rawClientData);
writer.releaseLock();
return tcpSocket2;
}
async function retry() {
const tcpSocket2 = await connectAndWrite(proxyIP || addressRemote, portRemote);
tcpSocket2.closed.catch((error) => {
console.log("retry tcpSocket closed error", error);
}).finally(() => {
safeCloseWebSocket(webSocket);
});
remoteSocketToWS(tcpSocket2, webSocket, null, log);
}
const tcpSocket = await connectAndWrite(addressRemote, portRemote);
remoteSocketToWS(tcpSocket, webSocket, retry, log);
}
function makeReadableWebSocketStream(webSocketServer, earlyDataHeader, log) {
let readableStreamCancel = false;
const stream = new ReadableStream({
start(controller) {
webSocketServer.addEventListener("message", (event) => {
if (readableStreamCancel) {
return;
}
const message = event.data;
controller.enqueue(message);
});
webSocketServer.addEventListener("close", () => {
safeCloseWebSocket(webSocketServer);
if (readableStreamCancel) {
return;
}
controller.close();
});
webSocketServer.addEventListener("error", (err) => {
log("webSocketServer error");
controller.error(err);
});
const { earlyData, error } = base64ToArrayBuffer(earlyDataHeader);
if (error) {
controller.error(error);
} else if (earlyData) {
controller.enqueue(earlyData);
}
},
pull(controller) {},
cancel(reason) {
if (readableStreamCancel) {
return;
}
log(`readableStream was canceled, due to ${reason}`);
readableStreamCancel = true;
safeCloseWebSocket(webSocketServer);
}
});
return stream;
}
async function remoteSocketToWS(remoteSocket, webSocket, retry, log) {
let hasIncomingData = false;
await remoteSocket.readable.pipeTo(
new WritableStream({
start() {},
/**
*
* @param {Uint8Array} chunk
* @param {*} controller
*/
async write(chunk, controller) {
hasIncomingData = true;
if (webSocket.readyState !== WS_READY_STATE_OPEN) {
controller.error(
"webSocket connection is not open"
);
}
webSocket.send(chunk);
},
close() {
log(`remoteSocket.readable is closed, hasIncomingData: ${hasIncomingData}`);
},
abort(reason) {
console.error("remoteSocket.readable abort", reason);
}
})
).catch((error) => {
console.error(
`remoteSocketToWS error:`,
error.stack || error
);
safeCloseWebSocket(webSocket);
});
if (hasIncomingData === false && retry) {
log(`retry`);
retry();
}
}
function base64ToArrayBuffer(base64Str) {
if (!base64Str) {
return { error: null };
}
try {
base64Str = base64Str.replace(/-/g, "+").replace(/_/g, "/");
const decode = atob(base64Str);
const arryBuffer = Uint8Array.from(decode, (c) => c.charCodeAt(0));
return { earlyData: arryBuffer.buffer, error: null };
} catch (error) {
return { error };
}
}
let WS_READY_STATE_OPEN = 1;
let WS_READY_STATE_CLOSING = 2;
function safeCloseWebSocket(socket) {
try {
if (socket.readyState === WS_READY_STATE_OPEN || socket.readyState === WS_READY_STATE_CLOSING) {
socket.close();
}
} catch (error) {
console.error("safeCloseWebSocket error", error);
}
}
export {
worker_default as
default
};
//# sourceMappingURL=worker.js.map

订阅：评论 (Atom)

VPS和VPN和机场

2026年1月9日星期五

2025年4月21日星期一

2025年4月13日星期日