Ling的博客

AI创作与人类创作

Tue, 06 May 2025 11:24:03 +0800

Ling的博客 https://blog.lty520.faith/%E9%9A%8F%E8%AE%B0/ai%E5%88%9B%E4%BD%9C%E4%B8%8E%E4%BA%BA%E7%B1%BB%E5%88%9B%E4%BD%9C/ -

从Chatgpt爆火到处都在讨论，到在自己电脑上用Stable Diffusion跑头像，再到Cursor编程，自己大学还没毕业似乎程序员就要毕业了。看着周围人对于AI的不同态度：全面拥抱、完全鄙视、随大流…
整理了一下自己的观点，利用五一假期写了这篇博客，与（少之又少的看我博客的）各位分享一下。

历史

2017 年 5 月 27 日，AlphaGo 战胜了人类最强围棋手，2022 年 11 月 30 日 Openai 推出 Chatgpt，大众第一次广泛地与如此强大的人工智能进行深度对话；2022 年 8 月 Stability AI 发布 Stable Diffusion，大众第一次广泛接触了高质量的AI绘画；2024 年 3 月 21 日 Suno AI 推出 Suno V3，大众第一次接触到了由人工智能轻松创作的完整音乐…
截止到 2025 年 05 月 04 日，LLM 在 MMLU 等热门基准测试上的准确率已超过 90%，在“人类的最后考试”中最强的 Openai O3 也达到了 20.3%的准确率和 34.0%的置信度。在“动脑子”的领域，AI 已经离人类越来越近，并且在部分领域开始超越了。AI 给人类打下手的幻想似乎变成了人类给 AI 打下手。

争议

AI 技术自诞生以来就伴随着大量的争议，比如 Chatgpt 大量爬取网站内容、大量下载盗版书籍；Stable Diffusion 的训练数据（如 LAION 数据集）包含了大量未经授权的插画作品以及部分用户使用指定的插画师的作品（只需几十张乃至十几张即可）来训练模型模仿特定画师的画风；Suno 遭受全球三大唱片公司联手起诉，指控其非法使用版权音乐训练模型并提供服务，涉嫌抄袭数千首歌曲。
总结来说就是：

训练时使用了盗版内容。
可以轻松模拟特定的作品（例如鲁迅的文风）。
产出的作品可能会和训练的作品相似而构成“抄袭”。

这三个问题在人类学习的时候就会遇到，但显然人类早已达成了共识：

学习、练习的时候能找到的素材可以随便拿来练，临摹就是练习最重要的一部分。
模仿文风、画风虽然一般只能进行道德上的谴责，不会也无法追究法律责任，但负责任的平台或厂商通常会设立规范，限制对特定在世艺术家风格的直接、恶意模仿，并避免在其产品或服务中直接使用明显侵权或引发争议的内容。这在一定程度上抑制了过于刻意的模仿在市场上的泛滥。
在最终创作时，成熟的创作者会有意识地避免与知名作品过于雷同，并可能借助工具（如论文的查重系统）来确保原创性。

AI 学习的太多太快

但是在 AI 到来之后，就出现了问题。
人类一辈子最多可能也就能看约 8GB 的文本。这在人类看来已经非常之多了，但相比世界上所有的书籍来说，依然少之又少。所以对于人类来说，阅读别人的作品来学习或给自己的作品提供灵感并无问题，毕竟世界上的作品一辈子也看不完。
GPT3 使用了 4000 亿 Token 训练（约 570GB），Deepseek V3 使用了 14.8 万亿 tokens 的预训练。Llama 3.1 用了 15 万亿 tokens，Qwen 2.5 使用了 18 万亿 token，Gemma 3 1B 都使用了 2 万亿个词元进行训练；Stable Diffusion 所使用的 LAION-5B 数据集更是包括了 58.5 亿个图像文本对。
相比于人类只能阅读少量的知名作品和自己感兴趣的作品（并且绝大部分只是泛读，极少部分才会精读多遍），AI 可以读遍从古至今人类所产出的所有知识，直接击碎了人们千百年来“默许”的“临摹”、“借鉴”、“参考”、“超越”的学习方式，因为 AI 真的读的太多了，学的太快了。

所有人都是从“抄袭”开始学习，AI 也是，只是 AI 学的太快了。

8GB 是按每分钟读 300 字，每天 10 小时，阅读 50 年计算，共 300×60×10×365×50 = 3,285,000,000 字（约 33 亿），按每个汉字约占 2.5 字节计算，合计约 7.65GB。

当前的法律与规范尝试

截止到 2025 年，各国目前正尝试通过援引各自著作权法中的合理使用或特定权利限制条款，来处理 AI 训练数据是否构成侵权的诉讼，但相关法律的适用标准和最终态度仍在探索或等待判例明确，尚未形成统一结论。
虽然各国已有的判例也各不相同，但不难看出一种普遍的倾向：既要对AI训练数据的版权问题进行规范，又担心过度限制会扼杀技术创新与发展——毕竟，人类自身的学习和创作过程也充满了对前人成果的借鉴与吸收。

笔者认为由官方整理出一批公开免授权的数据集供所有人训练、使用，并且立法要求所有 AI 生成的内容附带标识和水印，或许是比较合理的解决方案，但是法律毕竟是滞后于社会的，在法律还不够完善的当下，版权引起的争议还会持续很久。

AI 生成作品的“灵魂”

首先，一个作品本身只是不同字符、像素、声音的排列组合（或者说是 0 和 1 的排列组合），其本身当然是没有灵魂的。那么灵魂从哪儿来呢？显然是从创作者而来。是创作者在创作的过程中，倾注了自己的心血，做出了自己想要的东西，作品才拥有了灵魂。
那么严格依照甲方和上级的要求，修改了几十次完成的“作品”有没有灵魂呢？996 乃至 007 通宵达旦应付上的作品，有没有灵魂呢？自己作为专业人士明知道 A 方案更好，却不得不按照甲方这个外行人士的要求修改为更差的 B 方案后完成的作品，有没有灵魂呢？
我想是没有的。因为这些作品不是创作者自己想要创作的，仅仅是生活所迫而不得不完成；作品想表达的内涵也不是创作者自己心中所想的，仅仅是扮演了“画笔”和“乐器”，忠诚的完成了甲方的作品。

所以，AI 生成的作品，有“灵魂”吗？

我认为，这取决于人类在创作过程中的角色和意图。如果一个人带着清晰的构想和强烈的表达欲，将AI作为一种实现想法的工具（如同延伸了他的双手和思想），通过反复的提示、筛选、修改，主导了创作过程，最终生成的作品体现了他的心中所想，那么，即使借助了AI，这个作品也可以说被赋予了人的“灵魂”，这里的AI和画笔、乐器没有区别。
反之，如果作品仅仅是AI基于简单指令或自动化流程批量生产的产物，缺乏“创作者”自己的意图和情感的注入，那么它更像是一种技术性的工业产品，很难说拥有我们通常意义上所理解的“灵魂”。

AI 生成作品的“创新”

AI的“创新”一直是一个被很多人提到的问题，其中一种最常见的质疑是将AI绘画贬称为“尸块拼接”。
首先，从技术层面来看，这种比喻并不准确。无论是AI绘画常用的扩散模型（diffusion model），还是大语言模型（LLM）所依赖的Transformer架构，它们的核心机制并非简单地从数据库里抓取图像或文本片段进行拼凑（比如这张图里拿一只脚，从那张图里拿一个头，最后拼起来）。它们的本质是在海量数据中学习像素之间、或文本单元（Token）之间的统计规律与复杂关系，并基于这些学习到的模式总结出规律来生成全新的内容。这个过程更像是学习一种风格或模式，而非直接复制粘贴。
其次，对比之下，人类创作中的“绝对原创”也并非我们想象的那么普遍。
如果“创新”仅指那种“前无古人后无来者”的绝对独创，那么纵观历史，真正能达到此标准的也寥寥无几。大多数人类创作者的工作，是在前人成果基础上的改进、元素的重新组合、跨领域知识的迁移与应用——这些本身就是一种重要的创新形式。
从这个角度看，目前AI所展现出的能力，例如对现有风格的模仿、融合，以及在庞大数据模式中发现新的组合方式，与人类这种渐进式创新的过程表现出一定的相似性。AI通过学习、组合、随机，有时也能生成出乎意料、带来启发性的结果。再者，对于文学创作和艺术创作领域，有多少创作者敢断言自己创作的作品中没有前人的一丁点蛛丝马迹呢？那些可能在十几、几十年前无意中接触过的作品，早已沉淀在潜意识里，创作时其元素或风格可能在不经意间就融入了自己的作品。这并非需要苛责的“抄袭”，而是创作过程中普遍存在的现象。
事实上，深受前人影响并在此基础上进行演变和创造，是人类文明发展的常态，贯穿了数千年的艺术、文学与科技史。

结论

有多少“作家”、“画家”、“程序员”，在工作中是真的认为自己在创作一个伟大的作品呢？少之又少。绝大部分只是在完成工作，完成上级安排的任务，完成甲方的要求，机械性的给一个又一个不知道哪儿来的bug打补丁，本质上和建筑工人、司机没有区别。
而 AI 也将取代这些重复性的工作，这对于市场来说是好事，因为可以降低人工成本，并且 AI 不会有怨气，AI 会忠诚的完成指示，并且在制作了十几版方案“心平气和”的用回第一版方案。
影响最大的是谁呢？必然是原本的一线工作者（包括但不限于作家、画师、程序员）。但是这是无法改变也无法阻拦的，这就像是产业革命，会提高生产力，在未来提供更多的就业岗位和机会，但是必然会带来变革和痛苦。
如果一直局限于“AI 怎么抢了我的工作？”、“我要和 AI 卷”…就必然会在新的生产关系中被淘汰。
将工作和爱好分开，AI 只会取代你的工作，不可能取代你的爱好。有了打印机，依然有人喜欢书法；有了电子音乐，依然有人喜欢钢琴、吉他；有了汽车，依然有人喜欢骑马。积极使用 AI、拥抱 AI，挺过 AI 爆发的初期，AI 就会像蒸汽机和电力之于工业革命那样，给社会带来新的动力。

参考文章

- https://blog.lty520.faith/%E9%9A%8F%E8%AE%B0/ai%E5%88%9B%E4%BD%9C%E4%B8%8E%E4%BA%BA%E7%B1%BB%E5%88%9B%E4%BD%9C/ -

友链

Tue, 23 Apr 2024 21:29:06 +0800

Ling的博客 https://blog.lty520.faith/%E5%8F%8B%E9%93%BE/ -

认识的大佬们：
感谢大佬们的帮助OTZ

- https://blog.lty520.faith/%E5%8F%8B%E9%93%BE/ -

自建Docker Hub加速镜像

Tue, 16 Apr 2024 20:21:05 +0800

Ling的博客 https://blog.lty520.faith/%E5%8D%9A%E6%96%87/%E8%87%AA%E5%BB%BAdocker-hub%E5%8A%A0%E9%80%9F%E9%95%9C%E5%83%8F/ -

更新日志

2024 年 09 月 12 日
auth.docker.io 被墙，增加反代 auth.docker.io 的配置
官方的镜像仓库无论是否登录，都会要求认证，而当我们使用反代了官方仓库的镜像源拉取镜像时，官方仓库会首先返回一个 401 Unauthorized 响应，并附带一个 WWW-Authenticate 头，其中包含了获取认证所需的服务地址和授权范围（scope）。而这个“获取认证所需的服务地址”默认是 auth.docker.io。但是这个域名今天已经被封禁了，进而影响了我们拉取镜像。
在经过测试后发现可以通过重写这一 WWW-Authenticate 头，将认证请求导向我们自己的反代，交由反代服务器去访问 auth.docker.io，这样就规避了对 auth.docker.io 的封禁。

可选的加速方案

使用公共的加速镜像国内的 Docker Hub 镜像加速器，由国内教育机构与各大云服务商提供的镜像加速服务
- 速度通常不错，但由于 Docker hub 限制了未注册用户的拉取频率，可能会导致加速镜像无法及时同步最新的镜像（例如阿里云镜像源）
- 由于很高的成本，可能会导致一些原本提供了镜像源的厂商、机构停止提供（如 163、七牛云等）或转向仅为内网内的设备和用户提供服务（如腾讯云、中国科学技术大学开源软件镜像等）
使用代理拉取镜像如何配置 docker 通过代理服务器拉取镜像。简单来说就是通过设置由 systemd 管理的 docker daemon 的环境变量来实现利用代理拉取镜像
- 优点自然就是带宽几乎没有限制，并且镜像不会缓存，不会下载到未更新的镜像
- 缺点是需要设备上或局域网内有现成的代理且一些特殊设备（例如威联通、群晖）经过了厂商魔改难以手动设置环境变量，没有加速镜像的通用型强，需要每个设备单独设置
间接拉取镜像。在境外机器已经配置了代理的设备上拉取镜像，再将镜像导出、传输到需要使用镜像的设备上、最后导入。
- 优点…能用
- 缺点自然就是很麻烦，需要提前准备好传输文件的方案

最后整合上面我使用过的几个拉取镜像的方案，最后的选择是自建一个加速镜像，免得以后的到处找能用的加速镜像源

自建加速镜像

在尝试搭建之前找了挺多资料，主流的方式有：使用官方提供的 registry，第三方的 Nexus、Harbor。但是使用 registry 搭建一直没有成功，客户端一直报找不到指定镜像；使用 Nexus 搭建又有些太复杂。最后自己总结出来了这两个比较方便的方案。

一点小发现：
在使用 Nginx 搭建时，发现服务器的流量很小，经过检查 Nginx 的日志后发现，Docker hub 镜像仓库返回的下载地址是需要 307 跳转的，而跳转后的地址直连依然下载很慢，所以需要在服务端处理这个跳转，由服务端请求并将跳转后的数据返回客户端。

方案一：使用 Nginx 搭建

系统：Ububtu 22.04 服务器：Zgocloud 洛杉矶 9929+CMIN2
提到要加速一个网站，自然就能想到使用 Nginx 反代一下了。接下来是具体的配置方案

安装 Nginx
```
sudo apt update
sudo apt install nginx
```
防火墙放行指定端口
我这里使用的防火墙是系统自带的 UFW，并且没有开厂商提供的防火墙（忘记是关掉了还是本来就没有，反正没开），所以只需要 sudo ufw allow ‘Nginx Full’ 一条命令即可，这样就会放行 IPv4 和 IPv6 的 80 和 443 端口（当然也可以手动 sudo ufw allow 443 这样只开放 443 端口）
如果没有使用防火墙，就不用设置这一步，如果还使用了厂商提供的防火墙，就需要在厂商的面板处同样开放这些端口

配置 Nginx 使用命令 sudo vim /etc/nginx/nginx.conf 编辑 Nginx 配置，在 http 块下增加一个 server 块

/etc/nginx/nginx.conf

#反代docker hub镜像源
     server {
             listen 443 ssl;
             server_name 域名;

             ssl_certificate 证书地址;
             ssl_certificate_key 密钥地址;

             ssl_session_timeout 24h;
             ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256';
             ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;

             location /v2/ {
                     proxy_pass https://registry-1.docker.io;  # Docker Hub 的官方镜像仓库
                     proxy_set_header Host registry-1.docker.io;
                     proxy_set_header X-Real-IP $remote_addr;
                     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                     proxy_set_header X-Forwarded-Proto $scheme;

                     # 关闭缓存
                     proxy_buffering off;

                     # 转发认证相关的头部
                     proxy_set_header Authorization $http_authorization;
                     proxy_pass_header  Authorization;

                     # 重写 www-authenticate 头为你的反代地址
                     proxy_hide_header www-authenticate;
                     add_header www-authenticate 'Bearer realm="https://域名/token",service="registry.docker.io"' always;
                     # always 参数确保该头部在返回 401 错误时无论什么情况下都会被添加。

                     # 对 upstream 状态码检查，实现 error_page 错误重定向
                     proxy_intercept_errors on;
                     # error_page 指令默认只检查了第一次后端返回的状态码，开启后可以跟随多次重定向。
                     recursive_error_pages on;
                     # 根据状态码执行对应操作，以下为301、302、307状态码都会触发
                     error_page 301 302 307 = @handle_redirect;

             }
             # 处理 Docker OAuth2 Token 认证请求
             location /token {
                 resolver 1.1.1.1 valid=600s;
                 proxy_pass https://auth.docker.io;  # Docker 认证服务器

                 # 设置请求头，确保转发正确
                 proxy_set_header Host auth.docker.io;
                 proxy_set_header X-Real-IP $remote_addr;
                 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                 proxy_set_header X-Forwarded-Proto $scheme;

                 # 传递 Authorization 头信息，获取 Token
                 proxy_set_header Authorization $http_authorization;
                 proxy_pass_header Authorization;

                 # 禁用缓存
                 proxy_buffering off;
             }
             location @handle_redirect {
                     resolver 1.1.1.1;
                     set $saved_redirect_location '$upstream_http_location';
                     proxy_pass $saved_redirect_location;
             }
     }

然后按 Esc ，输入 : wq 保存退出即可

重新加载 Nginx 配置输入命令 sudo nginx -s reload，没有报错就说明配置已经生效

方案二：使用 CloudFlare Worker 搭建

作为一个贫穷（doge）的用户，可以免费使用的 CloudFlare Worker 自然要想方设法的用用了，虽然 CloudFlare Worker 的访问速度在国内也不算稳定，但在 CloudFlare 的边缘网络的加持下，白天的速度还是非常可观的，晚上会比较慢但还是比直接使用官方的镜像源要快上很多（又不要钱，要啥自行车.jpg）

这里是使用的基于 Cloudflare Worker 的容器镜像加速器，更详细的教程可以参考 2024 自建 Docker 镜像代理加速教程来了 3 分钟部署完毕

简单教程：

在面板左侧找到 Workers 和 Pages，然后点击右侧的 创建应用程序、创建 Worker，修改一个好记的名字，部署

接下来编辑代码，将 worker.js 的内容替换为下面内容，并且修改 工作服务器地址 为一个 dns 托管在 cloudflare 的域名，例如 let workers_url = ‘https://lty520.faith/';

worker.js

 // _worker.js

 // Docker镜像仓库主机地址
 let hub_host = 'registry-1.docker.io';
 // Docker认证服务器地址
 const auth_url = 'https://auth.docker.io';
 // 自定义的工作服务器地址
 let workers_url = 'https://xxx/';

 let 屏蔽爬虫UA = ['netcraft'];

 // 根据主机名选择对应的上游地址
 function routeByHosts(host) {
     // 定义路由表
     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 ];
     else return [ hub_host, true ];
 }

 /** @type {RequestInit} */
 const PREFLIGHT_INIT = {
     // 预检请求配置
     headers: new Headers({
         'access-control-allow-origin': '*', // 允许所有来源
         'access-control-allow-methods': 'GET,POST,PUT,PATCH,TRACE,DELETE,HEAD,OPTIONS', // 允许的HTTP方法
         'access-control-max-age': '1728000', // 预检请求的缓存时间
     }),
 }

 /**
 * 构造响应
 * @param {any} body 响应体
 * @param {number} status 响应状态码
 * @param {Object<string, string>} headers 响应头
 */
 function makeRes(body, status = 200, headers = {}) {
     headers['access-control-allow-origin'] = '*' // 允许所有来源
     return new Response(body, { status, headers }) // 返回新构造的响应
 }

 /**
 * 构造新的URL对象
 * @param {string} urlStr URL字符串
 */
 function newUrl(urlStr) {
     try {
         return new URL(urlStr) // 尝试构造新的URL对象
     } catch (err) {
         return null // 构造失败返回null
     }
 }

 function isUUID(uuid) {
     // 定义一个正则表达式来匹配 UUID 格式
     const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

     // 使用正则表达式测试 UUID 字符串
     return uuidRegex.test(uuid);
 }

 async function nginx() {
     const text = `
     <!DOCTYPE html>
     <html>
     <head>
     <title>Welcome to nginx!</title>
     <style>
         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>
     `
     return text;
 }

 async function searchInterface() {
     const text = `
     <!DOCTYPE html>
     <html>
     <head>
         <title>Docker Hub Search</title>
         <style>
         body {
             font-family: Arial, sans-serif;
             display: flex;
             flex-direction: column;
             align-items: center;
             justify-content: center;
             height: 100vh;
             margin: 0;
             background: linear-gradient(to right, rgb(28, 143, 237), rgb(29, 99, 237));
         }
         .logo {
             margin-bottom: 20px;
         }
         .search-container {
             display: flex;
             align-items: center;
         }
         #search-input {
             padding: 10px;
             font-size: 16px;
             border: 1px solid #ddd;
             border-radius: 4px;
             width: 300px;
             margin-right: 10px;
         }
         #search-button {
             padding: 10px;
             background-color: rgba(255, 255, 255, 0.2); /* 设置白色，透明度为10% */
             border: none;
             border-radius: 4px;
             cursor: pointer;
             width: 44px;
             height: 44px;
             display: flex;
             align-items: center;
             justify-content: center;
         }			
         #search-button svg {
             width: 24px;
             height: 24px;
         }
         </style>
     </head>
     <body>
         <div class="logo">
         <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 18" fill="#ffffff" width="100" height="75">
             <path d="M23.763 6.886c-.065-.053-.673-.512-1.954-.512-.32 0-.659.03-1.01.087-.248-1.703-1.651-2.533-1.716-2.57l-.345-.2-.227.328a4.596 4.596 0 0 0-.611 1.433c-.23.972-.09 1.884.403 2.666-.596.331-1.546.418-1.744.42H.752a.753.753 0 0 0-.75.749c-.007 1.456.233 2.864.692 4.07.545 1.43 1.355 2.483 2.409 3.13 1.181.725 3.104 1.14 5.276 1.14 1.016 0 2.03-.092 2.93-.266 1.417-.273 2.705-.742 3.826-1.391a10.497 10.497 0 0 0 2.61-2.14c1.252-1.42 1.998-3.005 2.553-4.408.075.003.148.005.221.005 1.371 0 2.215-.55 2.68-1.01.505-.5.685-.998.704-1.053L24 7.076l-.237-.19Z"></path>
             <path d="M2.216 8.075h2.119a.186.186 0 0 0 .185-.186V6a.186.186 0 0 0-.185-.186H2.216A.186.186 0 0 0 2.031 6v1.89c0 .103.083.186.185.186Zm2.92 0h2.118a.185.185 0 0 0 .185-.186V6a.185.185 0 0 0-.185-.186H5.136A.185.185 0 0 0 4.95 6v1.89c0 .103.083.186.186.186Zm2.964 0h2.118a.186.186 0 0 0 .185-.186V6a.186.186 0 0 0-.185-.186H8.1A.185.185 0 0 0 7.914 6v1.89c0 .103.083.186.186.186Zm2.928 0h2.119a.185.185 0 0 0 .185-.186V6a.185.185 0 0 0-.185-.186h-2.119a.186.186 0 0 0-.185.186v1.89c0 .103.083.186.185.186Zm-5.892-2.72h2.118a.185.185 0 0 0 .185-.186V3.28a.186.186 0 0 0-.185-.186H5.136a.186.186 0 0 0-.186.186v1.89c0 .103.083.186.186.186Zm2.964 0h2.118a.186.186 0 0 0 .185-.186V3.28a.186.186 0 0 0-.185-.186H8.1a.186.186 0 0 0-.186.186v1.89c0 .103.083.186.186.186Zm2.928 0h2.119a.185.185 0 0 0 .185-.186V3.28a.186.186 0 0 0-.185-.186h-2.119a.186.186 0 0 0-.185.186v1.89c0 .103.083.186.185.186Zm0-2.72h2.119a.186.186 0 0 0 .185-.186V.56a.185.185 0 0 0-.185-.186h-2.119a.186.186 0 0 0-.185.186v1.89c0 .103.083.186.185.186Zm2.955 5.44h2.118a.185.185 0 0 0 .186-.186V6a.185.185 0 0 0-.186-.186h-2.118a.185.185 0 0 0-.185.186v1.89c0 .103.083.186.185.186Z"></path>
         </svg>
         </div>
         <div class="search-container">
         <input type="text" id="search-input" placeholder="Search Docker Hub">
         <button id="search-button">
             <svg focusable="false" aria-hidden="true" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
             <path d="M21 21L16.65 16.65M19 11C19 15.4183 15.4183 19 11 19C6.58172 19 3 15.4183 3 11C3 6.58172 6.58172 3 11 3C15.4183 3 19 6.58172 19 11Z" stroke="white" fill="none" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"></path>
             </svg>
         </button>
         </div>
         <script>
         function performSearch() {
             const query = document.getElementById('search-input').value;
             if (query) {
             window.location.href = '/search?q=' + encodeURIComponent(query);
             }
         }

         document.getElementById('search-button').addEventListener('click', performSearch);
         document.getElementById('search-input').addEventListener('keypress', function(event) {
             if (event.key === 'Enter') {
             performSearch();
             }
         });
         </script>
     </body>
     </html>
     `;
     return text;
 }

 export default {
     async fetch(request, env, ctx) {
         const getReqHeader = (key) => request.headers.get(key); // 获取请求头

         let url = new URL(request.url); // 解析请求URL
         const userAgentHeader = request.headers.get('User-Agent');
         const userAgent = userAgentHeader ? userAgentHeader.toLowerCase() : "null";
         if (env.UA) 屏蔽爬虫UA = 屏蔽爬虫UA.concat(await ADD(env.UA));
         workers_url = `https://${url.hostname}`;
         const pathname = url.pathname;

         // 获取请求参数中的 ns
         const ns = url.searchParams.get('ns'); 
         const hostname = url.searchParams.get('hubhost') || url.hostname;
         const hostTop = hostname.split('.')[0]; // 获取主机名的第一部分

         let checkHost; // 在这里定义 checkHost 变量
         // 如果存在 ns 参数，优先使用它来确定 hub_host
         if (ns) {
             if (ns === 'docker.io') {
                 hub_host = 'registry-1.docker.io'; // 设置上游地址为 registry-1.docker.io
             } else {
                 hub_host = ns; // 直接使用 ns 作为 hub_host
             }
         } else {
             checkHost = routeByHosts(hostTop);
             hub_host = checkHost[0]; // 获取上游地址
         }

         const fakePage = checkHost ? checkHost[1] : false; // 确保 fakePage 不为 undefined
         console.log(`域名头部: ${hostTop}\n反代地址: ${hub_host}\n伪装首页: ${fakePage}`);
         const isUuid = isUUID(pathname.split('/')[1].split('/')[0]);

         if (屏蔽爬虫UA.some(fxxk => userAgent.includes(fxxk)) && 屏蔽爬虫UA.length > 0) {
             // 首页改成一个nginx伪装页
             return new Response(await nginx(), {
                 headers: {
                     'Content-Type': 'text/html; charset=UTF-8',
                 },
             });
         }

         const conditions = [
             isUuid,
             pathname.includes('/_'),
             pathname.includes('/r/'),
             pathname.includes('/v2/user'),
             pathname.includes('/v2/orgs'),
             pathname.includes('/v2/_catalog'),
             pathname.includes('/v2/categories'),
             pathname.includes('/v2/feature-flags'),
             pathname.includes('search'),
             pathname.includes('source'),
             pathname === '/',
             pathname === '/favicon.ico',
             pathname === '/auth/profile',
         ];

         if (conditions.some(condition => condition) && (fakePage === true || hostTop == 'docker')) {
             if (env.URL302) {
                 return Response.redirect(env.URL302, 302);
             } else if (env.URL) {
                 if (env.URL.toLowerCase() == 'nginx') {
                     //首页改成一个nginx伪装页
                     return new Response(await nginx(), {
                         headers: {
                             'Content-Type': 'text/html; charset=UTF-8',
                         },
                     });
                 } else return fetch(new Request(env.URL, request));
             } else if (url.pathname == '/'){
                 return new Response(await searchInterface(), {
                     headers: {
                     'Content-Type': 'text/html; charset=UTF-8',
                     },
                 });
             }

             const newUrl = new URL("https://registry.hub.docker.com" + pathname + url.search);

             // 复制原始请求的标头
             const headers = new Headers(request.headers);

             // 确保 Host 头部被替换为 hub.docker.com
             headers.set('Host', 'registry.hub.docker.com');

             const newRequest = new Request(newUrl, {
                     method: request.method,
                     headers: headers,
                     body: request.method !== 'GET' && request.method !== 'HEAD' ? await request.blob() : null,
                     redirect: 'follow'
             });

             return fetch(newRequest);
         }

         // 修改包含 %2F 和 %3A 的请求
         if (!/%2F/.test(url.search) && /%3A/.test(url.toString())) {
             let modifiedUrl = url.toString().replace(/%3A(?=.*?&)/, '%3Alibrary%2F');
             url = new URL(modifiedUrl);
             console.log(`handle_url: ${url}`);
         }

         // 处理token请求
         if (url.pathname.includes('/token')) {
             let token_parameter = {
                 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'
                 }
             };
             let token_url = auth_url + url.pathname + url.search;
             return fetch(new Request(token_url, request), token_parameter);
         }

         // 修改 /v2/ 请求路径
         if ( hub_host == 'registry-1.docker.io' && /^\/v2\/[^/]+\/[^/]+\/[^/]+$/.test(url.pathname) && !/^\/v2\/library/.test(url.pathname)) {
             //url.pathname = url.pathname.replace(/\/v2\//, '/v2/library/');
             url.pathname = '/v2/library/' + url.pathname.split('/v2/')[1];
             console.log(`modified_url: ${url.pathname}`);
         }

         // 更改请求的主机名
         url.hostname = hub_host;

         // 构造请求参数
         let parameter = {
             headers: {
                 'Host': hub_host,
                 '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 // 缓存时间
         };

         // 添加Authorization头
         if (request.headers.has("Authorization")) {
             parameter.headers.Authorization = getReqHeader("Authorization");
         }

         // 发起请求并处理响应
         let original_response = await fetch(new Request(url, request), parameter);
         let original_response_clone = original_response.clone();
         let original_text = original_response_clone.body;
         let response_headers = original_response.headers;
         let new_response_headers = new Headers(response_headers);
         let status = original_response.status;

         // 修改 Www-Authenticate 头
         if (new_response_headers.get("Www-Authenticate")) {
             let auth = new_response_headers.get("Www-Authenticate");
             let re = new RegExp(auth_url, 'g');
             new_response_headers.set("Www-Authenticate", response_headers.get("Www-Authenticate").replace(re, workers_url));
         }

         // 处理重定向
         if (new_response_headers.get("Location")) {
             return httpHandler(request, new_response_headers.get("Location"));
         }

         // 返回修改后的响应
         let response = new Response(original_text, {
             status,
             headers: new_response_headers
         });
         return response;
     }
 };

 /**
 * 处理HTTP请求
 * @param {Request} req 请求对象
 * @param {string} pathname 请求路径
 */
 function httpHandler(req, pathname) {
     const reqHdrRaw = req.headers;

     // 处理预检请求
     if (req.method === 'OPTIONS' &&
         reqHdrRaw.has('access-control-request-headers')
     ) {
         return new Response(null, PREFLIGHT_INIT);
     }

     let rawLen = '';

     const reqHdrNew = new Headers(reqHdrRaw);

     const refer = reqHdrNew.get('referer');

     let urlStr = pathname;

     const urlObj = newUrl(urlStr);

     /** @type {RequestInit} */
     const reqInit = {
         method: req.method,
         headers: reqHdrNew,
         redirect: 'follow',
         body: req.body
     };
     return proxy(urlObj, reqInit, rawLen);
 }

 /**
 * 代理请求
 * @param {URL} urlObj URL对象
 * @param {RequestInit} reqInit 请求初始化对象
 * @param {string} rawLen 原始长度
 */
 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') || '';
         const badLen = (rawLen !== newLen);

         if (badLen) {
             return makeRes(res.body, 400, {
                 '--error': `bad len: ${newLen}, except: ${rawLen}`,
                 'access-control-expose-headers': '--error',
             });
         }
     }
     const status = res.status;
     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,
         headers: resHdrNew
     });
 }

 async function ADD(envadd) {
     var addtext = envadd.replace(/[	 |"'\r\n]+/g, ',').replace(/,+/g, ',');	// 将空格、双引号、单引号和换行符替换为逗号
     if (addtext.charAt(0) == ',') addtext = addtext.slice(1);
     if (addtext.charAt(addtext.length - 1) == ',') addtext = addtext.slice(0, addtext.length - 1);
     const add = addtext.split(',');
     return add;
 }

 ```

接下来，点击右上角的部署，稍等片刻
最后，返回面板，在设置，触发器 处设置一个自己的域名，一切就大功告成了
不建议使用自带的 workers.dev 的域名，被墙了

方案一、二整合

本来上面的两个方案是独立的，一个使用 Nginx 部署，一个使用 CloudFlare Worker 部署，但是就在我写这篇博客的时候，突然想到，为什么不能把上面的两个方案整合起来呢？
利用服务器搭建的 Nginx 作为中转，优先由服务器直连 Docker hub 的官方仓库，当服务器的 IP 请求次数超限后（会报 429 错误），就把请求转发到 CloudFlare Worker 部署的镜像源上，利用 CloudFlare Worker 再做一次中转。这样就即保证了使用服务器中转提高速度，又保证了不会因为服务器的 IP 请求速度过多而受限制，唯一的限制就是服务器的带宽和流量了，几乎完美！！！

部署方法：
将上面部署的 Nginx 配置替换为下面的配置并使用 sudo nginx -s reload 重新加载即可

/etc/nginx/nginx.conf

#反代docker hub镜像源
    server {
            listen 443 ssl;
            server_name 域名;

            ssl_certificate 证书地址;
            ssl_certificate_key 密钥地址;

            proxy_ssl_server_name on; # 启用SNI

            ssl_session_timeout 24h;
            ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256';
            ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;

            location /v2/ {
                    proxy_pass https://registry-1.docker.io;  # Docker Hub 的官方镜像仓库

                    proxy_set_header Host registry-1.docker.io;
                    proxy_set_header X-Real-IP $remote_addr;
                    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                    proxy_set_header X-Forwarded-Proto $scheme;

                    # 关闭缓存
                    proxy_buffering off;

                    # 转发认证相关的头部
                    proxy_set_header Authorization $http_authorization;
                    proxy_pass_header  Authorization;

                    # 重写 www-authenticate 头为你的反代地址
                    proxy_hide_header www-authenticate;
                    add_header www-authenticate 'Bearer realm="https://域名/token",service="registry.docker.io"' always;
                    # always 参数确保该头部在返回 401 错误时无论什么情况下都会被添加。

                    # 对 upstream 状态码检查，实现 error_page 错误重定向
                    proxy_intercept_errors on;
                    # error_page 指令默认只检查了第一次后端返回的状态码，开启后可以跟随多次重定向。
                    recursive_error_pages on;
                    # 根据状态码执行对应操作，以下为301、302、307状态码都会触发
                    #error_page 301 302 307 = @handle_redirect;

                    error_page 429 = @handle_too_many_requests;
            }
            # 处理 Docker OAuth2 Token 认证请求
            location /token {
                resolver 1.1.1.1 valid=600s;
                proxy_pass https://auth.docker.io;  # Docker 认证服务器

                # 设置请求头，确保转发正确
                proxy_set_header Host auth.docker.io;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header X-Forwarded-Proto $scheme;

                # 传递 Authorization 头信息，获取 Token
                proxy_set_header Authorization $http_authorization;
                proxy_pass_header Authorization;

                # 禁用缓存
                proxy_buffering off;
            }
            #处理重定向
            location @handle_redirect {
                    resolver 1.1.1.1;
                    set $saved_redirect_location '$upstream_http_location';
                    proxy_pass $saved_redirect_location;
            }
            # 处理429错误
            location @handle_too_many_requests {
                    proxy_set_header Host 替换为在CloudFlare Worker设置的域名;  # 替换为另一个服务器的地址
                    proxy_pass http://替换为在CloudFlare Worker设置的域名;
                    proxy_set_header Host $http_host;
            }
    }

如果想要反代 ghcr 镜像源呢？只要参考上面的配置，将域名、header 修改一下即可
并且因为 ghcr 好像不像 docker hub 有下载频率的限制，所以也不用去 Cloudflare Worker 部署了，直接在服务器上部署一个就行。

#反代ghcr镜像源
server {
        listen 443 ssl;
        server_name 域名;

        ssl_certificate 证书地址;
        ssl_certificate_key 密钥地址;
        proxy_ssl_server_name on;
        ssl_protocols TLSv1.1 TLSv1.2 TLSv1.3;
        #error_log /home/ubuntuago/proxy_docker.log debug;
        if ($blocked_agent) {
                return 403;
        }

        location / {
                proxy_pass https://ghcr.io;  # Docker Hub 的官方镜像仓库

                proxy_set_header Host ghcr.io;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header X-Forwarded-Proto $scheme;

                # 关闭缓存
                proxy_buffering off;

                # 转发认证相关的头部
                proxy_set_header Authorization $http_authorization;
                proxy_pass_header  Authorization;
                # 对 upstream 状态码检查，实现 error_page 错误重定向
                proxy_intercept_errors on;
                # error_page 指令默认只检查了第一次后端返回的状态码，开启后可以跟随多次重定向。
                recursive_error_pages on;
                # 根据状态码执行对应操作，以下为301、302、307状态码都会触发
                error_page 301 302 307 = @handle_redirect;

                #error_page 429 = @handle_too_many_requests;

        }
        #处理重定向
        location @handle_redirect {
                resolver 1.1.1.1;
                set $saved_redirect_location '$upstream_http_location';
                proxy_pass $saved_redirect_location;
        }

}

新增的一些代码的作用：

proxy_ssl_server_name on;
HTTPS, 需要在握手时候验证证书, 所以在握手时候需要将域名告诉对方, 找到匹配的证书, 这就是 SNI 的工作. 否则会导致证书找不到而请求失败.
默认情况下, nginx 并不会开启 proxy_ssl_server_name, 也就是说不启用 SNI. 如果使用 nginx 反代一个虚拟主机的服务, 比如 Cloudflare Workers, 此时如果不开启 SNI, 会导致与 CF 握手时候, CF 并不清楚请求哪一个域名下的服务, 所以找不到匹配的证书, 因此会报 502 错误. 当然也可以使用 proxy_ssl_name 字段复写于最终服务器收到的域名.
引自：SNI
在尝试整合这两个方案的时候不知道这个参数，一直报 502..人都麻了
error_page 429 = @handle_too_many_requests;
当错误代码为 429 时（即请求次数超限）转发到在 Cloudflare Workers 部署的镜像源
proxy_set_header Host 替换为在 CloudFlare Worker 设置的域名;
将发给 CloudFlare Worker 的请求加上正确的域名方可让请求到达我们搭建的镜像源，如果不加会报 404

镜像源使用方式

配置镜像源的方式在网上有很多，这里不做赘述
但是使用“方案一”、“方案一、二整合”的方式搭建后，如果要使用我们的反代登录到官方仓库，应在 docker login 后增加反代服务器的域名，例如 docker login example.com 然后再正常输入 docker hub 的用户名、密码。

注意！如果利用反代服务器登录 docker hub 仓库，反代服务器是可以获取到你的账号密码的，所以请谨慎使用他人搭建的服务登录！
如果没有拉取自己的私有仓库的镜像的需求，保持匿名拉取相对会安全一些。

各种加速镜像实测

测试系统为 Debian12，测试镜像为 uptime-kuma: latest
使用命令 time docker pull 加速镜像地址/louislam/uptime-kuma 测试
测试时间为 2024 年 04 月 16 日 22 时

dockerproxy.com Docker 镜像代理
用时 19.370s
docker.m.daocloud.io DaoCloud 镜像站
用时 13.927s
docker.mirrors.sjtug.sjtu.edu.cn 上海交大镜像站
用时 12.157s
docker.nju.edu.cn 南京大学镜像站
用时 12.690s
Nginx 反代自建方案
1. 处理重定向
  - 晚上十点测试，用时 16.342s
  - 次日下午五点测试，用时 15.432s
2. 不处理重定向
  次日下午五点测试，虽然不会出现使用官方仓库一样的卡死，但极慢
CloudFlare Worker 反代自建方案
- 上午十一点测试，用时 15.731s
- 晚高峰几乎无法使用
直连官方镜像仓库
~~几乎无法使用，完全看脸~~
完全无法使用

总结

根据测试，自建一个 Docker hub 加速镜像完全可行，使用 Nginx 搭建会比较看重服务器的线路，但只要不算太差，就完全可用了。不处理跳转会比较节省流量，但是为了速度，节省这一点流量也没什么必要。有一定的成本，但是如果本身就已经买了服务器的话，搭建个镜像源就几乎是顺带的事情了。
而使用 CloudFlare Worker 搭建..只能说稍微好一点点，如果服务器需要大量拉取镜像的话或许会用到这个方案。
而将方案一、二整合，几乎就是现阶段最完美的方案了，速度快且不受拉取次数的限制，只要 Docker hub 别乱修改拉取镜像的流程，理论上可以用超久。

参考文章

- https://blog.lty520.faith/%E5%8D%9A%E6%96%87/%E8%87%AA%E5%BB%BAdocker-hub%E5%8A%A0%E9%80%9F%E9%95%9C%E5%83%8F/ -

使用脚本轻松消耗流量

Wed, 10 Apr 2024 23:08:06 +0800

Ling的博客 https://blog.lty520.faith/%E9%9A%8F%E8%AE%B0/%E4%BD%BF%E7%94%A8%E8%84%9A%E6%9C%AC%E8%BD%BB%E6%9D%BE%E6%B6%88%E8%80%97%E6%B5%81%E9%87%8F/ -

系统：Debian12
最初是想使用Speedtest测速来消耗流量的，但是发现官方的Speedtest-cli无法只测下载不测上传，所以就自己写了个脚本下载文件来消耗流量
想到有什么大文件能随便下载，就突然想到了“原神”，虽然没玩过，但是这个游戏体积贼大还是知道的。最后，就有了这个脚本
（嘛，稍微薅一点人家的CDN就行了，别一直在那儿下载就好）

脚本内容

mian.sh

#!/bin/bash

# 定义日志文件的路径
log_file="download_log.txt"

# 定义要下载的文件的URL列表，会依次下载，可以自行添加或删除
urls=(
  "https://autopatchcn.yuanshen.com/client_app/download/pc_zip/20230804185703_R1La3H9xIH1hBiHJ/YuanShen_4.0.0.zip" # 原神4.0游戏本体（56.15G）
  "https://autopatchcn.yuanshen.com/client_app/download/pc_zip/20230804185703_R1La3H9xIH1hBiHJ/Audio_Chinese_4.0.0.zip" # 原神中文语音包（10.45G）
  "https://autopatchcn.yuanshen.com/client_app/download/launcher/20240314153152_0AZRlFRox2kHeTKf/mihoyo/yuanshen_setup_20240313190827.exe" # 原神PC启动器（140M）
)

# 记录脚本开始运行的时间
start_time=$(date +"%Y-%m-%d %H:%M:%S")
echo "下载开始时间: $start_time" >> "$log_file"

# 遍历URL列表，下载每个文件并记录相关信息
for url in "${urls[@]}"; do
  echo "正在下载 $url..." >> "$log_file"

  # 使用curl下载文件并获取文件大小（字节），同时检查是否成功执行
  size_bytes=$(curl -s -w "%{size_download}" -o /dev/null "$url")

  # 检查是否成功获取到文件大小
  if [[ $size_bytes -eq 0 ]]; then
    echo "下载失败或文件为空 $url " >> "$log_file"
  else
    # 将文件大小从字节转换为GB并保留6位小数
    size_gb=$(awk "BEGIN {print $size_bytes / 1024 / 1024 / 1024}")

    echo "已下载 $url 文件大小: ${size_gb} GB" >> "$log_file"
  fi
done

# 记录脚本结束运行的时间
end_time=$(date +"%Y-%m-%d %H:%M:%S")
echo "下载完成时间: $end_time" >> "$log_file"

echo "==============================================="

设置可执行权限

chmod +x main.sh

定时执行

使用命令编辑定时任务

crontab -e

在最后面新加一行

0 */12 * * * cd "/home/debian/waste_downstream_traffic" && ./main.sh > /dev/null

其中前面的时间格式为 m h dom mon dow 即分，时，日，月，周（可以参考 Wiki）

像上面的写法，就是每十二小时会执行一次（本来打算是设置在凌晨的，但是试了试下载速度并不算很快，一千兆的带宽只能跑到三百多Mbps，所以也就没挑时间）

- https://blog.lty520.faith/%E9%9A%8F%E8%AE%B0/%E4%BD%BF%E7%94%A8%E8%84%9A%E6%9C%AC%E8%BD%BB%E6%9D%BE%E6%B6%88%E8%80%97%E6%B5%81%E9%87%8F/ -

自动下载Youtube视频并上传

Sat, 25 Nov 2023 22:24:29 +0800

Ling的博客 https://blog.lty520.faith/%E5%8D%9A%E6%96%87/%E8%87%AA%E5%8A%A8%E4%B8%8B%E8%BD%BDyoutube%E8%A7%86%E9%A2%91%E5%B9%B6%E4%B8%8A%E4%BC%A0/ -

软件选择

yt-dlp 用来下载 Youtube 频道的视频
rclone 用于将下载好的视频上传到网盘里
Onedrive 借助 Microsoft E5 账号，可以获得 5TB 的空间，并且下载上传的速度也比较快

依赖安装

安装 yt-dle

从 GitHub 存储库下载最新版本的 yt-dlp

sudo wget -qO /usr/local/bin/yt-dlp https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp

设置文件的读取和执行权限
```
sudo chmod a+rx /usr/local/bin/yt-dlp
```
现在yt-dlp可以作为系统的命令用于所有用户。
测试
```
yt-dlp --version
```
可以使用以下命令将 yt-dlp 更新到最新版本：
```
sudo yt-dlp -U
```

安装 ffmpeg

这个不用太追求新版，所以直接

sudo apt install ffmpeg

可以使用

ffmpeg -version

就说明安装成功了

安装 rclone

使用官方提供的脚本即可

sudo -v ; curl https://rclone.org/install.sh | sudo bash

添加网盘

这部分由瓦力箱子 Rclone安装配置教程: 挂载OneDrive同步文件稍加修改而来

获取OneDrive授权

这一步是在本地电脑Windows系统操作，进入Rclone下载页面，点击下载Windows版本的Rclone软件，选择Intel/AMD-64Bit即可。如果是32位操作系统，那么选择32Bit的。

下载后将全部文件解压到文件夹，在文件夹处打开CMD，输入下面的命令。

.\rclone.exe authorize "onedrive"

命令输入完回车后会自动打开浏览器，登录你的OneDrive账号，点击“是”按钮同意授权。成功后返回到命令窗口就能看到长串授权码，即花括号以及里面的内容。

将花括号内的内容复制下来保存备用，有效期1个小时。

配置Rclone

和安装相同，Rclone配置也只需要一条命令。不同的是后续操作比较繁琐，需要有耐心哈。在配置过程中如果输错字母，可以按Ctrl+Backspace删除。

我们首先在VPS远程登录窗口输入下面命令：

rclone config

新建远程网盘连接，输入字母n回车。

No remotes found - make a new one
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

给远程网盘随便起个名字，我这里就叫onedrive了

name> onedrive

接着会出现一系列网盘名字列表，我输入26选择OneDrive网盘。需要注意的是这个序号以后可能会有变动，填写的时候再次确认下。

Storage> 26

Client ID无需设置，直接回车使用默认的。
Client Secret也不用填写，回车使用默认值。

选择OneDrive网盘服务器的区域，我用的是国际版输入1，如果你用的是世纪互联，那就输入4

Choose national cloud region for OneDrive.
Choose a number from below, or type in your own value
 1 / Microsoft Cloud Global
   \ "global"
 2 / Microsoft Cloud for US Government
   \ "us"
 3 / Microsoft Cloud Germany
   \ "de"
 4 / Azure and Office 365 operated by 21Vianet in China
   \ "cn"
region> 1

不需要设置高级配置，输入n后回车

Edit advanced config? (y/n)
y) Yes
n) No (default)
y/n> n

因为我们是远程连接VPS主机，不能自动配置，填写n回车。

Use auto config?
 * Say Y if not sure
 * Say N if you are working on a remote or headless machine
y) Yes (default)
n) No
y/n> n

这时候将第二步获取的OneDrive授权码粘贴到config_token>后面，回车。

Enter a string value. Press Enter for the default ("").
config_token>

选择OneDrive网盘，输入1

Choose a number from below, or type in an existing value
 1 / OneDrive Personal or Business
   \ "onedrive"
 2 / Root Sharepoint site
   \ "sharepoint"
 3 / Sharepoint site name or URL (e.g. mysite or https://contoso.sharepoint.com/sites/mysite)
   \ "url"
 4 / Search for a Sharepoint site
   \ "search"
 5 / Type in driveID (advanced)
   \ "driveid"
config_type> 1

Rclone找到一个OneDrive盘，输入y确定回车。

Drive OK?
...
y) Yes (default)
n) No
y/n> y

确认OneDrive网盘的所有信息，输入y回车。

[onedrive]
type = onedrive
...
drive_type = personal
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d > y

配置完成后 Rclone 显示远程网盘列表，至此配置结束，输入 q 退出。

Current remotes:
Name                 Type
====                 ====
onedrive             onedrive
e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q > q

经过上面的设置后，我们就成功地将 Rclone 连接挂载到 OneDrive 网盘啦。

编写脚本

脚本由使用 yt-dlp 定时下载 youtube 频道视频并且上传到 onedrive 修改而来

main.sh

#!/bin/bash

# ------------------------------
# 用户可配置的变量
# ------------------------------

# 网盘的上传目录（请确保这个路径在您的网盘中是有效的）
REMOTE_PATH = "网盘: 路径"
YT_DLP_PATH = "yt-dlp"
RCLONE_PATH = "rclone"

# 指定下载频道的链接数组
channels =(
    'https://www.youtube.com/@aaa/videos'
    'https://www.youtube.com/@bbb/videos'
)

# 每下载多少个视频后上传
VIDEOS_PER_BATCH = 5

# 下载视频数量(从最新的视频往后算)
END = 10

# ------------------------------
# 脚本逻辑（一般无需修改）
# ------------------------------

# 获取脚本所在目录的路径
SCRIPT_DIR = "$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"

# 在脚本所在目录中创建必要的目录
mkdir -p "${SCRIPT_DIR}/yetpage "
mkdir -p "${SCRIPT_DIR}/log "
mkdir -p "${SCRIPT_DIR}/yetpage/videotxt "

# 进入下载目录
cd "${SCRIPT_DIR}/yetpage "

# 下载视频并上传
for channel in "${channels[@]}"; do
    # 定义计数器
    download_count = 0
    processed_count = 0

    # 使用 yt-dlp 获取频道视频列表
    video_list = $("$ YT_DLP_PATH " --flat-playlist -J --playlist-end " $END" -- "$ channel " | jq -r '.entries [] | "\(.url) \(.id)"')
    total_videos = $(echo "$ video_list " | wc -l)
    echo "频道：$channel, 总视频数：$ total_videos"

    # 遍历视频列表
    while IFS = read -r line; do
        video_url = $(echo "$ line " | awk '{print $1}')
        video_id = $(echo "$ line " | awk '{print $2}')
        echo " 处理视频 ID：$video_id, 进度：$((++processed_count)) / $total_videos "

        # 下载单个视频
        if "$YT_DLP_PATH " -f 'bv*+ba' \
        --download-archive videos.txt \
        --write-auto-sub --sub-format srt \
        --sub-lang zh-Hans --embed-sub \
        -o '%(channel)s/%(upload_date)s-%(title).200Bs.%(ext)s' \
        -- "$video_url "; then
            # 成功下载视频后递增下载计数器
            ((download_count++))
        fi

        # 检查是否达到上传阈值
        if [ $download_count -eq $VIDEOS_PER_BATCH ]; then
            # 上传视频并重置下载计数器
            "$RCLONE_PATH" move . "$ REMOTE_PATH" -v --onedrive-chunk-size 100M --exclude "videos.txt" -P >> "${SCRIPT_DIR}/log/yt-rclone.log " 2 >&1
            download_count = 0
        fi
    done <<< "$video_list "
done

# 将下载视频 id 的记录保存到视频文本目录
cat videos.txt > "${SCRIPT_DIR}/videotxt/videois.txt "

# 上传剩余的视频文件
"$RCLONE_PATH" move . "$ REMOTE_PATH" \
-v --exclude "videos.txt" \
-P >> "${SCRIPT_DIR}/log/yt-rclone.log " 2 >&1

添加到定时任务

定时任务使用 crontab 就好了
使用下面命令进行编辑，如果是第一次使用，会让你选择使用的编辑器，选择一个自己习惯的就好（如果都没用过…就先去研究一下怎么用吧…来自可以让新手随机字符的 Vim）

crontab -e

接下来，在最后一行添加上一句即可

0 1 * * * bash 脚本路径/main.sh

0 1 * * * 分别代表分钟、小时、日、月、周。所以这句就表示脚本会在每天的一点执行一次。

修改时区

如果发现脚本没有在自己设置的时间执行，很有可能是系统时区的原因。
可以使用下面命令来看到当前的系统时间。

date

如果时区不对，可以使用下面命令来修改为东八区

sudo timedatectl set-timezone Asia/Shanghai

参考文章

在 Ubuntu 20.04 安装 yt-dlp
瓦力箱子 Rclone安装配置教程: 挂载OneDrive同步文件
AhauFun 挂载神器：Rclone使用教程这篇文章的标题好难复制嗷…（小声）
YT-DLP: 2023年最完整指南— RapidSeedbox
使用 yt-dlp 定时下载 youtube 频道视频并且上传到 onedrive

- https://blog.lty520.faith/%E5%8D%9A%E6%96%87/%E8%87%AA%E5%8A%A8%E4%B8%8B%E8%BD%BDyoutube%E8%A7%86%E9%A2%91%E5%B9%B6%E4%B8%8A%E4%BC%A0/ -

关于2008年汶川地震因美国关闭GPS导致飞机失事事件存疑的资料

Sat, 18 Nov 2023 21:59:58 +0800

Ling的博客 https://blog.lty520.faith/%E5%8D%9A%E6%96%87/%E5%85%B3%E4%BA%8E2008%E5%B9%B4%E6%B1%B6%E5%B7%9D%E5%9C%B0%E9%9C%87%E7%BE%8E%E5%9B%BD%E5%85%B3%E9%97%ADgps%E5%AF%BC%E8%87%B4%E9%A3%9E%E6%9C%BA%E5%A4%B1%E4%BA%8B%E7%9A%84%E8%B5%84%E6%96%99/ -

实事求是，就是要客观地、全面地、本质地看待问题和解决问题。 ——1968 年汉版《毛泽东思想万岁》

失事飞机资料

米-171 直升机

长度: 20.17 米
旋翼直径: 21.29 米
高度: 4.76 米
空重: 7,055 公斤
载重: 4,000 公斤
最大起飞重量: 13,000 公斤
正常起飞重量: 11,100 公斤
最大速度: 250 公里/小时
巡航速度: 230 公里/小时
最大升限: 5,000 米
最大航程: 570 公里
发动机: 两部 TV3-117VM 涡轮发动机
功率: 2,070 匹马力
乘员: 20 至 26 人

电子系统：机载设备包括 BAKLAN-20 指挥无线电台、YADRO-1G1 通信无线电台、ARK-15M 短波无线电罗盘和 ARK-UD 搜索无线电罗盘、DISS-32-90 多普勒导航仪、AGK-77 主自动地平仪和 AGR-74V 备用自动地平仪、BKK-18 自动地平仪姿态监控器、A-037 无线电高度表、A-723 远程导航设备、8A-813 气象雷达。

未有雷达设备，必须靠机师目视（来自维基百科，存疑）

总结：
没有可以探测前方障碍物的雷达

资料来源：

失事过程资料

失事的直升飞机于当天下午 1 时由机长邱光华负责驾驶，由成都凤凰山机场起飞，执行运送第三军医大学防疫专家到灾区理县的任务，预定下午 2 时 20 分搭载伤者返航。
在汶川县映秀附近因高山峡谷局部气候瞬时变化，突遇低云大雾和强气流。
张晓峰回忆道，午后的山区，天气变化迅速。直升机进入山谷不久，突然出现大片浓云密雾，一下遮蔽了这个狭窄的通道。“不要动，看下航向！”这是邱光华留下的最后的声音，接着就从通信信号中消失了，从战友们的视线中消失了……
5 月 31 日 14 时 56 分，邱光华驾驶的编号为 734 的直升机与地面失去联系。
当时是两架直升机编队飞行，两机爬高时突遇低云大雾和强烈气流。两架直升机于是保持联系，并立即爬升企图避开气流。第一架飞机顺利返航，第二架则失去联系。
15 时 45 分，成都军区成立联合搜救指挥组。指挥部指示部队运用各种通讯手段联系机组。但从中午到深夜，一连 10 多个小时，一直没有回应。
机上共有人员 19 人，其中机组人员 5 人、因灾受伤转运的群众及相关人员 14 人。

资料来源：

失事地点资料

汶川映秀镇 3511 高地

峡谷细长，周边的山峰海拔都在 2000 米以上，直升机遭遇紧急情况，没有足够的空间爬升拉高，调头返航的回旋空间也很小。峡谷的气候变化太快，有时候飞得好好的，突然就飘来一朵云，直升机就像一头扎进雪堆里一样，什么都看不见。

汶川县映秀附近高山峡谷局部气候瞬时变化

张晓峰介绍，从成都到理县的空中航线，被飞行员们称为“死亡航线”。在这条航线上，尽管我们一次次化险为夷，把“死亡航线”变成了“生命通道”，

总结：
峡谷细长，气候变化快，在云中飞行没有足够的空间爬升

资料来源：

其他相关事件资料

无人机借助 GPS 完成地震灾区航拍自主起降获取影像
- 飞机系统采用 GPS 导航自主飞行
- 5 月 16 日，该公司总经理李保平率领的一行 12 人队伍赴川，参与汶川地震灾难救助。“华鹰”无人机航摄系统，在第一时间获取了大量灾区地震后详细的航空影像，为灾难救助提供了可靠的决策依据。
- 　盛新蒲说，公司已经于 5 月 15 日和 6 月 4 日先后两次到四川参与抗震救灾工作，“华鹰”无人机航摄系统成功获取了木鱼镇等地的灾后航空影像，为灾难救助和灾后重建评估提供了第一手资料。

总结：
地震期间有无人机借助 GPS 完成了灾区测绘

资料来源：

CCTV 无人机完成地震灾区航拍自主起降获取影像

总结

失事飞机没有可以探测前方障碍物的雷达，依靠目视飞行，因气候变化导致的强气流和低云大雾及没有足够的爬升空间导致失事。在事故期间没有其他地方报告 GPS 无法使用，且有无人机借助 GPS 完成了灾区测绘，以及没有官方消息表明当时 GPS 无法使用，所以基本可以排除是因美国关闭 GPS 导致飞机失事的可能。

参考资料：

- https://blog.lty520.faith/%E5%8D%9A%E6%96%87/%E5%85%B3%E4%BA%8E2008%E5%B9%B4%E6%B1%B6%E5%B7%9D%E5%9C%B0%E9%9C%87%E7%BE%8E%E5%9B%BD%E5%85%B3%E9%97%ADgps%E5%AF%BC%E8%87%B4%E9%A3%9E%E6%9C%BA%E5%A4%B1%E4%BA%8B%E7%9A%84%E8%B5%84%E6%96%99/ -

记一次给电脑添加硬盘

Wed, 15 Nov 2023 17:00:17 +0800

Ling的博客 https://blog.lty520.faith/%E9%9A%8F%E8%AE%B0/%E8%AE%B0%E4%B8%80%E6%AC%A1%E7%BB%99%E7%94%B5%E8%84%91%E6%B7%BB%E5%8A%A0%E7%A1%AC%E7%9B%98/ -

前言

电脑的第一块系统盘是 22 年 7 月买的三星 PM9A1 1TB ，花了 774 元，之后一直嫌硬盘价格贵就没加硬盘。在 23 年固态硬盘降价后，以及下了不少模型后导致硬盘空间严重不足，终于在 23 年双十一期间决定新增一块硬盘（然而已经过了硬盘的最低价格时间了 QAQ ）

选择

在考虑了主要用途为玩游戏以及存储文件且没有大文件传输需求的前提下，对速度的要求并不大，反而稳定更重要一点。决定买一块 2TB 的 Pcie3.0*4 的硬盘来扩容一下我的电脑。之后就是选硬盘了，主要考虑了

致态 tiplus5000
西数 sn570
雷克沙战神
爱国者固态 p7000z
宏碁 gm7
铠侠 rc20
以及一些梵想等小品牌的硬盘

在查询了一些资料后，发现致态 tiplus5000 和宏碁 gm7 有许多掉盘的事故发生，至于梵想等一些小品牌，出现事故的可能性就更大了…考虑到 1TB 的主盘可能不够虚拟机、存文件的使用，以后可能还是需要使用这块新硬盘来存文件的，所以还是只能排除掉这些风险相对大一些的硬盘了。
在剩下的几块硬盘之间，最后选择了铠侠 rc20 2TB ，速度不快，但听说很稳，再加上是在台式机里使用，基本没有散热的问题。
双十一期间购买，非京东自营，花费了 609.04 元，比历史最低高了一些，但还能接受。

安装

安装理论上没有什么难度，但是在小主板（M-ATX）和大显卡（310*131.5* 56mm）（小主板是为了节省空间，大显卡是因为这个显卡好看….）的限制下，必须拆掉显卡才能看到硬盘位。

第一次装上后，电脑没有画面，主板亮灯。（开始慌了）（没有核显的坏处啊..）
怀疑可能是加硬盘的时候把原有的硬盘拆开了后没装好（因为不知道哪个是空硬盘位），或者可能是显卡没插好。
然后再重新拆开，重新装显卡，重新装硬盘，插拔内存（有枣没枣打三杆）装显卡又出毛病了..可能是因为显卡长时间悬空的缘故，导致其有些变形，两个固定螺丝死活拧不上去…还是得大力出奇迹啊… 插电，开机，轻松..蓝屏。（至少有画面了啊）重启，终于可以进系统了，然后又识别不到新硬盘。再重启，终于可以识别到了..选择 GPT 分区，新建分区，终于可以用了（一个剩余 1.8TB 的超大硬盘）

问题

把 Steam 的游戏都转到新的 F 硬盘里，E 盘终于空下来了。
接下来就是离谱的《雨中冒险: 回归》疯狂闪退，玩几分钟就闪退…转移到老硬盘里就没事，校验文件也没有问题，重装也没用…就离谱…
看了看社区，好多抱怨闪退的…看来之前玩没有闪退过还是运气好…
尝试玩了一段时间后基本上不怎么闪退了，可以玩了。
但是 Chrome 浏览器又莫名的卡起来了…不知道是不是因为移出去了大量文件，硬盘开始整理空间了，总之就是莫名的好卡…个别页面很卡，油管很多视频封面和 F12 很多标签加载不出来…

问题：

游戏闪退
部分油管视频封面无法显示
F12 内标签无法显示
在开启 F12 后网页会奇卡无比，且滚轮在网页内无法使用
Chrome 经常出现类似“刷新”的现象，瞬间的消失后再次出现

修复

在两天后的 15 日尝试使用 Windows 的硬盘修复工具，修复后，就没有出现 Chrome 卡顿以及封面加载不出来和 F12 标签无法显示的问题了。

修复日志：

在卷快照上以扫描模式执行了 Chkdsk。  

检查 D: 上的文件系统
卷标是 软件。

阶段 1: 检查基本文件系统结构...
  已处理 607232 个文件记录。                                                          文件验证完成。
 阶段持续时间 (文件记录验证): 2.34 秒。
  已处理 418 个大型文件记录。                                     阶段持续时间 (孤立文件记录恢复): 1.12 毫秒。
  已处理 0 个错误的文件记录。                                       阶段持续时间 (文件记录检查错误): 0.88 毫秒。

阶段 2: 检查文件名链接...
  已处理 613 个重新解析记录。                                         已处理 979980 个索引项。                                                        索引验证完成。
 阶段持续时间 (索引验证): 6.03 秒。

 阶段持续时间 (孤立文件重新连接): 916.74 毫秒。

    发现目录“$I30”的索引“\??\D:\found.000”中丢失了文件“\QQ messages\.......”的索引项
        ... 已联机修复。
 阶段持续时间 (孤立文件恢复到回收箱): 7.33 毫秒。
  已处理 613 个重新解析记录。                                        阶段持续时间 (重分析点和对象 ID 验证): 5.52 毫秒。

阶段 3: 检查安全描述符...
安全描述符验证完成。
 阶段持续时间 (安全描述符验证): 1.32 毫秒。
  已处理 186375 个数据文件。                                             阶段持续时间 (数据属性验证): 1.36 毫秒。
CHKDSK 正在验证 Usn 日志...
Usn 日志验证完成。
Windows 已发现问题并联机修复了所有问题。
无需采取进一步操作。

总共有  209715199 KB 磁盘空间。
410925 个文件中有  165248532 KB。
186377 个索引     261528 KB。
系统正在使用     679763 KB。
日志文件占用了      65536 KB。
磁盘上   43525376 KB 可用。

每个分配单元中有       4096 字节。
磁盘上共有   52428799 个分配单元。
磁盘上有   10881344 个可用的分配单元。
总持续时间: 9.31 秒 (9318 毫秒)。

----------------------------------------------------------------------


阶段 1: 检查基本文件系统结构...

阶段 2: 检查文件名链接...
CHKDSK 正在扫描未编制索引的文件以便重新连接到其原始目录。
  已将 0 个未编制索引的文件恢复到原始目录。
CHKDSK 正在恢复剩余的未索引文件。
    回收箱位于 \found.000


阶段 3: 检查安全描述符...

复盘

怀疑可能是第一次在硬盘没有装好的情况下启动电脑（当时电脑处于休眠状态，应该关机后再安装硬盘）导致了一些数据的错误。
因而在修复硬盘后就恢复了正常

- https://blog.lty520.faith/%E9%9A%8F%E8%AE%B0/%E8%AE%B0%E4%B8%80%E6%AC%A1%E7%BB%99%E7%94%B5%E8%84%91%E6%B7%BB%E5%8A%A0%E7%A1%AC%E7%9B%98/ -

WP BUUCTF [BJDCTF2020]just_a_rar

Sat, 04 Feb 2023 00:30:28 +0800

Ling的博客 https://blog.lty520.faith/ctf/wp-buuctf-bjdctf2020just_a_rar/ -

题目链接: https://buuoj.cn/challenges#[BJDCTF2020]just_a_rar

题目

加密的压缩包

思路

一个四位数密码的压缩包，暴力破解即可得密码为 2016
解压得一张 jpg 图片，在备注处可以找到 flag
flag{Wadf_123}

- https://blog.lty520.faith/ctf/wp-buuctf-bjdctf2020just_a_rar/ -

WP BUUCTF [BJDCTF2020]鸡你太美

Sat, 04 Feb 2023 00:15:51 +0800

Ling的博客 https://blog.lty520.faith/ctf/wp-buuctf-bjdctf2020%E9%B8%A1%E4%BD%A0%E5%A4%AA%E7%BE%8E/ -

题目链接: https://buuoj.cn/challenges#[BJDCTF2020]%E9%B8%A1%E4%BD%A0%E5%A4%AA%E7%BE%8E

题目

篮球打坤坤的 gif
还有一个打不开的 gif

思路

第一张图没什么价值
第二张图缺少了 gif 的文件头
加上即可正常打开
得到 flag
flag{zhi_yin_you_are_beautiful}

- https://blog.lty520.faith/ctf/wp-buuctf-bjdctf2020%E9%B8%A1%E4%BD%A0%E5%A4%AA%E7%BE%8E/ -

WP BUUCTF [BJDCTF2020]你猜我是个啥

Sat, 04 Feb 2023 00:08:25 +0800

Ling的博客 https://blog.lty520.faith/ctf/wp-buuctf-bjdctf2020%E4%BD%A0%E7%8C%9C%E6%88%91%E6%98%AF%E4%B8%AA%E5%95%A5/ -

题目链接: https://buuoj.cn/challenges#[BJDCTF2020]%E4%BD%A0%E7%8C%9C%E6%88%91%E6%98%AF%E4%B8%AA%E5%95%A5

题目

一个压缩包

思路

作为压缩包打不开，尝试使用 binwalk 和 foremost 分离，使用 foremost 可以分出一张 png 图片，解码可得 flag祥婓涴
但这不是 flag ！！！！！
使用 notepad++ 打开压缩包，可以在文件末尾找到 flag
flag{i_am_fl@g}

所以这是让我猜啥啊？？

- https://blog.lty520.faith/ctf/wp-buuctf-bjdctf2020%E4%BD%A0%E7%8C%9C%E6%88%91%E6%98%AF%E4%B8%AA%E5%95%A5/ -