本文思维链：理解分区职能 → 拆开传统分区的两个角色 → 看清 LVM 的三层抽象 → 落到扩容流程与常见坑

基本概念

Linux 的存储从上到下是一条链：物理磁盘 → 分区表 → 分区 / PV → （VG）→ 文件系统 → 挂载点。 日常最容易混淆的是"分区"和"文件系统"——把它们分开看，后面所有扩容操作才讲得通。

分区概念

分区不是一块独立的设备，它只是分区表里的一条记录：「从第 X 个扇区开始，共 Y 个扇区」。内核读到这条记录后，生成一个块设备 /dev/sdb1，上层就能像读写整盘一样读写这段地址范围。

分区表写在磁盘最前面，常见两种：

分区与文件系统的分工：mkfs.xfs /dev/sdb1 是把文件系统的超级块、空闲块位图、inode 表写进分区覆盖的地址范围。也就是说：

• 分区决定「文件系统能用多大」——地址范围写在分区表里，建好即固定；
• 文件系统决定「这些空间怎么组织数据」——元数据写在分区内部。

两边互不知情，所以扩容时要拆成两次扩：先改分区表/LV 映射让块设备变大，再通知文件系统吃满新空间。这是全文最关键的一句话。

flowchart TD
    A[物理磁盘 /dev/sdb] --> B[分区表 MBR / GPT]
    B --> C[分区 /dev/sdb1]
    C --> D[文件系统 XFS / EXT4]
    D --> E[挂载点 /data]

查看命令

lsblk -f                              # 树形展示：磁盘→分区→文件系统→挂载点
lsblk -o NAME,SIZE,TYPE,MOUNTPOINT
blkid                                 # 查看 UUID / 文件系统类型
fdisk -l /dev/sdb                     # 查看分区表

LVM概念

LVM（Logical Volume Manager） 是架在 device-mapper（dm）之上的卷管理层：它把「物理空间」和「逻辑空间」解耦，用一张可动态修改的映射表取代固定地址。

层次结构：物理磁盘/分区 → PV → VG → LV → 文件系统

映射是怎么实现的：LV 并不是"把某块盘的一部分划出来"，而是 dm 里的一张 linear 映射表——「LV 的第 0 ~ 10239 个 LE → /dev/sdb 上第 0 ~ 10239 个 PE」。由此得到三个直接结论：

• 一个 LV 可以横跨多块 PV；
• 扩容只是往映射表尾部追加条目，已有条目的地址不动，所以不需要搬数据；
• 设备节点其实是 /dev/mapper/vg_data-lv_data，/dev/vg_data/lv_data 只是 udev 生成的软链接，两者是同一个设备。

元数据存在哪：LVM 自己的元数据（PV/VG/LV 结构、PE 分配表）有两份——磁盘上每个 PV 头部的 label + metadata area，以及 /etc/lvm/backup/、/etc/lvm/archive/ 里的文本备份，必要时可用 vgcfgrestore 回滚。这也是 LVM 比裸分区"更好救"的原因之一。

pvs                 # PV 清单
vgs                 # VG 清单（重点看 VFree：还剩多少可分配）
lvs -o +devices     # LV 清单，+devices 可看到它落在哪些 PV 上
pvdisplay -m        # 展开 PE → LE 的映射关系

两者关系

传统分区 /dev/sdb1 同时干了两件事：

1. 划分物理边界：把一块物理磁盘切成一段一段的存储区域
2. 作为文件系统的载体：mkfs /dev/sdb1，文件系统直接建在分区上

而 LVM 把这两个角色拆开了：

注：VG ≈ 传统里没有的中间池化层（把多个物理范围合并成一个可分配空间）。

两者区别

分区大小

LV 的物理边界不是固定的，而传统分区大小固定：

• 传统 /dev/sdb1 建好后，物理位置和大小就钉死了。
• LVM 的 /dev/vg_data/lv_data 逻辑上 50G，但底层可能横跨 /dev/sda3 和 /dev/sdb 两块盘，扩容后可以变成 150G。

也就是说，LV 只保留"文件系统载体"这个角色，丢掉了"固定物理边界"这个角色——物理边界被 PV/VG 接管了。这正是 LVM 灵活性的来源。

在线扩容

传统分区必须挂载新目录或调整分区，LVM 可通过 LV 实现逻辑上的扩展：

• PV 层面：pvcreate /dev/sdb 只是初始化磁盘元数据，不涉及已挂载的磁盘。
• VG 层面：vgextend vg_data /dev/sdb 只是在卷组里新增一个物理存储池成员，不影响现有 LV 的数据分布。
• LV 层面：lvextend -l +100%FREE /dev/vg_data/lv_data 是逻辑上的扩展，内核支持动态调整映射表。
• 文件系统层面：xfs_growfs /data 或 resize2fs 专门设计为在线扩展，底层文件系统会动态分配新空间到已有目录中。

整个过程业务进程无需重启，正在读写的文件不受影响（因为扩展的是空闲区域，不移动已有数据）。

扩容能力的边界

结论：LVM 换来灵活性，代价是多一层抽象（多一份要维护的元数据、多一处可能敲错的地方）。缩容不是它的强项，扩容才是它的主场。

扩容流程

扩容要先分清诉求，两种诉求的代价完全不同：

• A. 新增挂载点：磁盘满了，加一块盘，把新盘挂到新目录（如 /data2）——不需要停机。
• B. 扩大已有目录：磁盘满了，但业务路径不能改，必须让 /data 本身变大——这才是考验底层方案的地方。

新增磁盘（传统 & LVM）

场景1：为新磁盘新建分区（或 LV）并挂载到新目录，即上面的诉求 A。

传统流程：OS 层执行 rescan → 确认 lsblk → fdisk 分区 → mkfs 格式化 → mount 挂载 → df 验证→ fstab 永久挂载 → mount -a 验证

# OS层发现新设备
echo "- - -" > /sys/class/scsi_host/host0/scan
lsblk                        # 确认新容量已识别
fdisk /dev/sdb               # 分区
mkfs.xfs /dev/sdb1           # 格式化
mount /dev/sdb1 /mnt/data    # 挂载
df -h                        # 验证
# 永久挂载：获取UUID → 写入 /etc/fstab
blkid /dev/sdb1				 # 获取UUID
blkid /dev/sdb1 | grep -o ' UUID="[^"]*' | cut -d'"' -f2	# 获取纯UUID字段
vim /etc/fstab				 # vim 手动加一行或用 echo 追加
echo 'UUID=<UUID> /mnt/data xfs defaults 0 0' >> /etc/fstab
mount -a -v					 # 用 mount -a 测试 fstab 是否正确

LVM 流程：OS 层执行 rescan → 确认 lsblk → PV/VG/LV 操作 → mkfs → mount → df 验证 → fstab 永久挂载 → mount -a 验证

echo "- - -" > /sys/class/scsi_host/host0/scan
lsblk
pvcreate /dev/sdb                    # 相当于分区中的初始化物理边界
vgcreate vg_data /dev/sdb            # 建存储池（传统没有这层）
lvcreate -L 50G -n lv_data vg_data   # 相当于"切出分区"
mkfs.xfs /dev/vg_data/lv_data        # 格式化
mount /dev/vg_data/lv_data /mnt/data # 挂载
df -h
blkid /dev/sdb1
vim /etc/fstab
mount -a -v

场景2：为新磁盘新建分区（或 LV）并挂载到已有目录，即上面的诉求 B。

流程：停业务 → 搬运现有业务数据 → 识别新容量 → umount → 其余流程

为什么该流程要停止业务/不支持在线操作？

"新盘 + 新挂载点"这套流程本身不需要停机。mkfs 和 mount 只作用于新的块设备与新的空目录，完全不碰正在服务的文件系统。真正要停机的，是「想把新盘并进已有目录」（诉求 B）——传统分区方案做不到，只能停机搬数据。

拆开看，原因有三层：

1. 分区是固定地址，且不能跨盘：/dev/sda1 的边界写死在分区表里，/dev/sdb1 是另一段独立地址。"把 sdb 的空间追加给 sda1 上的文件系统"在传统分区里根本不存在对应操作。
2. 同一块盘内扩容也有限制：只有当盘上存在紧邻分区尾部的空闲空间时才能扩（growpart / parted resizepart → resize2fs）；改完分区表还要让内核重读（partprobe / partx -u），而分区正被挂载占用时，旧内核会直接拒绝重读，只能 umount。
3. 做不到就只能搬数据：换新盘意味着 rsync 全量搬运 → umount → 重新分区、mkfs → 改 /etc/fstab → 重新 mount。停机时间和数据量成正比，且搬运期间的新写入无法保证一致，业务必须停。

另外，mkfs 这个动作永远不可能在线做：它是"在块设备上从零构建文件系统元数据"的破坏性操作，等于把原有超级块、inode 表、位图全部重建。这和"扩容文件系统（在原有结构上变大、保留数据）"是两件完全不同的事。

LVM 在线扩容

生产环境中的最佳实践。不动现有磁盘/分区，而是把新磁盘加入卷组，再扩展 LV，让文件系统直接使用新空间。

流程：OS 层执行 rescan → 确认 lsblk → PV/VG/LV 操作 → xfs_growfs/resize2fs → df 验证

echo "- - -" > /sys/class/scsi_host/host0/scan
lsblk
pvcreate /dev/sdb                             # 新盘纳入 LVM
vgextend vg_data /dev/sdb                     # 加入卷组，VG 变大
lvextend -l +100%FREE /dev/vg_data/lv_data    # LV 变大（也可以 -L +50G 指定增量）
# 扩容文件系统，通知文件系统用满新空间
xfs_growfs /data                 # XFS：接挂载点
resize2fs /dev/vg_data/lv_data   # EXT4：接设备
# 检查
df -h

:::tip 想少敲一条命令，可以在扩 LV 时直接加 -r（等价于 --resizefs）：lvextend -r -l +100%FREE /dev/vg_data/lv_data，LVM 会顺带调用文件系统的扩容工具。 :::

为什么扩容流程中没有格式化/挂载操作？

• 格式化（mkfs）是对整个块设备"从无到有"创建文件系统的操作，只能做一次；而扩容是扩展文件系统（在原有基础上变大、保留数据），走的是另一条代码路径。
• 挂载（mount）只在全新磁盘 / 全新 LV 第一次投入使用时做一次，作用是把文件系统接入目录树；扩容是对已挂载的对象操作，属于两个不同阶段。
• 扩容其实是"拆成两次扩"：lvextend 让块设备变大（改 dm 映射表），xfs_growfs / resize2fs 让文件系统用满新空间。少做后一步，lsblk 已经变大而 df -h 毫无变化。

常见坑

1. 只扩了 LV，忘了扩文件系统：补一条 xfs_growfs /data（XFS）或 resize2fs /dev/vg_data/lv_data（EXT4）即可，对已挂载的文件系统是安全的（XFS 只支持扩、不支持缩）。
2. 参数搞反：xfs_growfs 接挂载点，resize2fs 接设备；lvextend 接 LV 路径，vgextend 接 VG 名 + 新 PV。
3. 对已有数据的盘执行 pvcreate：会覆盖磁盘头部（含分区表），旧数据事实不可见。新盘整盘使用没问题；复用旧盘前务必确认盘上没有要保留的数据。
4. 整盘做 PV 还是分区做 PV：pvcreate /dev/sdb 最省事；若这块盘还要分给别的用途、或需要保留分区表结构，就先建一个类型为 8e（Linux LVM）的分区，再 pvcreate /dev/sdb1。
5. 虚拟机扩完盘系统没识别：SCSI 用 echo "- - -" > /sys/class/scsi_host/host0/scan；NVMe 用 echo 1 > /sys/class/nvme/nvme0/rescan_controller；只改了分区表则用 partprobe /dev/sdb 或 partx -u /dev/sdb。
6. 缩容是另一回事：ext4 缩容要先 umount + e2fsck -f + resize2fs，顺序错一步就丢数据；XFS 根本不支持缩容。生产上想"腾出空间"，通常是新建 LV、迁移数据、再删旧 LV。
7. 变更前留后路：动 LV 之前可以先 lvcreate -s 打个快照，或确认有可用备份，扩容失败时可回滚。

小结

Kubernetes 核心组件有哪些？

• Master（控制平面）：kube-apiserver（API 入口）、etcd（配置存储）、kube-scheduler（调度）、kube-controller-manager（控制器）、cloud-controller-manager（云厂商控制器，可选）。
• Node（工作节点）：kubelet（Pod 生命周期）、kube-proxy（网络代理/负载均衡）、containerd（容器运行时）。

kube-apiserver 的作用？ 集群统一 API 入口，所有组件通过它通信。它是唯一直接读写 etcd 的组件，负责认证（Authentication）、鉴权（Authorization）、准入控制（Admission）、校验与持久化，并提供 Watch 机制供其他组件监听资源变化。

etcd 的作用？ 分布式 KV 存储，保存集群所有配置和状态数据。基于 Raft 协议保证强一致性，因此生产环境推荐 3/5 个奇数节点做高可用；它是集群的唯一真实数据源，备份 etcd 就等于备份整个集群。

kube-scheduler 如何调度 Pod？ 过滤（Filtering）→ 打分（Scoring）→ 绑定（Binding）。过滤阶段剔除不满足条件的节点（资源不足、污点不容忍、端口冲突、亲和性不符）；打分阶段按优先级函数（资源均衡、亲和性权重等）排序选出最优节点；最后把结果写入 Pod 的 nodeName（Binding）。调度考虑资源、亲和性、污点容忍、拓扑分布等。

kube-controller-manager 的作用？ 运行一系列控制循环（Reconcile Loop），让实际状态不断逼近期望状态。常见控制器：Deployment、ReplicaSet、StatefulSet、DaemonSet、Node、Job、EndpointSlice、ServiceAccount 等。多个控制器共享同一进程以减少复杂度。

kubelet 的作用？ 每个节点上的代理，负责 Pod 生命周期管理（创建、监控、销毁）。它监听 API Server 上属于自己的 Pod，通过 CRI 调用容器运行时拉起容器，并上报节点与 Pod 状态；它不管理非本节点创建的静态 Pod 之外的容器。

kube-proxy 的 iptables 和 IPVS 模式区别？

• iptables：基于规则链线性匹配，规则数量随 Service 数量增长而膨胀，适合小规模集群；随机负载均衡。
• IPVS：基于哈希表，性能高、支持 rr/wrr/lc/sh 等多种负载均衡算法与会话保持，适合大规模集群。
• 两者都只做四层转发，都从 EndpointSlice 获取后端地址。

一个 Pod 从创建到运行的完整流程？

1. kubectl 提交 YAML → apiserver 认证、鉴权、准入（Mutating/Validating）→ 写入 etcd。
2. controller-manager 中的 Deployment/ReplicaSet 控制器发现后创建对应的 Pod 对象。
3. scheduler 监听到未绑定的 Pod，筛选节点后写入 nodeName。
4. 目标节点的 kubelet watch 到该 Pod，调用 CRI 拉镜像、先跑 Init 容器、再按顺序启动业务容器；调用 CNI 分配 IP、挂载 Volume。
5. kubelet 上报状态，EndpointSlice 控制器把就绪 Pod 写入 Service 后端，CoreDNS 提供域名解析。

Pod

Pod 是什么？ Kubernetes 最小调度单元，一组容器的集合，共享网络（同一 Network Namespace 与 IP）和存储（Volume），可共享 UTS/IPC。每个 Pod 都有一个 pause 容器（Infra 容器）持有网络命名空间，业务容器加入其中。

为什么 Pod 是 K8s 调度的最小单元？ 调度、网络、存储和资源配额都以 Pod 为粒度：

1. 网络、存储和资源配额：容器只是进程的封装，如果容器需要共享 Network/UTS/IPC 命名空间与 Volume，必须被调度到同一节点，单独调度无法保证共置。
2. 调度：资源 requests/limits、QoS 等级、亲和性与污点容忍都定义在 Pod 级别（容器级别只是求和）。
3. 生命周期：Pod 是原子生命周期单位，副本数、滚动更新、扩缩容的计数对象都是 Pod。

Pod 的生命周期状态有哪些？

• Pending（等待调度/拉镜像）
• Running（至少一个容器运行中）
• Succeeded（全部容器成功退出且不会重启）
• Failed（至少一个容器异常退出且不会重启）
• Unknown（与节点失联）
• 容器自身的状态则为 Waiting、Running、Terminated。

Init 容器的作用？ 在主容器启动前串行执行、必须成功退出，常用于等待依赖服务就绪、初始化配置、修改数据卷权限；与普通容器不同的还有：不支持探针、不计入 QoS 计算。

Pod 与 Deployment 的区别？ Pod 是单个调度单元，生命周期短暂，重启/迁移后 IP 变化；Deployment 通过 ReplicaSet 管理 Pod 副本，提供声明式副本数、滚动更新和回滚。

Pod 健康检查的探针有哪些？

三种探针：

• Liveness Probe（存活探针，失败则按 restartPolicy 重启容器）
• Readiness Probe（就绪探针，失败则从 Service 后端摘除、不转发流量）
• Startup Probe（启动探针，成功前抑制其他探针，适合慢启动应用）

实现方式：exec（执行命令）、httpGet、tcpSocket、grpc。参数有 initialDelaySeconds、periodSeconds、timeoutSeconds、failureThreshold。

讲一下Pod重启，restartPolicy 有哪些？

• 重启是重启容器而不是重建 Pod，所以 Pod IP 不变，但重启间隔会指数退避（10s→20s→40s…上限 5min），这就是 CrashLoopBackOff。
• 重启策略：Always（默认，Deployment 用）、OnFailure、Never（Job 常用）。

Pod 处于 CrashLoopBackOff / ImagePullBackOff 怎么办？

• CrashLoopBackOff：kubectl logs --previous 看上次崩溃日志，常见原因有配置错误、依赖服务不可用、探针配置过严、OOMKilled（kubectl describe pod 看 Last State）。
• ImagePullBackOff：镜像名/标签错误、私有仓库缺少 imagePullSecrets、节点网络不通。
• Pending：资源不足、没有可调度节点、PVC 未绑定。
• Terminating 卡住：finalizer 未清理或节点失联。

Pod 的 QoS 等级？

• Guaranteed（所有容器都设了 requests == limits）
• Burstable（设了部分 requests，不满足 Guaranteed）
• BestEffort（完全没设）
• 节点内存不足时按 BestEffort → Burstable → Guaranteed 的顺序驱逐

Service 与网络

Service 的类型有哪些？

• ClusterIP（默认，仅集群内访问，虚拟 IP）；
• NodePort（每个节点开放 30000-32767 端口映射）；
• LoadBalancer（调用云厂商 LB，通常是 NodePort 的超集）；
• ExternalName（CNAME/DNS 别名，不转发流量）；
• 另外还有无头服务 Headless Service（clusterIP: None，直接返回 Pod IP，供 StatefulSet 使用）。

Service 的实现原理？ Service 只是一组 iptables/IPVS 规则的抽象：apiserver 分配 ClusterIP 后，kube-proxy 监听 Service 与 EndpointSlice 变化并下发规则，把访问 ClusterIP 的流量 DNAT 到某个就绪 Pod 的 IP:Port；CoreDNS 把 svc.namespace.svc.cluster.local 解析为 ClusterIP。三层结构 = DNS 名称 → ClusterIP → Pod IP。

Ingress 是什么？与 Service 的关系？ Ingress 提供集群外部到 Service 的 HTTP/HTTPS 路由规则集合（基于 Host/Path 转发、TLS 终止），本身只是一份配置，必须由 Ingress Controller（Nginx Ingress、Traefik、Higress 等）解析并生效。流量路径为：客户端 → Ingress Controller → Service → Pod。Ingress 是七层，Service 是四层。

CNI 是什么？常见实现？ Container Network Interface，容器网络插件标准（负责给 Pod 分配 IP、配置路由与网卡）。常见：Flannel（Overlay 网络，VXLAN/host-gw，简单但无 NetworkPolicy）、Calico（BGP 三层网络或 IPIP，性能好且支持 NetworkPolicy）、Cilium（eBPF，性能和可观测性更强）。

K8s 如何实现负载均衡？ 分层次实现：

1. 四层（Service）：kube-proxy 通过 iptables/IPVS 把 ClusterIP 的流量随机/轮询转发到后端 Pod，可用 sessionAffinity: ClientIP 做会话保持。
2. 七层（Ingress / Gateway API）：按域名、路径、Header、权重做路由。
3. 外部入口：LoadBalancer 类型 Service 或云厂商 SLB/Nginx 做最外层负载均衡。
4. 客户端侧：无头 Service + 客户端自行负载均衡（gRPC 常用）。

Pod 之间如何通信？跨节点呢？

• 同一 Pod 内通过 localhost；
• 同节点不同 Pod 通过 CNI 创建的 veth/bridge 通信；
• 跨节点由 CNI 路由（Flannel VXLAN 封装、Calico BGP 路由）完成，要求满足 K8s 网络模型：每个 Pod 一个 IP，Pod 间可直接通信无需 NAT。

Service 访问不通怎么排查？

1. kubectl get endpointslices 确认后端是否有就绪 Pod（没有则检查探针/标签选择器）。
2. kubectl exec 进 Pod 测 nslookup 与 curl ClusterIP，定位是 DNS 还是转发问题。
3. 检查 targetPort 与容器实际监听端口是否一致。
4. 检查 NetworkPolicy 是否拦截流量。

存储

PV、PVC、StorageClass 的关系？

• PV（PersistentVolume）：集群级存储资源，由管理员静态创建或由 provisioner 动态创建。
• PVC（PersistentVolumeClaim）：用户存储申请（容量、accessMode、storageClassName），绑定到某个 PV。
• StorageClass：动态存储供给配置，声明 provisioner 与参数（如 reclaimPolicy、磁盘类型），PVC 引用它即可自动创建 PV。

访问模式 accessMode 有哪些？

• ReadWriteOnce（RWO，单节点读写，最常见）
• ReadOnlyMany（ROX）
• ReadWriteMany（RWX，需 NFS/CephFS 等支持）
• ReadWriteOncePod
• 回收策略有 Retain / Delete / Recycle

PVC 处于 Pending 状态的可能原因？ 没有匹配的 PV（容量 / accessMode / storageClassName / 标签选择器不匹配）；StorageClass 不存在或 provisioner 故障；WaitForFirstConsumer 模式下还没有 Pod 使用它。

如何配置持久化存储？ 三步：创建 StorageClass（或管理员静态建 PV）→ 创建 PVC 申请 → Pod 通过 volumes 引用 PVC。

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: fast
provisioner: kubernetes.io/aws-ebs   # 或 csi 驱动
reclaimPolicy: Delete
volumeBindingMode: WaitForFirstConsumer
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data
spec:
  storageClassName: fast
  accessModes: ["ReadWriteOnce"]
  resources:
    requests:
      storage: 10Gi
---
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: nginx
      volumeMounts:
        - name: data
          mountPath: /data
  volumes:
    - name: data
      persistentVolumeClaim:
        claimName: data

emptyDir、hostPath 与 PVC 的区别？ emptyDir 生命周期与 Pod 相同（Pod 删除即清空），适合缓存与容器间共享；hostPath 挂载宿主机目录，Pod 漂移后数据仍在但强绑定节点，仅适合特殊场景（日志采集）；PVC 才是真正的持久化、与 Pod 解耦的存储。

配置与安全

ConfigMap 和 Secret 的区别？ ConfigMap 存明文非敏感配置；Secret 存敏感信息，值以 base64 编码存储（并非加密），可限制为 type: Opaque 或 dockerconfigjson 等。使用时都可以通过环境变量或 Volume 挂载注入。 注意：base64 是可逆编码不是加密，要真正安全需开启 etcd 静态加密、RBAC 限制读取、或使用外部密钥管理（Vault/KMS）。

更新 ConfigMap/Secret 后 Pod 会立即生效吗？ 环境变量方式注入的不会生效，必须重建 Pod（Deployment 可用 kubectl rollout restart）；以 Volume 挂载方式的最终会更新（kubelet 周期同步，约 1 分钟），但应用需自行 reload。

RBAC 中 Role 和 ClusterRole 的区别？ Role 作用于单个 Namespace；ClusterRole 作用于整个集群（或用于跨 Namespace 复用与集群级资源如 Node、PV）。通过 RoleBinding 绑定 Role/ClusterRole（限定在某 Namespace），通过 ClusterRoleBinding 绑定 ClusterRole（全集群生效）。RBAC 是纯允许模型，没有拒绝规则。

ServiceAccount 的作用？ Pod 访问 API Server 时的身份标识，未指定则使用 default。Token 会自动挂载到 /var/run/secrets/kubernetes.io/serviceaccount，配合 RoleBinding 即可实现 Pod 级别最小权限。

Pod 安全限制有哪些手段？ SecurityContext（runAsUser、readOnlyRootFilesystem、capabilities、privileged）、Pod Security Admission（baseline/restricted）、NetworkPolicy（网络隔离）、ResourceQuota/LimitRange（资源约束）。

高级资源

StatefulSet 和 Deployment 的区别？

• Deployment 用于无状态应用，Pod 完全等价、可随意替换；
• StatefulSet 用于有状态应用，常用于数据库、消息队列、ZooKeeper 等，提供：
  • 稳定的网络标识（pod-name-0.svc 依赖 Headless Service）
  • 稳定的独立存储（volumeClaimTemplates）
  • 有序的创建/删除/滚动（0→N创建，逆序删除）

DaemonSet 的典型应用场景？ 每个（或指定的）节点运行一个 Pod，如日志收集（Fluentd/Filebeat）、节点监控（Node Exporter）、CNI 组件、kube-proxy。新节点加入时会自动部署。

HPA 是什么？ Horizontal Pod Autoscaler，基于 CPU/内存或自定义指标自动扩缩容 Pod 副本数。默认每 15s 采集一次指标（依赖 Metrics Server），按 期望副本数 = 当前副本数 × 当前指标 / 目标指标 计算并受 tolerance 与扩缩容冷却时间限制。配套还有 VPA（垂直调资源）与 Cluster Autoscaler（扩节点）。

Job 和 CronJob 的区别？ Job 运行一次性任务直到成功（可设 completions/parallelism、backoffLimit）；CronJob 按 cron 表达式周期性创建 Job，支持 concurrencyPolicy 与历史保留数。

如何限制 Pod 资源使用？ 在 Pod 的 resources 字段定义 requests（调度依据，保证下限）和 limits（运行时上限，超出内存会被 OOMKilled、超出 CPU 会被限流）。命名空间级别可用 LimitRange 设默认值与上下限，用 ResourceQuota 限制总量。

节点亲和性与污点容忍的区别？

• 亲和性是 Pod 主动选择节点（吸引，支持 requiredDuringScheduling 硬性 与 preferredDuringScheduling 软性、nodeAffinity/podAffinity/podAntiAffinity）；
• 污点容忍是 Pod 被动适应节点（排斥），节点打污点排斥 Pod，Pod 加容忍才能调度上去。污点效果有 NoSchedule、PreferNoSchedule、NoExecute（NoExecute 还会驱逐不容忍的存量 Pod）。

包管理

Helm

Helm 是什么？ Kubernetes 的包管理器，把一组 YAML 抽象成可参数化、可版本化、可复用的 Chart。三个核心概念：Chart（模板包）、Release（Chart 的一次部署实例）、Repository（Chart 仓库）。

常用命令？

helm repo add bitnami https://charts.bitnami.com/bitnami
helm search repo nginx
helm install my-nginx bitnami/nginx -n web --create-namespace -f values.yaml
helm upgrade my-nginx bitnami/nginx --set replicaCount=3
helm rollback my-nginx 1        # 回滚到指定 revision
helm history my-nginx
helm uninstall my-nginx -n web
helm template ./chart           # 本地渲染，不部署

Helm 的目录结构？ Chart.yaml（元数据）、values.yaml（默认值）、templates/（Go Template 模板 YAML）、charts/（子 Chart 依赖）。升级/回滚依赖 release 的 revision 记录（存在 Secret 中）。

kustomize

kustomize 是什么？ K8s 原生命令（kubectl apply -k）的配置定制工具。不用模板，而是通过 base + overlay 的叠加（patch）方式复用同一份基础 YAML，适配不同环境。

典型目录结构？

base/
  kustomization.yaml     # resources: [deployment.yaml, service.yaml]
  deployment.yaml
overlays/
  dev/kustomization.yaml # resources: [../../base]; replicas/patch 覆盖
  prod/kustomization.yaml

kustomize 常用能力？ resources 引入基础资源、patchesStrategicMerge/patches 覆盖字段、replicas 改副本数、images 改镜像 tag、namePrefix/commonLabels 统一前缀与标签、configMapGenerator 自动生成配置并触发滚动更新。

Helm 与 kustomize 怎么选？ Helm 适合对外分发、需要参数化与版本管理的场景；kustomize 适合内部多环境、以 patch 为主、不想维护模板语法的场景。两者常组合使用（Helm 渲染 base + kustomize 做 overlay patch）。

更新与发布

什么是滚动更新？如何实现滚动更新与回滚？（命令） 滚动更新（RollingUpdate）是 Deployment 的默认策略：新建一个 ReplicaSet，逐步增加新 Pod 副本、同时减少旧 Pod 副本，过程中始终有可用实例，实现零中断发布。

kubectl set image deploy/app app=nginx:1.25      # 触发更新
kubectl rollout status deploy/app                # 观察进度
kubectl rollout history deploy/app               # 查看历史版本
kubectl rollout undo deploy/app --to-revision=2  # 回滚
kubectl rollout pause/resume deploy/app          # 暂停/继续

滚动更新涉及哪些组件？如何控制？ 链路是 Deployment → ReplicaSet → Pod：Deployment 控制器发现 Pod 模板变更后创建新的 ReplicaSet 并扩缩两个 RS 的副本数，kubelet 负责实际起停容器。控制参数在 strategy.rollingUpdate：

• maxSurge：更新过程中最多超出期望副本数的 Pod 数（默认 25%）；
• maxUnavailable：最多不可用的 Pod 数（默认 25%，设为 0 即"先扩后缩"的零中断更新）；
• minReadySeconds：Pod 就绪后多久才认为可用；
• progressDeadlineSeconds：超时未完成则标记为失败。 滚动更新不丢请求的前提是配置了 Readiness 探针与优雅退出（preStop + terminationGracePeriodSeconds）。

什么是 Recreate 策略？ Recreate 是一种用于更新应用的 Deployment 策略。它通过先终止所有旧的 Pod，再创建新的 Pod来完成更新。存在停机时间。适合不能同时运行多个版本的应用（如数据库迁移）。

什么是灰度发布 / 金丝雀发布？如何实现？ 灰度（金丝雀）发布指先让一小部分流量进入新版本，观察指标正常后再逐步放量到 100%。实现方式：

1. 副本比例：新旧两个 Deployment 共用同一个 Service 的标签，靠调节副本数比例分流（最粗糙，比例受 Pod 数限制）。
2. Ingress 注解：Nginx Ingress 的 nginx.ingress.kubernetes.io/canary: "true" + canary-weight: 10 / canary-by-header 精确切流。
3. 服务网格：Istio VirtualService 按权重/Header/用户维度切流，粒度最细。
4. 渐进式交付工具：Argo Rollouts、Flagger，支持自动分析指标并自动回滚。

滚动更新、蓝绿、金丝雀的区别？

• 滚动更新：逐个替换实例，资源占用小，回滚快，但新旧版本会短暂共存。
• 蓝绿发布：同时部署完整的新旧两套环境，切流量即完成发布/回滚，需要双倍资源，回滚最快。
• 金丝雀发布：按比例放量，风险最小，需要完善的监控与流量控制能力。

其他

K8s 为何要关闭 Swap？

1. 资源确定性被破坏：K8s 依赖 cgroups 严格限制 Pod 的内存上限（limits）。如果开启 Swap，Pod 写数据可能被换出到磁盘，导致 cgroups 统计的内存使用量不准确，容器无法精准判断自己是否达到内存限制。
2. 性能不可控：Swap 依赖磁盘 I/O，速度比内存慢几个数量级。一旦发生大量换页，Pod 响应延迟会急剧飙升，且这种抖动毫无预兆，破坏了 Kubernetes 承诺的 服务质量（QoS）。
3. 调度误判：Kubelet 根据节点上的内存容量进行 Pod 调度，如果 Swap 被占用，实际可用内存被稀释，容易产生节点资源枯竭但调度器不知情的情况。

K8s 节点上只有 containerd 而没有 Docker，如何构建镜像？ Docker 和 containerd 都是运行时，构建镜像需要单独的构建器：

• nerdctl + BuildKit：nerdctl 是兼容 Docker CLI 的 containerd 客户端，nerdctl build 依赖 buildkitd（需单独部署，buildkitd --oci-worker-no-process-sandbox），也支持 nerdctl compose。
• buildctl + buildkitd：直接用 BuildKit 原生客户端，支持多平台构建与缓存导入导出。
• 在集群内构建：Kaniko（无需特权，在 Pod 内构建）、Buildpacks、或 Tekton/Argo Workflows 流水线。
• 生产实践通常是 CI 里用 Docker/BuildKit 构建并推送镜像，节点只负责拉取运行。

K8s 与 Docker 的关系？ Docker 是容器技术的早期实现（CLI + daemon + 运行时 + 镜像格式）；K8s 是容器编排系统。早期 K8s 通过 dockershim 调用 Docker，1.24 起移除 dockershim，直接使用 CRI 对接 containerd/CRI-O，因此“K8s 弃用 Docker”弃用的是 dockershim 这层适配，镜像（OCI 标准）依然通用。

常用排错命令？

kubectl get pod -A -o wide                 # 全量 Pod 与所在节点
kubectl describe pod <pod>                 # 事件、探针、调度失败原因
kubectl logs <pod> -c <container> -f       # 日志（--previous 看上次崩溃）
kubectl exec -it <pod> -- sh
kubectl top node / pod                     # 资源使用（依赖 metrics-server）
kubectl get events --sort-by=.lastTimestamp
kubectl get pod <pod> -o yaml              # 看最终生效的 spec
kubectl auth can-i get pods --as=system:serviceaccount:default:default

Docker 是什么？ 容器化平台，将应用及其依赖打包成轻量级、可移植的容器，实现操作系统级虚拟化。

为什么容器被称为"一次构建，到处运行"？ 镜像把应用和它的所有依赖（库、运行时、配置）一起打包，容器运行时只依赖宿主机内核，因此只要内核兼容，任何装了 Docker 的机器行为都一致，消除了"环境不一致"问题。

Docker 镜像与容器的关系？ 镜像是只读模板（代码+依赖+环境），容器是镜像的运行实例（可读写层）。

Docker 的三大核心是什么？ 镜像（Image）、容器（Container）、仓库（Repository）。

Docker 工作原理是什么？ Docker 使用客户端-服务器架构。Docker 客户端与 Docker 守护进程通信，后者负责构建、运行和分发 Docker 容器的繁重工作。

Docker 组成部分？

1. docker client / CLI，客户端/命令行工具，为用户提供一系列可执行命令，用户用这些命令实现跟 docker daemon 交互；
2. docker daemon，守护进程，在宿主主机后台运行，等待接收来自客户端的请求消息；
3. docker build，用于构建镜像，使用 BuildKit 作为构建器；
4. docker container，容器，一个系统级别的服务，拥有自己的 ip 和系统目录结构。

Docker 容器与虚拟机的本质区别？ 虚拟机通过 Hypervisor 虚拟化硬件，每个 VM 运行独立 Guest OS（GB 级、分钟级启动）；Docker 共享宿主机内核，进程级隔离（MB 级、秒级启动）。

容器是一种轻量级虚拟机吗？ 不是。容器本质就是宿主机上被 namespace 隔离、被 cgroup 限流的普通进程，与宿主共享同一个内核，所以：

• 优势是启动快、开销小、密度高；
• 代价是隔离性弱于虚拟机，内核漏洞会影响所有容器，且无法运行不同内核版本（如 Linux 上跑 Windows 容器）。

Dockerfile / 镜像构建

Dockerfile 中常用指令？

• FROM（基础镜像）
• COPY/ADD（复制文件）
• RUN（构建时执行）
• CMD（默认命令）
• ENTRYPOINT（入口点）
• EXPOSE（声明端口，仅文档作用）
• WORKDIR（工作目录）
• ENV（环境变量）
• ARG（构建参数，构建后可丢弃）
• USER（运行用户）
• VOLUME（声明匿名卷）
• LABEL（元数据）
• HEALTHCHECK（健康检查）
• ONBUILD（被继承时触发）

CMD 和 ENTRYPOINT 的区别？

• CMD 可被 docker run 命令覆盖；
• ENTRYPOINT 不可覆盖，适合固定执行程序。
• 两者可组合使用：ENTRYPOINT 定可执行文件，CMD 提供默认参数。

ADD 和 COPY 的区别？

• COPY 只复制本地文件；
• ADD 支持自动解压 tar 和远程 URL 下载。
• 官方推荐用 COPY（行为更可预期）。

RUN、CMD、ENTRYPOINT 的区别？

• RUN 在构建时执行并把结果固化进镜像层；
• CMD/ENTRYPOINT 在容器启动时执行，写进镜像元数据，只有最后一条生效。

RUN 命令 shell 形式和 exec 形式的区别？

• RUN apt-get update（shell）等价于 /bin/sh -c "..."，能使用变量和管道，但会多一层 shell 进程；
• RUN ["apt-get","update"]（exec）直接执行，PID 1 就是目标进程，能正确接收信号。
• CMD/ENTRYPOINT 推荐用 exec 形式，否则 docker stop 的 SIGTERM 会被 sh 吞掉，导致容器等 10 秒后被杀（退出码 137）。

ARG 和 ENV 的区别？

• ARG 只在构建期有效，容器运行时拿不到（可用 --build-arg 传入，不应放敏感信息，docker history 能看到）；
• ENV 会写入镜像元数据，构建期和运行期都可见。

如何减小 Docker 镜像体积 / 加速镜像构建？

• .dockerignore 排除非必要文件（.git、node_modules）；
• 使用轻量级基础镜像（如 alpine/slim、distroless）；
• 编译型语言采用多阶段构建；
• 合并 RUN 命令减少层数；
• 清理 apt/pip/npm 缓存（且必须与安装写在同一层，否则删除只是标记，体积不减）；
• 把变化频率低的指令放前面，充分利用层缓存；
• BuildKit 的 --mount=type=cache 缓存包管理器目录。

多阶段构建的好处？ 最终镜像只保留运行时所需文件，不包含编译工具和中间产物，大幅减小镜像体积，同时降低攻击面（工具链不进生产镜像）。

镜像分层存储的好处？ 共享和缓存——多个镜像共享同一基础层只存一份；构建时缓存不变层，加快构建速度。写时容器只在其上叠加一个可写层（Copy-on-Write），多个容器可共享同一个只读镜像层。

镜像构建缓存机制？ Docker 逐条指令比对缓存，某条指令的命令文本、父层、以及 COPY/ADD 的文件内容校验和任一变化，该层及其后续所有层缓存全部失效，需要重新构建。所以：

• 先把 package.json 复制进去装依赖，再复制源码，改动代码时不会重装依赖；
• --no-cache 强制不用缓存，--cache-from 复用 CI 中拉取的镜像缓存。

HEALTHCHECK 的作用？ 在容器内定时执行命令检查应用是否健康（docker ps 显示 healthy/unhealthy），仅状态标记，Docker 本身不会自动重启 unhealthy 容器（这正是 K8s 探针要解决的问题）。

网络与存储

如何让容器随 Docker 服务自动重启？ --restart=always 或 --restart=unless-stopped，还有 on-failure[:max-retries]。注意 docker stop 手动停止的容器在 always 下仍会随 daemon 启动。

Docker 数据持久化方式？ Volume（docker volume create）、Bind Mount（挂载宿主机目录）、tmpfs（内存中）。

Volume 和 Bind Mount 的区别？

• Volume：由 Docker 管理，存放在 /var/lib/docker/volumes/，跨平台、可备份/迁移、可用 volume driver 接 NFS；适合生产数据。
• Bind Mount：直接映射宿主机任意路径，路径依赖宿主机结构，权限与 SELinux 容易出问题；适合开发时挂代码、挂配置文件。
• 两者用 docker inspect 的 Mounts 字段区分（Type 为 volume 或 bind）。
• 容器内数据不持久化的场景：不挂载时数据留在容器可写层，容器删除即丢失。

容器网络隔离方式？ 存在以下网络模式：

• Bridge 模式：默认模式，容器通过虚拟网桥 docker0 通信，拥有独立的网络命名空间。
• Host 模式：容器与宿主机共享网络命名空间，直接使用宿主机的 IP 和端口，性能较高但缺乏隔离。
• None 模式：容器没有网络配置，适用于无需网络的场景。
• Container 模式：多个容器共享一个网络命名空间，适合需要紧密协作的容器。
• Overlay / Macvlan：跨主机通信（Swarm）或让容器直接获得物理网段 IP。

容器之间如何互相通信？ 默认 bridge 网络下只能用 IP 互访，且没有 DNS 解析。推荐自定义 bridge 网络：docker network create app-net，加入同一网络的容器可直接用容器名 / --network-alias 作为主机名互访（Docker 内置 DNS 127.0.0.11）。

端口映射的原理？ -p 8080:80 由 docker-proxy 与 iptables 的 DNAT 规则实现，把宿主机 8080 的流量转发到容器 IP 的 80 端口。-P 随机映射所有 EXPOSE 端口，-p 127.0.0.1:8080:80 只监听本机。

容器

如何进入容器？

docker exec -it <容器> /bin/sh        # 推荐：新开一个进程进入
docker attach <容器>                  # 进入主进程的标准输入输出（Ctrl+C 会杀掉容器）
docker exec -it -u root <容器> bash   # 指定用户

exec 会在容器内新起一个进程（需镜像里有 shell，distroless 镜像没有）；调试特权容器还可用 nsenter -t <PID> -a 直接进入其命名空间（宿主机上无需容器内有工具）。

exec 和 attach 的区别？

• exec 启动一个新的进程，退出不影响主进程；
• attach 接管容器 PID 1 的标准流，退出（Ctrl+C）可能终止容器，且多个 attach 会共享输出。

如何查看容器日志？

docker logs -f --tail 100 <容器>      # 实时跟踪最近 100 行（-f 实时跟踪）
docker logs --since 10m <容器>        # 最近 10 分钟
docker logs --timestamps <容器>

日志来自容器主进程的 stdout/stderr，由 json-file 日志驱动落盘到 /var/lib/docker/containers/<id>/*-json.log。默认无大小限制，容易把磁盘写满，需配置 --log-opt max-size=10m --log-opt max-file=3（可在 /etc/docker/daemon.json 全局设置）。应用应把日志打到前台而不是文件里，这是容器的最佳实践。

如何查看容器信息与资源占用？

• docker ps -a（状态与端口）
• docker inspect（完整 JSON，含 IP、挂载、退出码）
• docker stats（实时 CPU/内存/网络）
• docker top（容器内进程）
• docker diff（可写层的文件变更）

容器退出码代表什么？ 0 正常退出；1 应用错误；126/127 命令不可执行/不存在；137 = 128+9 被 SIGKILL（OOM 或 docker kill）；143 = 128+15 被 SIGTERM（docker stop 优雅停止）。

镜像仓库

如何推送镜像到仓库？ docker login → docker tag app:1.0 registry.example.com/ns/app:1.0（必须带仓库地址前缀）→ docker push。拉取时同理，私有仓库需先登录或配置凭证。

镜像的命名规则？ [registry/][namespace/]repository[:tag][@digest]，tag 默认 latest。生产禁止依赖 latest，因为它是可变的，不同节点可能拉到不同版本；用不可变 tag（版本号或 commit id）或 digest 保证一致性。

如何减小镜像拉取时间？ 使用更小的基础镜像、减少层数、把 registry 部署在内网、开启镜像加速器、使用 P2P 分发（Dragonfly）或按需拉取（懒加载）。

Docker Compose

Docker Compose 是什么？ 单机多容器编排工具，用一个 docker-compose.yml 声明多个服务、网络、卷和依赖关系，一条 docker compose up -d 全部拉起。适合本地开发与小型部署；跨主机的生产编排应使用 Kubernetes/Swarm。

Compose 常用命令？ up -d（后台启动）、down（停止并删除）、ps、logs -f、exec、build、restart、config（校验并渲染最终配置）。

Compose 中 depends_on 能保证依赖服务就绪吗？ 不能，它只保证启动顺序。要等待服务真正可用需配合 healthcheck + condition: service_healthy，或在应用内做重试。

常用命令

# 镜像
docker build -t app:1.0 .            # 构建
docker images / docker image prune   # 列出 / 清理悬空镜像
docker tag / push / pull             # 打标签与仓库交互

# 容器
docker run -d --name web -p 8080:80 -v data:/usr/share/nginx/html nginx
docker ps -a / start / stop / restart / rm
docker cp file.txt web:/tmp/         # 与容器互拷文件
docker commit web web:snapshot       # 把容器存成镜像（不推荐，应用 Dockerfile）

# 清理
docker system df                     # 查看磁盘占用
docker system prune -a --volumes     # 清理未使用镜像/网络/卷

docker run 常用参数？ -d 后台运行、-it 交互式 TTY、--name 命名、-p 端口映射、-v 挂载、-e 环境变量、--network 网络、--restart 重启策略、--rm 退出即删除、--memory/--cpus 资源限制、--privileged 特权、-w 工作目录、--entrypoint 覆盖入口。

底层原理

Docker 使用的底层技术？ Namespaces（隔离：PID、NET、IPC、UTS、MNT、USER）、Cgroups（资源限制：CPU、内存）、UnionFS（分层存储）。

各个 Namespace 隔离了什么？

• PID：进程号，容器内 PID 1 是应用进程；
• NET：网卡、IP、端口、路由表；
• IPC：信号量、共享内存；
• UTS：主机名与域名；
• MNT：挂载点与文件系统视图；
• USER：用户与 UID 映射；
• Cgroup：cgroup 视图（较新）。

Cgroups 的作用？ 限制、统计和隔离进程组的资源使用（CPU、内存、IO、PID 数量）。CPU 用 quota/period（--cpus）或 shares（--cpu-shares 相对权重）；内存超限触发 OOM Killer，容器退出码 137。

Docker 的分层架构（与 containerd / runc / OCI 的关系）？ dockerd（接收 CLI 请求、构建、镜像管理）→ containerd（容器生命周期管理，K8s 也直接用它）→ runc（真正调用 Linux namespace/cgroup 创建进程）。镜像格式遵循 OCI Image Spec，运行时遵循 OCI Runtime Spec，因此 Docker 构建的镜像可以被 containerd、CRI-O、Podman 通用。Docker 1.24 之后 K8s 抛弃的是 dockershim 适配层，不是容器本身。

UnionFS 是如何工作的？ 采用写时复制（CoW）：镜像由多个只读层叠加而成，容器启动时在最上面追加一个可写层；读文件时从上层往下找，修改文件时先把文件复制到可写层再改，因此多个容器共享一份只读镜像层，启动快、占用小。Docker 默认存储驱动为 overlay2。

容器的 1 号进程与信号处理？ 容器 PID 1 就是应用进程（exec 形式时），它需要负责回收僵尸进程、处理 SIGTERM 优雅退出。若应用不处理信号或使用 shell 形式启动，Ctrl+C/docker stop 会失效或超时后被 SIGKILL（10 秒 grace period 可用 --stop-timeout 调整）。

安全与排错

容器为什么不安全？如何加固？

• 共享内核：内核漏洞可逃逸；应保持内核与 Docker 版本更新。
• 默认 root 运行：用 USER 指定非 root、--user 覆盖、开启 user namespace。
• 权限：避免 --privileged，按需 --cap-drop=ALL --cap-add=NET_BIND_SERVICE，使用 --security-opt no-new-privileges、只读根文件系统 --read-only。
• 敏感信息：不要把密钥写进镜像层（docker history 可见），用环境变量、secret 文件或外部密钥管理。
• 其他：AppArmor/SELinux 配置、限制资源防 DoS、镜像扫描（Trivy）与最小化基础镜像。

容器启动失败怎么排查？

1. docker ps -a 看状态与退出码，docker logs 看应用日志；
2. docker inspect 看 State.Error、OOMKilled、挂载与端口；
3. docker run -it --entrypoint /bin/sh image 进镜像手工验证命令与文件是否存在；
4. 端口冲突（netstat -tulnp）、磁盘满（docker system df）、权限问题（挂载目录 SELinux 需 :z）。

常见问题：磁盘被容器占满怎么办？ 先 docker system df -v 定位，再清理：docker container prune、docker image prune -a、docker volume prune、docker builder prune；同时配置日志 max-size、给容器日志与数据盘单独分区。

为什么容器里不能用 systemd / systemctl？ 容器只运行一个前台进程，没有 init 系统；应把每个服务拆成独立容器，或用 supervisor 管理多进程（不推荐），确需时用 --privileged + systemd 镜像（脏且不安全）。

Docker 与 Kubernetes 的关系？ Docker 是单机容器引擎，K8s 是集群编排系统；K8s 早期通过 dockershim 调用 Docker，1.24 起改为直接用 CRI 对接 containerd/CRI-O，镜像标准（OCI）保持通用。

面试官常问“三者的区别是什么”或“什么场景用谁”。记住一个口诀：grep 负责“查”，sed 负责“改”，awk 负责“算”和“格式化”。

二、grep（文本搜索器）

1. 核心功能

在文件或输入流中，根据正则表达式搜索文本，并打印匹配的行。

2. 高频选项

3. 典型面试题

4. 进阶考点：正则表达式引擎

grep默认使用NFA（非确定性有限自动机）引擎。需注意**灾难性回溯（Catastrophic Backtracking）**问题，例如模式(a+)+b匹配一长串a会消耗极长时间。生产环境中，对超大文件使用-m参数限制匹配次数是常见的优化手段。

三、sed（流编辑器）

1. 核心功能

非交互式地编辑文本流，主要进行“取行、删除、替换、插入”等操作。

2. 高频选项与命令

3. 典型面试题

4. 进阶考点：定址与分组

• 定址（Addressing）：可以指定操作的行范围，如'10,20d'删除10到20行。
• 分组（Grouping）：替换时使用(...)分组，并用\1、\2引用。例如sed -r 's#(^[^:]+):.*#\1#g'可以提取/etc/passwd中的用户名。（实际取列推荐下面的cut -d: -f1,2,...，-d 指定分隔符，-f 跟提取第几列，提取多列用逗号分隔）

四、awk（文本分析器）

1. 核心功能

一种强大的文本分析和格式化输出编程语言，以行为单位，默认以空白符为分隔符将行切分为字段。

2. 高频内置变量

3. 高频选项与模式

4. 典型面试题

5. 进阶考点：BEGIN与END

awk脚本可以包含BEGIN和END代码块，分别用于初始化和汇总。例如，在BEGIN中设置分隔符FS=":"，在END中打印统计总数，是极其常见的用法。

五、综合对比与常见组合

1. 三剑客对比总结

2. 经典组合用法

• grep + awk：先用grep粗筛，再用awk精处理。
  • grep "ERROR" app.log | awk '{print $1, $NF}'。
  • 统计php.ini中每个单词出现次数：grep -oE '[a-zA-Z]+' php.ini | awk '{dic[$0]++}END{for(i in dic) print i, dic[i]}'
• find + xargs + grep：在大量文件中搜索内容。例如：find . -name "*.log" | xargs grep "timeout"。
• grep + sed：查找并替换。例如：grep -l "old" *.txt | xargs sed -i 's/old/new/g'。

六、其他文本处理命令

1. 命令

• cut：按列切分，cut -d: -f1 /etc/passwd。
• sort：排序，-n（数字）、-r（逆序）、-k（指定列）、-t（指定分隔符）、-u（去重，等价于sort 'filename' | uniq）。
• uniq：去重（必须配合 sort 使用，仅去除相邻重复行）。常用 sort | uniq -c 统计次数。
• tr：字符替换/删除，tr 'A-Z' 'a-z'（大小写转换）、tr -d '\r'（删除回车）。
• xargs：将标准输入转为命令行参数。find . -name "*.log" | xargs rm -f（解决参数过长问题）。

2. 经典组合用法

• 查找当前目录所有包含有字符”123”的文件名称：grep -r "123" /root | cut -d: -f1 | sort -u

七、正则表达式规则

基础正则表达式（BRE）

• ^ / $：匹配行首、行尾
• .：匹配除换行符外的任意单字符
• *：匹配前一字符 0 次或多次
• [list] / [^list]：匹配列表内或不在列表内的任意字符
• {n}, {n,}, {n,m}：匹配前一字符的固定或范围次数（需转义 \{ \} ）

扩展正则表达式（ERE）

• +：匹配前一字符 1 次或多次
• ?：匹配前一字符 0 次或 1 次
• ()：分组，将括号内模式视为整体
• |：逻辑或，匹配任一模式
• {n}, {n,}, {n,m}：次数匹配（无需转义）

Shell脚本第一行是什么？为什么重要？ #!/bin/bash（shebang），指定脚本解释器。

变量赋值为什么报错command not found？ 等号两边不能有空格——name = "Alice"会被解析为命令，正确写法name="Alice"。

如何定义只读变量？ readonly var 或 declare -r var，后续无法修改。

如何撤销变量？ unset var（不能撤销只读变量）。

[ ]vs[[ ]]vs(())

判断文件是否存在且为普通文件 [ -f "$file" ] 或 [[ -f $file ]]。

数值计算

• $((...))（最推荐，纯 Bash 内建，速度最快）：sum=$((a + b))
• let 命令：let sum=a+b（无需 $ 前缀）
• expr 外部命令（慢，过时）：sum=$(expr $a + $b)（注意加号两侧必须有空格）
• 浮点数运算：必须借助 bc 或 awk，如 echo "scale=2; 5/3" | bc

exit和return的区别？ exit N终止整个脚本；return N从函数返回。0表示成功，非0表示失败。

位置参数$0、$1、$#、$?、$$、$@的含义？

• $0：脚本名，
• $1：第一个参数，
• $#：传递给脚本的参数个数，
• $?：上条命令退出码。
• $$：当前Shell进程的 PID（常用于生成临时唯一文件名，如 /tmp/a_$$）。
• $!：后台最后一个进程的 PID（配合 wait $! 使用）。
• $@：所有参数（带引号保留空格），

什么是IFS？"$*" 和 "$@" 区别？

Internal Field Separator（内部字段分隔符），是 Shell 中的一个特殊环境变量，用来决定 Shell 在哪些字符处把一个字符串拆分成多个单词（字段）。默认值是：空格 + 制表符 + 换行符

假设这样调用：./test.sh "a b" c d

重定向

用于改变命令的输入来源或输出目的地，替代默认的 键盘输入(stdin) 和 屏幕输出(stdout/stderr)

常用语法

• 输出覆盖：command > file（覆盖写入）
• 输出追加：command >> file（追加写入）
• 输入重定向：command < file（从文件读取输入）
• 错误输出：command 2> file（仅错误信息）
• 合并输出：command > file 2>&1（stdout 和 stderr 合并）
• Here Document：command << EOF ... EOF（内联多行输入），常用生成配置文件。
  • <<- 可以忽略前导 Tab（缩进友好）
• Here String：command <<< "string"（单行字符串作为标准输入）

2>&1 必须放在哪？

• 功能：将标准错误（2）重定向到标准输出（1）所在的地方。
• 正确写法：command > file 2>&1（先让标准输出去file，再把错误也指向file）。
• 错误写法：command 2>&1 > file（错误先指向了当前终端的标准输出，随后标准输出才去file，导致错误依然打印在屏幕上）
• 简写：command &> file 等效于上面正确的写法。

作用域

子 Shell 与大括号 {} 的区别？

• 小括号 ( ... )：在子 Shell 中执行，内部变量修改不影响父 Shell。
• 大括号 { ... }：在当前 Shell 中执行，内部变量修改会影响父 Shell。注意大括号内部左侧必须有空格，且命令结尾必须加分号 ;。

进程替换（<()）与管道（|）的本质区别

• 管道 |：会创建子 Shell，导致父 Shell 变量无法被子进程修改。a=1; echo "2" | read a; echo $a 依然输出 1。
• 进程替换 <()：不会引入子 Shell 的副作用，相当于把命令输出伪装成文件。while read line; do ...; done < <(cat file) 可以在当前 Shell 中执行循环（规避管道变零）。

export 变量和无export区别？

• 有 export：变量会传递给所有子进程（子Shell、外部命令、脚本等），称为环境变量。
• 无 export：变量仅在当前Shell进程中有效，子进程不可见，称为局部变量（或Shell变量）。

source/bash script.sh 和 ./script.sh 和 exec ./mod.sh的区别？ source在当前Shell执行，变量和环境变量保留；./script.sh在子Shell执行，变量不保留。

综合上面两个：

#!/bin/bash
export PATH="aaa"
cd bbb

记上述脚本为mod.sh，问：source/bash mod.sh 和 exec ./mod.sh 父 Shell 的 PATH 和当前目录怎么变化？为什么？

进阶与陷阱

如何安全地逐行读取文件？

while IFS= read -r line; do
    echo "$line"
done < file

使用IFS=将IFS设置为一个空字符串，以确保读取的行不会因为空格或制表符被截断，-r防止反斜杠转义。

set -e的作用？ set命令用于显示或设置 Shell 的特性和变量，-e 遇到非零退出码立即退出脚本。 注意：管道中命令失败不一定触发（需配合set -o pipefail）。

set -euxo pipefail 各参数含义？

• -e：脚本中任何命令失败（非0退出码）立即终止退出（防止错误蔓延）。
• -u：引用未定义变量时报错退出（防止空变量酿成事故）。
• -x：调试模式，执行前把每条命令打印到终端（用于排错）。
• -o pipefail：管道中任何一个子命令失败，整个管道就算失败（弥补 -e 只管管道最后一条命令的缺陷）。
• -n：仅语法检查，不执行（可用于排错）。
• -v：打印读取到的原始输入行（与 -x 不同，-x 打印展开后的命令）。

如何避免rm -rf误删？ 先ls确认再执行；用rm -i交互确认；关键操作前备份；脚本中用set -u防止空变量。

Shell脚本中如何捕获信号并做清理？ trap 'cleanup; exit' INT TERM 捕获中断和终止信号。

信号捕获与后台控制

• trap：捕获信号并执行自定义操作。常用于脚本退出时清理临时文件。
  • 语法：trap "rm -f /tmp/temp_$$" EXIT（脚本无论正常/异常退出都会触发）。
  • 常见信号：INT（Ctrl+C）、TERM、EXIT。
• wait：阻塞等待后台进程结束。wait $pid 等待指定进程，无参则等待所有后台子进程。
  • 面试题：sleep 3 & wait 会等待 sleep 结束再继续。

如何用Shell实现并发控制？ 使用&后台执行 + wait等待，或用xargs -P N、GNU parallel控制并发数。

后台运行 & vs nohup 的区别

• command &：放入后台运行，但进程依然属于当前终端（Shell）的子进程。终端关闭（收到 SIGHUP 信号），进程会随之消亡。
• nohup command &：让进程忽略 SIGHUP 信号（1信号），同时默认将输出重定向到 nohup.out。终端关闭后，进程依然存活。
• 最佳实践：想退出终端后服务不挂，必须用 nohup + &（或用 screen/tmux）。

如何定义函数并获取返回值？

• 定义：function func_name() { ... } 或 func_name() { ... }
• 局部变量：必须用 local 声明，否则默认全局污染。
• 返回值（数字）：return 0（成功）或 return 1（失败），通过 $? 接收。但 return 只能返回 0-255 的状态码。
• 返回字符串：不能用 return，必须用 echo 输出，调用方用 $(func) 接收。

单引号 '、双引号 "、反引号 ``和 $() 的区别

• 单引号 ''：所见即所得，完全保留字面意思，无视所有变量和转义符。
• 双引号 ""：部分保留，允许变量展开 $var 和命令替换 $()，但会阻止通配符 * 展开。
• 反引号 ``与 $()：均为命令替换（先执行内部命令）。强烈推荐 $()，\支持嵌套（如 $(grep $(whoami) file)）且引号处理更清晰。

登录Shell vs 非登录Shell 与 .bashrc/.bash_profile 加载逻辑

• 登录Shell（如 su -、SSH登录）：先读 /etc/profile，再找 ~/.bash_profile（或 ~/.bash_login、~/.profile），通常不读 ~/.bashrc。
• 非登录Shell（如手动敲 bash）：只读 ~/.bashrc。
• 解决痛点：为了登录Shell也能加载别名，通常在 ~/.bash_profile 里强制写入 source ~/.bashrc。

其他

命令连接符/逻辑判断：; 、&& 与 ||

• ;：无视成败，前面命令执行完（无论对错），无条件执行后面的命令。
• &&：短路与，前面命令执行成功（$?=0）才执行后面的。
• ||：短路或，前面命令执行失败（$?≠0）才执行后面的。
• 经典组合：make && make install || echo "Failed"（编译成功才安装，任一失败则报错）。

分支与循环结构速记

数组操作（Bash 特有）

内存泄漏如何排查？

思路：遵循 “自上而下+工具链” 的思路

1. 确认现象：用 free -h 看 available 是否持续走低，用 vmstat 1 看 si/so 是否频繁交换。
2. 定位进程：用 ps aux --sort=-%mem | head -n 10 或 top 按 M 排序，找到内存占用最高的 PID。
3. 深入分析（按语言选工具）：
   • Java 应用：用 jmap -dump 导出堆转储，配合 MAT 分析支配树和 GC Roots 引用链，定位泄漏对象。
   • C/C++ 应用：可用 memleak (eBPF) 追踪未释放的分配调用栈，或 valgrind 在测试环境分析。
4. 判断类型：结合 GC 日志判断是堆内存泄漏、元空间泄漏还是直接内存泄漏，再针对性修复

服务器CPU使用率飙升，如何排查？

思路：遵循 “自上而下+工具链” 的思路

标准排查流程：系统级/进程→线程→栈→系统调用

1. 系统级分析： top按 P 排序，或ps aux --sort=-%cpu | head -n 10，找到 %CPU 最高的异常进程 PID。
   • 使用 vmstat 1 观察 r（运行队列）是否长时间大于CPU核数，若 sy（内核态占用）飙升，可能是有频繁的上下文切换或中断。
   • 排查是否遭受了 DDoS/恶意攻击（大量握手请求占满CPU软中断 si）。
2. 转为线程级分析：
   • 执行 top -H -p [PID] 找出该进程内最耗CPU的线程ID（十进制）。（-H 显示详细线程，-p 指定PID）
   • 将线程ID转换为16进制：printf "%x\n" [线程ID]。
3. 抓线程栈：
   • JAVA：使用 jstack [PID] | grep -A 20 [16进制线程ID] 直接查看该线程正在执行的代码堆栈，定位到具体类和方法。
   • 使用 perf top -p [PID] 查看 CPU 在执行哪些内核/用户态函数，精细定位热点函数（如垃圾回收GC线程，或者正则计算）
4. 系统调用：如果栈显示卡在 read/write/futex 等，使用 strace -p [PID] 跟踪进程的系统调用，看是否卡在某个内核调用上（如不断重复读写文件）。

服务器频繁发生 OOM Kill，但业务进程内存占用并不高，如何排查？

根因：通常是 内核 slab 内存（内核缓存）暴涨 或 某个进程疯狂申请匿名内存页（如内存泄漏）但被漏看。

排查步骤：

1. dmesg -T | grep -i "Out of memory" 查看 OOM 发生时被杀的进程名和 oom_score。
2. 查看系统内存细分：cat /proc/meminfo 关注 Slab、SReclaimable、KernelStack。若 Slab 异常大，用 slabtop 看是哪个内核对象占用（如 dentry、inode_cache 暴涨，说明文件句柄泄露）。
3. 统计所有进程实际占用总和：ps aux | awk '{sum+=$6} END {print sum/1024 " MB"}'（单位 KB），若总和远小于总内存，差值就是内核占用了。
4. 检查是否有 内存超卖 情况（如 K8s Pod 的 limits 设置过小，虽然物理内存够，但 cgroup 限制内 OOM）。
5. vmstat -s 查看 pages paged in/out，确认是否有频繁换页加剧内存压力。

服务器负载（Load Average）飙升，但 CPU 使用率很低，什么原因？如何排查？

现象：top 看 load average 高达几十，但 %us 和 %sy 都很低。

根因：大量进程处于不可中断睡眠状态（D 状态），通常是因为 I/O 阻塞（磁盘/网络/外部设备）。

排查步骤：

1. top 按 D 键排序，查看处于 D 状态的进程数量。
2. ps aux | awk '$8=="D" {print $2,$NF}' 列出所有 D 状态进程。
3. strace -p [PID] 看卡在哪个系统调用（通常是 read/write 磁盘或 NFS）。
4. iostat -x 1 查看 %util 和 await，若接近 100% 或 await 极高，说明磁盘 I/O 已饱和。
5. 若磁盘正常，检查是否有 NFS 挂载超时：df -h 卡住不动说明 NFS 服务端不可达。

存储

磁盘空间报警，但 du 统计的总大小远小于磁盘已用空间，怎么回事？

根因：文件被删除但进程仍持有句柄，空间未真正释放；或 inode 耗尽。

排查步骤：

1. 先检查 inode：df -i，如果 IUse% 100%，说明小文件太多，用 find / -type f | wc -l 定位目录。
2. 若 inode 正常，查句柄泄露：lsof +L1 列出所有已删除但未释放句柄的文件（标记为 (deleted)）。
3. 找到占用进程后：ls -l /proc/[PID]/fd/ | grep deleted 确认，重启该进程即可释放空间。
4. 若不重启，可 echo > /proc/[PID]/fd/[fd号] 清空文件（风险操作，需确认业务影响）。

网络

客户端无法访问服务器8080端口，怎么全链路排查？

思路：从服务器着手，从物理层 → 网络层 → 传输层 → 应用层逐层递进。

排查步骤：

1. 服务器本机确认（物理层）：netstat -tlnp | grep 8080 或 ss -tlnp | grep 8080，确认进程是否在监听 0.0.0.0 还是 127.0.0.1（后者仅本机可访）。
2. 服务器防火墙（网络层）：iptables -L -n | grep 8080 和 firewall-cmd --list-all，检查是否有 DROP/REJECT 规则。
3. 连通性测试（传输层）：从客户端 telnet [IP] 8080 或 nc -zv [IP] 8080 看是否通；不通则逐跳 traceroute 看丢在哪。
4. 抓包分析（传输层）：tcpdump -i any port 8080 -nn，看三次握手是否完成（SYN→SYN+ACK→ACK）。若只有 SYN 无响应，说明服务端未回包；若回 RST，说明进程拒绝连接（可能是 backlog 满了或应用层拒绝）。
5. 应用层：curl -v [IP]:8080 看 HTTP 状态码，或查看应用日志是否有 Connection refused 异常。

无法 Ping 通目标主机/域名，如何排查？

思路：若域名不通 IP 通，直接定位到 DNS 故障。都不通则按分层排查思路。从下往上（物理层 → 网络层 → 传输层 → 应用层），逐层缩小范围。

简洁版：先确认本地网卡和 IP 配置，再 ping 网关判断是否局域网问题；若网关通，用 traceroute 定位丢包节点，同时检查本机防火墙；若域名不通 IP 通，定位到 DNS 故障，检查 /etc/resolv.conf，ping 域名服务器确定是域名服务器不可达还是解析问题；最后，考虑到很多生产环境出于安全考虑会主动禁 ICMP 协议，我会改用 telnet 端口探测 代替 ping。

第一层：自查（排除本地低级错误/物理层）

1. 网络连通性：先 ping 127.0.0.1 确认本机 TCP/IP 协议栈正常；再 ping 本机 IP（非 lo）确认网卡驱动正常。
2. 网卡状态：ip a 或 ifconfig 确认网卡是否 UP，RUNNING；检查网线/WiFi（物理层）。

第二层：网关与路由（局域网/网络层）

1. ping 网关：ping 默认网关（ip route | grep default 查），网关不通 → 问题在交换机/路由器/无线信号；网关通 → 问题在外网或目标端。
2. traceroute 追踪：
   • Linux：traceroute -n [目标IP]（加 -n 跳过 DNS 解析更快）。
   • Windows：tracert -d [目标IP]。
   • 看在哪一跳 超时/星号，大概率是该节点路由丢包或防火墙拦截了 ICMP 包（很多云厂商安全组默认屏蔽 ICMP）。

第三层：防火墙/安全组拦截（传输层/网络层）

1. 本机防火墙：
   • iptables -L -n -v | grep DROP 看是否有 DROP 规则。
   • firewall-cmd --state（CentOS 7+）或 ufw status（Ubuntu）。
2. 如果有目标主机访问权，检查：
   • 云安全组/ACL：登录云控制台，检查目标机器的 入方向安全组 是否放行了 ICMP 协议（允许 type 8 入站）。
   • 目标主机防火墙：目标主机如果开启 iptables 且 DROP 了 ICMP，本地 ping 会超时（但业务端口如 80/443 可能依然通，要区分）。

第四层：DNS 解析问题（应用层）

现象：ping 域名不通，但 ping IP 通

• 排查命令：
  1. cat /etc/resolv.conf 检查 DNS Server 配置（如 114.114.114.114 或内网 DNS）。
  2. ping 域名服务器确定是域名服务器不可达还是解析问题
  3. 检查 /etc/hosts 是否写死了解析（被错误覆盖）。
• 如果有装 nslookup dig 可以使用 dig @8.8.8.8 或 dig [目标域名] 排查

第五层：目标服务存活（终极确认）

注意：很多安全策略会 禁止 ICMP 协议（ping），但 业务端口（如 80/443）是通的。

• 此时应该用 端口探测 代替 ping：
  • telnet [目标IP] [端口] 或 nc -zv [目标IP] [端口]
  • 如果端口通但 ping 不通 → 属于正常现象（云厂商/运维策略屏蔽 ICMP）。
  • 如果端口也不通 → 目标服务挂了，或目标主机本身无法访问。

综合

如何查看服务/进程是否正常运行？

原则：进程在 ≠ 服务正常。 要分层判断：状态 → 进程 → 端口 → 健康探针 → 日志。

1. 托管状态：systemd 用 systemctl is-active + is-enabled，SysV 用 service xxx status；
2. 进程：没有托管就用 pgrep -af / ps -ef；
3. 端口：ss -lntp 确认监听；
4. 健康探针：curl 打业务健康接口，这才是真验证；
5. 日志：journalctl -u xxx 或日志文件，看有无报错。

只做①②不算查完，必须做到④才算真健康。

<details> <summary>参考 Shell 脚本</summary>

#!/bin/bash
# check_service.sh <name> [port] [health_url]
NAME="$1"; PORT="$2"; URL="$3"
[ -z "$NAME" ] && { echo "Usage: $0 <name> [port] [health_url]"; exit 2; }
FAIL=0

# systemd 优先
if systemctl list-unit-files 2>/dev/null | grep -q "^${NAME}\.service"; then
    echo ">>> systemd unit: $NAME.service"
    systemctl is-active --quiet "$NAME" \
        && echo "[OK] active" \
        || { echo "[FAIL] not active"; FAIL=1; }
    systemctl is-enabled --quiet "$NAME" \
        || echo "[WARN] not enabled (won't start on boot)"
    PID=$(systemctl show -p MainPID --value "$NAME")
else
    echo ">>> fallback: process check"
    if pgrep -f "$NAME" >/dev/null; then
        PID=$(pgrep -f "$NAME" | head -1)
        echo "[OK] process PID=$PID"
    else
        echo "[FAIL] process not found"; FAIL=1; PID=""
    fi
fi

# 端口
if [ -n "$PORT" ]; then
    ss -lntp 2>/dev/null | grep -q ":$PORT " \
        && echo "[OK] port $PORT listening" \
        || { echo "[FAIL] port $PORT not listening"; FAIL=1; }
fi

# 健康探针
if [ -n "$URL" ]; then
    CODE=$(curl -s -o /dev/null -w "%{http_code}" --max-time 5 "$URL")
    [ "$CODE" = "200" ] \
        && echo "[OK] health $URL -> 200" \
        || { echo "[FAIL] health $URL -> $CODE"; FAIL=1; }
fi

[ $FAIL -eq 0 ] && echo "=== HEALTHY ===" || echo "=== UNHEALTHY ==="
exit $FAIL

</details>

恢复

rm -rf / 误操作或误删重要文件后，怎么恢复（前提是进程未重启）？

核心原理：Linux 中文件名和 inode 分离，文件删除只是移除目录项，只要进程还在打开该文件，数据块未被回收。

恢复步骤（假设误删 /var/log/nginx/access.log）：

1. 立即停止写入：lsof | grep deleted 找到仍持有该文件句柄的进程（nginx 的 worker 进程）。
2. 查看 fd 路径：ls -l /proc/[PID]/fd/ 找到对应 fd 编号（如 4），显示为 /var/log/nginx/access.log (deleted)。
3. 重定向恢复：cat /proc/[PID]/fd/4 > /var/log/nginx/access.log 将文件内容原样拷回。
4. 安全操作：通过 kill -HUP [PID] 重新加载配置让进程重新打开新文件句柄。
5. 注：若进程已重启，则需依赖 extundelete 或 TestDisk 等工具做文件系统级别的恢复，但成功率取决于是否立即卸载分区并停止写入。

Linux常用文件操作命令？ ls、cd、pwd、mkdir、touch、cp、mv、rm、cat、vi/vim。

如何查看系统版本？ uname -a

如何查找文件？

# 按名称查找
find [路径] [匹配条件] [动作]
find / -name "filename" 
# 基于数据库快速查找（-i 忽略大小写; -n x 显示前x条）
locate -i "filename" 

如何查看文件内容 / 如何查看大文件？ cat（全部）、less/more（分页）、head/tail（头尾）、grep（过滤）。

less/more 区别？

• more 只能向前翻页，加载大文件慢，无交互搜索；
• less 支持双向滚动，按需加载性能优，内置搜索功能强，且在管道中可回溯，更适合大型文件和复杂操作。

如何查看当前目录？ pwd （Print Working Directory）

如何管理用户？

useradd 选项 用户名
userdel 选项 用户名
usermod 选项 用户名
passwd 选项 用户名

如何管理权限？

• chmod 改变文件/目录权限，三个数字owner/group/others，八进制表示法（读4 写2 执行1）
• chown 改变所有者，chgrp 改变所在组

目录权限含义？

• 读（r）：允许列出目录中的文件和子目录名称（ls）。
• 写（w）：允许在目录中创建、删除、重命名文件或子目录（会改变目录的文件列表）。
• 执行（x）：允许进入目录（cd）并访问其中的文件或子目录。
• 注意：
  • 只有 x 权限而无 r 权限，可以进入目录但无法列出文件名。
  • 只有 r 权限而无 x 权限，可以看到文件列表但无法进入目录或访问文件内容。

子目录有写权限但父目录没有，能修改子目录吗？

如何设置定时任务？ crontab -e 编辑当前用户 crontab 文件，* * * * * command 分/时/日/月/星期

硬链接与软链接（符号链接）的底层区别？ 硬链接是同一inode的多个入口，不能跨文件系统，不能指向目录，删除源不影响；软链接是新inode存储路径字符串，指向源文件路径，源删除则失效（高亮闪烁）。

硬链接为什么不能跨文件系统？

• 硬链接指向的是 inode，而 inode 号只在当前文件系统内有意义。每个文件系统都有自己的 inode 表，另一个文件系统里的同一个 inode 号不代表同一个文件。
• 软链接保存的是路径字符串，解析时按路径重新查找目标文件，所以可以跨文件系统

如何查看文件被哪个进程占用？ lsof filename

Linux系统结构，主要目录作用？

分层的树形结构，主要目录作用：

• /bin 存放常用的用户命令，如ls、cp等，普通用户和管理员均可使用。
• /sbin 存放系统管理员使用的管理命令，如ifconfig、reboot等。
• /etc 存放系统配置文件和子目录，例如网络配置文件/etc/hosts和DNS配置文件/etc/resolv.conf。
• /home 用户的主目录，每个用户都有一个以用户名命名的子目录。
• /root 超级用户（root）的主目录，仅供系统管理员使用。
• /lib和/lib64 存放系统的共享库文件，类似于Windows的DLL文件，几乎所有程序都依赖这些库。
• /usr 存放用户应用程序和文件，包括/usr/bin（用户命令）、/usr/sbin（管理员命令）和/usr/local（本地安装的软件）。
• /var 存放动态数据，如日志文件（/var/log）、邮件（/var/mail）和临时文件（/var/tmp）。
• /tmp 存放临时文件，系统重启后会清空。
• /dev 存放设备文件，例如硬盘（/dev/sda）和终端（/dev/tty）。
• /proc 虚拟文件系统，存储内核和进程信息，例如CPU信息（/proc/cpuinfo）和内存信息（/proc/meminfo）。
• /sys 类似于/proc，用于存储设备和内核模块的信息。
• /boot 存放启动相关文件，包括内核和引导加载器配置文件。
• /media和/mnt 用于挂载外部设备，如U盘和光驱。
• /opt 存放第三方软件或可选应用程序。
• /run 存储系统运行时的信息，系统重启后会清空。

如何查看文件类型？

ls -l 看第一列

• -：普通文件
• d：目录文件
• b：块设备文件（一般位于/dev，以块为单位进行读写的特殊设备文件，通常用于硬盘、光盘和U盘等存储设备）
• c：字符设备文件（一般位于/dev，允许用户按字节顺序与设备交互，例子包括键盘、鼠标、串口和终端设备）
• s：套接字文件
• p：管道文件
• l：链接文件（软链接）

su命令作用、参数？

作用：切换用户。主要参数：

• - / -l / --login 模拟完整登录，加载目标用户环境
• -c "cmd" 以目标用户执行一条命令后退出
• -s shell 指定使用的 shell
• -m / -p 保留当前环境变量（不重置）
• -g group 指定主组
• -G group 指定附加组

su user和su - user区别？

用 su user 跑脚本可能因 PATH 不对找不到命令；生产脚本建议用 su - user -c "cmd"。

2. 进程管理

进程排查

如何查看所有运行中的进程？ ps aux 或 ps -ef。

如何实时监控进程和系统资源？ top（实时刷新），关注%CPU、%MEM、load average。

top命令顶部输出含义？

• Tasks（进程任务）：total 总进程数；running 正在运行；sleeping 睡眠；stopped 暂停；zombie 僵尸进程（重点警戒值，不为0需关注）。
• %Cpu(s)：us 用户态占用；sy 内核态占用；id 空闲；wa I/O等待；hi/si 硬/软中断。
• MiB Mem（物理内存）：total 总内存；free 完全空闲；used 已分配（含缓存）；buff/cache 缓冲区+页缓存（Linux会把空闲内存拿来当缓存，所以看可用内存应看 available 列）。

数值异常 & 常见原因

排查套路

us 高 → top 看进程 → perf/火焰图
sy 高 → vmstat 看 cs/in → strace
wa 高 → iostat -x 1 → 看 %util / await
si 高 → mpstat -P ALL 1 → 看是否单核 → 调 RPS/RSS/多队列
st 高 → 找云厂商 / 换宿主机

ps aux / top命令各个关键字段含义？

• PID：进程ID
• USER：所属用户
• PR/NI：优先级与 nice 值
• VIRT/RES/SHR：虚拟内存、常驻内存、共享内存
• %CPU/%MEM：CPU/内存占用率
• TIME+：累计 CPU 时间
• COMMAND：命令名或完整命令行

CPU硬中断和软中断区别？ 硬中断由外部硬件触发，软中断由软件指令触发，它们在操作系统中分别处理实时事件和系统调用任务。

进程清理

kill与kill -9的区别？ kill默认发SIGTERM（可捕获、可清理）；kill -9发SIGKILL（强制终止，不可捕获）。

kill 命令中信号编号 1、2、3、9、15、18、19 的具体区别？

• 1 (SIGHUP)：终端挂起，常用于让进程重读配置（如Nginx -s reload本质发此信号）。
• 2 (SIGINT)：键盘中断（Ctrl+C），进程可捕获清理。
• 3 (SIGQUIT)：键盘退出（Ctrl+\），会产生core dump用于调试。
• 9 (SIGKILL)：强制终止，不可捕获/忽略，直接由内核回收，可能造成资源泄漏或脏数据。
• 15 (SIGTERM)：默认终止信号，可捕获，优雅停机首选（超时后补9）。
• 18 (SIGCONT)：继续运行被暂停的进程。
• 19 (SIGSTOP)：暂停进程（Ctrl+z，不可捕获，类似外部挂起）。
• 补充：Ctrl+d 表示输入结束，不发送信号，若输入为空，则返回0，类似EOF

僵尸进程是什么？如何清理？ 子进程退出后父进程未调用wait()回收，进程描述符残留在进程表中。无法kill僵尸本身，需kill父进程（PPID），父进程死后僵尸被init收养并清理。

孤儿进程是什么？ 父进程先退出，子进程被init（PID 1）收养，由init负责回收，通常无害。

进程间七种通信方式

1. 管道（Pipe）：父子进程间单向传输，数据无格式。
2. 命名管道（FIFO）：通过文件节点，允许无亲缘关系进程通信。
3. 信号（Signal）：异步通知机制（如 kill -9）。
4. 消息队列（Message Queue）：内核维护的消息链表，有格式。
5. 共享内存（Shared Memory）：最快的方式，映射同一块物理内存，需配合信号量使用。
6. 信号量（Semaphore）：本质上是一个计数器，用于进程/线程间的同步与互斥，而非传输数据。
7. 套接字（Socket）：用于跨网络或本机不同进程间的通信（TCP/UDP）。

3. 内存与存储

基础

Buffer和Cache的区别？ Buffer（Buffers）：块设备元数据缓存（inode、分区信息）。Cache（Page Cache）：文件内容缓存，读写都经过它。

手动drop_caches有什么风险？ echo 3 > /proc/sys/vm/drop_caches会清空Page Cache，导致CPU飙升重建索引、磁盘I/O风暴（Cache Miss），生产环境慎用。

如何查看内存使用情况？ free -h；vmstat 查看虚拟内存统计。

虚拟地址

缺页中断与内存映射

• 内存映射（mmap）：将磁盘文件或设备数据直接映射到进程的虚拟地址空间，使程序可以像访问内存一样访问文件数据，由内核在后台同步。
• 懒加载（Lazy Loading）：数据只有在首次访问时才会触发缺页异常，由内核将对应文件页加载到物理内存。
• 缺页异常（Page Fault）：当进程试图访问一个尚未加载到物理内存的虚拟页面时。
  • 次要异常/软缺页：数据已在 page cache，只需建立页表映射即可，很快。
  • 主要异常/硬缺页：数据不在 page cache，必须触发磁盘I/O将其读入内存（很慢，影响性能）。

虚拟内存

什么是Swap？什么时候会用到？

• 定义：Swap（交换分区）是硬盘上划出的一块空间。当物理内存（RAM）不足时，内核会将暂时不用的内存数据换出到Swap中，从而释放物理内存给当前活跃的进程。
• 触发时机：
  • 物理内存耗尽（剩余可用内存低于阈值）。
  • 内存回收压力大（内核的 kswapd0 线程被频繁唤醒）。
  • 主动冷数据迁移（即使内存还有余量，内核也会根据 vm.swappiness 参数决定是否把不活跃的页换出去，默认值通常是60）。

OOM

什么是OOM？什么会导致OOM？

• 定义：Out Of Memory，即内存溢出。当系统物理内存和Swap全部耗尽，内核无法再为任何进程分配内存时，会触发 OOM Killer 机制，它会根据评分（oom_score）挑选一个进程强制杀掉（发送 SIGKILL 信号）以释放内存，保障操作系统存活。
• 常见诱因：
  • 内存泄漏（程序申请的内存没有释放，积少成多耗尽资源）。
  • 不合理的大对象/大查询（如数据库一次性加载上亿行数据到内存）。
  • 流量突增（并发请求数暴增，导致创建大量线程或缓存对象）。
  • 内存分配速度超过GC/回收速度（特别是在 Java 或 Python 应用中）。

Linux 下 OOM Killer 的运作机制？ 系统内存耗尽时触发，根据 oom_score（受 /proc/[pid]/oom_adj 调节）打分，分数最高者被杀。可通过 echo -17 > /proc/[pid]/oom_adj 禁止被杀（仅对特定关键进程）。

ulimit

ulimit 什么作用？ ulimit 是 Linux 系统中用于控制 Shell 程序资源限制的内建命令。允许用户查看或设置当前会话的资源限制，包括文件大小、内存使用、CPU 时间等。

Linux 下 ulimit 的 soft limit 和 hard limit 区别？ soft 当前生效值（进程可主动修改，最多涨到hard），hard 系统硬上限（只有 root 能改）。生产常见坑：nofile（最大文件句柄数）未调大导致"Too many open files"。

LVM

LVM是什么？基本概念？ Logical Volume Manager，在线调整分区大小无需停机。三层：PV（物理卷）→ VG（卷组）→ LV（逻辑卷）。

LVM常用操作命令？ pvcreate创建物理卷，vgcreate创建卷组，lvcreate创建逻辑卷，vgextend扩展卷组，lvextend扩展逻辑卷。

LVM 在线扩容完整流程？（以虚拟机扩容为例）

最佳实践：生产环境一般不动现有磁盘/分区，而是作为新磁盘加入。 流程：虚拟层扩盘 → OS层执行rescan → 确认lsblk → PV/VG/LV操作 → xfs_growfs/resize2fs → df验证

• 虚拟化层操作：在虚拟机管理平台（如VMware/vCenter）中加新磁盘。
• OS层发现新设备：扫描SCSI总线 echo "- - -" > /sys/class/scsi_host/host0/scan 或重启（生产慎用）
• 确认识别新容量：用 lsblk （list block）确认新容量已识别。
• PV阶段：pvcreate /dev/sdb
• VG阶段：vgextend vg_data /dev/sdb
• LV阶段：lvextend -l +100%FREE /dev/vg_data/lv_data
• 文件系统层：resize2fs（ext4）或 xfs_growfs（xfs）。
• 确认扩容：df -h 验证扩容完成
• 注意：缩减（reduce）极其危险且需离线，生产禁用。

**传统扩容方法 / 给机器加一块磁盘，如何识别？**OS 层执行 rescan → 确认 lsblk → PV/VG/LV 操作 → mkfs → mount → df 验证 → fstab 永久挂载 → mount -a 验证。详细说明可参考 一文讲通 LVM 与传统扩容的异同。

磁盘与I/O

如何查看磁盘空间？ df -h 查看分区使用；du -sh * 查看目录大小。

如何排查磁盘I/O瓶颈？ iostat -x 1 查看I/O负载；iotop 查看进程I/O。

4. 网络

如何查看网络连接和监听端口？ netstat -tunlp 或 ss -tunlp（ss更快）。

netstat 常用参数 / -tunlp 分别代表什么

• -a (--all): 显示所有的网络连接和监听端口。
• -t (--tcp): 仅显示TCP连接。
• -u (--udp): 仅显示UDP连接。
• -n (--numeric): 显示IP地址和端口号，而不是尝试解析域名和服务名。
• -l (--listen): 显示监听中的端口
• -p (--programs): 显示哪个进程正在使用哪个套接字或网络端口。
• -x (--unix): 仅显示Unix域套接字连接。
• -r (--route): 显示路由表。
• -i (--interfaces): 显示网络接口信息。
• -s (--statistics): 显示网络协议的统计数据。

如何抓包/监听80端口数据？

tcpdump -i eth0 port 80 -w capture.pcap。

• -i：指定接口
• -w：保存到文件

如何测试网络连通性？ ping 测试连通性；telnet/nc 测试端口。

如何追踪数据包？ tracert 追踪数据包经过的路由路径，一层层显示路径。

常见的TCP内核参数调优（sysctl）？ net.ipv4.tcp_tw_reuse=1（允许复用TIME_WAIT）、net.ipv4.tcp_fin_timeout=30（缩短FIN超时）、net.core.somaxconn=65535（监听队列最大长度，Nginx配合backlog）。

如何配置IP？

# 持久化配置
# Ubuntu 系统，可以调整 /etc/network/interface
iface eth0 inet static
    address 192.168.1.100
    netmask 255.255.255.0
    gateway 192.168.1.1
# 然后重启网络服务
sudo systemctl restart networking

如何配置DNS？

sudo sh -c 'echo "nameserver 8.8.8.8" >> /etc/resolv.conf'

如何查看IP/DNS？

• IP 看 ip addr 的 eth0，DNS 看 cat /etc/resolv.conf 下的 nameserver
• DNS 常规为8.8.8.8，阿里云ECS默认100.100.2.136或138

5. 系统管理与启动

Linux系统从开机到登录的启动流程？ 上电复位 → BIOS/UEFI自检 → 引导加载程序（GRUB，GNU GRand Unified Bootloader）→ 内核加载 → 挂载根文件系统 → init进程（Systemd）→ 运行级别（SysV）/目标（systemd） → 用户登录。

Load Average是什么？怎么看？ 系统平均负载，表示单位时间内处于运行或不可中断状态的进程数。top或uptime查看三个时间点（1/5/15分钟）。

如何排查服务器性能瓶颈？ top看整体负载 → vmstat看CPU/内存/swap → iostat看磁盘I/O → netstat/iftop看网络。

什么是服务？服务和进程区别？

进程是操作系统资源调度的单位；服务是"被托管、可启停、可自愈、有生命周期管理"的长期运行进程，在后台持续运行、独立于用户会话，通常称为“守护进程”（Daemon）。

Systemd与Init的区别？

• Systemd并行启动、按需启动、支持socket/DBus激活；
• SysV init串行启动，依赖 /etc/init.d 目录下的脚本。

如何查看服务？

Systemd 服务：

systemctl --type=service
systemctl status xxx 看具体服务
systemctl start/restart/stop

SysV 服务：

service --status-all
service xxx status

6. 其他/操作系统

进程/线程区别？

• 内存分配
  • 进程：资源分配的基本单位，拥有独立的内存空间
  • 线程：CPU调度的基本单位，共享进程的资源
• 切换开销
  • 进程：大，有独立代码和数据段
  • 线程：小，只维护独立的堆栈和程序计数器
• 稳定性
  • 进程：隔离性更强，某个进程崩溃不会影响其他进程
  • 线程：弱，线程共享进程资源，崩溃可能导致整个进程异常
• 安全性
  • 进程：有独立内存空间，安全性高
  • 线程：共享内存空间，存在数据竞争和线程安全问题，需要同步/互斥机制
• 补充：MySQL 多线程，PostgreSQL/Oracle 多线程

并发/并行区别？

• 并发（Concurrency）：逻辑上的“同时”。单核CPU通过时间片轮转快速切换，看起来像是同时处理多个任务，本质是交替执行（强调结构，处理多件事）。
• 并行（Parallelism）：物理上的“同时”。多核CPU在同一时刻真正地执行多个任务（强调执行，同时做多件事）。

死锁的四个条件

用户态与内核态是什么？如何切换？

• 用户态：用户态下的程序只能访问受限的内存，不能直接访问硬件设备。用户态程序的执行权限较低，不能执行特权指令。

• 内核态：内核态下的程序可以访问所有的内存和硬件设备，具有最高的执行权限。内核态程序可以执行特权指令，如设置时钟、内存管理等。

用户态和内核态之间的切换是通过系统调用、异常和中断来实现的。

• 系统调用：用户态程序通过系统调用请求操作系统提供的服务，从而切换到内核态。例如，内存分配函数*malloc()会调用sbrk()*系统调用，从而切换到内核态。
• 异常：当CPU在执行用户态程序时发生异常（如缺页异常），会触发从用户态切换到内核态。
• 中断：当外围设备完成用户请求的操作后，会向CPU发出中断信号，CPU会暂停当前用户态程序的执行，转而执行中断处理程序，从而切换到内核态。

听说过 CFS 吗？ CFS（Completely Fair Scheduler，完全公平调度器）用于Linux系统中普通进程的调度。vruntime，红黑树结构，有利于交互式进程。听说过 CFS 吗？（Linux ） - 面试鸭 | 2026最新面试题+详细答案解析

ps 常用参数

• -A：显示所有进程。
• -e：与 -A 效果相同，显示所有进程。
• -a：显示所有终端上的进程，包括其他用户的进程。
• -x：显示没有控制终端的进程。
• -u：以用户为主的格式显示进程信息。
• -f：显示完整格式的进程信息，包括 UID、PPID 等。
• -l：以长格式显示进程信息。
• -o：自定义输出格式，例如 ps -o pid,cmd 仅显示进程 ID 和命令。
• --sort：按指定字段排序，例如 --sort=-%cpu 按 CPU 使用率降序排列。

部分内容来源于 Java-Guide

基础

分层模型

OSI七层模型与TCP/IP四层模型分别是什么？

• OSI七层：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层。
• TCP/IP四层：网络接口层、网际层、传输层、应用层。

每层功能？

• 应用层：为用户提供服务
• 表示层：数据表示（转换、加解密、解压缩）
• 会话层：管理应用程序之间的会话
• 传输层：主机通信（TCP/UDP）
• 网络层：路由、寻址、IP
• 数据链路层：帧编码、纠错、MAC地址
• 物理层：网卡、光纤

计算机网络体系是怎么工作的？

三个核心原则：

1. 分层解耦（分工协作）
   • 每一层只干自己的活，不越界。比如传输层只关心端到端可靠性，不关心数据内容；应用层只关心业务逻辑，不关心数据怎么走光纤。
   • 好处：各层独立升级（比如物理层从网线换光纤，应用层代码丝毫不用改）。
2. 对等通信（虚拟通信）
   • 虽然数据是物理上从上往下发、从下往上收，但逻辑上，发送端的“网络层”觉得是在和接收端的“网络层”直接沟通（实际上中间隔着下层）。这种“对等层之间的协议”决定了整个体系的稳定性。
3. 封装与解封装（带信封装）
   • 发送方：数据每往下一层，就包一层“信封”（头部 Header）；
   • 接收方：每往上一层，就拆一层“信封”。

整个体系就是“数据不动，协议动”——用户数据本身没变过，每一层都在它外面加上了自己的控制信息（头部），直到变成比特流传输出去。

网络层

• IP（Internet Protocol，网际协议）：主要作用是定义数据包的格式、对数据包进行路由和寻址，以便它们可以跨网络传播并到达正确的目的地。
• ARP（Address Resolution Protocol，地址解析协议），用于在局域网（LAN）中进行主机通信，是一种用于将网络层的地址转换为数据链路层地址的重要网络协议。 在TCP/IP网络中，ARP的主要功能是将IP地址转换为MAC地址。
• ICMP（Internet Control Message Protocol，互联网控制报文协议）：一种用于传输网络状态和错误消息的协议，常用于网络诊断和故障排除。例如，Ping 工具就使用了 ICMP 协议来测试网络连通性。
• NAT（Network Address Translation，网络地址转换协议）：NAT 协议的应用场景如同它的名称——网络地址转换，应用于内部网到外部网的地址转换过程中。具体地说，在一个小的子网（局域网，LAN）内，各主机使用的是同一个 LAN 下的 IP 地址，但在该 LAN 以外，在广域网（WAN）中，需要一个统一的 IP 地址来标识该 LAN 在整个 Internet 上的位置。

传输层

TCP/UDP区别？

TCP三次握手的过程？ 客户端发送SYN → 服务端回复SYN+ACK → 客户端回复ACK，连接建立。

TCP四次挥手的过程？ 主动方发送FIN → 被动方回复ACK → 被动方发送FIN → 主动方回复ACK。

TIME_WAIT状态的作用？ 确保最后一个ACK能到达对方，让迟到的报文段有足够时间被丢弃。可通过net.ipv4.tcp_tw_reuse允许复用。

CLOSE_WAIT状态是什么？成因？ 被动关闭方收到FIN后回复ACK进入的状态，表示等待应用层调用close()。堆积说明程序没正确关闭连接。

TCP 如何保证可靠传输？（重传/滑动窗口/拥塞控制）TCP 如何保证可靠传输？重传、滑动窗口与拥塞控制详解 | JavaGuide

应用层

应用层常见协议？基于TCP还是UDP？

• HTTP（Hypertext Transfer Protocol，超文本传输协议）：是一种用于传输超文本和多媒体内容的应用层协议，主要为 Web 客户端与服务器之间的通信而设计。HTTP/1.x 和 HTTP/2 通常基于 TCP，HTTP/3 则运行在基于 UDP 的 QUIC 之上。
• SMTP（Simple Mail Transfer Protocol，简单邮件发送协议）：基于 TCP 协议，是一种用于发送电子邮件的协议。注意 ⚠️：SMTP 协议只负责邮件的发送，而不是接收。要从邮件服务器接收邮件，需要使用 POP3 或 IMAP 协议。
• POP3/IMAP（邮件接收协议）：基于 TCP 协议，两者都是负责邮件接收的协议。IMAP 协议是比 POP3 更新的协议，它在功能和性能上都更加强大。IMAP 支持邮件搜索、标记、分类、归档等高级功能，而且可以在多个设备之间同步邮件状态。几乎所有现代电子邮件客户端和服务器都支持 IMAP。
• FTP（File Transfer Protocol，文件传输协议）：基于 TCP 协议，是一种用于在计算机之间传输文件的协议，可以屏蔽操作系统和文件存储方式。注意 ⚠️：FTP 是一种不安全的协议，因为它在传输过程中不会对数据进行加密。建议在传输敏感数据时使用更安全的协议，如 SFTP。
• Telnet（远程登陆协议）：基于 TCP 协议，用于通过一个终端登陆到其他服务器。Telnet 协议的最大缺点之一是所有数据（包括用户名和密码）均以明文形式发送，这有潜在的安全风险。这就是为什么如今很少使用 Telnet，而是使用一种称为 SSH 的非常安全的网络传输协议的主要原因。
• SSH（Secure Shell Protocol，安全的网络传输协议）：基于 TCP 协议，通过加密和认证机制实现安全的访问和文件传输等业务
• RTP（Real-time Transport Protocol，实时传输协议）：通常基于 UDP 协议，但也支持 TCP 协议。它提供了端到端的实时传输数据的功能，但不包含资源预留存、不保证实时传输质量，这些功能由 WebRTC 实现。
• DNS（Domain Name System，域名管理系统）：通常基于 UDP 协议（端口 53），用于解决域名和 IP 地址的映射问题。当响应数据过大或进行区域传送时会改用 TCP。

HTTP状态码分类？ 1xx信息、2xx成功、3xx重定向、4xx客户端错误、5xx服务端错误。

长连接与短连接的区别？ 短连接每次请求后断开；长连接保持连接复用（HTTP Keep-Alive），减少握手开销。

DNS解析的查询顺序？ 浏览器缓存 → 系统Hosts文件 → 本地DNS服务器 → 根域/顶级域递归查询。

HTTPS与HTTP的区别？ HTTPS在HTTP下加TLS/SSL层，提供加密传输和身份认证。

HTTP/1.1 和 HTTP/2.0 有什么区别？

• 多路复用（Multiplexing）：HTTP/2.0 在同一连接上可以同时传输多个请求和响应（可以看作是 HTTP/1.1 中长链接的升级版本），互不干扰。HTTP/1.1 则使用串行方式，每个请求和响应都需要独立的连接，而浏览器为了控制资源会有 6-8 个 TCP 连接的限制。这使得 HTTP/2.0 在处理多个请求时更加高效，减少了网络延迟和提高了性能。
• 二进制帧（Binary Frames）：HTTP/2.0 使用二进制帧进行数据传输，而 HTTP/1.1 则使用文本格式的报文。二进制帧更加紧凑和高效，减少了传输的数据量和带宽消耗。
• 队头阻塞：HTTP/2 引入了多路复用技术，允许多个请求和响应在单个 TCP 连接上并行交错传输，解决了 HTTP/1.1 应用层的队头阻塞问题，但 HTTP/2 依然受到 TCP 层队头阻塞的影响。
• 头部压缩（Header Compression）：HTTP/1.1 支持 Body 压缩，Header 不支持压缩。HTTP/2.0 支持对 Header 压缩，使用了专门为 Header 压缩而设计的 HPACK 算法，减少了网络开销。
• 服务器推送（Server Push）：HTTP/2.0 支持服务器推送，可以在客户端请求一个资源时，将其他相关资源一并推送给客户端，从而减少了客户端的请求次数和延迟。而 HTTP/1.1 需要客户端自己发送请求来获取相关资源。

HTTP请求从输入URL到页面展示的完整流程？

1. 浏览器解析 URL 并检查缓存：浏览器解析 URL 的各组成部分，并检查 HTTP 缓存（强缓存、协商缓存）是否已有该资源的有效副本。
2. DNS 解析：浏览器通过 DNS 协议（Hosts→本地DNS→递归查询），获取域名对应的 IP 地址。
3. 建立传输连接：HTTP/1.1 和 HTTP/2 通常先通过 TCP 三次握手建立连接；HTTP/3 则建立基于 UDP 的 QUIC 连接。
4. 建立安全通道（HTTPS）：HTTP/1.1 和 HTTP/2 通常在 TCP 建连后进行 TLS 握手；HTTP/3 在 QUIC 建连过程中集成 TLS 1.3，完成密钥协商和服务器身份验证。
5. 发送 HTTP 请求：浏览器在连接上向服务器发送 HTTP 请求报文，请求获取网页内容。
6. 服务器处理并返回响应：服务器收到请求后处理并返回 HTTP 响应报文。
7. 浏览器解析与渲染：浏览器解析 HTML、CSS，执行 JavaScript，并加载页面中引用的其他资源（图片、字体等）。
8. 连接管理：页面加载完成后，连接根据 keep-alive 策略复用或关闭。

从OSI七层模型的角度看每一层做了什么：

第一阶段：发送请求（应用层 → 物理层）

• 应用层：浏览器解析出协议（HTTP/HTTPS）、域名（如 www.baidu.com）和路径。
• 表示层：对数据进行“翻译”和“加密”。如果是 HTTPS，在此层进行 TLS/SSL 握手和加解密；同时将字符编码统一（如 UTF-8）。
• 会话层：建立、管理、维持本次通信的会话连接（Session）。虽然 HTTP 是无状态的，但此层负责确保断线重连时能续传。
• 传输层：通过 DNS 解析得到目标 IP 后，选择 TCP 或 UDP 协议。将数据切成数据段（Segment），并封装上源端口和目标端口（80/443）。
• 网络层：添加 IP 头部（源 IP 和 目标 IP）。通过路由算法查询下一跳地址，决定数据包走哪条路到达服务器。
• 数据链路层：添加 MAC 地址（源 MAC 和下一跳网关的 MAC）。通过 ARP 协议（地址解析协议）获取下一跳路由器的物理地址。
• 物理层：将数据帧转化为二进制 0/1 的比特流，通过网线、光纤或 Wi-Fi 的电磁波发送出去。

第二阶段：接收响应（物理层 → 应用层）从下往上逐层拆包（剥洋葱）：

• 物理层：接收电信号/光信号，还原成比特流。
• 数据链路层：检查 MAC 地址是否匹配，拆掉 MAC 头部，交由上层。
• 网络层：检查 IP 地址是否匹配，拆掉 IP 头部，交由上层。
• 传输层：拆掉 TCP 头部，回传 ACK 确认包（三次握手的最后一步），并把乱序的数据包重排好，交给应用。
• 会话/表示层：解密（HTTPS）、解压数据。
• 应用层：解析 HTTP 响应报文（状态码 200、HTML 内容），浏览器开始渲染引擎解析 HTML、加载 CSS/JS，最终呈现出你看到的网页。