Linux 零基础入门教程

一本写给"完全没接触过 Linux"的人的教程。 不需要任何基础，只要会开机、会打字，就能从头学到能上手干活。

写给翻开这本书的你

如果你有过下面这些念头，这本书就是为你写的：

• "Linux 是不是很难？我数学不好、英语不好，能学吗？"
• "命令那么多，我记不住怎么办？"
• "网上的教程一上来就是一堆术语，我看两行就懵了。"
• "敲错了会不会把电脑搞坏？"

先给你三个放心的答案：

1. 能学。 Linux 常用命令其实只有几十个，而且在真实工作里反复出现的就是那些。你不需要背，你需要的是"知道有这么个东西、用的时候能查回来"。
2. 不用背。 这本书里每一条命令都告诉你"它解决什么问题"。只要记住问题，命令忘了随时能查。
3. 不会搞坏。 我们会让你在虚拟机里练习。虚拟机是电脑里"模拟出来的一台电脑"，你怎么折腾都行，坏了删掉重建，你的真实电脑一点事没有。

这本书和其他教材有什么不一样

怎么用这本书

先看懂标记

• 🔰 必学：所有人都要掌握，后面会反复用到。
• 🔧 进阶：第一遍看不懂可以先跳过，只要知道"有这回事"，等用到了再回来。

全书 10 篇、59 章。第一遍建议只学 🔰 章节，🔧 章节当"选修课"。

每章都是同一个结构

每章都长这样，你熟悉一次就够了：

第N章 标题
> 学完这一章，你能：……        ← 每章开头告诉你目标
N.1 小节（先讲人话，再给命令）
N.2 小节
本章小结（一张表，把这一章的东西收拢）
动手练（几道小题 + 参考答案）

学习节奏：一天一章就够

⚠️ 注意：宁可一天一章敲扎实，不要一天十章看过去。看会了≠会了，手指头敲出来的才算会。

三步学习法（很重要）

1. 照着敲：把书里的例子一字不差敲进终端，看结果和书上写的是不是一样。
2. 改一改：把文件名、路径、数字改掉再敲一次，看会不会报错、为什么报错。这一步才是真正学东西的地方。
3. 合上书重做：不看答案，自己把这道题再做一遍。做不出来就再看一眼，然后接着试。

学习路线图

一个零基础的人，按每天 1 章的节奏，大约 3～4 周可以把全书 🔰 部分学完。

你需要准备什么

1. 一台电脑（Windows 就可以，不需要很新）。
2. 一个虚拟机软件：VMware Workstation 或 VirtualBox（免费）。
3. 一个 Linux 系统镜像：推荐 CentOS 7（本书示例都用它）或 Ubuntu 22.04。
4. 一个远程连接工具：Windows 自带的 cmd 或 PowerShell 就够，也可以装 Xshell、MobaXterm。

💡 小贴士：如果装虚拟机对你来说太麻烦，还有一个更省事的办法——用云服务器。很多云厂商有几十块钱一个月的入门配置，甚至学生可以免费领。这样你也不用担心"敲坏了"。

具体怎么装、怎么连，见第 6 章。

遇到问题怎么办（按这个顺序）

1. 先看报错。Linux 的报错一般第一行就说了原因，比如 No such file or directory（没有这个文件或目录）、Permission denied（权限不够）。看不懂就把它复制下来去搜。
2. 查手册。命令 --help 看简版说明，man 命令 看完整手册（按 q 退出）。
3. 搜英文报错原文。中文搜不到就直接搜英文原句，命中率高得多。
4. 问人的时候给出三样东西：完整命令、完整报错、你期望的结果。

三个心态提醒

1. 看不懂命令的语法，是正常的。 你们学开车的时候也不会先学发动机原理。先照着开，开着开着就懂了。
2. 报错是好东西，不是失败。 每一条报错都在告诉你"哪里不对"。熟练的人的差别不是不报错，而是会看报错。
3. 一定要动手。 这本书最大的价值不是读，是让你在终端里敲出第一个 ls、第一次看到自己的文件。今天就去敲。

目录

第一篇 认识 Linux

• 第1章 Linux 到底是什么 🔰
• 第2章 Linux 能用来做什么 🔰
• 第3章 我该选哪个版本 🔰
• 第4章 Linux 和 Windows 有什么不一样 🔰
• 第5章 Linux 的三个核心思想 🔰

第二篇 走进 Linux

• 第6章 第一次登录 Linux 🔰
• 第7章 看懂终端里那行字 🔰
• 第8章 命令是怎么组成的 🔰
• 第9章 认识目录树：文件都放在哪 🔰
• 第10章 必学的五个基础命令 🔰

第三篇 文件和目录

• 第11章 创建文件与文件夹：touch 和 mkdir 🔰
• 第12章 复制、移动、重命名：cp 和 mv 🔰
• 第13章 删除：rm 🔰
• 第14章 查看文件内容：cat、more、less、head、tail 🔰
• 第15章 软链接与硬链接 🔧
• 第16章 通配符和花括号：一次处理一批文件 🔰
• 第17章 重定向和管道 🔰
• 第18章 键盘上的省力技巧 🔰

第四篇 文本编辑：vi / vim

• 第19章 vi 是什么，为什么非学不可 🔰
• 第20章 vim 常用的三种模式与切换 🔰
• 第21章 十个够用的 vim 操作 🔰

第五篇 用户和权限

• 第22章 为什么要分用户 🔰
• 第23章 用户管理：useradd、passwd、su、id 🔰
• 第24章 组是什么 🔰
• 第25章 权限的三个字母 rwx 🔰
• 第26章 看懂 ls -l 的输出 🔰
• 第27章 修改权限 chmod 🔰
• 第28章 修改属主和属组：chown、chgrp 🔰
• 第29章 umask：新文件的默认权限 🔧
• 第30章 三个特殊权限 🔧
• 第31章 隐藏权限：chattr 和 lsattr 🔧
• 第32章 ACL：给某个用户单独开小灶 🔧
• 第33章 sudo：临时借用 root 的权力 🔰

第六篇 装软件

• 第34章 Linux 装软件的四种方式 🔰
• 第35章 yum：最常用的装软件方式 🔰
• 第36章 配置 yum 源 🔰
• 第37章 rpm：直接安装单个安装包 🔧
• 第38章 源码编译安装 🔧
• 第39章 压缩和解压 🔰

第七篇 磁盘管理

• 第40章 磁盘、分区、格式化、挂载：四个词一次讲清 🔰
• 第41章 分区：fdisk 与 gdisk 🔧
• 第42章 格式化：mkfs 🔧
• 第43章 挂载：mount、umount 与 /etc/fstab 🔧
• 第44章 swap 交换分区 🔧
• 第45章 LVM：能变大变小的硬盘 🔧
• 第46章 RAID：多块硬盘合作 🔧

第八篇 日常运维命令

• 第47章 查看系统状态 🔰
• 第48章 进程管理 🔰
• 第49章 网络排查 🔰
• 第50章 find：按条件找文件 🔰
• 第51章 history 和 alias 🔰

第九篇 文本三剑客

• 第52章 grep：从一堆文字里挑出你要的 🔰
• 第53章 sed：批量改文字 🔰
• 第54章 awk：按列取数据 🔰
• 第55章 正则表达式入门 🔧

第十篇 服务、网络与防火墙

• 第56章 systemctl：管理服务的开关 🔰
• 第57章 配置网络 🔰
• 第58章 防火墙 🔰
• 第59章 常见基础服务一览 🔧

附录

• 附录A 命令速查表
• 附录B 常见报错与解决办法
• 附录C 学习路线与下一步
• 附录D 原始文档整理说明（勘误）

第一篇 认识 Linux

这一篇不讲命令，只讲"Linux 到底是个什么东西"。 看似没用，其实最有用——概念没清，后面每一条命令都会背得痛苦。

第1章 Linux 到底是什么 🔰

学完这一章，你能：用自己的话向别人解释 Linux 是什么，以及为什么它既叫"内核"又叫"操作系统"。

1.1 先说操作系统是什么

一台电脑，从你按下电源键到能用鼠标点东西，中间有一层东西在干活：它要管屏幕亮不亮、管键盘按了哪个键、管文件存在哪、管程序怎么抢 CPU。

这层东西就是操作系统。

比喻：把电脑想成一家公司。 硬件（CPU、内存、硬盘）是员工，只会闷头干活，不会自己安排工作。 操作系统就是总经理：它安排谁干什么、什么时候干、干多久，还负责对接外面的人（你）。 Windows 是总经理，Linux 也是总经理，只是两个总经理的管理风格不一样。

所以你平常用的 Windows、手机上的安卓、苹果的 macOS，都是操作系统。

1.2 Linux 这个名字，其实有两种意思

这是所有初学者第一个绕不过去的点，一定要分清。

狭义上的 Linux：只是"内核"。

内核（kernel）是操作系统里最核心的那一小块程序，它只干四件事：

广义上的 Linux：一整套能用的操作系统。

光有内核，你是什么都干不了的——没有 ls、没有 cd、没有编辑器的界面。所以真正交到你手上的"Linux"，是内核 + 一大堆配套软件打包在一起的成品。

比喻：Linux 内核是发动机。 光有一台发动机，你开不走。要装上车架、轮子、方向盘、座椅，才是一辆能开的车。 这些"整车"，就叫发行版（distribution，简称"发行版"）。第 3 章专门讲怎么挑。

严格来说，我们日常用的这一整套，叫 GNU/Linux：

• GNU：一个开源软件组织，提供了大量基础工具（我们后面要用的 ls、cd、cat 都是它家的）。
• Linux：Linus Torvalds 在 1991 年写的内核。

💡 小贴士：以后看到 "GNU/Linux" 这个写法，别觉得奇怪，它是在说"内核是 Linux，工具是 GNU 的"。

1.3 Linux 是怎么来的（一分钟版本）

• 1970 年前后，美国贝尔实验室做了一个叫 Unix 的操作系统，非常好用，但价格贵、还闭源。
• 1980 年代，麻省理工的 Richard Stallman（斯托曼） 发起 GNU 计划，想做一个完全自由的操作系统，工具都写好了，就差内核。
• 1991 年，芬兰大学生 Linus Torvalds（林纳斯） 写了一个内核，发在学校 BBS 上，起名 Linux。
• 两边一凑，GNU 的工具 + Linux 的内核 = 一套完整免费的操作系统。

它为什么能火？因为它开源、免费。

开源的意思是：作者把程序的源代码（人能看懂的代码）公开出来，任何人都能看、能改、能再发布。于是全世界的程序员都往里加东西，它就越做越好。

1.4 为什么全世界的服务器都在用 Linux

• 全球 90% 以上的服务器运行 Linux。
• 你手机里的安卓系统，内核就是 Linux。
• 路由器、智能电视、车机、工业机器人、超级计算机，大量在用 Linux。

原因就三条：免费、稳定、可定制。服务器一开机就要跑好几年不重启，Windows 做不到，Linux 可以。

本章小结

动手练

1. 用自己的话说一遍：为什么"Linux 只是一个内核"却不能直接拿来用？
2. 你手机的操作系统内核可能是什么？
3. 判断题：Linux 是 Unix。（说说你的理由）

参考答案

1. 因为内核只负责管 CPU、内存、硬件、文件这些底层工作，没有给人用的命令、没有界面，也没有配套工具。必须先打包一堆软件，才能变成"能用的操作系统"。
2. 安卓手机的内核是 Linux。（顺便说一句，苹果的 macOS 和 iOS 走的是另一条路：Unix → macOS/iOS。所以"类 Unix 系统"有两个大分支：Unix 那一支和 Linux 这一支。）
3. 错。Linux 是类 Unix（Unix-like）系统——借鉴了 Unix 的设计思想，但不是从 Unix 的代码改出来的。真正从 Unix 代码派生出来的是 macOS、iOS 这一支。

第2章 Linux 能用来做什么 🔰

学完这一章，你能：说出 Linux 主要用在哪几个地方，以及学会它能找什么样的工作。

2.1 服务器：Linux 的主战场

服务器就是"专门给别的电脑提供服务的电脑"：网站、App 后台、数据库、文件存储，都跑在服务器上。

你在浏览器打开一个网页，背后可能是几十台 Linux 服务器在干活。银行、电商、12306 抢票、微信消息，全在 Linux 上跑。

2.2 云计算和容器

现在说的"云服务器""阿里云/腾讯云/AWS"，绝大多数底层是 Linux。

你可能听过 Docker、Kubernetes（K8s）这些词——它们全是跑在 Linux 上的技术。学 Linux 是学云计算的前置条件。

2.3 你口袋里的安卓手机

安卓系统的内核就是 Linux。所以严格说，你早就在用 Linux 了，只是它被包装得很漂亮。

2.4 各种智能设备（嵌入式）

路由器、机顶盒、智能音箱、汽车中控、工业机器人、ATM 机、POS 刷卡机……这些设备里塞不下 Windows，但它们塞得下 Linux。这类开发叫嵌入式开发。

2.5 超级计算机

全世界跑得最快的那些超级计算机，操作系统几乎清一色是 Linux。因为只有开源才能把它们改到极致。

2.6 学完 Linux 能找什么工作

💡 小贴士：就算你不打算做运维，只要你的工作会碰到"服务器"这两个字，Linux 就是绕不过去的门槛。

本章小结

动手练

1. 举三个你身边可能正在运行 Linux 的设备。
2. 为什么智能设备喜欢用 Linux，而不是 Windows？
3. 如果你以后想做运维，这本书哪些部分最重要？

参考答案

1. 参考：家里的路由器、安卓手机、智能电视/机顶盒。任何三个合理答案都可以。
2. 因为 Linux 免费、可裁剪（只要内核和必需的工具，能做得非常小）、开源可定制，而且对硬件要求低、能长期稳定运行。Windows 体积大、要授权费、不适合深度剪裁。
3. 第五篇（用户与权限）、第六篇（装软件）、第八篇（系统状态与排查）、第十篇（服务与网络）这几篇最常用，第一篇到第四篇是它们的地基。

第3章 我该选哪个版本 🔰

学完这一章，你能：认识常见的 Linux 发行版，并知道自己该装哪一个。

3.1 发行版是什么

第 1 章说过：内核是发动机，发行版是整车。同一个内核，不同厂家装出来的车，牌子、配置、用法都有差别。

这些"牌子"就叫发行版（distribution）。目前主流的可以分成两大流派，区别主要在装软件的工具不一样：

⚠️ 注意：这是新手最容易搞混的地方——网上的教程如果用的是 apt，而你的系统是 CentOS，那么 apt install 在你这儿就是不存在的命令。学习时一定要先确认教程是哪个流派。

3.2 Red Hat 系（国内企业最多）

💡 关于 CentOS 7：CentOS 7 已于 2024 年 6 月停止维护。但国内大量存量服务器和教材还在用它，而且它足够老、足够稳定、资料最多，所以本书的示例以 CentOS 7 为准。学完换 Rocky 9 / Ubuntu 只是换几条命令的事。

3.3 Debian 系

3.4 Ubuntu 的版本号怎么读

Ubuntu 一年发两个版本，版本号是"年份.月份"：

• Ubuntu 20.04 = 2020 年 4 月发布
• Ubuntu 22.04 = 2022 年 4 月发布
• Ubuntu 24.04 = 2024 年 4 月发布

偶数年的 4 月版本（.04 结尾）是长期支持版（LTS），一般支持 5 年。装系统优先选 LTS。

3.5 那到底装哪个？

⚠️ 注意：不用纠结。Linux 的内核、命令、目录结构、权限模型在所有发行版里是一样的，差别主要在"装软件"和"配网络"。学会一个，换另一个只需要一两天。

本章小结

动手练

1. 一个教程写着 sudo apt install nginx，另一个写着 sudo yum install nginx，分别适合什么系统？
2. Ubuntu 24.04 是哪年哪月发布的？是长期支持版吗？
3. 判断题：学会 CentOS 之后，Ubuntu 的命令要从头再学一遍。

参考答案

1. apt 用于 Debian 系（Ubuntu、Debian、Kali）；yum 用于红帽系（CentOS、RHEL、Rocky、麒麟）。
2. 2024 年 4 月发布；是 LTS（长期支持版）。
3. 错。绝大部分命令（ls、cd、chmod、ps……）完全通用，只有装软件（yum/apt）和部分网络配置文件的写法不同。

第4章 Linux 和 Windows 有什么不一样 🔰

学完这一章，你能：说出 Linux 和 Windows 最关键的 6 个差别，避免把 Windows 的习惯带到 Linux 里。

4.1 一张表看懂

下面挑最容易出事的几个详细说。

4.2 没有 C 盘 D 盘，所有东西都在 / 下面

Windows 里，文件可能放在 C:\Users\Tom\file.txt。Linux 里没有 C: 这种东西，所有硬盘、所有文件，都被"挂"在一棵以 /（读作"根"）开始的树上。

# 看看根目录下有什么
ls /
# 你会看到类似这样：
bin  boot  dev  etc  home  lib  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

具体每个目录是干什么的，第 9 章会一个个讲。这里只要记住一句话：没有盘符，只有一个 /。

4.3 Linux 区分大小写！

这是新手第一周最常见的事故来源。

在 Linux 里：

• File.txt、file.txt、FILE.TXT 是三个完全不同的文件。
• 命令也是：ls 能运行，LS 会报错 command not found。

⚠️ 注意：敲命令和写文件名时，照着书上一字不差地敲，别自己"顺手"改大小写。

4.4 没有回收站，rm 删了就是删了

在 Windows 里删文件，它进回收站，你反悔了还能还原。

Linux 命令行里的 rm 直接删掉，不进回收站。而且它不会问你"确定吗"。

⚠️ 注意：第 13 章会专门讲怎么安全地删。现在先记住一句：执行 rm -rf 之前，先把命令念一遍再说。

4.5 权限很严格

在 Windows 里，你平时是管理员，装软件、改系统设置一般点个"是"就过了。

Linux 里分得很清楚：平时你就是个普通用户，很多事干不了；需要管理员权限时，要在命令前面加 sudo，然后输入自己的密码。

这不是 Linux 不友好，恰恰是它安全的原因——服务器上的一个误操作，可能让整个公司的业务挂掉。

# 普通用户想改系统配置，会被拒绝
cat /etc/shadow
# 你会看到：
cat: /etc/shadow: 权限不够

# 借用管理员身份来做
sudo cat /etc/shadow
# 输入你自己（当前用户）的密码后，就能看了

💡 小贴士：这里第一次见到 # 开头的注释和 sudo，不用深究，第 33 章讲 sudo，第 25 章讲权限。

4.6 靠命令行干活，而且效率极高

Linux 当然也能装图形界面，但服务器上通常不装，因为图形界面占内存、还容易出问题。

用命令行的好处是：能批量、能组合、能写成脚本自动跑。

举个直观的例子——你要找出 /var/log 下面今天改过的所有 .log 文件：

• 用鼠标：一个个文件夹点开，看重的时间……点到天黑。
• 用命令：一行，几秒钟。

find /var/log -name "*.log" -mtime -1

这就是为什么学 Linux 必须学命令行——它不是"高级玩法"，它就是 Linux 的日常方式。

本章小结

动手练

1. 判断题：在 Linux 里 Data.txt 和 data.txt 是同一个文件。
2. 为什么服务器通常不装图形界面？
3. 你在 Windows 里习惯"复制到 D 盘备份"，在 Linux 里这句话要改成什么说法？

参考答案

1. 错。Linux 区分大小写，两个不同的文件。
2. 图形界面占内存和 CPU、组件多容易出问题、远程操作也不方便；命令行更轻、更稳、还能自动化。
3. Linux 没有 D 盘，要"复制到某个目录"，比如 cp 文件 /data/备份/——这里的 /data 是根目录下一个叫 data 的文件夹（它的背后可能是一块单独的硬盘）。

第5章 Linux 的三个核心思想 🔰

学完这一章，你能：理解 Linux 的设计逻辑，后面学命令时"秒懂"很多设计为什么是这样。

这三句话是 Linux 的"世界观"。第一次听可能没什么感觉，学完第三篇再回来看，你会发现处处都在印证它们。

5.1 一切皆文件

Linux 里，几乎所有东西都被当成"文件"来管理：

有什么好处？ 既然都是文件，那么一套读写文件的命令，就能操作所有东西。查看磁盘信息可以用 cat /proc/...，往设备里写数据也是"写文件"，简单统一。

比喻：这就像一个公司把所有事项都办成"一份文件走流程"。不管你是请假、报销还是领电脑，都是填表走流程。规矩统一，好管。

5.2 一个命令只干一件事，组合起来干大事

Linux 的命令都很"小"：ls 只负责列文件，grep 只负责按关键字过滤，awk 只负责按列取数。它们单个都很简单，但能用管道 | 串起来。

管道的含义很直白：把前一个命令的输出，直接交给后一个命令当输入。

# 需求：只看当前系统里正在监听的网络端口
ss -lnutp
# 输出很多，看着累

# 组合起来：只保留含 sshd 的那几行
ss -lnutp | grep sshd
# 你会看到类似：
tcp   LISTEN  0  128  0.0.0.0:22  0.0.0.0:*  users:(("sshd",pid=987,fd=3))

比喻：就像流水线。工位 A 只管拧螺丝，工位 B 只管装盖子，一个产品从 A 传到 B，最后出来的是成品。没有哪个工人会干全部的活，但流水线能干出很复杂的活。

这个思想会在第 17 章（管道）和第九篇（文本三剑客）里反复用到。

5.3 尽量少交互

"交互"就是"命令停下来等你按个 y 或 n"。

Linux 的设计倾向于：别停下来问我，要问就让我提前在命令里写好答案。

# 会停下来问你 "Is this ok [y/N]: "，要手敲 y 回车
yum install nginx

# 加 -y，表示"所有问题都替我回答 yes"，一路装到底
yum install -y nginx

好处：可以把它写成脚本，让机器半夜自己跑，不用人守着。这也是"自动化运维"的基础。

5.4 顺带说说：开源和许可证

既然 Linux 是开源的，那"开源"到底是怎么规定的？靠许可证（License）。你只需要知道最常见的三种：

💡 小贴士：做开发的同学要注意——GPL 的代码不能随便用进闭源的商业软件，否则可能被要求开源。这是真实存在的法律风险。

本章小结

动手练

1. 判断题：既然"一切皆文件"，那用 cat 命令读一块硬盘的数据，理论上是可行的。
2. 用一句话解释管道 | 是干什么的。
3. yum install 和 yum install -y 的区别是什么？为什么运维更喜欢后一种？

参考答案

1. 对。硬盘在 Linux 里就是 /dev/sda 这样的文件，cat /dev/sda 确实能读出二进制数据（但会刷满屏幕，实践中用 dd 等工具）。
2. 管道把前一个命令的输出，交给后一个命令当输入，像流水线一样把两个简单命令拼成复杂功能。
3. yum install 会中途停下来问你是否确认；yum install -y 自动回答"是"。运维喜欢后一种，因为可以在脚本里无人值守地批量安装。

第二篇 走进 Linux

这一篇开始真正动手。你会第一次登进 Linux，看懂那个黑窗口里每一段字的意思， 然后学会最基本的几个命令。别怕敲错——在虚拟机里，敲坏了删掉重来就是。

第6章 第一次登录 Linux 🔰

学完这一章，你能：把自己"送进"Linux 系统，干完活再安全地退出来。

6.1 登录，就是进自己家的门

Linux 是一台"多人共用"的机器，每个人有自己的账号和密码，像一栋楼里每户人家有自己的钥匙。 登录 = 交出名字和密码，系统确认"哦，是你"，然后把工作台交给你。

进 Linux 有两扇门：本地登录（人坐在虚拟机屏幕前直接敲）和远程登录（用你自己的 Windows 电脑，通过网络连服务器）。日常干活 99% 是远程。

6.2 本地登录：开机后出现 login:

系统启动完，屏幕最后一行会停下来等你：

# 屏幕显示（光标在冒号后闪）：
localhost login:
# 输入用户名 root，回车，接着出现：
Password:

这时你敲键盘，屏幕上一个字符都不显示。不是键盘坏了，是 Linux 故意不显示密码，防止偷看。 把密码敲完回车，对了就会看到：

[root@localhost ~]#

这行字叫提示符，意思是"我准备好了，请下命令"。第7章会逐字拆解它。

💡 小贴士：root 的密码是装系统时设的。密码区分大小写，Abc123 和 abc123 不是一回事。

6.3 远程登录：用自己电脑连服务器

在 Windows 上按 Win + R，输入 cmd 回车，打开命令提示符，然后敲：

ssh root@192.168.8.120
# 第一次连接会看到：
The authenticity of host '192.168.8.120' can't be established.
Are you sure you want to continue connecting (yes/no)?

这里输入 yes 再回车（必须打完整的 yes，只打 y 不算），然后输入密码，看到下面这行就成功了：

[root@Server120 ~]#

💡 小贴士：SSH 就像给服务器打了个电话。电话通了，你的键盘和屏幕就接到服务器上；挂掉电话（关窗口），服务器还在跑，活也没停。

6.4 干完活，怎么退出

exit
# 远程登录时你会看到：
Connection to 192.168.8.120 closed.

6.5 常见坑 ⚠️

• 密码敲了没反应：正常，接着敲完回车，别反复按回车。
• # 不是让你敲的：[root@localhost ~]# 整行都是提示符，命令从 # 后面的空格开始。
• 登录失败别连试十次：有些系统会锁账号，先检查用户名大小写和键盘布局。
• 远程连不上：先 ping 服务器IP，网络不通时输多少次密码都没用。

本章小结

动手练

1. 用自己的话说明：为什么输入密码时屏幕上什么都不显示？
2. 远程登录 IP 为 192.168.8.120 的服务器，用户名 root，写出完整命令。
3. 登录成功后，看屏幕上什么位置能判断"可以开始敲命令了"？

参考答案：

1. 防止旁边的人看到密码，Linux 连星号都不显示，这是正常的，照常输完回车即可。
2. ssh root@192.168.8.120；第一次连接输入 yes，再输入 root 密码。
3. 看有没有出现提示符 [root@Server120 ~]#，光标在最右边闪，就可以敲命令了。

第7章 看懂终端里那行字 🔰

学完这一章，你能：一眼看出"我是谁、我在哪台机器上、我站在哪个文件夹"，不再对着提示符发懵。

7.1 提示符：终端在"问你话"

登录成功或敲完一条命令后，屏幕上总有一行字停在那里，光标在最后闪：

[root@localhost ~]#

这行字不是命令，也不是报错，它叫提示符。它其实在回答三个问题：你是谁、你在哪台机器上、你现在站在哪个文件夹里。

把它想成电梯里的楼层显示屏：告诉你现在在几层、能去哪几层，看懂了才不会按错按钮。

7.2 逐段拆解 [root@localhost ~]#

注意：提示符里的文件夹只显示最后一段名字。站在 /etc/sysconfig/network-scripts 时，它只显示 network-scripts。想看完整路径，敲 pwd。

7.3 # 和 $：一眼看出自己的权限

[root@localhost ~]#      # root 用户，最高权限，能改任何东西
[tom@localhost ~]$       # 普通用户 tom，权限受限

• 看到 #，说明你是 root，这时的命令都是"没有保险的命令"，删除、改配置直接生效，慢点敲。
• 看到 $，说明你是普通用户。有些操作报"权限不够"不是你敲错了，是权限不够（第33章用 sudo 解决）。

⚠️ 注意：# 在配置文件里还有另一个身份——"注释"，表示这一行不算数。提示符里的 # 只是装饰。

7.4 用命令验证提示符里的信息

whoami
# 你会看到：
root

hostname
# 你会看到：
localhost

pwd
# 你会看到：
/root

三行输出正好对应提示符的三段：用户名、主机名、所在文件夹。pwd 输出 /root，这就解释了为什么提示符里写 ~——root 的家目录就是 /root。

7.5 常见坑 ⚠️

• 把提示符一起复制进终端：网上抄命令时连 [root@localhost ~]# 一起粘进去，必然报 command not found。只复制 # 后面那部分。
• 以为 ~ 是根目录：~ 是家目录（root 是 /root，普通用户是 /home/用户名），根目录是 /，两码事。
• 提示符变了就慌：[root@localhost etc]# 只是你进了 /etc，不是出错。

本章小结

动手练

1. 提示符是 [root@localhost ~]#，现在你是哪个用户？用命令验证。
2. 这个 ~ 具体是哪个文件夹？用命令证明。
3. 提示符变成 [tom@localhost ~]$，你能判断出哪两件事？

参考答案：

1. whoami，输出 root。
2. pwd，输出 /root——root 的家目录就是 /root。
3. ① 当前是普通用户 tom（$ 号）；② 你在名为 localhost 的机器上，站在 tom 的家目录 /home/tom 里。

第8章 命令是怎么组成的 🔰

学完这一章，你能：把一条命令拆成"命令、选项、参数"三块看懂，敲错了知道错在哪。

8.1 一条命令 = 命令 + 选项 + 参数

在饭馆点菜："来一碗牛肉面，大份，不要香菜"。牛肉面是命令（要做的事），大份是选项（怎么做的细节），不要香菜是参数（对谁做）。

格式固定成一句话：命令 选项 参数，中间用空格隔开。比如 ls -l /etc：命令 ls、选项 -l、参数 /etc。

8.2 最小可用写法 + 完整示例

ls -l /tmp
# 你会看到（每个文件一行，含权限、大小、时间）：
总用量 4
-rw-r--r--. 1 root root 12 10月 30 18:40 a.txt
drwxr-xr-x. 2 root root  6 10月 30 18:35 dir1

只要记住三件事：命令必须存在、选项必须真实、参数（路径）必须存在，三者有一个不对就报错。

8.3 短选项和长选项

同一个功能通常有两种写法，效果一样：

-l、-a、-h 是新手最先要记的三个。短选项可以合并：ls -l -a = ls -la = ls -al；长选项不能合并，要一个一个写。

8.4 命令敲错了，会看到什么

Linux 区分大小写：ls 能跑，LS、Ls 一律 command not found。

8.5 忘了怎么用：--help 和 man

ls --help    # 一屏英文帮助，列出所有选项
man ls       # 帮助手册：空格翻页，q 退出，/name 搜索

--help 短平快，man 详细权威。新手先看 --help，基本够用。

8.6 常见坑 ⚠️

• ls-l 中间没空格：整串被当成一个命令名，报 command not found。
• 中文输入法没切：打出全角空格 、中文逗号 ，，终端不认，报的错还看不出原因。
• 复制带提示符：连 # 一起粘进去，等于让 shell 去找一个叫 # 的命令。

本章小结

动手练

1. ls -lh /etc 里，命令、选项、参数分别是什么？
2. 想让 ls 同时显示隐藏文件和详细信息，最短怎么写？
3. 为什么 ls　-l（中间是全角空格）会报错？

参考答案：

1. 命令 ls，选项 -lh（= -l + -h），参数 /etc。
2. ls -la（或 ls -al）。
3. 全角空格 和英文空格不是同一个字符，shell 不把它当分隔符，整串被当成一个命令，所以报 command not found。

第9章 认识目录树：文件都放在哪 🔰

学完这一章，你能：像查门牌号一样，用路径准确说出"某个文件在哪"，不再到处乱翻。

9.1 Linux 里只有一棵树

Windows 有 C 盘、D 盘、U 盘，各是各的"独立王国"。Linux 不一样：所有东西都挂在唯一的一棵树下面，这棵树的树根叫根目录，写法是一个斜杠 /，所有文件夹、硬盘、U 盘都从 / 往下长：

/
├── etc        配置文件
├── home       普通用户的家
├── root       root 的家
├── usr        软件安装的地方
└── var        日志、数据

💡 小贴士：U 盘插进 Linux 后不是多出一个"F 盘"，而是被挂载到某个文件夹上（比如 /media），那个文件夹就代表这个 U 盘。

9.2 根目录下各文件夹是干什么的

不用背，先记住：/etc 改配置、/var/log 看日志、/home 放自己的东西、/tmp 随便练。

9.3 绝对路径：从 / 开始说

绝对路径 = 从根目录 / 一路写下来，不管你现在在哪，它都指向同一个地方。

cd /etc/sysconfig/network-scripts
pwd
# 你会看到：
/etc/sysconfig/network-scripts

9.4 相对路径：相对于"我现在在哪"

相对路径 = 不以 / 开头，从你当前站的位置算起。三个符号先记牢：

cd /etc/sysconfig
cd network-scripts      # 相对路径：进 /etc/sysconfig 下的 network-scripts
pwd
# 你会看到：
/etc/sysconfig/network-scripts

9.5 常见坑 ⚠️

• cd /root 和 cd root 完全不同：前者是根目录下的 root 文件夹，后者是当前目录里名叫 root 的子文件夹。
• .. 别写成 .：cd .. 是上一层，cd . 是原地不动，你会觉得"没反应"。
• 在根目录再 cd ..：/ 的上一层还是 /，不报错，容易把自己绕晕。随时用 pwd 确认。
• 相对路径换个地方就失效：在 /etc 下能 cd sysconfig，跑到 /root 下再敲就报错。拿不准就用绝对路径。

本章小结

动手练

1. 你当前在 /etc，用相对路径回到根目录 /。
2. 当前在 /usr/share/doc，用绝对路径进入 /var/log。
3. cd root 和 cd /root 有什么区别？

参考答案：

1. cd ..（/etc 的上一层就是 /）。
2. cd /var/log。
3. cd /root 是绝对路径，去根目录下的 root 文件夹；cd root 是相对路径，去当前目录下名叫 root 的子文件夹。在 / 下两者碰巧一样，换个目录就完全不同。

第10章 必学的五个基础命令 🔰

学完这一章，你能：随时回答"我在哪、这里有什么、怎么去别处"，终端不再让你迷路。

10.1 pwd：我在哪

在商场找店铺，第一件事是看楼层指示牌。pwd 就是那块牌子：打印你现在站的位置。

pwd
# 你会看到：
/root

10.2 ls：这里有什么

ls
# 你会看到当前文件夹里的名字：
anaconda-ks.cfg  dir1  a.txt
ls -l
# 你会看到详细信息（权限、属主、大小、时间、名字）：
总用量 4
-rw-------. 1 root root 1584 9月  20 16:09 anaconda-ks.cfg
drwxr-xr-x. 2 root root    6 10月 30 18:35 dir1

-l 详细列表、-a 含隐藏文件（以 . 开头）、-h 大小带单位。先记 ls -lh。

10.3 cd：我去哪（本章重点）

cd /var/log        # 绝对路径：从根开始
cd sysconfig       # 相对路径：从当前位置开始
cd ..              # 回上一层
cd -               # 回到上一次所在的目录

最容易被搞混的几条，必须记牢：

cd 和 cd ~ 是"回家"，cd / 是"去整台机器的根"——这是新手最容易混的一对。

10.4 clear 和 history：让终端清爽一点

clear          # 清屏，快捷键 Ctrl + L 效果一样
# 你会看到：屏幕清空，提示符回到左上角
history        # 列出敲过的命令，带编号
history 10     # 只看最近 10 条
!2             # 重新执行编号为 2 的命令

clear 只擦屏幕，不删文件和历史。按上方向键也能翻出刚敲的命令，比 history 更常用。

10.5 常见坑 ⚠️

• cd 后面没写就回车：不是没反应，是回家了，用 pwd 确认。
• cd / 和 cd ~ 当成一回事：一个去根目录，一个回家目录，差很远。
• clear 以为删了东西：只清屏，文件和命令历史都还在。

本章小结

动手练

1. 登录后不确定自己在哪，敲什么命令？
2. 从 /etc/sysconfig 回到 /etc，最短怎么写？
3. 说出 cd、cd ~、cd / 分别去哪里。

参考答案：

1. pwd。
2. cd ..。
3. cd 和 cd ~ 都回家目录（root 是 /root，普通用户是 /home/用户名）；cd / 去根目录 /。

第三篇 文件和目录

这一篇讲 Linux 里最日常的活：新建、复制、查看、改名、删除。 学完这一篇，你就能自己整理文件、找到东西，并且知道怎么删才安全。

第11章 创建文件与文件夹：touch 和 mkdir 🔰

学完这一章，你能：想要一个空文件、一个空文件夹（目录），随手就能建出来。

11.1 两个命令的分工

mkdir 是盖一间空房间（建文件夹），touch 是往房间里放一张白纸（建空文件）。一个管容器，一个管内容。

11.2 touch：建一个空文件

cd /tmp
touch a.txt
ls -l a.txt
# 你会看到（大小是 0，说明是空文件）：
-rw-r--r--. 1 root root 0 10月 30 18:40 a.txt

一次建多个，用空格隔开：

touch b.txt c.txt d.txt
ls
# 你会看到：a.txt b.txt c.txt d.txt 都在

touch 还有第二个用途：更新文件时间。对已存在的文件敲 touch，内容不会被清空，只是"最后修改时间"变成现在。

11.3 mkdir：建一个空文件夹

cd /tmp
mkdir dir1
ls -ld dir1
# 你会看到（开头是 d，表示 directory 文件夹）：
drwxr-xr-x. 2 root root 6 10月 30 18:41 dir1

-p 是最有用的选项：父目录不存在就一起建出来，目标已存在也不报错。

mkdir -p /tmp/project/src/main
cd /tmp/project/src/main
pwd
# 你会看到：
/tmp/project/src/main

不用 -p 直接建多层，系统会报 No such file or directory，因为中间那层 project 还不存在。

11.4 常用写法小表

11.5 常见坑 ⚠️

• touch 建不了文件夹：touch mydir 建的是名叫 mydir 的文件。要文件夹就用 mkdir。
• mkdir 忘了 -p：建多层路径直接报 No such file or directory。
• 文件名带空格：mkdir my dir 会建出两个文件夹。要带空格得写 mkdir "my dir"，但更建议用下划线。
• 以为不区分大小写：A.txt 和 a.txt 是两个不同的文件。
• 用 rmdir 删目录：它只能删空目录，里面有一个文件就报错。真删目录用第13章的 rm -r。

本章小结

动手练

1. 在 /tmp 下建一个空文件 note.txt，并写出查看它大小的命令。
2. 在 /tmp 下建出三层文件夹 /tmp/web/html/static，一条命令完成。
3. 怎么确认建出来的是"文件夹"而不是"文件"？

参考答案：

1. touch /tmp/note.txt；ls -l /tmp/note.txt，大小显示 0。
2. mkdir -p /tmp/web/html/static。
3. ls -ld /tmp/web，输出开头是 d（drwxr-xr-x）就是文件夹。

第12章 复制、移动、重命名：cp 和 mv 🔰

学完这一章，你能：把文件复制一份做备份、搬到别的文件夹、原地改个名字，都不会弄丢原件。

12.1 一个复印机，一个搬家公司

cp 像复印机：原件还在，多一份副本。 mv 像搬家公司：东西搬走了，原处就没了；如果只是从一个房间挪到隔壁，那就是"改名"。

12.2 cp 的最小写法

格式永远是 cp 源文件 目标：目标写"新名字"就是复制并改名，写"文件夹"就是复制进去、名字不变。

cd /tmp
echo "hello linux" > a.txt
cp a.txt b.txt          # 复制并改名
cp a.txt dir1/          # 复制到 dir1 文件夹里
ls
# 你会看到：a.txt  b.txt  dir1

12.3 复制文件夹：必须加 -r

mkdir -p dir1/sub
cp dir1 dir2
# 你会看到报错：
cp: 略过目录 'dir1'
cp -r dir1 dir2
ls dir2
# 你会看到：
sub

-r 是递归：连文件夹里面的东西一起复制。复制目录忘了它，一定失败。

12.4 mv：移动、剪切、改名

mv b.txt c.txt          # 原地改名：b.txt 变成 c.txt
mv c.txt dir1/          # 移动到 dir1 文件夹
mv dir1 /tmp/dir1_new   # 文件夹也能移动、改名

同一个文件夹里 mv = 改名；mv 到另一个文件夹 = 剪切。 不管哪种，原位置都不会再留着。

12.5 覆盖：同名文件会怎样

目标位置已经有同名文件时，cp 和 mv 默认直接覆盖，没有回收站、没有提示。

不过 CentOS 7 的 root 账号默认加了 -i 别名，覆盖前会问你一句：

cp a.txt b.txt
# 你会看到（问你是否覆盖）：
cp: 覆盖 'b.txt' 吗？
# 输入 y 回车 = 覆盖；输入 n 回车 = 不覆盖

看到提示别慌，这是好事。没看到提示就直接覆盖了也正常，说明没有这个别名，操作前自己要先想清楚。

12.6 常见坑 ⚠️

• 复制目录忘 -r：报 略过目录，目录根本没复制成功。
• 把"移动"当成"备份"：mv 之后原位置什么都没有了，要备份请用 cp。
• 目标写错：cp a.txt /tmp 是复制进 /tmp；cp a.txt /tmp/newname 是复制并改名。写之前用 ls 确认目标存在。

本章小结

动手练

1. 把 /etc/hostname 复制到 /tmp，命令怎么写？原件还在吗？
2. 把 /tmp/a.txt 改名为 /tmp/hello.txt。
3. 复制 /tmp/dir1 整个文件夹到 /tmp/dir3，命令怎么写？

参考答案：

1. cp /etc/hostname /tmp/；原件 /etc/hostname 还在，/tmp 下多了一个副本。
2. mv /tmp/a.txt /tmp/hello.txt。
3. cp -r /tmp/dir1 /tmp/dir3。

第13章 删除：rm 🔰

学完这一章，你能：安全地删掉不要的文件，并且真正明白"为什么删之前要停三秒"。

13.1 rm 是一台碎纸机

Windows 删除是丢进回收站，后悔还能捞回来。Linux 的 rm 是碎纸机：纸进去就成碎片，没有回收站，删了就没了。这一章所有注意事项，都是从这一句话来的。

13.2 最小可用：删一个文件

cd /tmp
touch del.txt
ls
# 你会看到：del.txt 在列表里
rm del.txt
ls
# 你会看到：del.txt 已经不在列表里了

删的时候没有任何提示，也不问你确认。

13.3 删文件夹：-r 和 -f

rm dir1
# 你会看到报错（rm 默认不删文件夹）：
rm: 无法删除 'dir1': 是一个目录
rm -r dir1        # 递归删除：文件夹和里面的东西一起删
rm -rf dir1       # 强制删除：不提示、不报错、直接删（和上一条二选一）

13.4 真实后果：删错了会发生什么

• 删掉 /etc 下的配置文件，对应的服务重启后直接起不来，网络、远程登录都可能断掉。
• 删掉数据库目录，数据只能从备份恢复；没有备份就是永久丢失。
• 在 /etc 里敲 rm -rf ./*，会把当前文件夹里的所有东西全删掉——它删的是你站的地方。
• rm -rf / 是想删掉整个系统。新版本的 rm 会拒绝执行并提示危险，但千万别去试绕过它的参数，那是真的会把系统删没。

⚠️ 注意：-f 会把报错也吞掉，看起来"很顺利"，其实可能已经删过头了。越是安静，越要回头看。

13.5 三个安全习惯（请背下来）

1. 删之前先 ls：把 rm 换成 ls 敲一遍，看看这条命令到底会选中哪些文件，确认了再删。
2. 回车前从右往左读一遍路径：重点看 / 和空格。rm -rf /data/logs 和 rm -rf / data logs 是两条完全不同的命令。
3. 重要的先备份，不确定的先预览：用 echo 把通配符展开看一眼（第16章），或者先把文件移到 /tmp 放几天。

13.6 常见坑 ⚠️

• 以为删错了能恢复：不能。极少数情况可以靠专业工具，但别指望。
• rm -rf 手滑多打一个空格：空格会把一条命令拆成几条，后果不可控。
• rm ./* 和 rm * 是一回事：都删当前目录全部，区别只是 ./ 写得明白一点。
• 脚本里 rm -rf $DIR 而 $DIR 是空的：命令会变成危险的样子。写脚本时先判断变量不为空。

本章小结

动手练

1. 删掉 /tmp 下的 del.txt，要求先预览再删，写出两条命令。
2. rm -r 和 rm -rf 有什么区别？什么时候千万不能用 -rf？
3. 同事让你在 /etc 下执行 rm -rf ./*，你应该怎么做？

参考答案：

1. ls /tmp/del.txt 确认存在，再 rm /tmp/del.txt。
2. -r 只负责递归删文件夹，删不掉的会报错；-f 强制、不提示、不报错。路径不明确、通配符没预览过时千万不能用 -rf。
3. 停下来问清楚要删什么，先 ls ./* 看清楚；/etc 是系统配置目录，这条命令会毁掉系统，不能执行。

第14章 查看文件内容：cat、more、less、head、tail 🔰

学完这一章，你能：不管文件多长多短，都挑对命令看清楚它的内容。

14.1 五个命令各管一段

想象手里有一本厚书：cat 是把整本书摊在桌上，less 是一页页翻，more 是只能往后翻，head 是只看开头几页，tail 是只看最后几页。

14.2 cat：短文件，一次看完

cat /etc/os-release
# 你会看到：
NAME="CentOS Linux"
VERSION="7 (Core)"
...

加 -n 显示行号，找行、报错定位都靠它：

cat -n /etc/os-release
# 你会看到：
     1  NAME="CentOS Linux"
     2  VERSION="7 (Core)"

cat 文件1 文件2 可以把几个文件连着输出。

14.3 less 和 more：长文件，翻着看

less /etc/passwd
# 你会看到：整屏内容，底部显示 : 或 (END)
# 按 空格 翻一屏，回车 翻一行，按 q 退出

more 和 less 用法几乎一样，但 more 只能往下翻，翻过头只能按 q 退出重来。所以长文件优先用 less。

14.4 head 和 tail：只看头和尾

head /etc/passwd          # 默认前 10 行
head -n 3 /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
tail -n 2 /etc/passwd     # 最后 2 行

tail -f 是看日志的神器：它不退出，一直盯着文件末尾，有新内容就立刻显示，看完按 Ctrl + C 退出。例如 tail -f /var/log/messages。

14.5 常见坑 ⚠️

• 用 cat 打开大日志：几十万行刷屏，滚半天。先 head 看头，再 less 翻。
• 用 cat 看压缩包或二进制文件：满屏乱码，还会把终端搞乱（敲 reset 恢复）。先用 file 文件名 看类型。
• tail -f 之后退不出去：它在等新日志，按 Ctrl + C 才停。
• Permission denied：不是命令写错，是没权限读这个文件（第25章）。

本章小结

动手练

1. 想只看 /etc/passwd 的前 3 行，命令怎么写？
2. 打开一个大日志文件，想边看边搜索关键字 error，用哪个命令、按什么键？
3. 实时监控 /var/log/messages 的新内容，命令怎么写？怎么退出？

参考答案：

1. head -n 3 /etc/passwd。
2. less /var/log/文件名，输入 /error 回车，n 跳到下一个，q 退出。
3. tail -f /var/log/messages，按 Ctrl + C 退出。

第15章 软链接与硬链接 🔧

学完这一章，你能：看懂 ls -l 里的 l 和 ->，知道链接坏了是怎么回事；第一遍只要理解比喻，不必背命令。

15.1 两个比喻先记住

• 硬链接 = 同一个人的两个名字。人只有一个（文件只有一份），身份证号（inode）也只有一个，只是名字有两个。叫哪个名字，来的都是同一个人。
• 软链接 = 快捷方式。桌面上那个图标不是文件本身，只是一张写着"文件在那边"的纸条；原文件被删，快捷方式就打不开了。

💡 一句话说 inode：inode 是文件的"身份证"，记录文件的大小、权限、数据放在哪；内容不变，inode 编号就不变。

15.2 硬链接：ln

cd /tmp
echo "hello linux" > a.txt
ln a.txt a_hard
ls -li a.txt a_hard
# 你会看到（第一列 inode 编号相同，第三列硬链接数是 2）：
16777219 -rw-r--r--. 2 root root 12 10月 30 18:50 a.txt
16777219 -rw-r--r--. 2 root root 12 10月 30 18:50 a_hard

两个名字、一个 inode，就是同一个文件。删掉其中一个，另一个还能正常打开。

15.3 软链接：ln -s

ln -s a.txt a_soft
ls -l a_soft
# 你会看到（开头是 l，末尾有 -> 指向原文件）：
lrwxrwxrwx. 1 root root 5 10月 30 18:50 a_soft -> a.txt

软链接自己是一个独立的小文件，里面只存着"原文件在哪"。所以：

rm a.txt
cat a_hard
# 你会看到：
hello linux
cat a_soft
# 你会看到：
cat: a_soft: 没有那个文件或目录

硬链接 a_hard 还是好的，软链接 a_soft 已经失效。

15.4 硬链接和软链接的区别

15.5 常见坑 ⚠️

• ln -s 忘了写 -s：变成硬链接，本想删链接结果动了原文件。
• 软链接用相对路径：ln -s a.txt /tmp/a_soft 里的 a.txt 是按链接所在目录算的，链接一挪就失效。给软链接指路时尽量写绝对路径：ln -s /tmp/a.txt /tmp/a_soft。
• 给目录建硬链接：Linux 系统层面就禁止，root 也不行，会直接报错，这不是你操作错了。
• 把硬链接当备份：它不是副本，文件内容一改，两个名字看到的都变。

本章小结

动手练

1. 在 /tmp 建文件 x.txt，为它建一个硬链接 x_hard，用什么命令？
2. 怎么用一条命令证明 x.txt 和 x_hard 是同一个文件？
3. 软链接指向的原文件被删了，软链接会怎样？

参考答案：

1. ln /tmp/x.txt /tmp/x_hard。
2. ls -li /tmp/x.txt /tmp/x_hard，两行第一列 inode 编号相同。
3. 软链接还在，但打开会报 没有那个文件或目录（失效了）；ls -l 看它还是 l 开头、带 ->。

第16章 通配符和花括号：一次处理一批文件 🔰

学完这一章，你能：用一个"模式"同时点名一批文件，批量删除、复制、创建不再一个个敲。

16.1 通配符就是"点名时说的姓什么"

老师点名："姓张的同学站起来。"这一句能叫起一片人。通配符就是让 shell 帮你把"一片文件"写成一句话，命令照着展开。

先准备练习素材：

mkdir -p /tmp/prac
cd /tmp/prac
touch file1.txt file2.txt file3.txt file10.txt note.txt data.log
ls
# 你会看到：
data.log  file1.txt  file10.txt  file2.txt  file3.txt  note.txt

16.2 *：任意多个字符

ls *.txt
# 你会看到：
file1.txt  file10.txt  file2.txt  file3.txt  note.txt
ls file*.txt
# 你会看到（file10 排在 file2 前面，因为它是按字符逐个比大小的）：
file1.txt  file10.txt  file2.txt  file3.txt

* 可以代表零个、一个、多个任意字符，是最常用的通配符。

16.3 ? 和 []：精确一点

ls file?.txt
# 你会看到（? 只代表一个字符）：
file1.txt  file2.txt  file3.txt
ls file[12].txt
# 你会看到：
file1.txt  file2.txt

16.4 {}：生成一串，不是通配符

{ } 不负责"匹配已有文件"，它负责先展开成一串：

echo {1..5}
# 你会看到：
1 2 3 4 5
mkdir -p /tmp/prac/{A,B,C}
ls /tmp/prac
# 你会看到多了 A B C 三个文件夹

16.5 常见坑 ⚠️

• 通配符是 shell 展开的，不是命令的功能：没匹配到文件时，ls *.jpg 会把 *.jpg 原样交给 ls，于是报 No such file or directory。
• rm * 等于删除当前目录全部：先 ls * 看一眼，确认了再删（第13章的三个习惯）。
• {a,b} 里不能有空格：{A, B} 会变成两个不完整的东西。逗号也要用英文逗号。
• * 不匹配隐藏文件：以 . 开头的文件，* 看不见，要单独写 .*。

本章小结

动手练

1. 列出 /tmp/prac 下所有 .txt 文件。
2. 一次建出 p1.txt 到 p5.txt 五个空文件，一条命令。
3. 为什么 ls *.jpg 可能报 No such file or directory？

参考答案：

1. ls /tmp/prac/*.txt。
2. touch p{1..5}.txt。
3. 因为当前目录里没有 .jpg 文件，shell 无法展开，把 *.jpg 原样交给 ls，ls 找不到这个"文件名"就报错。

第17章 重定向和管道 🔰

学完这一章，你能：把命令的输出存进文件、追加到文件末尾，还能用管道把几条命令串起来干活。

17.1 比喻：屏幕是出水口

命令干活的结果默认"流"到屏幕上。重定向就是给水管换个出口，接到文件里：> 像先倒掉旧水再装，文件原来的内容被清空；>> 像接着往桶里倒，原来的内容保留，新内容加在最后。管道 | 像流水线：上一步的产出直接变成下一步的原料，屏幕上什么都不显示。

17.2 > 覆盖 和 >> 追加

cd /tmp
echo "第一行" > 1.txt
cat 1.txt
# 你会看到：
第一行
echo "第二行" > 1.txt     # 注意还是 >
cat 1.txt
# 你会看到：
第二行

第一行没了！这就是覆盖。想保留就换 >>：

echo "第三行" >> 1.txt
cat 1.txt
# 你会看到：
第二行
第三行

记法：箭头多一个，内容多一份。

17.3 < 和 <<：反过来喂数据

wc -l < /etc/passwd
# 你会看到：一个数字，比如 45

< 是"从文件读入"，不经过屏幕，wc -l 就是数行数。<< 是"我下面敲的几行都算输入，直到遇到结束标记"：

cat >> /tmp/1.txt << EOF
hello
linux
EOF
cat /tmp/1.txt
# 你会看到最后多了 hello 和 linux 两行

17.4 管道 |：串起几条命令

ls /etc | wc -l
# 你会看到：/etc 下有多少项
ip a | grep inet
# 你会看到：只留下带 inet 的行（grep 第52章细讲）

左边命令的输出，直接成为右边命令的输入，中间不落盘。想存下来就再接一个重定向：ls -l /etc > /tmp/etc_list.txt。

17.5 常见坑 ⚠️

• 该用 >> 却写了 >：文件被清空，只剩最后一条内容。
• cat 文件 > 同一个文件：文件会先被清空，再读就是空的，内容全丢。要改内容先 cp 备份。
• > 没有提示：覆盖是静默的，敲完回车前先确认文件名。

本章小结

动手练

1. 把 free -h 的结果保存到 /tmp/mem.txt，命令怎么写？
2. 已经有一个 /tmp/mem.txt，想再追加一条日期信息，用 > 还是 >>？
3. 用一条命令数出 /etc 下有多少个文件和文件夹。

参考答案：

1. free -h > /tmp/mem.txt。
2. >>，例如 date >> /tmp/mem.txt。
3. ls /etc | wc -l。

第18章 键盘上的省力技巧 🔰

学完这一章，你能：少敲一半的字、少打一半的错，还会用一行命令干几件事。

18.1 Tab 补全：最救命的一个键

打字最怕打错。Tab 让系统帮你把剩下的字补齐，不用自己敲全。像点外卖时输入"宫保"，系统自动弹出"宫保鸡丁"。

# 敲命令名时：
cle           # 按一下 Tab，变成
clear

# 敲路径时：
cd /etc/sysc  # 按一下 Tab，变成
cd /etc/sysconfig/

• 按一次 Tab 没反应或"叮"一声：说明有多个候选，再按一次 Tab 会把候选全列出来。
• 按一次就补全了：说明前缀唯一，直接回车就行。
• 命令名、文件夹名、文件名都能补全，能补全就别手打。

18.2 翻历史：上下方向键和 Ctrl + R

# 按 上方向键：一条条翻出刚才敲过的命令；按 下方向键：往回翻
# Ctrl + R 后输入关键字，直接搜到用过的命令：
(reverse-i-search)`pass': cat /etc/passwd

Ctrl + R 找到后按回车直接执行；再按 Ctrl + R 继续往前搜同一个关键字。

18.3 Ctrl 组合键：记住这六个

Ctrl + Z 是"把当前命令暂停扔到后台"，不是撤销，新手先别按（恢复用 fg）。

18.4 一行敲几条命令：; && ||

cd /tmp ; ls          # 先 cd 再 ls，不管前面成不成功
mkdir /tmp/t1 && cd /tmp/t1     # 前一个成功才执行后一个
ls /tmp/nofile || echo "目录不存在"
# 你会看到：
ls: 无法访问/tmp/nofile: 没有那个文件或目录
目录不存在

18.5 常见坑 ⚠️

• Ctrl + C 当成复制：终端里它是"终止"。复制用右键菜单或 Ctrl + Shift + C。
• Ctrl + Z 当成撤销：它只是把命令暂停了，按 fg 能恢复；真撤销是 vim 里的 u。
• && 后面没执行：说明前面那条失败了，先看前面的报错。

本章小结

动手练

1. 输入 cd /etc/sysc 后按 Tab，会发生什么？
2. 想清屏但不想丢失任何东西，按什么键？
3. cd /tmp && ls 和 cd /tmp ; ls 有什么区别？

参考答案：

1. 自动补全成 cd /etc/sysconfig/（若有两个以上候选，会列出候选让你继续输）。
2. Ctrl + L（等于 clear），它只清屏幕。
3. && 是前一条成功才执行 ls；; 不管成功失败都执行 ls。

第四篇 文本编辑：vi / vim

服务器上没有记事本，改配置只能靠 vi。 这一篇只教你“够用”的那部分：能打开、能改、能保存、能退出，日常工作就够用了。

第19章 vi 是什么，为什么非学不可 🔰

学完这一章，你能：用 vi 打开一个文件、敲进内容、保存退出；并且知道为什么绕不开它。

19.1 vi 就是 Linux 自带的"记事本"

vi 是 Unix/Linux 上最老牌的文本编辑器，差不多等于 Windows 的记事本——只能打字，没有鼠标，没有按钮。vim 是 vi 的升级版，多了颜色高亮和插件，日常说的"vi"通常就是 vim。

它有个和记事本完全不同的地方：按键分"模式"。同样一个 i，在记事本里就是打出一个 i，在 vi 里可能是"准备开始输入"。第20章专门讲模式。

19.2 为什么非学不可

• 服务器没有图形界面，改配置只能编辑文本文件，/etc 下的配置全是纯文本。
• 几乎所有 Linux 都自带 vi，连最小安装、救援模式里都有它；别的编辑器可能没装。
• 配网络、装软件、起服务，最后一步常常都是"vi 改一下这个文件"。
• 用 echo 往文件里写一两行还行，改几十行的配置就没法用了。

💡 小贴士：vi 就像家里的万能钥匙——不好用，但每次都能开锁。先学会它，别的编辑器再慢慢挑。

19.3 打开文件

vi /tmp/hello.txt
# 你会看到：屏幕被清空，底部出现
"/tmp/hello.txt" [New File]

• 文件不存在：vi 会新建，底部标 [New File]。
• 打开前先用 pwd 看清你在哪，不然保存到哪个目录都不知道。

19.4 先只会三步，就能活下去

新手只要会 i、Esc、:wq 三个动作就能活：

vi /tmp/hello.txt
# 1. 按 i，左下角出现 -- INSERT --，说明可以打字了
# 2. 敲：hello vim
# 3. 按 Esc，回到命令模式
# 4. 输入 :wq 回车（w=write 保存，q=quit 退出）

cat /tmp/hello.txt
# 你会看到：
hello vim

• 不想保存：按 Esc，输入 :q! 回车，强行退出。
• 改了一半想重来：Esc 后 :q!，改了的内容全丢。

19.5 装 vim 和练手

最小安装里可能只有精简版 vi，没有 vim 命令。装它需要 yum（第35章）：

yum install -y vim
vimtutor
# 你会看到：vim 自带的互动教程，照着做完一遍，基本操作就记住了

19.6 常见坑 ⚠️

• 打开 vi 后按字母没反应：不是卡死，是你在命令模式，先按 i 才能打字。
• 退不出去：按 Esc，再输入 :q! 回车，一定退得出来。
• :q 提示 E37："已修改但尚未保存"。要么 :wq 保存，要么 :q! 放弃。
• 别用 vi 打开压缩包和图片：满屏乱码，什么也改不了。
• 保存到哪了？：打开时用了什么路径就存到哪，不确定就用绝对路径打开。

本章小结

动手练

1. 用 vi 新建 /tmp/me.txt，写一行 I love Linux，保存退出，写出完整操作步骤。
2. 在 vi 里改了内容但不想保存，怎么退出？
3. 为什么说"服务器上绕不开 vi"？

参考答案：

1. vi /tmp/me.txt → 按 i → 输入 I love Linux → 按 Esc → 输入 :wq 回车；再用 cat /tmp/me.txt 验证。
2. 按 Esc，输入 :q! 回车，强行退出不保存。
3. 服务器通常没有图形界面，配置都是文本文件；vi 几乎每台 Linux 都自带，最小安装和救援模式里只有它。

第20章 vim 常用的三种模式与切换 🔰

学完这一章，你能：清楚知道自己现在在哪个"房间"，不再出现"打字打不进去""退不出来"的慌乱。

20.1 三个房间

把 vim 想成一套三居室：

• 命令模式（进门的大厅）：默认就在这。按字母不是打字，而是"下命令"，比如删一行、复制一行。
• 编辑模式（书房）：只有在这里，你敲的字才会进到文件里。
• 末行模式（门口的柜台）：保存、退出、显示行号、查找替换，都在这办。

20.2 怎么在三个房间之间走

启动 vi ──► 命令模式（默认）
              │ 按 i / a / o
              ▼
           编辑模式 ──按 Esc──► 命令模式
命令模式 ──按 : ──► 末行模式 ──回车或 Esc──► 命令模式

20.3 一次完整的走法

vi /tmp/mode.txt
# 1. 打开后先按 i → 左下角出现 -- INSERT --
# 2. 输入：hello vim
# 3. 按 Esc → -- INSERT -- 消失，回到命令模式
# 4. 输入 :wq 回车 → 保存并退出，回到 [root@localhost ~]#

cat /tmp/mode.txt
# 你会看到：
hello vim

20.4 怎么判断自己在哪

• 左下角有 -- INSERT --（或 -- 插入 --）：编辑模式，可以打字。
• 左下角什么都没有（不显示 -- INSERT --）：命令模式。
• 光标跑到屏幕最底下一行，以 : 开头：末行模式。

拿不准就按两下 Esc，一定会回到命令模式，不会删掉任何内容。

20.5 常见坑 ⚠️

• 在编辑模式里敲 :wq：: 会被打进正文，文件里多出一行 :wq。先 Esc 再敲。
• Esc 按一下没回到命令模式：有的场景要按两下，多按一次不吃亏。
• :q 退不出去：说明文件改过了，用 :wq 保存或 :q! 放弃。
• 以为 vim 死机了：绝大多数是模式搞混了，按 Esc 再试。

本章小结

动手练

1. 打开 vim 后直接敲字母没反应，你在哪个模式？怎么才能打字？
2. 从编辑模式回到命令模式按什么键？从命令模式进末行模式按什么键？
3. 屏幕最下面一行显示 : 开头，你在哪个模式？这时按回车会发生什么？

参考答案：

1. 命令模式；按 i（或 a、o）进入编辑模式才能打字。
2. 编辑→命令按 Esc；命令→末行按 :。
3. 末行模式；回车执行你输入的那条末行命令（比如 :wq 就保存退出，命令敲错会报错但不会退出）。

第21章 十个够用的 vim 操作 🔰

学完这一章，你能：用十个按键完成日常九成的编辑工作，不再怕"改配置文件"。

21.1 十个操作，先记住这张表

vim 的按键像开车：i 是踩油门（能输入了），Esc 是刹车（停下来），:wq 是熄火锁车（保存走人）。另外 10gg 跳到第 10 行，G 跳到文件最后一行，gg 回第一行——这三个配合 dd、yy 很好用。

21.2 走一遍完整的编辑

vi /tmp/prac.txt
# 按 i，输入三行：
line one
line two
line three
# 按 Esc，输入 :wq 回车

再打开它，把第二行删掉、保存：

vi /tmp/prac.txt
# 命令模式下把光标移到第二行，按 dd
# 输入 :wq 回车
cat /tmp/prac.txt
# 你会看到：
line one
line three

21.3 三个进阶操作：查找、替换、行号

/hello        # 命令模式下输入：向下查找 hello，n 下一个，N 上一个
:%s/hello/HELLO/g    # 末行模式：全文把 hello 换成 HELLO
:set nu       # 末行模式：显示行号
:set nonu     # 末行模式：取消行号

:%s/旧/新/g 里的 g 是"每行所有匹配都换"，不加 g 只换每行第一个。替换前先 :w 或者先备份文件。

21.4 常见坑 ⚠️

• dd 以为删一个字符：它是删整行。删一个字符用 x。
• yy 之后没粘贴：复制完要按 p 才会粘出来。
• p 粘到哪了：粘在当前行下面；想粘到上面用 P。
• :q 退不出：改过内容，用 :wq 或 :q!。
• 替换完才发现改错：:%s 影响全文，保存前可以用 u 撤销，或者先备份文件。

本章小结

动手练

1. 用 vim 打开 /tmp/prac.txt，把第一行改成 Linux is easy，保存退出。
2. 在 vim 里删掉第 3 行，撤销一次，再保存退出，写出按键顺序。
3. 把文件里所有的 linux 替换成 Linux，写出末行命令。

参考答案：

1. vi /tmp/prac.txt → 光标在第一行按 dd 删掉旧行 → 按 i 输入 Linux is easy → Esc → :wq。
2. 光标移到第 3 行按 dd → 按 u 撤销 → :wq。
3. :%s/linux/Linux/g，回车执行；确认无误后 :wq 保存。

第五篇 用户和权限

这一篇是 Linux 的"规矩"。 看起来琐碎，但它是运维工作的地基：90% 的"莫名其妙失败"最后都归到权限上。 学完这一篇，你会拥有一项别人很羡慕的能力：看到 Permission denied，知道该改哪里。

第22章 为什么要分用户 🔰

学完这一章，你能：说清 Linux 里为什么有"用户"这个东西，以及三类用户分别是谁。

22.1 一个假设：如果人人都能改一切

想象一台公司服务器，上面跑着工资表、网站代码、数据库。

如果所有人都能用同一个账号登录、都能随便删文件，会发生什么？

• 实习生手一抖，rm -rf 把网站目录删了，公司业务挂掉；
• 谁都能看工资表；
• 出了事，查日志发现"所有人都叫同一个名字"，根本查不出是谁干的。

所以必须分用户。分用户带来三个好处：

比喻：一栋写字楼，如果只有一把万能钥匙，谁都能进任何房间。正常的做法是：每个人都有自己办公室的钥匙，需要进会议室另外申请。Linux 的"权限"就是这套钥匙系统。

22.2 每个用户都有一个编号：UID

系统真正认的不是你的名字，而是一个数字，叫 UID（User ID，用户编号）。

名字只是给人看的，数字才是系统内部用的。

# 看看你自己是谁、编号多少
id
# 你会看到类似：
uid=1000(tom) gid=1000(tom) groups=1000(tom)

逐段读一下，很简单：

• uid=1000(tom) —— 你的用户编号是 1000，名字叫 tom；
• gid=1000(tom) —— 你的主组编号是 1000，组名叫 tom（组的概念第 24 章讲）；
• groups=... —— 你还在哪些组里。

22.3 Linux 里的三类用户

三个重点，请记住：

1. root 的 UID 固定是 0。不是"名字叫 root 才是管理员"，是"UID 是 0 才是管理员"。
2. 系统用户是给程序用的。比如 MySQL 服务，它不希望用 root 身份跑（万一被攻破，损失太大），所以系统给它建一个 mysql 用户，权限很小，即使被攻破也搞不坏整个系统。
3. 普通用户权限有限。能管自己的文件，不能管别人的、不能改系统配置。

那普通用户想干管理员的事怎么办？两种方式：

• su - 切换到 root（第 23 章）；
• 在命令前加 sudo（第 33 章，更推荐）。

22.4 家目录：每个用户自己的房间

每个用户登录后，都会落在一个属于自己的文件夹里，这个文件夹叫家目录（也就是"主目录"）。

在家目录里，你就是主人，想怎么改都行。所以养成把东西放在自己家目录里的习惯，别到处乱放。

# 回到自己的家目录
cd ~
# 看看当前在哪个目录（~ 就代表家目录）
pwd
# 你会看到（普通用户 tom）：
/home/tom

22.5 用户信息存在哪

两个文件，知道位置就行，不用背：

# 看一眼 /etc/passwd 的最后一行（最新建的用户）
tail -1 /etc/passwd
# 你会看到类似（7 段，用冒号隔开）：
tom:x:1000:1000::/home/tom:/bin/bash

七段的含义：用户名:密码占位:UID:GID:简介:家目录:登录shell

💡 小贴士：/etc/passwd 里密码那一段是个 x，意思是"密码不在这儿，去 /etc/shadow 里找"。这就是为什么普通用户能看 /etc/passwd 却看不到别人密码的原因。

本章小结

动手练

1. 用 id 看看你现在的 UID 是多少，属于哪一类用户。
2. 为什么数据库软件要单独建一个 mysql 用户来运行，而不是直接用 root？
3. 判断题：只要用户名不叫 root，就肯定不是超级管理员。

参考答案

1. 执行 id，如果 uid=0(root) 就是超级管理员；uid 是 1000 及以上一般是普通用户。
2. 为了"降权"。如果数据库用 root 跑，一旦数据库被攻破，攻击者就拿到了整台机器的最高权限；用 mysql 这个权限很小的账号跑，即使被攻破，能造成的破坏也有限。
3. 错。判断是不是管理员看 UID 是否为 0。理论上你可以建一个叫 admin 的账号并把它的 UID 设成 0，那它也是超级管理员。

第23章 用户管理：useradd、passwd、su、id 🔰

学完这一章，你能：新增一个用户、给他设密码、切换过去、用完删掉。

23.1 先学会"看"

动手前先学会看，不然你不知道自己做对没做对。

# 我是谁
whoami
# 你会看到：
root

# 我的详细身份（UID、GID、所属组）
id
# 你会看到：
uid=0(root) gid=0(root) groups=0(root)

# 当前有哪些人登录着
who
# 你会看到类似：
root     pts/0        2026-10-30 09:12 (192.168.8.1)

who 输出里的 pts/0 是远程登录（通过网络连上来的），tty1 是在机器面前直接登录。

23.2 创建一个用户：useradd

# 创建一个叫 tom 的用户
useradd tom

# 看看建成了没有
id tom
# 你会看到：
uid=1000(tom) gid=1000(tom) groups=1000(tom)

useradd 干了三件事：

1. 在 /etc/passwd 里加一行；
2. 建一个和用户名同名的组；
3. 建家目录 /home/tom（从 /etc/skel 模板复制过来的）。

常用选项（先记这几个就够）：

关于 -s（这个选项在实际工作里很常用）：

• /bin/bash —— 正常登录，能用命令行（默认值）。
• /sbin/nologin —— 禁止登录。登录时会直接把你踢出来。

给软件建账号时，标准写法就是这样：

# 建一个不能登录、没有家目录、UID 固定的 mysql 账号
useradd -M -u 306 -s /sbin/nologin mysql

23.3 设置密码：passwd

useradd 建出来的用户是没有密码的，没密码就登不进去，必须设一个。

# 给 tom 设置密码（root 可以改任何人的密码）
passwd tom
# 你会看到提示：
Changing password for user tom.
New password:
# 注意：这时候你敲的密码屏幕上什么都不显示，这是正常的，不是卡了
Retype new password:
passwd: all authentication tokens updated successfully.

passwd 的其他用法：

⚠️ 注意：密码输入时屏幕没有任何显示（连星号都没有），这是 Linux 的正常设计，不是键盘坏了。输完直接回车。

新手最常见的笑话，就是这个："我密码输不进去，是不是终端卡了？"——没卡，就是不显示。

💡 小贴士：批量设密码可以用 echo "123.com" | passwd --stdin tom，但这是红帽系（CentOS）的用法，Ubuntu 不支持 --stdin。

23.4 切换用户：su

# 从普通用户切到 root（要输 root 的密码）
su -
# 提示：Password:
# 输完密码后，提示符变成 # 开头，说明你已经是 root
[root@localhost ~]#

# 想退回原来的用户
exit

su 和 su - 的区别（必须搞清楚，面试也常问）：

💡 结论：推荐一律用 su -。因为 su 用户名 会带着上一个用户的环境变量过去，可能出现"命令找到了却运行不了""路径不对"等莫名其妙的问题。

还有一条规矩要记住：

• 普通用户切 root，要输 root 的密码；
• root 切普通用户，不用输密码（root 是老板，老板进谁办公室都不用敲门）。

23.5 删除用户：userdel

# 只删用户，保留家目录
userdel tom

# 删用户，同时把家目录和邮件也删掉（慎用！）
userdel -r tom

⚠️ 注意：userdel -r 会把 /home/tom 里的所有文件一起删掉，没有回收站。删之前确认这个人的数据你是不是真的不要了。

23.6 修改用户：usermod

# 把 tom 加到 wheel 组（wheel 组默认有 sudo 权限）
usermod -aG wheel tom

# 锁定 / 解锁账号
usermod -L tom
usermod -U tom

# 改 UID
usermod -u 1500 tom

⚠️ 注意：-G 有一个大坑——usermod -G 是"重新设定"附加组列表，不是"追加"。如果你用了 usermod -G wheel tom，tom 原来在的其他附加组会被清掉。

所以想追加组，必须写成 -aG（a = append 追加）。这是运维事故高发点。

本章小结

动手练

1. 建一个用户 zhangsan，设密码，然后切换到它，确认 pwd 的结果是什么。
2. su zhangsan 和 su - zhangsan 执行完，pwd 的结果一样吗？为什么？
3. 把 zhangsan 加到 wheel 组，用 id zhangsan 验证。

参考答案

1. useradd zhangsan → passwd zhangsan → su - zhangsan；pwd 会显示 /home/zhangsan。
2. 不一样。su zhangsan 保持原来的当前目录（比如原来是 /root，切换后还在 /root）；su - zhangsan 会切到 /home/zhangsan。
3. usermod -aG wheel zhangsan，然后 id zhangsan，输出里 groups= 后面会多出 10(wheel)。

第24章 组是什么 🔰

学完这一章，你能：说清"组"是干什么用的，并给别人分配组。

24.1 为什么要有组

如果公司有 20 个开发要访问同一个项目目录，你打算怎么办？

• 办法一：给这 20 个人一个一个设权限。——新人来了要加一次，走人要删一次，改权限要改 20 遍。
• 办法二：建一个"开发组"，把 20 个人都放进去，然后只给这个组设一次权限。

显然是办法二。组（group）就是为了"批量授权"而存在的。

比喻：权限就像门禁卡。你不会给每个人单独配一把锁（太麻烦），你会给"部门"配一张卡，人来了进部门就有卡，走了退部门就失效。

24.2 主组和附加组（重点，别混）

每个用户必然有一个主组，还可以有零到多个附加组。

比喻：

• 主组像你的"班级"——你只有一个班级，你交的作业默认写的是你班级的名字。
• 附加组像你的"社团"——你可以同时参加多个社团，每个社团的活动你都能参加。

一条必须记住的话：

主组决定你"新创建的文件属于哪个组"；附加组只决定你"能访问哪些组的资源"。

24.3 看看组在哪里

# 看系统里有哪些组（文件很长，看最后几行）
tail -5 /etc/group
# 你会看到类似：
tom:x:1000:
wheel:x:10:tom
docker:x:994:

# 看某个用户到底在哪些组里
id tom
# 你会看到：
uid=1000(tom) gid=1000(tom) groups=1000(tom),10(wheel),994(docker)

/etc/group 每行四段：组名:密码占位:GID:组里的成员列表

24.4 组的增删改

# 创建组
groupadd dev

# 改组名
groupmod -n developer dev

# 删组
groupdel developer

# 把用户加进组（两种写法，效果一样）
usermod -aG dev tom
gpasswd -a tom dev

# 把用户从组里移除
gpasswd -d tom dev

⚠️ 注意：usermod -G 不加 -a 会覆盖原有的附加组列表，见第 23 章的坑。

💡 小贴士：用户被加进新组后，当前已经登录的会话不会立刻生效。要么退出重新登录，要么执行 newgrp 组名 临时切换。这是"明明加了组却不生效"的常见原因。

24.5 有几个组名你要认识

本章小结

动手练

1. 建一个组 dev，建一个用户 lisi，把 lisi 加进 dev 组，用 id lisi 验证。
2. lisi 新建一个文件，这个文件的属组是什么？
3. 判断题：给 dev 组设了读权限，lisi 就一定能读，因为他已经在 dev 组里了。

参考答案

1. groupadd dev；useradd lisi；usermod -aG dev lisi；id lisi 输出里应出现 dev。
2. 是 lisi 的主组，也就是 lisi（因为主组和用户同名）。注意：不是 dev，除非你把 lisi 的主组改成了 dev。
3. 不一定。要看他当前登录的会话有没有加载新组——刚用 usermod 加的组，需要重新登录（或 newgrp dev）才生效。

第25章 权限的三个字母 rwx 🔰

学完这一章，你能：说清 r、w、x 分别是什么，以及它们对"文件"和"目录"的意义为什么完全不同。

25.1 权限是给"三种人"分的

Linux 把所有人分成三类身份，权限针对这三类分别设置：

这三类合起来叫 UGO。每个文件，系统都会分别记录"这三种人各有什么权限"。

25.2 权限只有三种：rwx

那个数字（4、2、1）很有用，第 27 章讲 chmod 数字法时会用到，先记着。

25.3 关键：rwx 对文件和对目录，意思不一样！

这是初学者最大的坎，请务必看清楚。 同一个 r，对文件和目录是完全不同的两件事。

用"房间"来理解目录权限：

比喻：把目录想成一个房间。

• r = 你能站在门口看到里面有什么（但不能进去）；
• x = 你能推门进去；
• w = 你能往房间里搬东西、扔东西。

于是会有一个反直觉但非常重要的结论：

⚠️ 注意：只有 r 没有 x，你是进不去目录的。 也就是说 ls 目录 能列出文件名，但 cd 目录 会失败，也打不开里面的文件。

反过来，只有 x 没有 r：你能 cd 进去，也能访问你已经知道名字的文件，但 ls 看不到里面有什么。

25.4 对目录的 w 有个"隐藏技能"

这里有个超纲但很实用的知识点，理解了你会少踩很多坑：

删除一个文件，看的是"它所在目录"的 w 权限，而不是文件本身的 w 权限。

也就是说：一个文件哪怕设成 444（谁都不能改），只要你对它所在的目录有 w，你依然能 rm 把它删掉。

原因很简单：文件的"名字"是记录在目录里的，删文件本质上是"从目录里删掉这个名字"。

⚠️ 注意：这也解释了第 13 章的"rm 没有回收站"为什么这么危险——只要有目录写权限，删掉就真没了。

顺带一提，/tmp 目录用了 Sticky Bit（第 30 章），就是为了解决"大家都能往 /tmp 写，但只能删自己的文件"这个矛盾。

本章小结

动手练

1. 一个目录权限是 r--（只有 r），你能 ls 它吗？能 cd 进去吗？
2. 一个文件权限是 444，但它在权限为 777 的目录里。你能删掉这个文件吗？
3. 为什么"能 ls 看到文件名"不等于"能打开这个文件"？

参考答案

1. 能 ls（看得到文件名列表），但不能 cd（没有 x），也打不开里面的文件。
2. 能。删除看的是目录的 w 权限，与文件自身权限无关。
3. 因为 ls 只需要目录的 r；而打开文件需要对目录有 x（能进入），还需要对文件本身有 r。

第26章 看懂 ls -l 的输出 🔰

学完这一章，你能：看懂 ls -l 每一列在说什么，一眼判断"这是文件还是目录、谁能动它"。

26.1 先跑一下

ls -l
# 你会看到类似这样的输出：
总用量 4
-rw-r--r--. 1 root root 2058 5月  11 16:21 a.txt
drwxr-xr-x. 2 root root    6 5月  13 09:41 dir01
lrwxrwxrwx. 1 root root    7 5月  13 10:02 link.txt -> a.txt

一行里挤了 9 段信息，我们把它们拆开看。

26.2 逐段拆解

以这行为例：

-rw-r--r--.  1  root  root  2058  5月 11 16:21  a.txt
└────┬───┘  │   │     │      │         │         │
  ①权限    ②  ③属主 ④属组 ⑤大小   ⑥修改时间  ⑦文件名

26.3 第①段细看：10 个字符怎么读

-rw-r--r-- 这 10 个字符这样切：

 -   rw-   r--   r--
└┘  └┬┘   └┬┘   └┬┘
类型  属主  属组  其他

• 第 1 个字符：文件类型

日常你 99% 只会碰到前三种：-、d、l。

• 后面 9 个字符：三组权限，每组 3 位，顺序永远是 r w x：

rw-r--r--
rw- | r-- | r--
属主 r+w   属组 只读   其他 只读

所以 -rw-r--r-- 读作："这是一个普通文件；主人能读能写；同组的人只能读；其他人只能读。"

再看 drwxr-xr-x：这是一个目录；主人能读能写能进；同组能读能进；其他人能读能进。

26.4 后面那个点 . 和加号 +

-rw-r--r--. 1 root root 2058 5月 11 16:21 a.txt
          ↑
-rw-rw----+ 1 root root    0 5月 14 16:14 1.txt
          ↑

💡 小贴士：看到 + 号就说明"这个文件的权限没你想的那么简单"，想搞清楚要用 getfacl 文件名 看。

26.5 两种等价的查看方式

ls -l a.txt     # 只看一个文件
ls -l /etc/     # 看某个目录里所有文件的详情
ls -ld /etc/    # 只看 /etc 这个目录本身的权限，不列出里面的内容

⚠️ 注意：ls -l /etc/ 列出的是 /etc 里面的文件；想知道 /etc 这个目录自己的权限，必须加 -d。新手经常在这里搞错，看到一堆文件却找不到"目录的权限在哪"。

本章小结

动手练

1. -rwxr-x--- 分别表示三种身份有什么权限？
2. 用一条命令只看 /etc 这个目录本身的权限。
3. 输出里大小显示 4096 的 d 类型条目，这个 4096 是什么？

参考答案

1. 属主 rwx（可读可写可执行），属组 r-x（可读可执行），其他 ---（什么权限都没有）。
2. ls -ld /etc。
3. 目录的大小不是"里面文件的总大小"，而是记录这个目录里文件名清单所占用的磁盘空间，通常固定占一个块（4096 字节 = 4KB）。要看目录里文件的总大小，用 du -sh 目录。

第27章 修改权限 chmod 🔰

学完这一章，你能：用两种方法精确地设置权限，并知道常用的几个权限数字代表什么。

27.1 只有两种人会改权限

1. 文件的属主（自己的文件自己能改）；
2. root（什么都能改）。

改权限的命令叫 chmod（change mode，改变模式）。

它有两种写法：符号法（像说话一样，好理解）和数字法（快，但要想一下）。两种都要会。

27.2 符号法：u / g / o / a + / - / = 和 rwx

格式：chmod 谁 加还是减 什么权限 文件

• 谁：u（属主）、g（属组）、o（其他）、a（所有人 = ugo）
• 怎么改：+ 增加、- 减少、= 直接设定成这个值
• 什么权限：r、w、x

# 给属主增加写权限
chmod u+w a.txt

# 去掉属组的执行权限
chmod g-x a.txt

# 给其他人增加读权限
chmod o+r a.txt

# 给所有人加上执行权限（最常用的一条）
chmod +x run.sh

# 一次设定三个身份：属主 rwx、属组 r-x、其他无
chmod u=rwx,g=r-x,o=--- a.txt

# 一次给属主和属组都加读权限（逗号分隔）
chmod u+r,g+r a.txt

符号法的优点：改的时候不用管原来是什么权限，只说我"要加/减/设"什么。适合微调。

27.3 数字法：把三个权限加起来

这是工作中最常用的写法，也是面试必考。原理很简单：

一个有权限的组合，就把对应数字加起来：

然后三个身份三个数字，拼成一个三位数：

chmod  7 5 5  文件
       │ │ └── 其他：5 = r-x
       │ └──── 属组：5 = r-x
       └────── 属主：7 = rwx

练习一下口算（自己先算，再看答案）：644 是什么？

• 6 = 4+2 = rw-
• 4 = r--
• 4 = r--
• 所以 644 = -rw-r--r--，也就是"主人能读能写，其他人只能读"。

# 一次性把文件设成 rw-r--r--
chmod 644 a.txt

# 给所有用户全部权限（危险！）
chmod 777 a.txt

27.4 五个你必须记住的常用权限

⚠️ 注意：chmod 777 是新手最爱干、运维最讨厌见到的操作。

遇到"权限不够"就 chmod 777，确实能"解决"，但同时打开了所有人的权限：

• 网站目录 777，别人可以上传恶意脚本；
• 私钥文件 777，等于把密码贴墙上；
• 更可怕的是 chmod -R 777 /（对根目录递归），系统直接报废，救不回来。

正确的思路永远是：想清楚"谁需要什么权限"，只给到够用为止。

27.5 递归改权限：-R

# 把目录和里面所有文件的权限都改成 755（递归）
chmod -R 755 /data/app

⚠️ 注意：-R 会连子目录、子文件全部改掉，而且文件和目录用同一个数字会出问题——目录需要 755（有 x 才能进），普通文件通常只需要 644。全都设成 755 虽然能用但不符合最小权限原则；全都设成 644 则目录进不去。

专业做法是分开设：

```bash

目录设 755，普通文件设 644

find /data/app -type d -exec chmod 755 {} \; find /data/app -type f -exec chmod 644 {} \; ```

27.6 特殊：给文件加执行权限

# 写了一个脚本，想让它能直接运行
chmod +x backup.sh

# 然后就能这样跑
./backup.sh

💡 小贴士：为什么用 ./backup.sh 而不是 backup.sh？因为当前目录 . 默认不在系统的 PATH 搜索路径里。敲 ./ 的意思是"就在当前目录找这个文件"。这是很常见的疑惑，记住就好。

本章小结

动手练

1. chmod 640 a.txt 之后，ls -l 显示的是什么？
2. 把 a.txt 设成"属主可读写执行，属组可读，其他人无权限"，用数字法怎么写？
3. 一个目录权限是 644，别人能 cd 进去吗？为什么？

参考答案

1. -rw-r-----（6=rw-，4=r--，0=---）。
2. 属主 7（rwx）、属组 4（r--）、其他 0（---），所以是 chmod 740 a.txt。
3. 不能。进入目录需要 x 权限，而 644 拆开是 rw- / r-- / r--，三段里一个 x 都没有，所以连属主自己也进不去，别人更进不去。

第28章 修改属主和属组：chown、chgrp 🔰

学完这一章，你能：把文件"过户"给别人，或者挂到某个组下面。

28.1 什么时候需要改属主

场景：你用 root 解压了一个网站程序到 /var/www/html，结果文件属主全是 root。网站是以 apache 用户运行的，它改不了这些文件，网站就报错。

这时候要做的是改属主，而不是 chmod 777。这是"权限问题"最常见的正确处理方式。

28.2 chown：改属主

chown = change owner（改变主人）。

# 只改属主
chown apache a.txt

# 改属主的同时改属组，用冒号连起来
chown apache:apache a.txt

# 递归改整个目录
chown -R apache:apache /var/www/html

语法：chown 属主[:属组] 文件

• chown tom file —— 只把属主改成 tom，属组不动
• chown tom:dev file —— 属主改成 tom，属组改成 dev
• chown :dev file —— 只改属组（冒号前面空着）
• chown tom: file —— 注意：这样写会把属组改成 tom 的主组

💡 小贴士：chown tom:dev 这种"用户:组"的写法最常用，一次搞定两件事，比用两条命令省事。

28.3 chgrp：只改属组

chgrp = change group。功能单一，就是改属组。

# 把文件的属组改成 dev
chgrp dev a.txt

# 递归改目录
chgrp -R dev /data/project

它和 chown :dev a.txt 效果一样，你挑一个顺手的记就行。

28.4 谁有权改属主

道理很简单：如果能随便把文件"过户"给别人（尤其是 root），就可以用来栽赃或提权，所以这个权限被锁死了。

⚠️ 注意：普通用户执行 chown 会报 Operation not permitted（不允许的操作），这是正常的，加 sudo 就行。

28.5 一个完整案例（很典型，建议跟着敲）

# 1. 建一个测试目录
mkdir -p /data/web
echo "hello" > /data/web/index.html

# 2. 看看现在是谁的
ls -l /data/web/
# 你会看到：属主属组都是 root（因为你用 root 建的）
-rw-r--r--. 1 root root 6 10月 30 10:00 index.html

# 3. 把整个目录交给 tom
chown -R tom:tom /data/web
ls -l /data/web/
# 你会看到：属主属组都变成了 tom
-rw-r--r--. 1 tom tom 6 10月 30 10:00 index.html

# 4. 切换到 tom 试试能不能改
su - tom -c 'echo "hi" >> /data/web/index.html'
# 没有报错就成功了（因为 tom 现在有写权限）

本章小结

动手练

1. 把 /data/web 目录（含里面所有文件）的属主和属组都改成 tom。
2. chown tom file 和 chown tom: file 有什么区别？
3. 网站报 "Permission denied"，文件属主是 root、目录属主是 root，网站进程是 apache 用户。正确的做法是什么？

参考答案

1. chown -R tom:tom /data/web。
2. chown tom file 只改属主，属组保持不变；chown tom: file 会把属主改成 tom，同时把属组改成 tom 的主组。
3. 把文件交给 apache：chown -R apache:apache /var/www/html，再配合 chmod 755（目录）/644（文件）。不要用 chmod 777。

第29章 umask：新文件的默认权限 🔧

学完这一章，你能：解释"为什么我新建的文件权限是 644 而不是 777"，并会自己改默认值。

29.1 一个自然的问题

你新建一个文件，没设过任何权限，那它的权限是谁定的？

答案：系统按一个"默认规则"自动给的，这个规则叫 umask（权限掩码）。

# 看看当前的 umask
umask
# 你会看到：
0022

29.2 umask 是"减掉的权限"

先记住两个基准值（系统定的，背下来）：

💡 为什么文件不是 777？ 因为 Linux 觉得"新建一个文本文件就带执行权限"太危险了（万一被塞了恶意脚本，一敲就执行）。所以文件的基础权限里天生不带 x。

然后 umask 的作用是"从基准值里减掉这些权限"：

目录：777 - 022 = 755   →  drwxr-xr-x
文件：666 - 022 = 644   →  -rw-r--r--

022 的意思是"从属组和其他人那里，各减掉写权限（2）"。所以：

• 目录默认 755：主人能读写进，别人只能读和进；
• 文件默认 644：主人能读写，别人只能读。

29.3 验证一下

# 新建一个目录和一个文件
mkdir testdir
touch testfile

ls -ld testdir testfile
# 你会看到：
drwxr-xr-x. 2 root root 6 10月 30 10:05 testdir
-rw-r--r--. 1 root root 0 10月 30 10:05 testfile

和推算的 755 / 644 完全一致。

29.4 改 umask

# 临时改（只对当前这个终端有效，关掉就没了）
umask 077

mkdir private_dir
ls -ld private_dir
# 你会看到：目录变成了 700（只有自己能进）
drwx------. 2 root root 6 10月 30 10:06 private_dir

077 = "把属组和其他的所有权限都减掉"，所以目录变成 700、文件变成 600。这在做安全加固时很常用。

永久修改要写到配置文件里（比如 ~/.bashrc 末尾加一行 umask 077），然后重新登录。

29.5 常见的 umask 值

⚠️ 注意：umask 是"减"不是"加"，这是最容易记反的地方。而且这种减法其实是按位减（去掉对应权限位），只是对常见的 022 来说，直接当算术减法算出来的结果恰好一样，方便你理解。看到 027 这类值时别硬算，理解成"去掉对应权限位"就好。

本章小结

动手练

1. umask 是 022 时，新建目录和新建文件的权限各是多少？
2. 想让新建文件默认是 600（只有自己能读写），umask 要设成多少？
3. 判断题：把 umask 设成 000，新建文件就是 777。

参考答案

1. 目录 777-022=755；文件 666-022=644。
2. 077。它的含义是"把属组和其他的所有权限都去掉"，所以文件变成 600、目录变成 700。
3. 错。文件的基础权限是 666，天生没有 x，所以 umask 设成 000 时新建文件是 666（rw-rw-rw-），不是 777。只有目录才会是 777。

第30章 三个特殊权限 🔧

学完这一章，你能：看懂 ls -l 里出现的 s 和 t，并知道它们各自解决什么问题。

30.1 它们解决什么"普通权限解决不了"的问题

普通的 rwx 有三个场景搞不定：

1. 普通用户要改自己的密码，但密码存在只有 root 能改的文件里 —— 怎么做到的？
2. 一个团队共享目录，大家新建的文件都要自动属于同一个组 —— 怎么做到的？
3. /tmp 所有人可写，怎么防止我删掉别人的文件？ —— 怎么做到的？

答案就是三个特殊权限：SUID、SGID、Sticky Bit。

30.2 SUID（4）：临时借用"主人"的身份

作用：一个程序带了 SUID，任何人运行它，都会以"程序的主人"的身份运行，而不是以自己的身份。

最经典的例子就是 passwd：

ls -l /usr/bin/passwd
# 你会看到（属主那一段是 rws，注意这个 s）：
-rwsr-xr-x. 1 root root 27856 4月   1 2020 /usr/bin/passwd

分析一下：

• 这个文件的属主是 root；
• 它的属主权限是 rws（s 就是 SUID）；
• 所以普通用户执行 passwd 时，实际上是"以 root 身份"在运行；
• 而 /etc/shadow（存密码的文件）只有 root 能改，所以普通用户才能改自己的密码。

没有 SUID 会怎样？ 普通用户就改不了自己的密码了——因为他没有权限写 /etc/shadow。

设置方法：

chmod u+s 程序名        # 符号法
chmod 4755 程序名       # 数字法：在前面加个 4

⚠️ 注意：SUID 只有对可执行程序才有意义。而且如果文件本身没有 x 权限，s 会显示成大写 S，表示"设置了但没生效"。

另外，SUID 是提权手段，也是黑客最爱利用的东西。运维定期检查系统里"谁是 SUID 文件"，就是为了排查后门。

30.3 SGID（2）：目录里的文件自动继承组

SGID 有两个作用，对目录的那个作用最实用：

场景：/data/project 是 dev 组共享的开发目录，组里有 tom、jerry、alice。

问题：tom 新建一个文件，属组是 tom（他的主组）。jerry 就改不了这个文件，因为 jerry 只属于 dev 组。

解决：给目录加 SGID，之后任何人在这个目录里新建文件，属组都自动是 dev。

# 给目录加 SGID
chmod g+s /data/project
# 或者数字法（2755）
chmod 2755 /data/project

ls -ld /data/project
# 你会看到属组权限位变成了 rws：
drwxrwsr-x. 2 root dev 6 10月 30 10:10 /data/project

30.4 Sticky Bit（1）：只能删自己的文件

作用：加了 Sticky Bit 的目录，里面的文件只有"文件的主人"或 root 才能删，别人就算有目录写权限也删不了。

经典例子就是 /tmp：

ls -ld /tmp
# 你会看到最后一位是 t：
drwxrwxrwt. 12 root root 4096 10月 30 10:11 /tmp

/tmp 的权限是 777（所有人可写），但因为它带了 t，所以：

• 你可以在 /tmp 里新建自己的文件（有 w）；
• 你删不掉别人的文件（被 t 挡住了）。

没有 t 会怎样？ 任何人在 /tmp 里都能删你正在用的临时文件，程序就崩了。

# 设置方法
chmod o+t 目录名
chmod 1777 目录名     # 数字法前面加 1

30.5 三个放在一起记

数字法的口诀：这三位是"第四位"，写在原来的三位权限前面。

chmod 4755 程序    →  SUID + rwxr-xr-x
chmod 2755 目录    →  SGID + rwxr-xr-x
chmod 1777 目录    →  Sticky + rwxrwxrwx

⚠️ 注意：SGID 和 Sticky 都是给目录用的，而且目录本身必须有 x 权限才会生效——否则你连目录都进不去，特殊权限也就没了意义。

本章小结

动手练

1. 为什么 /usr/bin/passwd 需要 SUID？如果没有会怎样？
2. /tmp 是 777，为什么你删不掉别人在里面建的文件？
3. 给目录 /data/share 加 SGID，用数字法怎么写？

参考答案

1. 因为普通用户改密码时要写 /etc/shadow，而这个文件只有 root 能写。有了 SUID，普通用户运行 passwd 时相当于以 root 身份执行，才能完成写密码文件的操作。没有 SUID，普通用户就改不了自己的密码。
2. 因为 /tmp 带了 Sticky Bit（t），规则变成"只有文件主人和 root 能删"，目录的 w 权限被这条规则限制住了。
3. chmod 2755 /data/share（或 chmod g+s /data/share）。

第31章 隐藏权限：chattr 和 lsattr 🔧

学完这一章，你能：给重要文件上一把"连 root 都打不开"的锁。

31.1 普通权限管不住 root

前面讲的 UGO、ACL，对 root 都无效——root 是老板，什么门都拦不住他。

但有些场景，恰恰需要"连 root 也不能乱动"：

• 系统关键日志文件，怕被误删或篡改；
• 服务器被入侵后，攻击者常会改配置文件留后门；
• 重要配置文件，怕手抖删掉。

这就是隐藏权限（也叫文件属性）的用武之地。它对包括 root 在内的所有用户都生效。

31.2 查看隐藏权限：lsattr

lsattr anaconda-ks.cfg
# 你会看到：
---------------- anaconda-ks.cfg

那一串 - 表示"什么都没设置"。如果某个位置出现字母，就表示设置了对应的属性。

31.3 最常用的两个属性：+i 和 +a

# 给文件加"不可变"锁
chattr +i important.conf

# 验证一下
lsattr important.conf
# 你会看到（i 出现了）：
----i----------- important.conf

# 现在试试删它（root 也不行！）
rm -f important.conf
# 你会看到：
rm: cannot remove 'important.conf': Operation not permitted

# 想改？先解锁
chattr -i important.conf

# 日志文件只能追加，不能删改
chattr +a /var/log/messages

# 现在不能覆盖，但能追加
echo "test" >> /var/log/messages   # 成功
> /var/log/messages                # 失败！不允许清空

⚠️ 注意：忘了自己加过 +i，会是一个非常抓狂的经历。

表现是：明明你是 root，明明权限是 777，就是删不掉、改不了，报错还特别含糊。这时候第一反应应该是：

bash lsattr 文件名

看到 i 就 chattr -i 解锁。这个坑很多人踩过，记住能省你半天时间。

本章小结

动手练

1. 给文件加 +i 后，用 root 执行 rm 会怎样？
2. 日志文件该用 +i 还是 +a？为什么？
3. 你发现一个文件权限是 777、属主是 root、你也是 root，但就是删不掉。先查什么？

参考答案

1. 会失败，报 Operation not permitted。因为不可变属性对 root 也生效。
2. 用 +a。因为日志需要持续追加新内容，+i 会连追加都禁止，日志就写不进去了；+a 允许追加但禁止删除和覆盖，正好防篡改。
3. 先执行 lsattr 文件名，看是不是被加了 i（或者 a）属性。

第32章 ACL：给某个用户单独开小灶 🔧

学完这一章，你能：在"属主/属组/其他"之外，单独给某一个人或某个组开权限。

32.1 UGO 不够用的时候

假设有个文件：

• 属主是 tom；
• 属组是 dev（里面有 jerry、alice）；
• 权限是 640（rw-r-----）。

现在有个既不是 tom、也不在 dev 组的人叫 bob，他临时需要读这个文件。

怎么办？

• 把 bob 加进 dev 组？——那他就获得了 dev 组所有的权限，给多了。
• 把文件改成 644？——那"其他所有人"都能读了，给多了。

UGO 只有三个格子，塞不下"只给 bob 一个人读"这种需求。

这就是 ACL（Access Control List，访问控制列表）要解决的问题：在三个格子之外，再单独点名授权。

比喻：UGO 是"公司通行证分三种：本人、本部门、外人"。ACL 就是"临时访客单"——我可以专门给张三开一张，只允许他进 3 楼会议室。

32.2 看一个文件有没有 ACL

ls -l 权限位后面出现 + 号，就说明有 ACL：

ls -l a.txt
# 注意权限位末尾的那个 +
-rw-rw----+ 1 root root 0 10月 30 10:14 a.txt

32.3 给某个用户单独授权：setfacl

# 给用户 bob 单独加读、写权限
setfacl -m u:bob:rw a.txt

# 查看结果
getfacl a.txt
# 你会看到：
# file: a.txt
# owner: root
# group: root
user::rw-
user:bob:rw-          ← 这一行就是专门给 bob 的
group::---
mask::rw-
other::---

语法：setfacl -m 类型:名字:权限 文件

32.4 撤销和清空

# 撤销 bob 的 ACL
setfacl -x u:bob a.txt

# 清空这个文件的所有 ACL
setfacl -b a.txt

32.5 给目录设 ACL，让新文件自动继承

这是 ACL 最实用的功能。加个 d:（default，默认）前缀：

# 让 /data/share 目录里"以后新建的文件"都自动带上 bob 的 rw 权限
setfacl -m d:u:bob:rw /data/share

# 查看
getfacl /data/share
# 你会看到多了一组 default 开头的：
default:user::rwx
default:user:bob:rw-
default:group::---
default:mask::rwx
default:other::---

⚠️ 注意：d: 只对"设置之后新建的"文件生效，对目录里已有的文件不起作用。 想要已有的文件也生效，得用 setfacl -R -m ... 递归设置。

32.6 mask 是什么（简单了解一下）

getfacl 输出里的 mask 是"ACL 权限的上限天花板"：

• 你给 bob 设了 rwx，但 mask 只有 rw-，那 bob 实际只有 rw-；
• 这就是 getfacl 里有时会显示 #effective:rw- 的原因——生效的权限被 mask 削掉了。

如果发现"我明明设了权限怎么不生效"，先看 mask。

本章小结

动手练

1. 给文件 a.txt 单独授予用户 bob 读写权限，并验证。
2. 撤销 bob 的权限。
3. 怎么让 /data/share 目录以后新建的文件，都自动给 bob 读权限？

参考答案

1. setfacl -m u:bob:rw a.txt，然后用 getfacl a.txt 看到 user:bob:rw- 就成功了（ls -l 会多出 +）。
2. setfacl -x u:bob a.txt。
3. setfacl -m d:u:bob:r /data/share（d: 是 default，只对之后新建的文件生效）。

第33章 sudo：临时借用 root 的权力 🔰

学完这一章，你能：用 sudo 安全地执行管理操作，并给其他用户授权。

33.1 为什么不干脆一直用 root

新手最常见的做法是：直接 su - 变成 root，然后就再也不退出来了。这是运维大忌。

原因：

正确姿势：平时用普通用户干活，只在需要的时候，用 sudo 临时提一下权。

比喻：sudo 就像"临时借用经理的门禁卡"。你不是经理，但你需要进资料室的时候，可以刷一下卡进去办这件事，办完出来还是你自己。而不是"我干脆把自己变成本经理"。

33.2 怎么用 sudo

用法极其简单：在命令前面加 sudo。

# 想改系统配置，普通用户直接干会被拒绝
vim /etc/hosts
# 提示："/etc/hosts" E212: Can't open file for writing（写不进去）

# 加 sudo 就行
sudo vim /etc/hosts
# 提示：你会被要求输入密码
[sudo] password for tom:
# 输你自己的密码（注意：是"你自己的"，不是 root 的！），然后就能正常改了

几个关键点，一定要记牢：

1. sudo 要输的是"你自己的密码"，不是 root 的密码。这点和 su - 完全不同，新手经常在这里懵。
2. 密码输入时屏幕没有显示，输完直接回车。
3. 输入一次密码后，默认 5 分钟内不用重复输。
4. 只有被授权的用户才能用 sudo，没授权的人会看到 tom is not in the sudoers file。

33.3 谁能用 sudo？看组

不同发行版的"可以 sudo 的组"不一样：

所以授权最简单的办法就是把人加进这个组：

# CentOS：把 tom 加进 wheel 组
usermod -aG wheel tom

# Ubuntu：把 tom 加进 sudo 组
usermod -aG sudo tom

💡 小贴士：加完组后，tom 要重新登录才生效（第 24 章提过）。不生效别怀疑命令写错了，先退出重登。

33.4 更精细的授权：/etc/sudoers

上面的办法是"要么全给，要么不给"。如果你想只给某几条命令的权限，就要改 /etc/sudoers 文件。

# 1. 必须用 visudo 命令编辑（重要！）
visudo

# 2. 在文件末尾加一行，例如允许 tom 用 sudo 执行任意命令、且不用输密码
tom  ALL=(ALL)  NOPASSWD:ALL

# 3. 保存退出（vim 操作：Esc 然后 :wq 回车）

这行的意思是：

更安全的写法（只授权特定命令）：

# 只允许 tom 用 sudo 管理系统服务和查看日志，其他一概不行
Cmnd_Alias  SVC = /usr/bin/systemctl, /usr/bin/journalctl
tom  ALL=(ALL)  SVC

禁止某些命令（用 ! 排除）：

# 给全部权限，但禁止改密码、禁止重启
tom  ALL=(ALL)  ALL,!/usr/bin/passwd,!/usr/sbin/reboot

⚠️ 注意：/etc/sudoers 必须用 visudo 命令改，不要直接用 vim 打开改。

为什么？因为 visudo 会在你保存时自动检查语法，写错会提示你，不让你保存。

而如果你用 vim 直接改，语法写错了，所有用户（包括 root）都用不了 sudo 了，那时候连修都修不了（因为修它本身需要 sudo）。这是一个能让你重装系统的坑。

33.5 sudo 常用参数

# 看看我被授权做什么
sudo -l
# 你会看到类似：
User tom may run the following commands on localhost:
    (ALL) NOPASSWD: ALL

33.6 出错排查：三行报错对照表

本章小结

动手练

1. 用普通用户执行 sudo whoami，输出是什么？为什么？
2. su - 和 sudo -i 都要输密码，区别是什么？
3. 为什么改 /etc/sudoers 一定要用 visudo？

参考答案

1. 输出是 root。因为 sudo 让这条命令以 root 身份执行了。
2. su - 要输 root 的密码（需要知道 root 密码，所有权限一把抓）；sudo -i 要输 自己的密码（只需自己账号密码，且受 sudoers 授权范围限制）。sudo -i 更安全，因为它不暴露 root 密码。
3. 因为 visudo 会在保存前自动校验语法，写错会提示并不允许保存；直接用 vim 改，语法错误会让所有人都无法使用 sudo，包括 root 自己，可能连修复的机会都没有。

第六篇 装软件

Linux 装软件不是“下载 exe、双击下一步”，而是一条命令从“仓库”里取。 这一篇讲清四种装法，重点是 yum——它是你以后用得最多的一条命令。

第34章 Linux 装软件的四种方式 🔰

学完这一章，你能：说出 Linux 装软件的四种方式，知道每种方式什么时候用。

34.1 一句话：装软件就是往系统里"加东西"

在 Windows 里装软件，一般就是下载一个 .exe，双击，下一步下一步。

在 Linux 里，大部分软件不用点鼠标，而是敲一条命令。装法常分成四种，各有各的用处。

比喻：这就像给家里添家具，四种方式就是四种买法。

34.2 先看看系统里现在有什么

# 列出已经装好的软件包，只看前 3 行
yum list installed | head -3
# 你会看到类似这样的结果：
Loaded plugins: fastestmirror
Installed Packages
acl.x86_64          2.2.51-15.el7          @anaconda

系统里的软件包通常有几百行，所以接 head 只看前几行。

34.3 什么时候用哪一种

• 有网、想省事 → yum
• 手上只有一个 .rpm 安装包（或一张软件光盘），或必须装某个指定版本 → rpm
• 要最新版、要改代码、要关掉某个功能 → 源码编译
• MySQL、JDK 这类大软件，官方直接给打好包的 → 二进制包

💡 小贴士：还有一种更新的方式叫"容器"（Docker），把软件连环境一起打包，换台机器也能跑。这是进阶内容，现在知道有这回事就行。

34.4 常见坑 ⚠️

• 以为 Linux 也能双击 .rpm 安装。桌面版可能能双击，服务器上一律用命令。
• yum 装不上就急着找源码。先看报错，多半是网络或者 yum 源的问题（下一章讲）。
• rpm 和 yum 混着用。用 rpm 装的包，yum 有时不知道它要什么，越装越容易乱。

本章小结

动手练

1. 一台服务器不能上网，但手里有一张安装光盘，能用 yum 装软件吗？
2. 哪种方式可以修改软件的源代码？
3. 判断：在 Linux 里，软件一般靠双击安装包来安装。（对/错）

参考答案：

1. 能。把光盘配成本地 yum 源就行，第 36 章会教你 6 步配好。
2. 源码编译安装。拿到源码后可以改，再自己编译。
3. 错。Linux 服务器上一般用命令安装。

第35章 yum：最常用的装软件方式 🔰

学完这一章，你能：用 yum 装、卸、查软件，看懂 -y 是干什么的。

35.1 它是什么

yum 是"软件管家"。你说要什么，它去 yum 源里找，把软件和它需要的东西一起装好。

比喻：yum 就是外卖 App。你点一份套餐（软件），店家把配套的餐具（依赖）一起送来，不用你一份一份凑。

依赖：A 软件要用到 B 软件，B 就是 A 的依赖。少一个 B，A 就装不好。这是 rpm 最头疼的地方，yum 专门解决它。

35.2 最小可用：装一个软件

# 装 vim，-y 表示一路同意，不再问你
yum install -y vim
# 你会看到类似这样的结果：
Loaded plugins: fastestmirror
---> Package vim-enhanced.x86_64 2:7.4.629-8.el7_9 will be installed
...
Complete!

看到最后一行 Complete! 就装好了。中途刷很多行是正常的。

35.3 五个命令够用了

35.4 -y 到底是什么意思

不加 -y 时，yum 装之前会问你一句：

yum install vim
# 你会看到：
Is this ok [y/d/N]:     ← 停在这里等你输入

输入 y 回车才继续。-y 就是把这一步自动回答成 y。

💡 练手时加 -y 省事；想看清要装什么，就先不加。

35.5 常见坑 ⚠️：报错了先查这两件事

# 1. 网络通不通
ping -c 3 www.baidu.com
# 你会看到：3 packets transmitted, 3 received, 0% packet loss
# 100% packet loss 就是网络问题

# 2. yum 源对不对
yum repolist
# 你会看到：
repo id           repo name             status
base/7/x86_64     CentOS-7 - Base       10019

status 是 0，或报 Cannot find a valid baseurl，就是源没配好（第 36 章）。

还有一点：yum remove 会把依赖它的软件一起删掉，卸载前看清楚要删哪些。

本章小结

动手练

1. 用一条命令装 wget、tree、zip，中间不要停下来问。
2. 想装一个软件但不知道包名，怎么办？
3. yum 报 Cannot find a valid baseurl，最可能是哪两个原因？

参考答案：

1. yum install -y wget tree zip
2. 先搜：yum search 关键字，从结果里找包名。
3. 网络不通，或者 yum 源配错了（baseurl 写错、光盘没挂载）。

第36章 配置 yum 源 🔰

学完这一章，你能：配好本地光盘源，没网也能装软件；也知道网络源失效了怎么查。

36.1 yum 源是什么

比喻：yum 是外卖 App，yum 源就是它背后那家超市的地址。地址写错，App 再好也点不了单。

yum 源就是软件仓库（仓库 = 一堆 rpm 包放在一起的地方），分两种：网络源（在互联网上，如阿里云、华为云镜像站）和本地源（在你自己的机器上，如安装光盘、局域网服务器）。

配置都放在 /etc/yum.repos.d/，一个 .repo 文件就是一个仓库。

36.2 配本地光盘源：6 步走

⚠️ 前提：CentOS 7 安装光盘 ISO 已挂到虚拟机（虚拟机设置里"连接 CD/DVD"）。

第 1～3 步：确认光盘、建挂载点、挂上去

lsblk
# 你会看到（TYPE 是 rom 的那个就是光盘）：
NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sr0     11:0    1  4.4G  0 rom

mkdir -p /media/cdrom
mount -r /dev/sr0 /media/cdrom    # -r 只读，光盘本来也写不进去
ls /media/cdrom
# 你会看到 Packages 和 repodata 都在，说明包齐全：
CentOS_BuildTag  EFI  GPL  Packages  repodata  ...

第 4 步：备份原来的源（用 mv 别用 rm，以后有网要改回来）

cd /etc/yum.repos.d/
mkdir bak && mv *.repo bak/

第 5 步：写新的源文件（vi local.repo，按 i 编辑，粘进下面内容；Esc 后输 :wq 保存）

[c7-media]
name=CentOS-7 - Media
baseurl=file:///media/cdrom/
gpgcheck=0
enabled=1

第 6 步：让 yum 认识这个源，然后就能装软件了

yum makecache
# 你会看到：
c7-media | 3.6 kB  00:00
Metadata Cache Created

36.3 有网时用网络源

CentOS 7 已经在 2024 年 6 月停止维护，官方源已下线。老机器要配源，一般换成镜像站（阿里云、华为云、清华等）的地址：做法和第 5 步一样，只换 baseurl。

baseurl=https://镜像站给的地址/centos-vault/7.9.2009/os/x86_64/

💡 地址请去镜像站网页复制，不要手敲，错一个字母就下不了。新机器建议直接用 Rocky Linux、AlmaLinux 或 Ubuntu，不用再折腾 CentOS 7。

36.4 常见坑 ⚠️

• baseurl 写成 file://media/cdrom/（少一个斜杠）→ 本地路径必须是三条斜杠 file:///
• 光盘没挂载就 yum makecache → 报 Cannot find a valid baseurl
• 写了 gpgcheck=1 却没配 gpgkey → GPG 校验失败，新手先写 gpgcheck=0
• 直接 rm 掉默认源，以后想恢复很麻烦

本章小结

动手练

1. local.repo 里写的是 baseurl=file://media/cdrom/，yum makecache 一直报错，问题在哪？
2. yum repolist 里某个源的 status 是 0，说明什么？
3. 配本地源时，为什么建议 mv *.repo bak/ 而不是 rm *.repo？

参考答案：

1. 少了一个斜杠，本地路径必须是 file:///。
2. 这个仓库里一个可用的软件包都没有，源配错了或者光盘没挂载好。
3. mv 只是挪走，随时能挪回来；rm 删了就没了。

第37章 rpm：直接安装单个安装包 🔧

学完这一章，你能：装一个本地的 .rpm 包，查看它装在哪、属于谁，也知道它为什么会报"依赖错误"。

37.1 它是什么

rpm 是 RedHat 系的老牌安装工具。.rpm 文件就是"打包好的软件"，里面有程序、配置文件、帮助文档。

比喻：rpm 包是一箱已经拆好的家具，箱里有一张零件清单。它能告诉系统"东西放哪"，但不会替你去买缺的螺丝（依赖）。缺一颗就装不上。

37.2 最小可用：安装

# 安装当前文件夹下的一个 rpm 包
rpm -ivh 软件包名.rpm
# 你会看到类似这样的结果：
Preparing...             ################################# [100%]
   1:软件包名-1.0-1.el7  ################################# [100%]

三个字母：-i 安装，-v 显示过程，-h 显示进度条。

37.3 五个查询命令（比安装更常用）

rpm -q vim-enhanced
# 你会看到：
vim-enhanced-7.4.629-8.el7_9.x86_64

rpm -qf /usr/bin/vim
# 你会看到：
vim-enhanced-7.4.629-8.el7_9.x86_64

rpm -qf 很好用：看到一个命令不知道是哪个包提供的，一查就知道。

37.4 卸载

rpm -evh 软件包名
# 例如：
rpm -evh wget

⚠️ -e 后面写的是包名（wget），不是文件名（wget-1.14-18.el7.x86_64.rpm）。

37.5 常见坑 ⚠️

• 依赖报错（最常见）：error: Failed dependencies:，就是缺东西。 解决：改用 yum 装这个本地包，它会自动补依赖：

bash yum localinstall -y /路径/软件包名.rpm

• 拿文件名当包名：rpm -q wget-1.14.rpm 查不到，要写 rpm -q wget。

• 以为 rpm 装完就完事：rpm 只管"放文件"，不会帮你启动服务、改配置。

本章小结

动手练

1. 装了一个包，想知道它到底往系统里放了哪些文件，用哪个命令？
2. 看到 /usr/sbin/sshd 这个程序，想知道它属于哪个软件包？
3. rpm -ivh 报 Failed dependencies，最简单的解决办法是什么？

参考答案：

1. rpm -ql 包名
2. rpm -qf /usr/sbin/sshd（结果是 openssh-server）
3. 用 yum localinstall -y 包路径 装，让 yum 把缺的依赖补上。

第38章 源码编译安装 🔧

学完这一章，你能：照着步骤把 nginx 从源码装进系统，知道每一步在干什么。

38.1 它是什么

源码就是程序员写的原始代码，不能直接运行，要先用编译器"翻译"成程序。

比喻：源码是面粉和菜谱。rpm/yum 是超市买的半成品菜，热一下就能吃；自己做饭麻烦，但想少放盐、多放辣椒都行——要最新版、要改代码时就该用它。

38.2 三步口诀

38.3 跟着做：装 nginx

需要联网。版本号以官网为准，这里用 1.24.0 举例。

第 1 步：装编译工具（第一次装一定要先装，不然 configure 会报错）