适用人群：计算机系新生、转行入门者、需要系统掌握 Linux 操作与 Shell 脚本能力的开发者和运维人员
前置要求：具备基础终端使用能力，能打开终端并执行简单命令
最后更新：2026-03-13
如果你开发后端服务、使用 Docker 容器、维护云服务器，或者将来从事任何与服务器打交道的工作，你几乎肯定会在 Linux 上运行代码。全球超过 96% 的 Web 服务器运行 Linux，几乎所有云计算基础设施（AWS、阿里云、腾讯云）的底层都是 Linux，Android 手机的内核也是 Linux。
Linux 不是一个操作系统，而是一类操作系统的统称——它们都基于 Linus Torvalds 于 1991 年发布的 Linux 内核。常见的发行版包括：
| 发行版 | 主要用途 | 包管理工具 |
|---|---|---|
| Ubuntu | 开发者、云服务器（最主流） | apt |
| Debian | 稳定服务器环境 | apt |
| CentOS / RHEL | 企业级服务器 | yum / dnf |
| Fedora | 开发者桌面，新技术试验场 | dnf |
| Alpine | Docker 容器（极致精简） | apk |
| Arch Linux | 高度自定义，偏好高级用户 | pacman |
本文以 Ubuntu/Debian 系为主要示例，但核心概念和大多数命令在所有 Linux 发行版上通用。
Linux 设计哲学中最重要的一条是"一切皆文件"：普通文档是文件，目录是文件，设备（硬盘、键盘、网卡）是文件，进程信息是文件，甚至网络连接也可以用文件描述符表示。这个统一的抽象让所有工具都能通过相同的方式（读写文件）与系统交互，也是 Linux 命令组合能力强大的根本原因。
在服务器环境中，通常没有图形界面（GUI），只有命令行（CLI）。命令行有几个图形界面无法替代的优势：
- 可脚本化：命令可以组合、自动化、重复执行，GUI 操作很难自动化
- 资源效率：命令行几乎不占用额外资源，图形界面要消耗大量 CPU 和内存
- 远程操作：通过 SSH 连接远程服务器时，只有命令行可用
- 精确性：命令行操作明确、可审计，GUI 操作容易误点
Linux 只有一棵目录树，根目录是 /（正斜杠），所有文件和目录都挂载在这棵树上。路径分为两种：
- 绝对路径：从根目录开始，如
/etc/nginx/nginx.conf - 相对路径：从当前目录开始，如
./config/app.yaml或../logs/app.log
特殊路径符号：
.：当前目录..：上一级目录~：当前用户的 Home 目录（通常是/home/username）-：上一个工作目录（cd -回到上一个位置，非常实用）
/
├── etc/ ← 系统和应用的配置文件（nginx、ssh、hosts 等）
├── var/
│ ├── log/ ← 系统和应用日志文件
│ ├── lib/ ← 应用运行时的持久化数据
│ └── www/ ← Web 服务器文件（惯例）
├── usr/
│ ├── bin/ ← 用户可执行程序（ls、grep、curl 等）
│ ├── sbin/ ← 系统管理员程序（需要 sudo）
│ └── local/ ← 本地安装的软件（非包管理器安装）
├── bin/ ← 基础系统命令（实际上通常链接到 /usr/bin）
├── sbin/ ← 系统管理命令
├── home/
│ └── username/ ← 各用户的家目录
├── root/ ← root 用户的家目录（独立于 /home）
├── tmp/ ← 临时文件（重启后清空）
├── proc/ ← 进程信息（虚拟文件系统，运行时动态生成）
├── sys/ ← 系统硬件信息（虚拟文件系统）
├── dev/ ← 设备文件（磁盘、终端等）
├── mnt/ ← 临时挂载点
└── opt/ ← 第三方大型软件（不通过包管理器安装时）
记住规律："去哪里找什么"：
- 服务启动失败 → 先查
/etc/<服务名>/配置，再查/var/log/<服务名>/日志 - 命令找不到 → 通常在
/usr/bin/或/usr/local/bin/ - 临时测试文件 → 放
/tmp/，不用担心清理
# 显示当前所在路径
pwd
# 切换目录
cd /etc/nginx # 切换到绝对路径
cd ../ # 上一级
cd ~ # 回到 Home 目录
cd - # 回到上一个工作目录（反复执行可在两个目录间切换）
# 列出目录内容
ls # 基础列表
ls -l # 详细信息（权限、大小、时间等）
ls -a # 包含隐藏文件（以 . 开头的文件）
ls -lh # 详细信息 + 人类可读的文件大小
ls -alh # 以上全部
ls -lt # 按修改时间排序（最新的在前）
ls -lS # 按文件大小排序
# 查看目录树结构（需要安装 tree）
tree /etc/nginx
tree -L 2 /var/log # 只显示 2 层深度# 查看整个文件内容
cat /etc/hostname
cat /etc/hosts
# 分页查看（空格翻页，q 退出）
less /var/log/syslog
more /etc/nginx/nginx.conf
# 查看文件开头/结尾
head -n 20 /var/log/syslog # 前 20 行
tail -n 50 /var/log/nginx/access.log # 最后 50 行
tail -f /var/log/nginx/access.log # 实时追踪（跟踪新增内容，Ctrl+C 退出）
tail -f -n 100 /var/log/app.log # 从最后 100 行开始实时追踪
# 查看文件详细元信息（权限、inode、时间戳等）
stat /etc/passwd# 创建空文件（或更新时间戳）
touch newfile.txt
touch -t 202601010000 oldfile.txt # 设置指定时间戳
# 快速写入内容（> 覆盖，>> 追加）
echo "Hello, Linux" > hello.txt
echo "Second line" >> hello.txt
echo "" >> hello.txt # 追加空行
# 用 nano 编辑（新手友好，底部有快捷键提示）
nano /etc/hosts
# Ctrl+O 保存，Ctrl+X 退出，Ctrl+W 搜索
# 用 vim 编辑（功能强大，学习曲线较陡）
vim /etc/nginx/nginx.conf
# i 进入插入模式，Esc 返回命令模式
# :w 保存，:q 退出，:wq 保存并退出，:q! 强制退出不保存
# /keyword 搜索，n 下一个，N 上一个
# 在文件末尾追加多行内容（heredoc 语法）
cat >> /etc/profile.d/custom.sh << 'EOF'
export MY_APP_HOME=/opt/myapp
export PATH=$PATH:$MY_APP_HOME/bin
EOF# 复制文件
cp source.txt destination.txt
cp -r /source/dir/ /destination/dir/ # 递归复制目录
cp -a /source/ /backup/ # 保留权限和时间戳的归档复制
# 移动文件或重命名
mv oldname.txt newname.txt # 重命名
mv /tmp/file.txt /var/www/html/ # 移动
# 删除文件（无法撤销！操作前三思）
rm file.txt
rm -r directory/ # 递归删除目录
rm -rf /path/to/dir/ # 强制递归删除（高危命令！）
rmdir emptydir/ # 只能删除空目录
# 关于 rm -rf 的警告
# 永远不要执行 rm -rf / 或 rm -rf /*（会删除整个系统）
# 删除前用 ls 先确认路径，养成习惯# 创建目录
mkdir newdir
mkdir -p /opt/app/config/env # 递归创建多级目录（父目录不存在时自动创建）
# 创建软链接（类似 Windows 的快捷方式）
ln -s /opt/app/current /opt/app/latest
# 访问 /opt/app/latest 实际上访问的是 /opt/app/current
# 查看链接指向
ls -l /opt/app/latest
# lrwxrwxrwx 1 root root /opt/app/latest -> /opt/app/current
# 创建硬链接（两个文件名指向同一个 inode）
ln /original/file.txt /another/path/file.txt# find：在目录树中按条件搜索
find /var/log -name "*.log" # 按名称搜索
find /etc -name "nginx.conf" -type f # 只找文件（不包括目录）
find /home -user alice # 找属于 alice 的文件
find /tmp -mtime +7 # 找超过 7 天未修改的文件
find /opt -size +100M # 找大于 100MB 的文件
find /var/log -name "*.log" -mtime +30 -delete # 查找并删除 30 天前的日志
# locate：基于数据库快速搜索（需要 mlocate 包）
locate nginx.conf
updatedb # 更新数据库（sudo）
# which：找命令在哪里
which nginx
which python3
# whereis：找命令、源码、手册
whereis nginxLinux 权限是生产环境稳定性的关键保障之一。理解权限能帮你：
- 排查
Permission denied错误（最常见的 Linux 报错之一） - 保护敏感文件（如密钥、配置文件）不被未授权读取
- 控制服务进程能访问哪些资源
- 在 Docker、CI 环境中正确配置容器权限
执行 ls -l 时，每一行开头的字符串就是权限位：
-rwxr-xr-- 1 alice developers 4096 Mar 13 10:00 deploy.sh
│└──┴──┴── │ │ │ │ │ │
│ 属主 属组 │ 属主 属组 大小 修改时间 文件名
│ 其他用户 └── 链接数
└── 文件类型（- 普通文件，d 目录，l 软链接，c 字符设备）
权限位的三组含义：
| 字符位置 | 作用于 | r（读） | w（写） | x（执行） |
|---|---|---|---|---|
| 2-4 位 | 属主（Owner） | 能读取文件内容 | 能修改文件 | 能执行文件 |
| 5-7 位 | 属组（Group） | 同上 | 同上 | 同上 |
| 8-10 位 | 其他人（Others） | 同上 | 同上 | 同上 |
对于目录来说，权限含义稍有不同：
r：能列出目录内容（ls）w：能在目录中创建、删除、重命名文件x：能进入目录（cd）以及访问目录内的文件
权限也可以用三位八进制数字表示：r=4、w=2、x=1，三个权限加起来：
| 数字 | 权限 | 含义 |
|---|---|---|
7 |
rwx |
读+写+执行 |
6 |
rw- |
读+写 |
5 |
r-x |
读+执行 |
4 |
r-- |
只读 |
0 |
--- |
无权限 |
常用权限组合：
chmod 755 script.sh # 属主全权，其他人只读+执行（可执行脚本）
chmod 644 config.conf # 属主读写，其他人只读（配置文件）
chmod 600 id_rsa # 只有属主可读写（SSH 私钥）
chmod 700 ~/.ssh # 只有属主可进入（SSH 目录）
chmod 777 /tmp/shared # 所有人全权（临时共享目录，不建议生产使用）# 修改文件权限
chmod 755 deploy.sh
chmod +x deploy.sh # 给所有人加执行权限
chmod u+x,g-w deploy.sh # 给属主加执行，去掉属组写权限
chmod -R 755 /opt/app/ # 递归修改目录下所有文件
# 修改属主和属组
chown alice deploy.sh
chown alice:developers deploy.sh
chown -R appuser:appgroup /opt/app/ # 递归修改整个目录
# 只修改属组
chgrp developers /opt/app/logs/umask 是一个掩码，决定新建文件和目录的默认权限。系统默认 umask 022：
- 新建文件默认权限：
666 - 022 = 644（rw-r--r--） - 新建目录默认权限：
777 - 022 = 755（rwxr-xr-x）
# 查看当前 umask
umask
# 输出：0022
# 临时修改（仅当前会话有效）
umask 027 # 新建文件为 640，目录为 750（更严格的团队环境）
# 永久修改：写入 ~/.bashrc 或 /etc/profile
echo "umask 027" >> ~/.bashrc# sudo：以 root 权限执行单条命令（推荐方式，可审计）
sudo apt update
sudo systemctl restart nginx
sudo -u www-data ls /var/www # 以指定用户身份执行
# su：切换用户身份（需要目标用户密码）
su alice # 切换到 alice 用户
su - # 切换到 root（需要 root 密码）
su - alice # 切换到 alice 并加载其环境变量
# 查看当前用户有哪些 sudo 权限
sudo -l# 查看当前用户
whoami
id # 显示用户ID、组ID等详细信息
id alice # 查看指定用户的信息
# 创建用户
sudo useradd alice # 基础创建
sudo useradd -m -s /bin/bash alice # 创建家目录，指定 Shell
sudo useradd -m -s /bin/bash -G sudo alice # 同时加入 sudo 组
# 设置密码
sudo passwd alice
# 修改用户信息
sudo usermod -s /bin/zsh alice # 修改 Shell
sudo usermod -aG docker alice # 追加到 docker 组（-a 不会删除已有组）
sudo usermod -l newname alice # 重命名用户
# 删除用户
sudo userdel alice # 只删除用户，保留家目录
sudo userdel -r alice # 删除用户及其家目录和邮件
# 查看所有用户
cat /etc/passwd
# 格式：用户名:密码:UID:GID:描述:家目录:Shell# 查看用户所属的组
groups
groups alice
# 创建用户组
sudo groupadd developers
# 将用户加入组
sudo usermod -aG developers alice
# 注意：修改组成员后，需要重新登录（或执行 newgrp）才能生效
newgrp developers # 在当前会话中激活新组
# 删除用户组
sudo groupdel developers
# 查看所有用户组
cat /etc/groupsudo 的权限配置在 /etc/sudoers 文件（必须用 visudo 编辑，它会检查语法）：
sudo visudo
# /etc/sudoers 常用配置示例：
# alice ALL=(ALL:ALL) ALL # alice 可以执行所有 sudo 命令
# %developers ALL=(ALL) NOPASSWD: /bin/systemctl restart nginx
# ↑ developers 组可以无密码重启 nginx
# 推荐：在 /etc/sudoers.d/ 目录下创建独立文件
sudo tee /etc/sudoers.d/developers << 'EOF'
%developers ALL=(ALL) NOPASSWD: /bin/systemctl restart app
%developers ALL=(ALL) NOPASSWD: /usr/bin/docker
EOF
sudo chmod 440 /etc/sudoers.d/developers每个运行中的程序都是一个进程，有唯一的进程 ID（PID）。Linux 的所有进程构成一棵树，起点是 PID 1（系统初始化进程，现代 Linux 通常是 systemd）。理解进程管理是排查服务异常、分析性能问题的基础。
# ps：进程快照
ps # 只看当前终端的进程
ps -e # 所有进程
ps -ef # 全格式（UID、PID、PPID、命令等）
ps -ef | grep nginx # 过滤特定进程
ps -aux # BSD 风格，带 CPU/内存占用
# 输出字段含义：
# UID PID PPID C STIME TTY TIME CMD
# 用户 进程ID 父进程ID CPU 启动时间 终端 CPU时间 命令
# pgrep：按名称查找 PID
pgrep nginx # 返回所有 nginx 进程的 PID
pgrep -l nginx # 同时显示进程名
# top：实时进程监控（默认 3 秒刷新）
top
# 常用交互键：
# q 退出 k 终止进程（输入 PID） 1 切换单核/多核显示
# P 按 CPU 排序 M 按内存排序 u 过滤用户
# htop：更友好的 top（需要安装）
sudo apt install htop
htop
# pstree：以树形显示进程关系
pstree
pstree -p # 显示 PID
pstree -u # 显示用户Linux 通过"信号（Signal）"控制进程行为：
# kill：向进程发送信号
kill 1234 # 默认发送 SIGTERM（15），请求进程优雅退出
kill -15 1234 # 明确发送 SIGTERM（让程序有机会清理资源）
kill -9 1234 # 发送 SIGKILL，强制立即终止（进程无法捕获）
kill -HUP 1234 # 发送 SIGHUP，通常用于让服务重新读取配置
# killall：按进程名终止
killall nginx # 终止所有 nginx 进程
killall -9 python3 # 强制终止所有 python3 进程
# pkill：按名称或条件终止
pkill -u alice # 终止 alice 用户的所有进程
pkill -f "python app.py" # 按完整命令行匹配
# 为什么优先用 SIGTERM 而不是 SIGKILL？
# SIGTERM 允许程序捕获信号，执行清理：关闭数据库连接、写入日志、完成当前请求
# SIGKILL 直接由内核终止，程序没有机会处理，可能导致数据损坏或日志不完整常用信号列表：
| 信号 | 编号 | 含义 |
|---|---|---|
| SIGTERM | 15 | 请求优雅退出（默认） |
| SIGKILL | 9 | 强制立即终止 |
| SIGHUP | 1 | 挂起/重新加载配置 |
| SIGINT | 2 | 键盘中断（Ctrl+C） |
| SIGSTOP | 19 | 暂停进程（Ctrl+Z） |
| SIGCONT | 18 | 恢复暂停的进程 |
# 在后台运行命令（& 放末尾）
python3 server.py &
# 输出：[1] 12345 ← [任务编号] PID
# 查看后台任务
jobs
# 将后台任务移到前台
fg %1 # %1 是任务编号
# 将前台任务切到后台（先 Ctrl+Z 暂停，再 bg）
# 运行中按 Ctrl+Z 暂停
bg %1 # 在后台继续运行
# nohup：即使关闭终端也继续运行
nohup python3 server.py > /var/log/server.log 2>&1 &
# 输出重定向到日志文件，& 放后台
# 查看特定进程的详细信息
ls -l /proc/12345/ # 进程虚拟目录
cat /proc/12345/status # 进程状态信息
cat /proc/12345/environ # 进程环境变量systemd 是现代 Linux（Ubuntu 16+、CentOS 7+）的初始化系统和服务管理器。它统一管理所有系统服务的启动、停止、依赖和日志。在 systemd 出现之前，每个发行版有自己的服务管理方式（SysVinit、Upstart 等），造成了大量混乱。systemctl 是与 systemd 交互的核心命令。
# 查看服务状态（最常用，第一时间看这个）
systemctl status nginx
# 输出包含：服务状态、进程PID、最近日志
# 启动 / 停止 / 重启服务
sudo systemctl start nginx
sudo systemctl stop nginx
sudo systemctl restart nginx # 停止后重新启动（会短暂中断）
sudo systemctl reload nginx # 重新加载配置，不中断服务（nginx支持热重载）
# 开机自启设置
sudo systemctl enable nginx # 设置开机自启
sudo systemctl disable nginx # 取消开机自启
sudo systemctl enable --now nginx # 设置开机自启并立即启动（组合操作）
# 快速判断状态
systemctl is-active nginx # 输出 active 或 inactive
systemctl is-enabled nginx # 输出 enabled 或 disabled
systemctl is-failed nginx # 输出 failed 或其他# 列出所有正在运行的服务
systemctl list-units --type=service --state=running
# 列出所有服务（包括未运行的）
systemctl list-units --type=service --all
# 列出所有失败的服务（故障排查入口）
systemctl list-units --state=failed
# 查看服务的依赖关系
systemctl list-dependencies nginx当你需要让自己的应用以服务方式运行时，创建一个 Service Unit 文件：
# 创建服务配置文件
sudo nano /etc/systemd/system/myapp.service文件内容示例：
[Unit]
Description=My Application Server
After=network.target # 在网络就绪后启动
Requires=postgresql.service # 依赖 PostgreSQL（可选）
[Service]
Type=simple
User=appuser # 以指定用户运行（不要用 root）
Group=appgroup
WorkingDirectory=/opt/myapp
EnvironmentFile=/opt/myapp/.env # 从文件加载环境变量
ExecStart=/usr/bin/node /opt/myapp/server.js
ExecReload=/bin/kill -HUP $MAINPID
Restart=always # 崩溃后自动重启
RestartSec=5 # 重启前等待 5 秒
StandardOutput=journal # 输出到 systemd journal
StandardError=journal
[Install]
WantedBy=multi-user.target # 在多用户模式下启用# 加载新服务配置
sudo systemctl daemon-reload
# 启动并设置开机自启
sudo systemctl enable --now myapp
# 查看状态
systemctl status myapp# 更新软件包索引（安装前必须先更新）
sudo apt update
# 升级所有已安装的软件包
sudo apt upgrade
sudo apt full-upgrade # 更积极的升级（可能删除冲突包）
# 安装软件包
sudo apt install nginx
sudo apt install nginx curl git # 一次安装多个
# 安装指定版本
sudo apt install nginx=1.18.0-6ubuntu14
# 查看可用版本
apt-cache policy nginx
# 删除软件包
sudo apt remove nginx # 删除但保留配置文件
sudo apt purge nginx # 彻底删除（含配置文件）
sudo apt autoremove # 删除不再需要的依赖
# 搜索软件包
apt search "web server"
apt-cache search nginx
# 查看软件包信息
apt show nginx
apt list --installed # 列出所有已安装包
apt list --installed | grep nginx # 查找特定包# 更新
sudo dnf update
sudo yum update # 旧版 CentOS
# 安装
sudo dnf install nginx
sudo yum install nginx
# 删除
sudo dnf remove nginx
# 搜索
dnf search nginx
# 查看信息
dnf info nginx
# 列出已安装
dnf list installed# 原则一：先查版本，再升级
apt-cache policy nginx # 查看当前版本和可用版本
# 原则二：安装前先测试在非生产环境
# 生产升级应在测试/预发布环境验证后进行
# 原则三：记录变更
# 把软件版本和安装时间记录在变更日志里
# 原则四：关键配置先备份
cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak-$(date +%F-%H%M%S)
sudo apt upgrade nginx
# 查看某个命令属于哪个软件包
dpkg -S /usr/bin/nginx # 反查命令来自哪个包
which nginx | xargs dpkg -S # 结合 which 使用# 查看所有挂载分区的使用情况
df -h
# 输出示例：
# Filesystem Size Used Avail Use% Mounted on
# /dev/sda1 50G 18G 29G 38% /
# 查看 inode 使用情况（有时磁盘空间足够但 inode 用完了）
df -i
# 查看当前目录下各子目录的磁盘占用
du -sh *
du -sh /var/log/* # 查看日志目录各文件大小
du -sh /* 2>/dev/null # 查看根目录各文件夹大小
# 找出磁盘占用最大的文件/目录
du -sh /var/log/* | sort -h | tail -10 # 找最大的 10 个
find / -size +500M -type f 2>/dev/null # 找大于 500MB 的文件
# 常见"磁盘满了"排查流程
df -h # 定位哪个分区满了
du -sh /var/log/* | sort -h # 找哪个日志文件最大
du -sh /opt/* | sort -h # 找哪个应用目录最大# 查看内存使用概况
free -h
# 输出示例：
# total used free shared buff/cache available
# Mem: 7.7G 3.2G 1.1G 245M 3.4G 4.0G
# Swap: 2.0G 0B 2.0G
# available 列才是真正可用的内存（包括可回收的缓存）
# 实时监控内存（每 2 秒刷新）
watch -n 2 free -h
# 查看详细内存信息
cat /proc/meminfo
# 清理文件系统缓存（仅在确实需要时使用）
sudo sync && sudo echo 3 > /proc/sys/vm/drop_caches# 查看系统负载和运行时间
uptime
# 输出：10:30:00 up 15 days, 2:30, 2 users, load average: 0.52, 0.45, 0.40
# load average 三个数字：1分钟、5分钟、15分钟的平均负载
# 负载值接近或超过 CPU 核心数时，系统处于高负载状态
# 查看 CPU 核心数
nproc
cat /proc/cpuinfo | grep "model name" | head -1
# vmstat：综合系统资源监控（每 1 秒采样，共 5 次）
vmstat 1 5
# 关注列：r（运行队列）、b（阻塞进程）、si/so（swap）、wa（IO等待）
# iostat：磁盘 IO 监控
iostat -x 1 5
# sar：历史性能数据（需要 sysstat 包）
sudo apt install sysstat
sar -u 1 5 # CPU 使用率
sar -r 1 5 # 内存使用
sar -d 1 5 # 磁盘 IO# 查看网卡和 IP 地址
ip addr
ip addr show eth0 # 只看特定网卡
# 查看路由表
ip route
ip route show # 同上
# 查看 DNS 配置
cat /etc/resolv.conf
# 查看主机名
hostname
hostname -f # 完全限定域名（FQDN）# ss：查看套接字状态（取代旧的 netstat）
ss -tulpen
# 参数：-t TCP -u UDP -l 监听 -p 进程 -e 扩展 -n 不解析名称
ss -tlnp # 查看所有 TCP 监听端口及对应进程
ss -tlnp | grep :80 # 检查 80 端口是否被监听
ss -anp | grep nginx # 查看 nginx 的所有连接
# 等效的 netstat 命令（较旧的系统）
netstat -tulpen
netstat -tlnp | grep :80
# lsof：查看进程打开的文件和网络连接
lsof -i :8080 # 谁在监听 8080 端口
lsof -i tcp # 所有 TCP 连接
lsof -p 1234 # 进程 1234 打开的所有文件
lsof -u alice # alice 用户打开的文件# ping：测试网络连通性
ping -c 4 google.com # 发 4 个包
ping -c 4 -i 0.2 8.8.8.8 # 间隔 0.2 秒
# traceroute：追踪网络路径（每一跳的延迟）
traceroute google.com
mtr google.com # 更强的路由追踪（实时刷新）
# curl：测试 HTTP/HTTPS 接口
curl https://example.com
curl -I https://example.com # 只看响应头
curl -v https://example.com # 详细输出（含请求/响应头）
curl -o /dev/null -w "%{http_code}\n" https://example.com # 只看状态码
curl -X POST -H "Content-Type: application/json" \
-d '{"key":"value"}' \
https://api.example.com/endpoint
# wget：下载文件
wget https://example.com/file.zip
wget -O custom-name.zip https://example.com/file.zip
wget -q --spider https://example.com # 检查 URL 是否可访问（不下载）
# nc（netcat）：测试 TCP 端口是否可达
nc -zv server.example.com 22
nc -zv server.example.com 80
nc -zv -w 3 server.example.com 5432 # 3 秒超时
# dig / nslookup：DNS 查询
dig google.com
dig +short google.com # 只显示 IP
nslookup google.com# 查看所有系统日志（按时间倒序）
journalctl
# 查看特定服务的日志
journalctl -u nginx
journalctl -u nginx -n 100 --no-pager # 最近 100 行，不分页
# 实时追踪日志（类似 tail -f）
journalctl -u nginx -f
# 按时间范围过滤
journalctl -u nginx --since "2026-03-13 10:00:00"
journalctl -u nginx --since "1 hour ago"
journalctl -u nginx --since "2026-03-13 10:00" --until "2026-03-13 10:10"
# 只看错误级别以上的日志
journalctl -p err
journalctl -p err -n 100 --no-pager # 最近 100 条错误
journalctl -u nginx -p err -n 50 # nginx 的最近 50 条错误
# 查看本次启动以来的日志
journalctl -b
journalctl -b -1 # 上次启动的日志
# 日志占用磁盘查看与清理
journalctl --disk-usage
sudo journalctl --vacuum-size=500M # 清理到只保留 500MB
sudo journalctl --vacuum-time=7d # 清理 7 天前的日志# 常见日志文件位置
/var/log/syslog # 系统日志（Ubuntu/Debian）
/var/log/messages # 系统日志（CentOS/RHEL）
/var/log/auth.log # 认证和授权日志（登录记录）
/var/log/kern.log # 内核日志
/var/log/nginx/access.log # Nginx 访问日志
/var/log/nginx/error.log # Nginx 错误日志
/var/log/mysql/error.log # MySQL 错误日志
# 实时追踪多个日志文件
tail -f /var/log/nginx/access.log /var/log/nginx/error.log
# 搜索日志中的关键词
grep "ERROR" /var/log/app.log
grep -i "error\|fatal\|critical" /var/log/syslog
grep "Mar 13" /var/log/nginx/error.log | grep "upstream"
# 统计错误出现次数
grep "ERROR" /var/log/app.log | wc -l
# 查看最近登录记录
last # 所有登录记录
lastb # 失败的登录尝试（需要 root）
lastlog # 每个用户的最后登录时间遇到服务异常，建议按以下顺序排查：
# 第一步：确认错误出现的时间点
journalctl -u myapp --since "2026-03-13 09:55" --until "2026-03-13 10:05"
# 第二步：查看前后 30 秒的上下文，是否有依赖服务同时异常
journalctl --since "2026-03-13 09:58" --until "2026-03-13 10:02" -p err
# 第三步：检查同一时间点的系统资源状态
# （是否有磁盘满、内存耗尽等资源类问题）
sar -u -r -d -s 09:55:00 -e 10:05:00 2>/dev/null || echo "需要安装 sysstat"Shell 是用户与操作系统内核之间的接口，负责解释你输入的命令并传递给内核执行。你每次打开终端，实际上是运行了一个 Shell 程序。常见的 Shell 有：
| Shell | 说明 |
|---|---|
| bash | Bourne Again Shell，Linux 默认，最广泛使用 |
| zsh | macOS 现默认，功能更丰富，插件生态好（Oh My Zsh） |
| sh | 最基础的 POSIX Shell，脚本兼容性最好 |
| fish | 用户友好，开箱即用的自动补全 |
| dash | Ubuntu 的 /bin/sh，执行速度快 |
查看当前使用的 Shell：
echo $SHELL # 当前用户的默认 Shell
echo $0 # 当前正在运行的 Shell
cat /etc/shells # 系统安装的所有 Shell 列表Shell 脚本是一个包含一系列命令的文本文件，可以批量自动化执行操作。
#!/bin/bash
# 第一行 shebang：告诉系统用哪个 Shell 解释这个脚本
# ↑ #!/usr/bin/env bash 更具移植性
# 这是注释
echo "Script started at $(date)"
# 退出码：0 表示成功，非 0 表示失败
# set -e 让脚本在任何命令失败时立即退出（推荐）
# set -u 让脚本在使用未定义变量时报错
# set -o pipefail 让管道中任何命令失败都算失败
set -euo pipefail给脚本添加执行权限并运行：
chmod +x deploy.sh
./deploy.sh # 执行
bash deploy.sh # 用 bash 解释执行（不需要执行权限）
bash -x deploy.sh # 调试模式：打印每条命令执行情况# 赋值（等号两侧不能有空格！）
name="Alice"
age=25
pi=3.14
# 使用变量（加 $）
echo $name
echo "Hello, $name!"
echo "Age: ${age}" # 花括号：明确变量边界，推荐养成习惯
# 命令赋值给变量
current_date=$(date +%F)
file_count=$(ls /tmp | wc -l)
echo "Today is $current_date, /tmp has $file_count files"
# 只读变量
readonly MAX_RETRIES=3
# MAX_RETRIES=5 # 会报错
# 删除变量
unset name
# 查看所有环境变量
env
printenv
echo $HOME
echo $PATH这是 Shell 中最容易出错的点，必须理解三种引号的区别：
name="World"
# 双引号：解析变量和命令替换
echo "Hello, $name!" # 输出：Hello, World!
echo "Today: $(date +%F)" # 输出：Today: 2026-03-13
# 单引号：完全原样输出，不解析任何内容
echo 'Hello, $name!' # 输出：Hello, $name!
echo 'Today: $(date +%F)' # 输出：Today: $(date +%F)
# 反引号（老式命令替换，推荐用 $() 替代）
files=`ls /tmp` # 不推荐
files=$(ls /tmp) # 推荐
# 转义特殊字符
echo "Price: \$100" # 输出：Price: $100
echo "Path: /home/user/file" # 普通斜杠不需要转义str="Hello, Linux World"
# 字符串长度
echo ${#str} # 输出：18
# 子字符串截取（从位置 7 开始，截取 5 个字符）
echo ${str:7:5} # 输出：Linux
# 字符串替换（替换第一个匹配）
echo ${str/Linux/Shell} # 输出：Hello, Shell World
# 字符串替换（替换所有匹配）
path="/usr/local/bin:/usr/bin"
echo ${path//:/\\n} # 把 : 替换为换行
# 去掉前缀（最短匹配）
file="archive.tar.gz"
echo ${file#*.} # 输出：tar.gz（去掉 archive.）
# 去掉后缀（最长匹配）
echo ${file%%.*} # 输出：archive（去掉所有扩展名）
echo ${file%.*} # 输出：archive.tar（只去掉最后一个 .gz）
# 转换大小写（bash 4+）
str="Hello World"
echo ${str,,} # 全小写：hello world
echo ${str^^} # 全大写：HELLO WORLD# 脚本相关特殊变量
echo $0 # 当前脚本名
echo $1 # 第一个参数
echo $2 # 第二个参数
echo $@ # 所有参数（作为独立字符串）
echo $* # 所有参数（作为一个字符串）
echo $# # 参数个数
echo $$ # 当前 Shell 的 PID
echo $! # 最近后台进程的 PID
echo $? # 上一个命令的退出码（0 成功，非 0 失败）
# 示例脚本：接受参数
#!/bin/bash
if [ $# -lt 1 ]; then
echo "Usage: $0 <name>"
exit 1
fi
echo "Hello, $1!"Linux 的每个进程默认有三个文件描述符：
0：标准输入（stdin）：键盘1：标准输出（stdout）：终端屏幕2：标准错误（stderr）：终端屏幕
# 标准输出重定向
echo "Hello" > output.txt # 覆盖写入
echo "World" >> output.txt # 追加写入
ls -la > file_list.txt
# 标准错误重定向
ls /nonexistent 2> error.log
find / -name "*.conf" 2>/dev/null # 把错误丢弃（常用！）
# 同时重定向 stdout 和 stderr
command > output.txt 2>&1 # 两者都写到同一文件
command > output.txt 2> error.txt # 分别写入不同文件
command &> all_output.txt # bash 简写，效果同上
# 标准输入重定向（从文件读取）
mysql -u root -p mydatabase < schema.sql
sort < unsorted.txt > sorted.txt
# /dev/null：黑洞设备，丢弃所有写入
command > /dev/null 2>&1 # 完全静默运行管道（|）把前一个命令的输出作为后一个命令的输入，是 Linux 命令组合能力的核心。
# 基础管道
ps -ef | grep nginx # 过滤进程
cat /var/log/nginx/access.log | wc -l # 统计行数
ls -la | sort -k5 -n -r # 按文件大小倒序
# 多级管道
ps -ef | grep nginx | grep -v grep | awk '{print $2}'
# 找 nginx 进程 → 过滤掉 grep 本身 → 提取 PID 列
# 统计 Nginx 访问日志中各 IP 的请求数（Top 10）
cat /var/log/nginx/access.log | awk '{print $1}' | sort | uniq -c | sort -rn | head -10
# tee：同时输出到屏幕和文件
./build.sh | tee build.log # 输出到屏幕并保存到文件# heredoc：将多行文本传给命令
cat << 'EOF'
Line 1
Line 2
Line 3
EOF
# 写入配置文件
sudo tee /etc/myapp/config.yaml << 'EOF'
database:
host: localhost
port: 5432
name: mydb
EOF
# 传给 SSH 执行多行命令
ssh user@server << 'ENDSSH'
echo "Running remote setup"
mkdir -p /opt/app
cd /opt/app
git pull origin main
ENDSSH# 基础 if
if [ condition ]; then
# 条件为真时执行
elif [ another_condition ]; then
# 另一个条件
else
# 以上都不满足时
fi
# 常用条件判断
file="/etc/nginx/nginx.conf"
if [ -f "$file" ]; then
echo "文件存在"
fi
if [ -d "/var/log" ]; then
echo "目录存在"
fi
if [ -e "$file" ]; then # 存在（文件或目录）
echo "路径存在"
fi
if [ -r "$file" ]; then # 可读
echo "文件可读"
fi
if [ -w "$file" ]; then # 可写
echo "文件可写"
fi
if [ -x "/usr/bin/python3" ]; then # 可执行
echo "python3 可执行"
finame="Alice"
count=10
# 字符串比较
if [ "$name" = "Alice" ]; then echo "匹配"; fi # 相等
if [ "$name" != "Bob" ]; then echo "不匹配"; fi # 不等
if [ -z "$name" ]; then echo "为空"; fi # 为空
if [ -n "$name" ]; then echo "非空"; fi # 非空
# 数字比较（必须用 -eq/-ne/-lt/-le/-gt/-ge，不能用 = < >）
if [ $count -eq 10 ]; then echo "等于10"; fi
if [ $count -ne 5 ]; then echo "不等于5"; fi
if [ $count -gt 5 ]; then echo "大于5"; fi
if [ $count -lt 20 ]; then echo "小于20"; fi
if [ $count -ge 10 ]; then echo "大于等于10"; fi
if [ $count -le 10 ]; then echo "小于等于10"; fi
# 更现代的写法（[[ ]] 支持正则和逻辑运算符）
if [[ "$name" == Al* ]]; then echo "以 Al 开头"; fi # 通配符匹配
if [[ "$name" =~ ^[A-Z] ]]; then echo "以大写开头"; fi # 正则匹配
if [[ $count -gt 5 && $count -lt 20 ]]; then echo "在范围内"; fi当需要对同一变量做多种匹配时，case 比多个 if-elif 更清晰：
#!/bin/bash
env=$1
case "$env" in
production|prod)
echo "部署到生产环境"
;;
staging|stag)
echo "部署到预发布环境"
;;
development|dev)
echo "部署到开发环境"
;;
*)
echo "未知环境: $env"
echo "用法: $0 [prod|staging|dev]"
exit 1
;;
esac# 遍历列表
for fruit in apple banana orange; do
echo "Fruit: $fruit"
done
# 遍历文件
for file in /var/log/*.log; do
echo "Processing: $file"
wc -l "$file"
done
# 遍历命令输出
for user in $(cat /etc/passwd | cut -d: -f1); do
echo "User: $user"
done
# C 风格数字循环
for ((i=1; i<=10; i++)); do
echo "Number: $i"
done
# 使用 seq 生成序列
for i in $(seq 1 5); do
echo "Step $i"
done
# 实用示例：批量备份配置文件
for conf in nginx mysql redis; do
src="/etc/$conf/$conf.conf"
if [ -f "$src" ]; then
cp "$src" "/backup/${conf}.conf.$(date +%F)"
echo "Backed up: $conf"
fi
done# while：条件为真时继续循环
count=1
while [ $count -le 5 ]; do
echo "Count: $count"
((count++))
done
# 逐行读取文件（推荐方式）
while IFS= read -r line; do
echo "Line: $line"
done < /etc/hosts
# 无限循环（用于守护进程或轮询）
while true; do
if curl -sf http://localhost:8080/health > /dev/null; then
echo "Service is up"
break
fi
echo "Waiting for service..."
sleep 5
done
# until：条件为假时继续（与 while 相反）
until [ -f "/tmp/ready.flag" ]; do
echo "Waiting for ready flag..."
sleep 2
done
echo "Ready flag found!"for i in $(seq 1 10); do
if [ $i -eq 3 ]; then
continue # 跳过本次迭代，继续下一次
fi
if [ $i -eq 7 ]; then
break # 退出整个循环
fi
echo $i
done
# 输出：1 2 4 5 6# 定义函数
log_info() {
echo "[$(date +%T)] INFO: $1"
}
log_error() {
echo "[$(date +%T)] ERROR: $1" >&2 # 错误输出到 stderr
}
# 调用函数
log_info "Script started"
log_error "Something went wrong"
# 函数带返回值（通过 echo 输出）
get_timestamp() {
echo $(date +%Y%m%d_%H%M%S)
}
ts=$(get_timestamp)
echo "Timestamp: $ts"
# 函数带参数
deploy() {
local env=$1 # local：局部变量，不影响全局
local version=$2
log_info "Deploying version $version to $env"
if [ -z "$env" ] || [ -z "$version" ]; then
log_error "Usage: deploy <env> <version>"
return 1 # 函数退出码
fi
# ... 部署逻辑 ...
return 0
}
deploy production v2.1.0#!/bin/bash
set -euo pipefail
# 错误处理函数（在脚本退出时调用）
cleanup() {
local exit_code=$?
if [ $exit_code -ne 0 ]; then
echo "Script failed with exit code: $exit_code"
# 清理临时文件等
rm -f /tmp/lock.$$
fi
}
trap cleanup EXIT # 无论正常退出还是出错都会调用
# 检查命令是否成功
if ! command -v nginx >/dev/null 2>&1; then
echo "Error: nginx is not installed"
exit 1
fi
# 或者更简洁的写法
nginx -t || { echo "Nginx config test failed"; exit 1; }这三个工具是 Linux 文本处理的核心，掌握它们可以高效处理日志、配置文件和数据。
# 基础搜索
grep "error" /var/log/app.log
grep -i "Error" /var/log/app.log # 忽略大小写
grep -n "error" /var/log/app.log # 显示行号
grep -c "error" /var/log/app.log # 只显示匹配行数
grep -v "DEBUG" /var/log/app.log # 排除包含 DEBUG 的行
# 扩展正则表达式（-E 或 egrep）
grep -E "error|warning|critical" app.log # 或匹配
grep -E "^[0-9]{4}-" app.log # 以4位数字开头的行
grep -E "\b404\b" access.log # 精确匹配单词 404
# 上下文显示
grep -A 3 "ERROR" app.log # 匹配行 + 后 3 行
grep -B 3 "ERROR" app.log # 匹配行 + 前 3 行
grep -C 3 "ERROR" app.log # 匹配行 + 前后各 3 行
# 递归搜索目录
grep -r "TODO" /opt/app/src/
grep -rl "password" /etc/ # -l 只显示文件名
# 统计日志中各类状态码的数量
grep -oE '"[0-9]{3} ' access.log | sort | uniq -c | sort -rn# 基础替换（s/旧内容/新内容/g）
sed 's/http/https/g' config.txt # 输出到屏幕
sed -i 's/http/https/g' config.txt # 直接修改文件（-i 原地编辑）
sed -i.bak 's/http/https/g' config.txt # 修改前自动备份为 .bak
# 只替换第 2 次出现
sed 's/foo/bar/2' file.txt
# 指定行范围操作
sed '5,10d' file.txt # 删除第 5 到 10 行
sed '1d' file.txt # 删除第 1 行（删除文件头部注释）
sed '/^#/d' config.txt # 删除所有注释行
sed '/^$/d' file.txt # 删除所有空行
# 在特定行前后插入内容
sed '3i\新增这一行' file.txt # 在第 3 行前插入
sed '/server_name/a\ listen 443 ssl;' nginx.conf # 在匹配行后插入
# 提取特定行
sed -n '10,20p' file.txt # 只输出第 10-20 行
sed -n '/BEGIN/,/END/p' file.txt # 输出 BEGIN 到 END 之间的内容
# 实用示例：修改配置文件中的端口
sed -i 's/^port = .*/port = 8080/' /etc/myapp/config.iniawk 是一个完整的文本处理语言，特别擅长处理按列分隔的数据：
# 基础：打印特定列（默认按空白分隔）
awk '{print $1}' file.txt # 打印第 1 列
awk '{print $1, $3}' file.txt # 打印第 1 和第 3 列
awk '{print NR, $0}' file.txt # 打印行号和完整行
df -h | awk '{print $1, $5}' # 打印分区名和使用率
# 指定分隔符（-F）
awk -F: '{print $1, $7}' /etc/passwd # 打印用户名和 Shell
awk -F, '{print $1}' data.csv # 处理 CSV
# 条件过滤
awk '$3 > 100' data.txt # 只处理第 3 列大于 100 的行
awk '/ERROR/ {print $0}' app.log # 包含 ERROR 的行
awk 'NR > 10 && NR < 20' file.txt # 只处理第 11-19 行
# 计算统计
awk '{sum += $1} END {print "Total:", sum}' numbers.txt
awk '{count[$1]++} END {for (ip in count) print count[ip], ip}' access.log | sort -rn | head
# 实用示例：分析 Nginx 访问日志
# 统计各 HTTP 状态码数量
awk '{print $9}' /var/log/nginx/access.log | sort | uniq -c | sort -rn
# 统计各 IP 的请求次数（Top 10）
awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -10
# 提取响应时间超过 1 秒的请求
awk '$NF > 1.0 {print $0}' /var/log/nginx/access.log下面是一个贴近真实场景的部署脚本，综合运用了前面所有知识点：
#!/bin/bash
# deploy.sh - 应用部署脚本
# 用法: ./deploy.sh [production|staging] [version]
set -euo pipefail
# ─── 配置 ──────────────────────────────────────────────
APP_NAME="myapp"
DEPLOY_DIR="/opt/${APP_NAME}"
LOG_DIR="/var/log/${APP_NAME}"
BACKUP_DIR="/opt/backups/${APP_NAME}"
SERVICE_NAME="${APP_NAME}"
# ─── 工具函数 ───────────────────────────────────────────
log_info() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] [INFO] $*"; }
log_warn() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] [WARN] $*" >&2; }
log_error() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] [ERROR] $*" >&2; }
# 脚本退出时的清理工作
cleanup() {
local code=$?
[ $code -ne 0 ] && log_error "Deployment failed! Exit code: $code"
rm -f /tmp/deploy.$$.lock
}
trap cleanup EXIT
# ─── 参数检查 ───────────────────────────────────────────
if [ $# -lt 2 ]; then
log_error "Usage: $0 <env> <version>"
log_error " env: production | staging"
log_error " version: e.g. v2.1.0"
exit 1
fi
ENV=$1
VERSION=$2
case "$ENV" in
production|staging) ;;
*) log_error "Unknown environment: $ENV"; exit 1 ;;
esac
# ─── 防止并发部署 ────────────────────────────────────────
LOCK_FILE="/tmp/deploy.$$.lock"
if [ -f "$LOCK_FILE" ]; then
log_error "Another deployment is in progress!"
exit 1
fi
touch "$LOCK_FILE"
# ─── 主流程 ─────────────────────────────────────────────
log_info "Starting deployment: $APP_NAME $VERSION → $ENV"
# 1. 检查依赖
for cmd in git systemctl nginx; do
if ! command -v $cmd &>/dev/null; then
log_error "Required command not found: $cmd"
exit 1
fi
done
# 2. 备份当前版本
mkdir -p "$BACKUP_DIR"
if [ -d "$DEPLOY_DIR/current" ]; then
BACKUP_PATH="${BACKUP_DIR}/${VERSION}-$(date +%Y%m%d_%H%M%S)"
log_info "Backing up current version to $BACKUP_PATH"
cp -a "$DEPLOY_DIR/current" "$BACKUP_PATH"
fi
# 3. 拉取新版本
log_info "Fetching version $VERSION..."
cd "$DEPLOY_DIR"
git fetch --tags
git checkout "$VERSION"
# 4. 安装依赖并构建
log_info "Installing dependencies..."
npm ci --production 2>&1 | tee -a "$LOG_DIR/deploy.log"
# 5. 配置检查
log_info "Validating nginx config..."
nginx -t || { log_error "Nginx config validation failed!"; exit 1; }
# 6. 重启服务
log_info "Restarting service..."
sudo systemctl restart "$SERVICE_NAME"
# 7. 健康检查（最多等 30 秒）
log_info "Waiting for service health check..."
for i in $(seq 1 6); do
if curl -sf "http://localhost:8080/health" > /dev/null; then
log_info "Health check passed!"
break
fi
if [ $i -eq 6 ]; then
log_error "Health check failed after 30 seconds!"
exit 1
fi
log_warn "Health check attempt $i/6 failed, retrying in 5s..."
sleep 5
done
log_info "Deployment completed successfully: $APP_NAME $VERSION → $ENV"| 命令 | 说明 |
|---|---|
pwd |
显示当前路径 |
cd /path |
切换目录 |
ls -alh |
详细列出文件（含隐藏文件，人类可读大小） |
ls -lt |
按时间排序 |
mkdir -p /a/b/c |
递归创建目录 |
cp -a src dst |
保留属性复制 |
mv old new |
移动/重命名 |
rm -rf dir/ |
递归强制删除（高危） |
ln -s target link |
创建软链接 |
find /path -name "*.log" |
按名称搜索文件 |
find /path -mtime +7 |
搜索 7 天前的文件 |
| 命令 | 说明 |
|---|---|
cat file |
输出文件全部内容 |
less file |
分页查看 |
head -n 20 file |
查看前 20 行 |
tail -n 50 file |
查看后 50 行 |
tail -f file |
实时追踪文件新增内容 |
stat file |
查看文件详细元信息 |
| 命令 | 说明 |
|---|---|
chmod 755 file |
修改权限（数字） |
chmod +x file |
添加执行权限 |
chown user:group file |
修改属主属组 |
chown -R user:group /dir |
递归修改 |
umask |
查看默认权限掩码 |
sudo command |
以 root 权限执行 |
sudo -l |
查看当前用户 sudo 权限 |
useradd -m -s /bin/bash user |
创建用户 |
usermod -aG group user |
追加用户到组 |
| 命令 | 说明 |
|---|---|
ps -ef |
查看所有进程 |
ps -ef | grep name |
过滤进程 |
top / htop |
实时进程监控 |
pgrep -l name |
按名称查找 PID |
kill -15 PID |
优雅终止进程 |
kill -9 PID |
强制终止进程 |
killall name |
按名称终止所有进程 |
nohup cmd & |
后台持久运行 |
| 命令 | 说明 |
|---|---|
systemctl status svc |
查看服务状态 |
systemctl start svc |
启动服务 |
systemctl stop svc |
停止服务 |
systemctl restart svc |
重启服务 |
systemctl reload svc |
重载配置（不中断） |
systemctl enable svc |
设置开机自启 |
systemctl disable svc |
取消开机自启 |
systemctl enable --now svc |
设置自启并立即启动 |
systemctl list-units --state=failed |
列出失败服务 |
| 命令 | 说明 |
|---|---|
df -h |
磁盘分区使用情况 |
du -sh /path/* |
目录磁盘占用 |
free -h |
内存使用情况 |
uptime |
系统负载 |
vmstat 1 5 |
综合系统资源采样 |
iostat -x 1 5 |
磁盘 IO 监控 |
| 命令 | 说明 |
|---|---|
journalctl -u svc -n 100 |
服务最近 100 行日志 |
journalctl -u svc -f |
实时追踪服务日志 |
journalctl -p err -n 50 |
最近 50 条错误 |
journalctl --since "1 hour ago" |
最近 1 小时日志 |
tail -f /var/log/nginx/error.log |
追踪 Nginx 错误日志 |
| 命令 | 说明 |
|---|---|
grep -n "keyword" file |
搜索并显示行号 |
grep -v "exclude" file |
排除匹配行 |
grep -E "pat1|pat2" |
多模式匹配 |
grep -C 3 "ERROR" file |
匹配行及前后 3 行 |
sed 's/old/new/g' file |
全局替换 |
sed -i.bak 's/old/new/g' file |
原地替换并备份 |
awk '{print $1}' file |
打印第一列 |
awk -F: '{print $1}' /etc/passwd |
指定分隔符 |
sort | uniq -c | sort -rn |
排序去重统计频率 |
wc -l file |
统计行数 |
- Linux man-pages：所有 Linux 命令和系统调用的权威手册，用
man command在本地查阅 - The Linux Documentation Project (TLDP)：大量 Linux 学习指南和 HOWTO 文档，适合系统性学习
- GNU Coreutils 手册：常用 Linux 基础命令（如
cp、mv、ls、cat）的官方参考
- systemctl 手册（man7）：systemctl、journalctl、Unit 文件相关操作的权威手册入口
- systemd by Example：通过大量实例理解 systemd 各组件
- Bash 参考手册：Bash 官方完整文档
- Shell Scripting Tutorial：循序渐进的 Shell 脚本学习教程
- ShellCheck：在线 Shell 脚本静态检查工具，帮你发现常见错误（强烈推荐！）
- Google Shell Style Guide：Google 内部 Shell 脚本规范，适合进阶学习
- Nginx 运维文档：Nginx 配置与优化的官方参考
- The Art of Command Line：高质量命令行使用技巧集合，中文版
本文档持续维护更新。如有错误或建议，欢迎提交 Issue 或 PR。