# 1. 找出哪个目录最大（逐层下钻）
du -h --max-depth=1 /var/log | sort -rh | head
# → 发现 /var/log/myapp 占 45G

# 2. 看具体文件
du -sh /var/log/myapp/* | sort -rh | head
# → app-2026-07-*.log 每天 2G，保留 30 天全在

# 3. 止血：清理 7 天前的日志（先确认没有进程句柄问题）
find /var/log/myapp -name "app-*.log" -mtime +7 -delete
df -h /var/log                       # 确认空间回落

# 4. 治本：配置 logrotate 自动轮转（/etc/logrotate.d/myapp）
#   /var/log/myapp/*.log { daily rotate 7 compress missingok copytruncate }

# 1. 先统计影响面
find /var/www/html -name "*.html.tmp" | wc -l        # 确认 2000 个

# 2. 抽样验证 1 个文件没问题后，批量改回
find /var/www/html -name "*.html.tmp" -exec sh -c 'mv "$1" "${1%.tmp}"' _ {} \;

# 3. 验证
find /var/www/html -name "*.html.tmp" | wc -l        # 应为 0
curl -I http://localhost/index.html                  # 抽查可访问

# 过滤：Where-Object（别名 ? / where）
Get-Process | Where-Object { $_.CPU -gt 100 }

# 选列：Select-Object（别名 select）
Get-Process | Select-Object Name, CPU -First 10

# 遍历：ForEach-Object（别名 % / foreach）
gci *.log | ForEach-Object { $_.Name }

# 大文件排序找前10
gci -Recurse | Sort Length -Desc | Select -First 10 FullName, Length

# 统计目录大小（MB）
"{0:N2} MB" -f ((gci -Recurse | Measure Length -Sum).Sum / 1MB)

# 批量重命名（加前缀）
gci *.txt | Rename-Item -NewName { "new_" + $_.Name }

# 查看文件 MD5/SHA256
Get-FileHash .\file.zip -Algorithm SHA256

# 解压/压缩
Expand-Archive a.zip -DestinationPath .\out
Compress-Archive .\dir\* out.zip

# servers.txt 每行一个主机名，用 Invoke-Command 并行收集
$servers = Get-Content .\servers.txt
Invoke-Command -ComputerName $servers -ScriptBlock {
    [PSCustomObject]@{
        Server    = $env:COMPUTERNAME
        DiskFreeGB = [math]::Round((Get-PSDrive C).Free / 1GB, 1)
        IISStatus = (Get-Service W3SVC -ErrorAction SilentlyContinue).Status
        LastBoot  = (Get-CimInstance Win32_OperatingSystem).LastBootUpTime
    }
} | Export-Csv .\report.csv -NoTypeInformation -Encoding UTF8

# 输出 CSV 直接用 Excel 打开交差，异常机器一目了然

# 1. 查系统启动与关机事件（System 日志）
Get-WinEvent -FilterHashtable @{LogName='System'; Id=6005,6006,1074,41} -MaxEvents 20 |
    Format-Table TimeCreated, Id, Message -AutoSize
#   6005=开机 6006=正常关机 1074=谁发起的重启 41=异常断电/蓝屏

# 2. 若是 41 号事件（Kernel-Power）= 非正常关机，查蓝屏转储
Get-ChildItem C:\Windows\MEMORY.DMP, C:\Windows\Minidump\*.dmp -ErrorAction SilentlyContinue

# 3. 若是 1074，Message 里直接写明哪个进程/用户发起的重启

# 统计昨天日志里各 IP 的请求量 Top20（IIS 日志是空格分隔）
$log = "C:\inetpub\logs\LogFiles\W3SVC1\u_ex$(Get-Date (Get-Date).AddDays(-1) -Format yyMMdd).log"
Get-Content $log | Where-Object { $_ -notmatch '^#' } |
    ForEach-Object { ($_ -split ' ')[8] } |          # 第9列是客户端IP
    Group-Object | Sort-Object Count -Descending | Select-Object -First 20 Name, Count

# 配合状态码分析：找出产生大量 404 的 IP（扫描器特征）
Get-Content $log | Where-Object { $_ -match ' 404 ' } |
    ForEach-Object { ($_ -split ' ')[8] } | Group-Object | Sort Count -Desc | Select -First 10

# Linux：从根目录一层层找最大的
du -h --max-depth=1 / 2>/dev/null | sort -rh | head -20

# Linux：找出超过 500M 的文件
find / -type f -size +500M -exec ls -lh {} \; 2>/dev/null

# Windows PowerShell：找出当前目录下最大的10个文件
gci -Recurse -File | Sort Length -Desc | Select -First 10 FullName, @{N='SizeMB';E={[math]::Round($_.Length/1MB,2)}}

# Linux：看 8080 被谁占用
ss -tlnp | grep 8080        # 或 lsof -i :8080
kill -9 <PID>

# Windows CMD 两步走
netstat -ano | findstr :8080        # 拿到最后一列 PID
tasklist | findstr <PID>            # 看进程名
taskkill /pid <PID> /f              # 杀掉

# Linux 方式一：nohup
nohup ./myserver > server.log 2>&1 &

# Linux 方式二：screen / tmux（可随时再进入查看）
tmux new -s work      # 新建会话，跑程序
# 按 Ctrl+B 再按 D 脱离；重新进入：tmux attach -t work

# 找 error 并显示前后各 5 行上下文
grep -n -C 5 "error" app.log

# 实时跟踪日志并过滤关键字
tail -f app.log | grep --line-buffered "ERROR"

# 统计每类错误出现次数
grep "ERROR" app.log | awk '{print $5}' | sort | uniq -c | sort -rn

# PowerShell 实时跟踪+过滤
Get-Content app.log -Wait -Tail 100 | Select-String "ERROR"

# Linux → Linux（scp）
scp ./file.zip user@192.168.1.100:/home/user/

# 整个目录
scp -r ./dir user@192.168.1.100:/home/user/

# Windows → Linux 用 WinSCP（图形界面）或 scp（Win10+ 自带 OpenSSH 客户端）
scp .\file.zip user@192.168.1.100:/home/user/

# Linux：所有 .go 文件中的 old 替换为 new
grep -rl "old" . --include="*.go" | xargs sed -i 's/old/new/g'

# PowerShell
(gci -Recurse -Filter *.go) | ForEach-Object {
    (Get-Content $_.FullName -Raw) -replace 'old','new' | Set-Content $_.FullName
}

# Linux 临时生效
export PATH=$PATH:/my/bin

# Linux 永久生效（写入 ~/.bashrc 或 ~/.zshrc）
echo 'export PATH=$PATH:/my/bin' >> ~/.bashrc && source ~/.bashrc

# Windows 临时（仅当前窗口）
set PATH=%PATH%;C:\my\bin

# Windows 永久（用户级）
setx PATH "%PATH%;C:\my\bin"     # 注意：setx 有 1024 字符截断风险

# PowerShell 永久（推荐方式）
[Environment]::SetEnvironmentVariable("MY_VAR", "value", "User")

# Linux
tar -zcvf backup.tar.gz ./dir     # 打包压缩
tar -zxvf backup.tar.gz           # 解压
tar -zxvf backup.tar.gz -C /tmp   # 解压到指定目录
unzip a.zip -d ./out              # zip 解压

# Windows（新版自带 tar）
tar -zcvf backup.tar.gz dir
tar -zxvf backup.tar.gz

# Linux 一键看重点
top                  # 整体情况
free -h              # 内存
df -h                # 磁盘
iostat -x 1          # IO（需装 sysstat）

# Windows
Get-Process | Sort CPU -Desc | Select -First 10   # CPU 最高的进程
Get-Process | Sort WS -Desc | Select -First 10    # 内存最高的进程
# 或者直接用图形界面：taskmgr / resmon / perfmon

# Linux
history | grep ssh        # 搜索历史
!123                      # 重新执行第123条
Ctrl+R                    # 交互式反向搜索（神器！）

# PowerShell / CMD
Get-History               # PowerShell 历史
# 或按 F7（CMD 中弹窗显示历史）
# Ctrl+R 在 PowerShell 7 / Windows Terminal 中同样可用

# 1. 查看哪些文件冲突
git status                       # 冲突文件标记为 both modified

# 2. 手动编辑文件，删除 <<<<<<<、=======、>>>>>>> 标记，保留正确内容

# 3. 标记为已解决并继续
git add <冲突文件>
git merge --continue             # merge 场景（或直接 git commit）
git rebase --continue            # rebase 场景

# 中途想放弃，回到冲突前
git merge --abort
git rebase --abort

git commit --amend -m "正确的消息"    # 还没 push 时

git log --oneline -1                # 记下提交 id，如 a1b2c3
git reset --hard HEAD~1             # 当前分支撤销（改动还在 reflog 里）
git switch 正确的分支
git cherry-pick a1b2c3              # 把提交摘过来

git fetch origin
git reset --hard origin/main        # 丢弃所有本地提交和改动，慎用

git fetch
git checkout origin/main -- path/to/file

# 1. 当前改动先 stash 封存（未跟踪的新文件也要，加 -u）
git stash push -u -m "feature开发到一半"

# 2. 从 main 拉 hotfix 分支修复
git switch main && git pull
git switch -c hotfix/order-null-fix
# ... 修复代码 ...
git commit -am "fix: 修复订单空指针"

# 3. 推 hotfix 分支走紧急评审合并上线
git push -u origin hotfix/order-null-fix

# 4. 回到原来的开发分支，恢复现场继续干活
git switch feature/order-v2
git stash pop                        # 改动回来了，无缝衔接
git stash list                       # 确认 stash 已清空

# 1. reflog 是 HEAD 的全程录像，删分支也留痕
git reflog
# → 找到 feature/pay 最后一次提交 id：a3f8c2d

# 2. 现场重建分支（提交原封不动回来）
git branch feature/pay a3f8c2d
git switch feature/pay && git log --oneline -5     # 确认提交都在

# 3. 重新推送（正常 push，不要再强推）
git push origin feature/pay

docker run -d \                    # -d 后台运行
  --name mynginx \                # 容器命名
  -p 8080:80 \                    # 端口映射：宿主机:容器
  -v /host/data:/container/data \ # 目录挂载：宿主机:容器
  -e TZ=Asia/Shanghai \           # 环境变量
  --restart unless-stopped \      # 重启策略（开机自起，除非手动停）
  nginx:1.25

# 其他常用：
#   -it            交互式终端（配合 /bin/bash 调试镜像）
#   --rm           退出后自动删除（一次性调试容器）
#   --network host 使用宿主机网络
docker run -it --rm ubuntu:22.04 /bin/bash    # 临时进个干净环境调试

# 进入运行中的容器（最常用）
docker exec -it mynginx /bin/bash

# 没有 bash 的精简镜像（如 alpine）用 sh
docker exec -it mynginx /bin/sh

# 不进入容器，直接执行单条命令
docker exec mynginx ls /etc/nginx
docker exec -e KEY=val mynginx env        # 带环境变量执行

# 以 root 身份进入（容器默认用户权限不够时）
docker exec -it -u root mynginx /bin/bash

services:
  web:
    image: nginx:1.25
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
    restart: unless-stopped

  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: root123
    volumes:
      - db_data:/var/lib/mysql

volumes:
  db_data:

docker ps -a                        # 看退出码，如 Exited (1)
docker logs <容器>                  # 第一优先：看日志找报错
# 常见原因：主进程结束（容器的生命 = 主进程的生命），可用 -it 手动运行排查
docker run -it --rm <镜像> /bin/sh

docker exec -it mysql容器 mysql -uroot -p
# 或导出备份
docker exec mysql容器 mysqldump -uroot -p密码 dbname > backup.sql

# 1. 看 Docker 磁盘分布
docker system df -v | head -40

# 2. 定位到大头：containers 层占用 60G → 逐容器查日志文件
du -sh /var/lib/docker/containers/*/*-json.log 2>/dev/null | sort -rh | head
# → 某容器 json.log 单文件 35G（应用 DEBUG 日志狂喷）

# 3. 止血：清空日志文件（不要 rm，文件被占用删了不释放空间）
truncate -s 0 /var/lib/docker/containers/<id>/<id>-json.log

# 4. 治本：全局限制日志大小，/etc/docker/daemon.json
#   { "log-driver": "json-file", "log-opts": { "max-size": "100m", "max-file": "3" } }
systemctl reload docker        # 只对新创建的容器生效！

# 排查：进容器看时间
docker exec myapp date               # 显示 UTC，比北京时间晚 8 小时

# 修复方式一：运行参数注入时区（最简单）
docker run -e TZ=Asia/Shanghai -v /etc/localtime:/etc/localtime:ro ...

# 修复方式二：docker-compose
#   environment:
#     - TZ=Asia/Shanghai

# 验证
docker exec myapp date               # 显示 CST 东八区

# 进入 Pod 中的容器（最常用）
kubectl exec -it <pod> -- /bin/bash

# 精简镜像没有 bash 时用 sh
kubectl exec -it <pod> -- /bin/sh

# 多容器 Pod 必须指定容器名
kubectl exec -it <pod> -c <容器名> -- /bin/bash

# 不进入，直接执行单条命令
kubectl exec <pod> -- ls /app
kubectl exec <pod> -- env                # 看环境变量是否注入正确

kubectl describe pod <pod> -n prod
kubectl describe deploy <name>
kubectl describe node <节点名>           # 节点压力大/资源不足时看

# 把本地 8080 转发到 Pod 的 80（调试用，无需改 Service）
kubectl port-forward <pod> 8080:80

# 转发 Service（推荐，会负载到后端任一 Pod）
kubectl port-forward svc/myapp 8080:80

# 转发 Deployment
kubectl port-forward deploy/myapp 8080:80

# 转发后另开终端访问：curl localhost:8080

kubectl set image deploy/myapp myapp=myrepo/myapp:v2   # 1. 更新镜像
kubectl rollout status deploy/myapp                    # 2. 盯发布进度
kubectl get pods -w                                    # 观察新 Pod 起来、旧 Pod 销毁
# 出问题立刻回滚：
kubectl rollout undo deploy/myapp

kubectl describe pod <pod>
# 看 Events：多半是资源不足（Insufficient cpu）或 PVC 未绑定、污点调度问题

kubectl logs <pod> --previous      # 看崩溃前日志，十有八九是应用报错
kubectl describe pod <pod>         # 看退出码和探针失败记录
kubectl get pod <pod> -o yaml | grep -A5 lastState   # 看上次退出原因

kubectl get endpoints <svc名>      # 为空 = 没有匹配到 Pod，检查 selector 标签
kubectl describe svc <svc名>       # 核对 selector 与 Pod 的 label 是否一致
# 进入某个 Pod 测试：wget -qO- <svc名>:<port>

kubectl run debug --rm -it --image=busybox:1.28 -- sh
# 进去后可 nslookup <svc>、wget 测连通性，退出自动删除

# 1. 看新 Pod 为什么没就绪
describe=$(kubectl get pods -l app=myapp --sort-by=.metadata.creationTimestamp | tail -1 | awk '{print $1}')
kubectl describe pod $describe | tail -20
# → Events: Readiness probe failed: Get http://:8080/health: connection refused

# 2. 看应用日志，确认是启动慢还是起不来
kubectl logs $describe --tail=50
# → 应用在初始化缓存，需要 90 秒才监听端口，但探针 10 秒就开始探

# 3. 决策：不是代码问题，是探针参数太激进。回滚 or 修探针？
#    业务高峰期 → 先回滚止损：
kubectl rollout undo deploy/myapp
kubectl rollout status deploy/myapp          # 确认老版本全部恢复

# 4. 事后修复探针再发布：initialDelaySeconds: 60 或改用 startupProbe

# 1. 看上次退出原因（关键！应用日志是看不到的，因为是内核直接杀）
kubectl get pod <pod> -o jsonpath='{.status.containerStatuses[0].lastState}'
# → {"terminated":{"exitCode":137,"reason":"OOMKilled"}}

# 2. 看内存 limit 与实际用量
kubectl top pod <pod>
kubectl get pod <pod> -o jsonpath='{.spec.containers[0].resources}'
# → limit 512Mi，但 JVM 默认堆是物理内存的 1/4（按节点内存算！）

# 3. 修复：JVM 参数适配容器限制 + 适当调大 limit
#    老版本 JDK 用 -Xmx400m；JDK 8u191+/11+ 用 -XX:MaxRAMPercentage=75

# 备份单个库（最常用）
mysqldump -u root -p dbname > dbname_backup.sql

# 备份指定表
mysqldump -u root -p dbname table1 table2 > tables.sql

# 备份所有库
mysqldump -u root -p --all-databases > all.sql

# 只导结构不导数据（-d）
mysqldump -u root -p -d dbname > schema.sql

# 只导数据不导结构（-t）
mysqldump -u root -p -t dbname > data.sql

# 带条件导出（比如只导最近的数据）
mysqldump -u root -p dbname orders --where="create_time>'2026-01-01'" > orders.sql

# 备份并压缩（大库推荐）
mysqldump -u root -p dbname | gzip > dbname_$(date +%F).sql.gz

# 恢复
mysql -u root -p dbname < dbname_backup.sql
zcat dbname.sql.gz | mysql -u root -p dbname        # 压缩包直接恢复

-- 导出查询结果为 CSV（文件在 MySQL 服务器上，需 secure_file_priv 权限）
SELECT * FROM orders
INTO OUTFILE '/var/lib/mysql-files/orders.csv'
FIELDS TERMINATED BY ',' ENCLOSED BY '"'
LINES TERMINATED BY '\n';

-- 从 CSV 导入
LOAD DATA INFILE '/var/lib/mysql-files/orders.csv'
INTO TABLE orders
FIELDS TERMINATED BY ',' ENCLOSED BY '"'
LINES TERMINATED BY '\n'
IGNORE 1 ROWS;          -- 跳过表头

-- 查看当前用户及所有用户
SELECT USER(), CURRENT_USER();
SELECT user, host FROM mysql.user;

-- 创建用户（% 表示允许任意主机连接，生产建议限定 IP 段）
CREATE USER 'app'@'%' IDENTIFIED BY 'Strong@123';

-- 授权：只给需要的库的最小权限
GRANT SELECT, INSERT, UPDATE, DELETE ON appdb.* TO 'app'@'%';
FLUSH PRIVILEGES;

-- 查看某用户的权限
SHOW GRANTS FOR 'app'@'%';

-- 改密码 / 删用户
ALTER USER 'app'@'%' IDENTIFIED BY 'NewPass@456';
DROP USER 'app'@'%';

-- 查看各表占用空间 Top 10
SELECT table_name, table_rows,
       ROUND(data_length/1024/1024, 2) AS data_mb,
       ROUND(index_length/1024/1024, 2) AS index_mb
FROM information_schema.tables
WHERE table_schema = 'dbname'
ORDER BY data_length DESC LIMIT 10;

# String（缓存、计数器）
SET name "tom"                     # 写入
GET name                           # 读取
SET name "tom" EX 60               # 写入并设60秒过期
SETNX lock:order 1                 # 不存在才写入（分布式锁基础）
INCR counter / DECR counter        # 自增自减
MSET a 1 b 2 / MGET a b            # 批量读写

# Hash（存对象）
HSET user:1 name tom age 20        # 写字段
HGET user:1 name                   # 读单字段
HGETALL user:1                     # 读全部字段
HINCRBY user:1 age 1               # 字段自增

# List（队列、最新消息列表）
LPUSH queue task1                  # 左入队
RPOP queue                         # 右出队（配合 LPUSH = 队列）
LRANGE queue 0 -1                  # 查看全部（0 -1 = 从头到尾）
LLEN queue                         # 长度

# Set（去重集合、共同好友）
SADD tags:post1 go redis           # 添加
SMEMBERS tags:post1                # 查看全部
SISMEMBER tags:post1 go            # 是否成员
SINTER set1 set2                   # 交集

# ZSet（排行榜）
ZADD rank 100 "tom" 85 "jerry"    # 写入（分数 成员）
ZRANGE rank 0 -1 WITHSCORES        # 按分数升序看全部
ZREVRANGE rank 0 9 WITHSCORES      # 降序 Top10（排行榜）
ZINCRBY rank 5 "tom"              # 加分
ZRANK rank "tom"                  # 查排名

SCAN 0 MATCH session:* COUNT 100   # 返回下一游标，用返回值继续扫，直到返回 0
# 命令行一次性扫描所有匹配：
redis-cli --scan --pattern 'session:*' | head -100

INFO memory                        # 看 used_memory_human 和 maxmemory
redis-cli --bigkeys                # 扫描大 key（官方工具，边采样边扫，安全）
MEMORY USAGE <key>                 # 确认某个可疑 key 的大小

# 配合管道批量设置（示例：给所有 session: 开头的 key 设 24 小时）
redis-cli --scan --pattern 'session:*' | xargs -L1 redis-cli EXPIRE 86400

redis-cli MONITOR                  # 打印所有执行的命令（调试可用，生产慎用影响性能）
redis-cli --stat                   # 持续输出请求数/连接数/内存概况（生产安全）
SLOWLOG GET 10                     # 查看最近10条慢查询

-- 1. 现场抓正在执行的 SQL（第一证据）
SHOW FULL PROCESSLIST;
-- → 几十条同样的查询，Time 都在 20+ 秒，State = Sending data
--    SELECT * FROM orders WHERE user_phone = '138xxxx' ORDER BY create_time DESC

-- 2. 看执行计划
EXPLAIN SELECT * FROM orders WHERE user_phone = '138xxxx';
-- → type: ALL（全表扫描），rows: 800万，key: NULL（没走任何索引）

-- 3. 止血：先杀掉堆积的查询让业务恢复
KILL 12834;  KILL 12835;  -- ...（或写脚本批量杀同模式查询）

-- 4. 治本：加索引（800 万行表在线加，MySQL 5.6+ 支持 ONLINE DDL 不锁表）
ALTER TABLE orders ADD INDEX idx_user_phone (user_phone);

-- 5. 验证
-- EXPLAIN 再看 type 变成 ref，rows 降到个位数，页面恢复

# 1. 找大 key（官方安全工具）
redis-cli --bigkeys
# → 发现 key "rank:all_users" 是 2.8G 的 ZSet（500万成员，全量用户排行榜）

# 2. 看内存策略
CONFIG GET maxmemory-policy
# → noeviction（默认：满了直接拒绝写入！这就是缓存写不进的原因）

# 3. 止血：改策略让缓存可淘汰
CONFIG SET maxmemory-policy allkeys-lru    # 所有 key 按 LRU 淘汰
# （CONFIG SET 即时生效，但要写进 redis.conf 才能重启后保留）

# 4. 治本：大 key 拆分（rank:all_users → 按月分 rank:202607 等）+ 只存 TopN

user  nginx;                          # 运行用户
worker_processes  auto;               # 工作进程数，auto = CPU核数
error_log  /var/log/nginx/error.log;  # 全局错误日志

events {
    worker_connections  1024;         # 每个进程最大连接数
}

http {                                # HTTP 全局设置
    include       /etc/nginx/mime.types;
    sendfile      on;
    keepalive_timeout  65;
    client_max_body_size 50m;         # 上传大小限制（413 报错就改它）

    access_log  /var/log/nginx/access.log;

    include /etc/nginx/conf.d/*.conf; # 加载各站点配置
}

server {
    listen       80;                    # 监听端口
    server_name  api.example.com;       # 域名（可多个空格分隔，支持 * 泛域名）
    root         /var/www/html;         # 站点根目录
    index        index.html;

    # 静态资源 + 缓存
    location /static/ {
        alias /data/static/;            # 注意 root 与 alias 的路径拼接区别
        expires 7d;                     # 浏览器缓存7天
    }

    # location 匹配优先级：= > ^~ > 正则(~ / ~*) > 普通前缀
    location = /healthz {               # 精确匹配（最高优先）
        return 200 'ok';                # 直接返回内容，常用于健康检查
    }

    location ~ \.(js|css|png)$ {        # 正则匹配（区分大小写，~* 不区分）
        expires 30d;
    }

    location / {                        # 普通前缀（最低优先，兜底）
        try_files $uri $uri/ /index.html;   # SPA 单页应用必配（防止刷新404）
    }
}

location /api/ {
    proxy_pass http://127.0.0.1:8080/;   # 末尾带 / 会替换掉 /api/ 前缀

    # 透传客户端真实信息（后端拿到真实 IP 的关键）
    proxy_set_header Host              $host;
    proxy_set_header X-Real-IP         $remote_addr;
    proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;

    # 超时设置（后端慢导致 504 时调大）
    proxy_connect_timeout 5s;
    proxy_read_timeout    60s;
}

# WebSocket 代理（多了两行 Upgrade 头）
location /ws/ {
    proxy_pass http://127.0.0.1:8080/;
    proxy_http_version 1.1;
    proxy_set_header Upgrade    $http_upgrade;
    proxy_set_header Connection "upgrade";
}

upstream backend {
    # 默认轮询（round-robin）
    server 192.168.1.11:8080;
    server 192.168.1.12:8080 weight=2;      # weight 权重，流量2倍
    server 192.168.1.13:8080 backup;        # backup 备用，其他挂了才启用
    server 192.168.1.14:8080 max_fails=3 fail_timeout=30s;  # 30秒内失败3次则摘除

    # 其他策略（按需选一）：
    # least_conn;              # 最少连接（后端耗时不均时推荐）
    # ip_hash;                 # 同一 IP 固定到同一台（简单会话保持）
}

server {
    listen 80;
    location / {
        proxy_pass http://backend;
    }
}

vim /etc/nginx/conf.d/myapp.conf      # 1. 改配置
nginx -t                              # 2. 检查语法（必须看到 successful）
nginx -s reload                       # 3. 平滑重载

# 实时看访问日志
tail -f /var/log/nginx/access.log

# 统计状态码分布（快速判断问题面）
awk '{print $9}' /var/log/nginx/access.log | sort | uniq -c | sort -rn

# 找出访问最多的 IP Top10
cut -d' ' -f1 /var/log/nginx/access.log | sort | uniq -c | sort -rn | head

# 找所有 5xx 错误
awk '$9 >= 500' /var/log/nginx/access.log | tail -50

# 看最慢的请求（需 log_format 配 $request_time，默认在最后字段）
awk '{print $NF, $7}' /var/log/nginx/access.log | sort -rn | head

log_format main '$remote_addr - [$time_local] "$request" '
                '$status $body_bytes_sent '
                'rt=$request_time uct=$upstream_connect_time urt=$upstream_response_time';
access_log /var/log/nginx/access.log main;

# 1. 量化错误分布
awk '{print $9}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head
# → 200 正常占多数，499 和 502 各占 5%

# 2. 看错误日志找 502 原因
tail -500 /var/log/nginx/error.log | grep -E "upstream|connect"
# → upstream timed out (110: Connection timed out) while connecting to upstream

# 3. 定位：后端连接数耗尽。查 upstream 是否启用 keepalive
grep -A5 "upstream backend" /etc/nginx/conf.d/*.conf
# → 没有 keepalive 配置，每个请求都新建 TCP 连接，压测下端口耗尽

upstream backend {
    server 10.0.1.11:8080;
    server 10.0.1.12:8080;
    keepalive 64;                        # 关键：与后端保持长连接池
}
location / {
    proxy_pass http://backend;
    proxy_http_version 1.1;              # 长连接必需
    proxy_set_header Connection "";      # 清掉客户端的 Connection 头
}

server {
    listen 80;
    server_name api.example.com;
    return 301 https://$host$request_uri;    # 301 会保留路径和参数
}

server {
    listen 443 ssl;
    server_name api.example.com;
    ssl_certificate     /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;
    ssl_protocols       TLSv1.2 TLSv1.3;     # 禁用老旧 TLS1.0/1.1
    location / { proxy_pass http://backend; }
}

# 基础：找 ERROR 或 WARN 开头的行
grep -E '^(ERROR|WARN)' app.log

# 提取 IP 地址（-o 只输出匹配部分）
grep -oE '\b([0-9]{1,3}\.){3}[0-9]{1,3}\b' access.log

# 找手机号
grep -oE '1[3-9][0-9]{9}' data.txt

# 找邮箱
grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' mail.txt

# 统计每个 IP 出现次数（grep + sort + uniq 经典三件套）
grep -oE '\b([0-9]{1,3}\.){3}[0-9]{1,3}\b' access.log | sort | uniq -c | sort -rn | head

# PCRE 模式：支持非贪婪、\d 等（提取引号中的内容）
grep -oP '"name"\s*:\s*"\K[^"]+' data.json

# 简单替换：所有 error 改成 ERROR（g = 每行全部替换）
sed -i 's/error/ERROR/g' app.log

# 分组捕获：交换日期格式 2026-07-27 → 27/07/2026
sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3\/\2\/\1/g' date.txt

# 提取：把 "name=tom age=20" 只保留名字
echo 'name=tom age=20' | sed -E 's/name=([a-z]+).*/\1/'
# 输出：tom

# 删除行尾空白（日志清洗常用）
sed -i 's/[ \t]*$//' file.txt

# 删除注释行和空行（处理配置文件）
sed -e '/^#/d' -e '/^$/d' nginx.conf

# 只打印第 10~20 行（sed 当 head/tail 用）
sed -n '10,20p' app.log

# 打印匹配行（-n 抑制默认输出 + p 打印）
sed -n '/ERROR/p' app.log

# 给每行加行号前缀
echo -e 'a\nb\nc' | sed '=' | paste - -

# 筛选：第 9 列（状态码）是 5xx 的行（~ 表示正则匹配）
awk '$9 ~ /^5/' access.log

# 筛选：第 3 列包含 error（忽略大小写用 tolower）
awk 'tolower($3) ~ /error/' app.log

# 反选：第 1 列不以 192. 开头（!~ 不匹配）
awk '$1 !~ /^192\./' access.log

# 统计：每个 IP 的访问次数（数组用法）
awk '{count[$1]++} END {for (ip in count) print count[ip], ip}' access.log | sort -rn | head

# 求和：统计 GET 请求返回的总字节数
awk '$6 ~ /GET/ {sum += $10} END {print sum" bytes"}' access.log

# 指定分隔符：分析 /etc/passwd（冒号分隔）
awk -F: '$3 >= 1000 {print $1, $3}' /etc/passwd

# 多分隔符：按逗号或分号切
awk -F'[,;]' '{print $2}' data.txt

# 范围提取：打印两个标记之间的行（日志切片神器）
awk '/2026-07-27 10:00/,/2026-07-27 11:00/' app.log

# 格式化输出
awk '{printf "%-15s %6d\n", $1, $2}' data.txt

# 1. 找出请求量最大的 IP Top20
grep -oE '\b([0-9]{1,3}\.){3}[0-9]{1,3}\b' /var/log/nginx/access.log \
  | sort | uniq -c | sort -rn | head -20
# → 前 5 个 IP 每个请求 10 万+，正常用户不可能

# 2. 看这些 IP 在请求什么（确认是攻击不是爬虫）
grep "^1.2.3.4 " /var/log/nginx/access.log | awk '{print $7}' | sort | uniq -c | sort -rn | head
# → 全部密集请求 /api/login，确认 CC 攻击

# 3. 提取攻击 IP 清单（请求超 1 万的）
awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn \
  | awk '$1 > 10000 {print $2}' > /tmp/attack_ips.txt
wc -l /tmp/attack_ips.txt

# 4. 批量封禁
cat /tmp/attack_ips.txt | while read ip; do
    firewall-cmd --add-rich-rule="rule family=ipv4 source address=$ip drop"
done

# 5. 验证恢复
ss -s                                # 连接数回落
tail -f /var/log/nginx/access.log    # 流量正常化

# 1. 本地生成密钥（一路回车）
ssh-keygen -t ed25519

# 2. 公钥内容追加到服务器的 ~/.ssh/authorized_keys
cat ~/.ssh/id_ed25519.pub | ssh user@host "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"

# 3. 服务器侧权限必须正确（否则免密失败，常见坑！）
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

# -L 本地转发：访问本地 13306 等于访问远端内网的 MySQL
ssh -L 13306:10.0.1.20:3306 user@jump-server -N
#   -N 不执行远程命令（只建隧道），可加 -f 放后台

# -R 远程转发：把本地的 8080 服务暴露到公网服务器的 18080
ssh -R 18080:localhost:8080 user@public-server -N

# -D 动态转发：本地 1080 变 SOCKS5 代理，浏览器配上即可访问整个内网
ssh -D 1080 user@jump-server -N

# 本地目录同步到远端（最常用组合 -avz）
rsync -avz ./dist/ user@host:/var/www/html/
#   -a 归档（保留权限/时间/软链）  -v 显示过程  -z 压缩传输
#   注意末尾斜杠：dist/ 同步内容，dist 同步目录本身

# 断点续传大文件（-P = --partial --progress）
rsync -avzP bigfile.iso user@host:/data/

# 删除目标多余文件（完全镜像，危险但有用）
rsync -avz --delete ./dist/ user@host:/var/www/html/

# 排除文件/限速/指定 SSH 端口
rsync -avz --exclude='*.log' --exclude='.git' --bwlimit=10000 -e 'ssh -p 2222' ./src/ user@host:/backup/

# 拉取远端到本地（方向反过来）
rsync -avz user@host:/var/log/nginx/ ./logs/

# 常用参数：
#   -i any   所有网卡（生产抓包常用，避免选错网卡）
#   -nn      不解析域名/服务名（显示纯 IP 端口，更快更准）
#   -c 100   抓够 100 个包自动停
#   -s 0     抓完整包（默认可能截断）

# 实战组合：抓 3306 端口的前 200 个包存文件
tcpdump -i any -nn -c 200 -s 0 -w /tmp/mysql.pcap port 3306