Linux | 技术站点

Linux简介与环境准备

Fri, 02 Jan 2026 00:00:00 +0000

Linux简介

什么是Linux？

Linux是一种自由和开源的操作系统内核，由Linus Torvalds于1991年首次发布。它是Unix-like系统的一种实现，以其稳定性、安全性和灵活性著称。

Linux核心特性

开源免费：内核代码公开，可自由修改和分发
多用户多任务：支持多个用户同时使用，支持多任务并发执行
强大的网络功能：天生为网络而生，是服务器领域的首选
高稳定性：许多服务器可以连续运行数年无需重启
安全性：权限模型和SELinux/AppArmor提供细粒度安全控制

Linux发展历程

年份	里程碑事件
1991	Linus Torvalds发布Linux 0.01
1992	Linux采用GPL许可证开源
1994	Linux 1.0正式发布
1996	Tux企鹅成为官方吉祥物
2003	企业级应用开始普及
2011	容器技术Docker诞生
2020	Linux迎来30周年

Linux的应用领域

┌─────────────────────────────────────────────────────────────┐
│                      Linux 应用领域                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   📱 移动设备 ─── Android系统基于Linux内核                   │
│                                                             │
│   💻 桌面系统 ─── Ubuntu、Fedora个人电脑                     │
│                                                             │
│   🖥️ 服务器 ─── 全球90%以上的服务器运行Linux                  │
│                                                             │
│   🔧 嵌入式 ─── 智能家居、物联网设备                          │
│                                                             │
│   ☁️ 云计算 ─── AWS、阿里云等云平台                           │
│                                                             │
│   🐳 容器平台 ─── Docker、Kubernetes                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Linux发行版介绍

主要发行版家族

Linux发行版是由Linux内核加上GNU工具和应用程序组成的完整操作系统。

1. Debian系

发行版	特点	适用场景
Ubuntu	用户友好，社区活跃	桌面、服务器、初学者
Linux Mint	基于Ubuntu，界面友好	桌面用户
Debian	稳定可靠，软件丰富	服务器、专业环境

2. Red Hat系

发行版	特点	适用场景
RHEL	企业级，商业支持	企业服务器
CentOS	RHEL克隆，免费稳定	服务器（已停止）
Rocky Linux	RHEL替代，社区驱动	企业服务器
AlmaLinux	RHEL替代，稳定可靠	企业服务器
Fedora	前沿技术，尝鲜首选	桌面、开发者

3. SUSE系

发行版	特点	适用场景
openSUSE	稳定可靠，YaST工具	桌面、服务器
SLES	企业级，商业支持	企业环境

4. 其他发行版

发行版	特点	适用场景
Arch Linux	滚动更新，高度定制	高级用户
Gentoo	源码编译，极度优化	性能极致追求者
Deepin	国产精品，界面美观	桌面用户

如何选择发行版？

选择决策树：

├── 我是初学者
│   └── 推荐：Ubuntu Desktop / Linux Mint
│
├── 我要搭建服务器
│   ├── 需要商业支持 → RHEL / SLES
│   ├── 需要稳定免费 → Rocky Linux / AlmaLinux
│   └── 需要最新软件 → Ubuntu LTS
│
├── 我追求最新技术
│   └── 推荐：Fedora / Arch Linux
│
└── 我要深入学习Linux
    └── 推荐：Arch Linux / Gentoo

安装Linux系统

方式一：虚拟机安装

1. 下载安装VirtualBox/VMware

VirtualBox（免费）：

# Ubuntu/Debian
sudo apt update
sudo apt install virtualbox

# Fedora
sudo dnf install VirtualBox

2. 创建虚拟机步骤

下载Linux发行版ISO镜像
打开VirtualBox，点击"新建"
选择类型为Linux，版本选择对应发行版
分配内存建议至少2GB
创建虚拟硬盘，建议20GB以上
加载ISO镜像，启动虚拟机
按照安装向导完成系统安装

3. 推荐的虚拟机配置

组件	最低配置	推荐配置
内存	2GB	4GB+
硬盘	20GB	50GB+
处理器	1核	2核+
显存	128MB	256MB

方式二：双系统安装

重要提示

安装双系统前务必备份重要数据！误操作可能导致数据丢失。

Windows下制作启动U盘

# 使用Rufus（Windows工具）
# 1. 下载Rufus: https://rufus.ie/
# 2. 插入U盘（至少8GB）
# 3. 选择下载的ISO文件
# 4. 选择GPT分区方案
# 5. 点击开始，等待写入完成

Linux安装基本步骤

制作启动U盘
重启电脑，进入BIOS/UEFI设置
设置从USB启动
进入Ubuntu安装程序
选择语言（简体中文）
选择安装类型：
- 与Windows共存（推荐新手）
- 清除整个磁盘（需备份）
- 自定义分区（高级用户）
设置时区、用户名、密码
等待安装完成，重启

方式三：WSL（Windows子系统）

# 以管理员身份打开PowerShell

# 1. 启用WSL和虚拟机平台
wsl --install

# 2. 重启电脑后，安装Ubuntu
wsl --install -d Ubuntu

# 3. 首次启动设置用户名和密码

WSL常用命令

wsl --list              # 列出已安装的发行版
wsl --status            # 查看WSL状态
wsl -d Ubuntu           # 启动指定发行版
wsl.exe --shutdown       # 关闭所有WSL实例

开发环境配置

安装基础开发工具

Ubuntu/Debian

# 更新软件源
sudo apt update
sudo apt upgrade

# 安装基础开发工具
sudo apt install build-essential

# 安装GCC编译器
sudo apt install gcc g++ gdb

# 安装Git版本控制
sudo apt install git

# 安装Vim编辑器
sudo apt install vim

# 安装Python（如果需要）
sudo apt install python3 python3-pip

Fedora/RHEL

# 安装基础开发工具
sudo dnf groupinstall "Development Tools"

# 安装常用工具
sudo dnf install gcc gcc-c++ gdb git vim python3

配置国内镜像源

Ubuntu阿里云镜像

# 备份原始源
sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak

# 编辑源列表
sudo vim /etc/apt/sources.list

# 替换为以下内容（以Ubuntu 22.04为例）

# 阿里云镜像源
deb https://mirrors.aliyun.com/ubuntu/ jammy main restricted universe multiverse
deb https://mirrors.aliyun.com.com/ubuntu/ jammy-updates main restricted universe multiverse
deb https://mirrors.aliyun.com.com/ubuntu/ jammy-backports main restricted universe multiverse
deb https://mirrors.aliyun.com/ubuntu/ jammy-security main restricted universe multiverse

# 更新源
sudo apt update

CentOS阿里云镜像

# 备份
sudo cp /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.bak

# 编辑
sudo vim /etc/yum.repos.d/CentOS-Base.repo

[base]
name=CentOS-$releasever - Base - Aliyun mirrors
baseurl=https://mirrors.aliyun.com.com/centos/$releasever/BaseOS/$basearch/os/
enabled=1
gpgcheck=1
gpgkey=https://mirrors.aliyun.com.com/centos/RPM-GPG-KEY-CentOS-7

常用开发软件安装

# VS Code
sudo snap install code --classic

# IntelliJ IDEA
sudo snap install intellij-idea-ultimate --classic

# Docker
curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker $USER

# MySQL
sudo apt install mysql-server

# PostgreSQL
sudo apt install postgresql postgresql-contrib

# Redis
sudo apt install redis-server

快速入门命令

打开终端

在Linux中，几乎所有操作都可以通过终端完成。

快捷键：
- Ctrl + Alt + T    # 打开终端（GNOME桌面）
- Ctrl + Shift + T   # 新建终端标签页
- Ctrl + C           # 终止当前命令
- Ctrl + Z           # 挂起当前命令
- Ctrl + D           # 退出当前Shell

第一个命令

# 查看当前用户名
whoami

# 查看当前目录
pwd

# 列出当前目录文件
ls

# 查看系统信息
uname -a

# 查看帮助
man ls

命令学习技巧

使用 man <命令> 查看命令手册
使用 <命令> --help 查看快速帮助
使用 TAB 键自动补全
使用 ↑/↓ 箭头浏览历史命令

课后练习

实践任务

在虚拟机中安装Ubuntu 22.04 LTS
配置国内镜像源并更新系统
安装build-essential、git、vim基础工具
使用 man 命令学习 ls、cd、pwd 命令的用法
尝试使用 whoami、uname、date 等基础命令

下一篇预告：我们将学习Linux桌面环境的使用，包括文件管理器、系统设置、常用快捷键等。

Linux桌面环境入门

Sat, 03 Jan 2026 00:00:00 +0000

Linux桌面环境概述

Linux与其他操作系统的主要区别之一是它提供了多种桌面环境供用户选择。每个桌面环境都有其独特的设计理念和用户界面风格。

什么是桌面环境？

桌面环境（Desktop Environment，DE）是Linux系统中提供图形用户界面（GUI）的完整软件套装，通常包括：

┌─────────────────────────────────────────┐
│           桌面环境组件                    │
├─────────────────────────────────────────┤
│                                         │
│   🖥️ 窗口管理器 ─── 控制窗口行为           │
│                                         │
│   🖼️ 文件管理器 ─── 图形化文件操作         │
│                                         │
│   ⚙️ 面板/任务栏 ─── 快速启动、应用切换     │
│                                         │
│   🔔 系统托盘 ─── 通知、状态指示器         │
│                                         │
│   ⚡ 控制中心 ─── 系统设置、偏好配置       │
│                                         │
│   🎨 主题引擎 ─── 外观、图标、字体         │
│                                         │
└─────────────────────────────────────────┘

主流桌面环境对比

桌面环境	特点	系统资源占用	推荐发行版
GNOME	现代、简洁、功能强大	中高	Ubuntu、Fedora
KDE Plasma	高度可定制、类似Windows	高	openSUSE、KDE Neon
Xfce	轻量级、老旧硬件友好	低	Xubuntu、Manjaro Xfce
LXQt	超轻量、资源占用极低	极低	Lubuntu
MATE	经典风格、GNOME 2延续	低	Linux Mint MATE
Cinnamon	现代化、类似Windows	中	Linux Mint Cinnamon
Deepin	国产精品、界面美观	中	Deepin

GNOME桌面环境

GNOME概述

GNOME是当前最流行的Linux桌面环境之一，以其现代化的设计和简洁的用户体验著称。

┌────────────────────────────────────────────────────────┐
│                        GNOME 概览                       │
├────────────────────────────────────────────────────────┤
│                                                        │
│   GNOME 42+ 采用全新的libadwaita设计语言               │
│                                                        │
│   ├── Activities概览 ─── 按Super键快速访问              │
│   ├── 扩展程序 ─── 高度可定制                          │
│   ├── GNOME Shell ─── 现代化桌面Shell                   │
│   └── GTK4应用程序 ─── 统一的视觉体验                   │
│                                                        │
└────────────────────────────────────────────────────────┘

GNOME基本操作

Activities概览

快捷键：Super 键（Windows键）

功能：
├── 搜索应用程序 ─── 直接输入应用名称
├── 切换窗口 ─── 点击已打开的窗口
├── 创建工作区 ─── 点击右上角"+"
├── 快速启动 ─── 点击左下角应用程序图标
└── 文件搜索 ─── 搜索Documents中的文件

窗口操作

操作	快捷键	说明
关闭窗口	`Alt + F4` / `Super + Q`	关闭当前窗口
最大化	`Super + ↑`	全屏显示
最小化	`Super + H`	最小化到任务栏
切换窗口	`Alt + Tab`	切换应用程序
移动窗口	`Super + 左键拖动`	自由移动
调整大小	`Super + 右键拖动`	自由调整

工作区管理

# 切换工作区
Super + Page Up      # 上一工作区
Super + Page Down    # 下一工作区

# 将窗口移到另一工作区
Super + Shift + Page Up/Down

# 直接跳转到指定工作区
Super + 数字键 (1-9)

GNOME常用配置

安装GNOME扩展

# 1. 安装GNOME扩展管理器
sudo apt install gnome-extension-manager

# 2. 推荐扩展（从 extensions.gnome.org 安装）
# - Dash to Dock        # 自定义dock栏
# - Clipboard Indicator # 剪贴板历史
# - User Themes         # 用户主题支持
# - Blur My Shell       # 毛玻璃效果

调整日期时间格式

# 通过设置 → 区域与语言 → 格式选择
# 推荐选择"中文（简体、中国）"以获得完整中文支持

GNOME优化技巧

# 禁用自动挂载（减少干扰）
gsettings set org.gnome.desktop.media-handling automount false
gsettings set org.gnome.desktop.media-handling automount-open false

# 禁用屏幕锁定
gsettings set org.gnome.desktop.screensaver lock-enabled false

# 显示桌面图标
gsettings set org.gnome.shell.extensions.desktop-icons show-home false
gsettings set org.gnome.shell.extensions.desktop-icons show-trash false

# 调整启动动画延迟
gsettings set org.gnome.desktop.session idle-delay 600

KDE Plasma桌面环境

KDE概述

KDE Plasma是一个高度可定制的桌面环境，提供了类似Windows的熟悉界面和丰富的自定义选项。

┌─────────────────────────────────────────┐
│           KDE Plasma 特性               │
├─────────────────────────────────────────┤
│                                         │
│   🎨 主题丰富 ─── 数千种主题和图标包      │
│                                         │
│   ⚙️ 高度可定制 ─── 每个组件皆可定制      │
│                                         │
│   📱 多种模式 ─── 支持平板/手机界面      │
│                                         │
│   🔌 插件系统 ─── KDE Gadgets小部件      │
│                                         │
└─────────────────────────────────────────┘

KDE基本操作

面板配置

组件	说明
面板小程序	时钟、天气、系统监控
任务栏	显示已打开应用
系统托盘	网络、音量、电源图标
应用菜单	开始菜单

KDE快捷键

操作	快捷键
应用菜单	`Super`
锁定屏幕	`Ctrl + Alt + L`
截图	`Shift + Print Screen`
全屏截图	`Print Screen`
活动视图	`Super + D`

KDE个性化设置

# 安装主题管理器
sudo apt install plasma-discover

# 安装额外主题
sudo apt install kde-themes

# 全局主题安装位置
~/.local/share/plasma/look-and-feel/
~/.usr/share/plasma/look-and-feel/

# 图标主题安装位置
~/.local/share/icons/
~/.usr/share/icons/

文件管理器

GNOME Files（Nautilus）

基本操作

# 快捷键
Ctrl + N          # 新建窗口
Ctrl + T          # 新建标签页
Ctrl + L          # 地址栏
Ctrl + H          # 显示隐藏文件
Ctrl + F          # 搜索
Delete            # 移至回收站
Shift + Delete    # 直接删除

# 导航
Alt + ←/→         # 后退/前进
Alt + ↑           # 上一级目录

常用路径

路径	说明
`~` 或 `$HOME`	用户主目录
`~/Desktop`	桌面
`~/Documents`	文档
`~/Downloads`	下载
`~/.config`	配置文件夹
`/media/用户名/`	外接设备

Dolphin（KDE）

# 快捷键
F2              # 重命名
F4              # 终端打开
Ctrl + Shift + F # 全局搜索

# 面板
F9              # 侧边栏
F3              # 分栏视图

系统设置

Ubuntu/GNOME系统设置

┌─────────────────────────────────────────────────────────┐
│                    系统设置菜单                          │
├─────────────────────────────────────────────────────────┤
│                                                         │
│   ⚙️ 显示 ─── 分辨率、亮度、外接显示器                    │
│                                                         │
│   🔊 声音 ─── 输出设备、音量、声音效果                    │
│                                                         │
│   🌐 网络 ─── WiFi、以太网、VPN                           │
│                                                         │
│   🔵 蓝牙 ─── 蓝牙设备配对                               │
│                                                         │
│   👤 用户账户 ─── 用户管理、登录选项                     │
│                                                         │
│   🔔 通知 ─── 通知设置、勿扰模式                         │
│                                                         │
│   ⏰ 电源 ─── 节能、电池设置                              │
│                                                         │
│   🖱️ 鼠标和触控板 ─── 指针速度、触摸手势                  │
│                                                         │
│   ⌨️ 键盘快捷键 ─── 自定义快捷键                         │
│                                                         │
└─────────────────────────────────────────────────────────┘

命令行配置工具

# GNOME设置（命令行）
gsettings list-schemas | grep -i theme
gsettings set org.gnome.desktop.interface gtk-theme 'Yaru'
gsettings set org.gnome.desktop.interface icon-theme 'Yaru'
gsettings set org.gnome.desktop.interface cursor-theme 'Yaru'

# 字体设置
gsettings set org.gnome.desktop.interface font-name 'Noto Sans 11'
gsettings set org.gnome.desktop.interface document-font-name 'Noto Sans 11'

# 启动应用管理
gnome-session-properties

系统监控

# GNOME系统监视器
gnome-system-monitor

# 或安装更强大的监控工具
sudo apt install htop bashtop

# 运行时监控
htop          # 交互式进程监控
iotop         # I/O监控
nethogs       # 网络流量监控

常用软件安装

浏览器

# Chrome
wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo dpkg -i google-chrome-stable_current_amd64.deb

# Firefox（通常预装）
sudo snap install firefox

# Edge
wget https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-dev/microsoft-edge-dev_112.0.1722.5-1_amd64.deb
sudo dpkg -i microsoft-edge-dev_112.0.1722.5-1_amd64.deb

办公软件

# LibreOffice（通常预装）
sudo apt install libreoffice

# WPS Office（国产）
wget https://wdl1.pcfg.cache.wpscdn.com/wpsdn/20190702/WPS_Office_11.1.0.9524_XA_amd64.deb
sudo dpkg -i WPS_Office_11.1.0.9524_XA_amd64.deb

媒体播放

# VLC（全能播放器）
sudo apt install vlc

# GIMP（图像编辑）
sudo apt install gimp

# Shotcut（视频编辑）
sudo snap install shotcut --classic

开发工具

# VS Code
sudo snap install code --classic

# JetBrains全家桶
sudo snap install intellij-idea-ultimate --classic
sudo snap install pycharm-professional --classic

# Terminator（高级终端）
sudo apt install terminator

高效使用技巧

通用桌面快捷键

快捷键	功能
`Super + L`	锁屏
`Super + Tab`	应用切换器
`Alt + F2`	运行命令（GNOME）
`Alt + Space`	命令运行器（Dolphin）
`Ctrl + Alt + Delete`	登出/关机对话框
`PrtSc`	截图
`Alt + PrtSc`	截图当前窗口

多任务处理

# 平铺窗口
Super + Left       # 左半屏
Super + Right      # 右半屏
Super + Up         # 最大化
Super + Down       # 最小化

# 混合窗口（KDE）
Super + Meta + 方向键  # 角落平铺

剪切板管理

# 安装剪切板管理器
sudo apt install gnome-shell-pomodoro  # 不推荐这个

# 推荐扩展
# Clipboard Indicator - GNOME扩展

# 或命令行工具
sudo apt install xclip
xclip -selection clipboard -o    # 查看剪贴板

桌面环境切换

安装多个桌面环境

# Ubuntu安装KDE Plasma
sudo apt install kde-plasma-desktop

# Ubuntu安装Xfce
sudo apt install xfce4 xfce4-goodies

# 安装后注销，在登录界面选择桌面环境

切换桌面会话

1. 注销当前会话
2. 在登录界面点击用户名
3. 点击密码输入框下方的⚙️图标
4. 选择需要的桌面环境
5. 输入密码登录

注意事项

建议只安装一个主要桌面环境，其他作为备用。安装多个桌面环境会增加系统资源占用，可能导致冲突。

课后练习

实践任务

熟悉GNOME或KDE的基本操作
尝试安装和配置GNOME扩展（如Dash to Dock）
练习使用快捷键完成日常操作
配置个性化主题（桌面、图标、字体）
安装常用软件（浏览器、VS Code）
尝试切换到其他桌面环境体验

下一篇预告：我们将深入学习Linux文件系统与目录结构，理解Linux如何组织和管理文件。

文件系统与目录结构

Sun, 04 Jan 2026 00:00:00 +0000

Linux文件系统概述

什么是文件系统？

文件系统是操作系统用于组织、存储和管理数据的方法。它定义了文件在存储设备上的存储格式和访问方式。

┌─────────────────────────────────────────────────────────────┐
│                    文件系统架构                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   用户程序 ──→ 文件系统API ──→ VFS（虚拟文件系统）           │
│                         │                                   │
│              ┌──────────┼──────────┐                       │
│              ▼          ▼          ▼                        │
│           ext4        XFS        Btrfs                      │
│              │          │          │                        │
│              └──────────┴──────────┘                        │
│                         │                                   │
│              ┌──────────┴──────────┐                        │
│              ▼                     ▼                        │
│         磁盘分区                 内存                        │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Linux文件系统特点

核心特性

一切皆文件：设备、进程、套接字都作为文件处理
大小写敏感：File.txt 和 file.txt 是不同文件
无文件扩展名强制：扩展名仅用于提示，Linux不依赖扩展名
长文件名支持：支持最多255个字符的文件名

常见Linux文件系统类型

文件系统	特点	适用场景
ext4	稳定可靠，日志功能	通用场景
XFS	大文件高性能	大型企业存储
Btrfs	快照、压缩、校验	现代桌面/服务器
ZFS	企业级特性，完整数据保护	存储服务器
swap	交换空间	内存扩展
vfat	Windows兼容	U盘、移动存储

FHS文件系统层次结构

Linux遵循**Filesystem Hierarchy Standard (FHS)**标准，定义了目录结构和内容。

┌─────────────────────────────────────────────────────────────┐
│                  Linux 根目录结构                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   /                                                         │
│   ├── bin/        ──  Essential command binaries           │
│   ├── boot/       ──  Boot loader files                     │
│   ├── dev/        ──  Device files                          │
│   ├── etc/        ──  Configuration files                    │
│   ├── home/       ──  User home directories                  │
│   ├── lib/        ──  Essential shared libraries            │
│   ├── media/      ──  Removable media mount points          │
│   ├── mnt/        ──  Temporary mount points                │
│   ├── opt/        ──  Optional add-on packages              │
│   ├── proc/       ──  Virtual filesystem (process info)     │
│   ├── root/       ──  Root user's home directory            │
│   ├── run/        ──  Runtime data                          │
│   ├── sbin/       ──  System binaries                       │
│   ├── srv/        ──  Service data                          │
│   ├── sys/        ──  Virtual filesystem (kernel info)      │
│   ├── tmp/        ──  Temporary files                       │
│   ├── usr/        ──  User utilities and applications       │
│   └── var/        ──  Variable data (logs, caches)          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

核心目录详解

/bin - 基本命令

存放所有用户都可以执行的二进制命令文件。

# 常用命令
/bin/ls           # 列出目录
/bin/cp           # 复制
/bin/mv           # 移动
/bin/rm           # 删除
/bin/cat          # 查看文件
/bin/mkdir        # 创建目录
/bin/rmdir        # 删除目录
/bin/chmod        # 改变权限
/bin/chown        # 改变所有者
/bin/ping         # 网络测试

/sbin - 系统管理命令

存放只有系统管理员（root）才能执行的系统管理命令。

# 常用命令
/sbin/ifconfig    # 网络配置
/sbin/fsck        # 文件系统检查
/sbin/mkfs        # 创建文件系统
/sbin/iptables     # 防火墙
/sbin/reboot       # 重启
/sbin/shutdown     # 关机
/sbin/partition    # 分区工具

/etc - 系统配置

存放系统和应用程序的配置文件。

# 重要配置目录
/etc/passwd       # 用户账户信息
/etc/shadow       # 用户密码（加密）
/etc/group        # 用户组信息
/etc/fstab        # 文件系统挂载表
/etc/hosts        # 主机名解析
/etc/resolv.conf  # DNS配置
/etc/network/     # 网络配置
/etc/nginx/       # Nginx配置
/etc/apache2/     # Apache配置
/etc/ssh/         # SSH配置

谨慎操作

/etc目录下的配置文件直接控制系统行为。修改前务必备份！

/home - 用户主目录

存放普通用户的主目录，每个用户有一个以用户名命名的子目录。

/home/
├── user1/
│   ├── Desktop/
│   ├── Documents/
│   ├── Downloads/
│   ├── Music/
│   ├── Pictures/
│   ├── Videos/
│   └── .config/        # 用户配置
├── user2/
└── ...

/root - root主目录

root用户（系统管理员）的主目录，与普通用户分离。

/var - 变量数据

存放经常变化的文件，如日志、缓存、数据库等。

/var/
├── log/           # 系统日志
│   ├── syslog     # 系统日志
│   ├── auth.log   # 认证日志
│   ├── dmesg      # 启动信息
│   └── apache2/   # Apache日志
├── cache/         # 应用缓存
├── lib/           # 状态信息
├── spool/         # 打印队列
└── www/html/      # Web根目录

/tmp - 临时文件

存放临时文件，系统重启后可能清空。

tmpfs

很多系统将 /tmp 挂载为 tmpfs（内存文件系统），提供极速读写性能。

/usr - 用户程序

存放用户安装的应用程序和库文件。

/usr/
├── bin/           # 用户命令
├── sbin/          # 用户系统管理命令
├── lib/           # 库文件
├── include/       # 头文件（C/C++）
├── share/         # 架构无关数据
│   ├── man/       # 手册页
│   └── doc/       # 文档
├── local/         # 本地安装程序
└── src/           # 源代码

/proc - 虚拟文件系统

提供内核和进程信息的虚拟文件系统。

# 内核参数
/proc/sys/net/ipv4/ip_forward    # IP转发
/proc/cpuinfo                     # CPU信息
/proc/meminfo                     # 内存信息
/proc/diskstats                   # 磁盘统计
/proc/loadavg                     # 系统负载

# 进程信息
/proc/1234/                       # PID 1234的进程信息
/proc/1234/cmdline                # 启动命令
/proc/1234/environ                # 环境变量
/proc/1234/fd/                    # 打开的文件描述符

/dev - 设备文件

存放设备文件，Linux将硬件设备映射为文件。

# 设备类型
/dev/sda           # 第一块SATA硬盘
/dev/sda1          # 第一块硬盘的第一个分区
/dev/nvme0n1       # NVMe SSD
/dev/null          # 空设备（丢弃所有数据）
/dev/zero          # 零字节生成器
/dev/random        # 随机数生成器
/dev/tty           # 当前终端
/dev/pts/0         # 伪终端

# 设备类型标识
brw-rw----  1 root disk     # 块设备（b）
crw-rw----  1 root video     # 字符设备（c）
lrwxrwxrwx  1 root root     # 符号链接（l）

/boot - 启动文件

存放内核和启动加载器文件。

/boot/
├── vmlinuz-5.15.0-generic    # Linux内核
├── initrd.img-5.15.0-generic # 初始化RAM磁盘
├── config-5.15.0-generic     # 内核配置
├── grub/                     # GRUB启动引导器
│   └── grub.cfg              # 启动菜单配置
└── System.map-5.15.0-generic # 内核符号表

/media 和 /mnt - 挂载点

# /media - 自动挂载的可移动设备
/media/cdrom/        # 光盘
/media/usb/          # U盘

# /mnt - 手动挂载的临时挂载点
/mnt/backup/         # 备份盘挂载点
/mnt/win/            # Windows分区挂载点

文件类型

Linux中有七种文件类型：

┌─────────────────────────────────────────┐
│            文件类型标识                  │
├─────────────────────────────────────────┤
│                                         │
│   -          普通文件 (regular file)    │
│   d          目录文件 (directory)        │
│   l          符号链接 (symbolic link)   │
│   c          字符设备 (character device)│
│   b          块设备 (block device)       │
│   p          管道文件 (pipe)             │
│   s          套接字 (socket)             │
│                                         │
└─────────────────────────────────────────┘

文件类型示例

$ ls -la /dev/
total 0
crw-rw---- 1 root video    226,   0 Jan 15 09:00 card0      # c: 字符设备
crw-rw---- 1 root video    226,   1 Jan 15 09:00 card1      # c: 字符设备
brw-rw---- 1 root disk      8,   0 Jan 15 09:00 sda         # b: 块设备
brw-rw---- 1 root disk      8,   1 Jan 15 09:00 sda1       # b: 块设备
crw-rw-rw- 1 root root       1,   7 Jan 15 09:00 full       # c: 字符设备
prw-r--r-- 1 root root             0 Jan 15 09:00 initctl   # p: 管道
srw-rw-rw- 1 root root             0 Jan 15 09:00 rw-rw-rw-  # s: 套接字
lrwxrwxrwx 1 root root            12 Jan 15 09:00 fd -> /proc/self/fd   # l: 符号链接

文件路径

绝对路径与相对路径

# 绝对路径 - 从根目录开始的完整路径
/etc/nginx/nginx.conf
/home/user/Documents/report.pdf

# 相对路径 - 从当前目录开始的路径
./scripts/backup.sh          # 当前目录下的scripts目录
../config/settings.ini       # 上级目录的config目录
../../var/log/syslog         # 上级目录的上级目录

路径快捷方式

符号	说明	示例
`~`	用户主目录	`~/Documents` = `/home/user/Documents`
`.`	当前目录	`./script.sh`
`..`	上级目录	`cd ..`
`-`	上次目录	`cd -`

文件操作命令

ls - 列出目录内容

# 基本用法
ls                  # 列出当前目录
ls /etc             # 列出指定目录
ls -l               # 详细信息
ls -a               # 包含隐藏文件
ls -lh              # 人类可读大小
ls -lt              # 按修改时间排序
ls -lS              # 按文件大小排序
ls -R               # 递归列出子目录

# 高级用法
ls -la --sort=size  # 按大小排序
ls -la --time=atime # 按访问时间排序
ls -d */            # 只列目录
ls -i               # 显示inode号

# 颜色标识（自动）
# 蓝色: 目录    绿色: 可执行文件    白色: 普通文件
# 青色: 符号链接  红色: 压缩文件    黄色: 设备文件

cd - 切换目录

cd                  # 返回主目录
cd /etc/nginx       # 切换到绝对路径
cd ./projects       # 切换到相对路径
cd ..               # 返回上级目录
cd -                # 返回上次目录
cd ~user            # 切换到指定用户主目录

# pushd/popd - 带记忆的目录切换
pushd /var/log      # 切换并记住当前位置
popd                # 返回上一个位置
dirs                # 显示记住的目录栈

pwd - 显示当前目录

pwd                 # 显示当前绝对路径
pwd -P              # 显示物理路径（解析符号链接）

mkdir - 创建目录

# 基本用法
mkdir newdir                    # 创建单个目录
mkdir dir1 dir2 dir3            # 创建多个目录
mkdir -p project/src/lib        # 递归创建（父目录不存在时自动创建）

# 设置权限
mkdir -m 755 mydir              # 指定权限
mkdir -p ~/backup/$(date +%Y%m%d)  # 使用命令替换

rm - 删除文件/目录

# 删除文件
rm file.txt                     # 删除单个文件
rm -f file.txt                  # 强制删除（不提示）
rm -i file.txt                  # 删除前确认

# 删除目录
rm -r mydir                     # 递归删除目录
rm -rf mydir                    # 强制递归删除（危险！）
rm -r directory1 directory2     # 删除多个目录

# 示例
rm -rf /tmp/*                   # 清空临时目录（常用）

危险操作

rm -rf 删除操作不可恢复！务必确认路径后再执行！

cp - 复制文件/目录

# 基本语法
cp source destination

# 复制文件
cp file.txt /backup/            # 复制到目录
cp file1.txt file2.txt          # 复制并重命名
cp -i file.txt /backup/          # 覆盖前确认

# 复制目录
cp -r mydir /backup/            # 递归复制目录
cp -ra /home /backup/home      # 归档复制（保留属性）

# 高级选项
cp -u source destination        # 只复制更新的文件
cp -v source destination       # 显示详细信息
cp -p source destination       # 保留文件属性

mv - 移动/重命名文件

# 移动文件
mv file.txt /new/location/      # 移动到目录
mv file1.txt file2.txt          # 重命名

# 移动目录
mv olddir newdir                # 重命名目录
mv mydir /other/location/       # 移动目录

# 选项
mv -i file.txt /backup/         # 覆盖前确认
mv -n file.txt /backup/        # 不覆盖已存在的文件
mv -v file.txt /backup/        # 显示详细信息
mv -f file.txt /backup/        # 强制覆盖

ln - 创建链接

# 符号链接（软链接）
ln -s target link_name         # 创建软链接
ln -s /etc/nginx nginx.conf    # 常用写法
ln -sf /new/target link        # 强制覆盖

# 硬链接
ln target hardlink              # 创建硬链接

# 查看链接
ls -la link_name               # 查看链接属性
readlink link_name             # 查看链接目标

软链接 vs 硬链接

特性	软链接	硬链接
本质	指向原文件的路径	指向同一个inode
跨分区	支持	不支持
目录	可以链接目录	不可以链接目录
原文件删除	链接断开	仍可访问

touch - 创建空文件

# 创建空文件
touch newfile.txt              # 创建单个文件
touch file1.txt file2.txt      # 创建多个文件

# 更新时间戳
touch -a file.txt              # 只更新访问时间
touch -m file.txt              # 只更新修改时间
touch -t 202601011200 file.txt # 指定时间戳
touch -r reference.txt file.txt # 使用参考文件的时间戳

file - 判断文件类型

file document.txt              # 查看文件类型
file -z archive.tar.gz         # 查看压缩包内容
file -i filename               # MIME类型输出

stat - 显示文件详细信息

stat filename
# 输出：
#   File: filename
#   Size: 4096        Blocks: 8          IO Block: 4096   regular file
# Device: 801h/2049d  Inode: 131081      Links: 1
# Access: (0644/-rw-r--r--)  Uid: ( 1000/    user)   Gid: ( 1000/    user)
# Access: 2026-01-04 10:00:00.000000000 +0800
# Modify: 2026-01-04 10:00:00.000000000 +0800
# Change: 2026-01-04 10:00:00.000000000 +0800

查找文件

find - 强大的文件搜索工具

# 基本语法
find [路径] [选项] [表达式]

# 按名称查找
find /home -name "*.txt"           # 查找所有txt文件
find /home -iname "*.TXT"          # 忽略大小写
find . -name "file*"               # 通配符搜索

# 按类型查找
find /home -type f                 # 普通文件
find /home -type d                 # 目录
find /home -type l                 # 符号链接
find /home -type b                 # 块设备
find /home -type c                 # 字符设备

# 按大小查找
find /home -size +100M             # 大于100MB
find /home -size -1k               # 小于1KB
find /home -size 10M               # 正好10MB

# 按时间查找
find /home -mtime -7               # 7天内修改
find /home -atime +30              # 30天前访问
find /home -ctime -1               # 今天属性改变
find /home -mmin -30               # 30分钟内修改

# 按权限查找
find /home -perm 755               # 精确权限
find /home -perm -u+x              # 包含执行权限
find /home -perm /222              # 任何写权限

# 按所有者查找
find /home -user username          # 指定用户
find /home -group groupname        # 指定组
find /home -uid 1000               # 指定UID
find /home -nouser                 # 无效用户

# 执行动作
find /home -name "*.log" -delete   # 删除找到的文件
find /home -name "*.txt" -exec cat {} \;     # 执行命令
find /home -name "*.txt" -exec cat {} +      # 批量执行（高效）
find /home -name "*.txt" -print -o -name "*.doc" -print

# 组合条件
find /home -type f -name "*.txt" -size +1M -mtime -7

locate - 快速文件搜索

# 安装并更新数据库
sudo apt install mlocate
sudo updatedb

# 使用
locate filename
locate -i filename                 # 忽略大小写
locate -c filename                 # 显示数量
locate -l 10 filename              # 限制数量
locate -r "regex_pattern"          # 正则表达式

locate vs find

locate依赖数据库，搜索速度快但需定期更新数据库 find实时搜索，精确但较慢

which - 查找命令位置

which python              # 查找python命令
which -a python           # 查找所有同名命令
which -s python           # 只返回状态码

whereis - 查找命令及源码

whereis python
# 输出：python: /usr/bin/python /usr/bin/python3.10 /usr/lib/python3.10 /usr/include/python3.10 /usr/share/man/man1/python.1.gz

压缩与归档

tar - 归档工具

# 创建归档
tar -cvf archive.tar file1 file2 dir1/      # 创建.tar归档
tar -czvf archive.tar.gz dir1/             # 创建.tar.gz压缩
tar -cjvf archive.tar.bz2 dir1/            # 创建.tar.bz2压缩
tar -cJvf archive.tar.xz dir1/              # 创建.tar.xz压缩

# 查看归档内容
tar -tvf archive.tar                        # 列出文件
tar -tvf archive.tar.gz                     # 列出.tar.gz内容

# 解压归档
tar -xvf archive.tar                        # 解压.tar
tar -xzvf archive.tar.gz                    # 解压.tar.gz
tar -xjvf archive.tar.bz2                   # 解压.tar.bz2
tar -xJvf archive.tar.xz                    # 解压.tar.xz

# 解压到指定目录
tar -xzvf archive.tar.gz -C /target/dir/

# 追加文件
tar -rvf archive.tar newfile.txt

# 常用选项
-c, --create        # 创建归档
-x, --extract      # 解压归档
-t, --list         # 列出内容
-v, --verbose      # 详细输出
-f, --file=FILE    # 指定文件名
-z, --gzip         # gzip压缩
-j, --bzip2        # bzip2压缩
-J, --xz           # xz压缩
-C, --directory    # 切换目录
-p, --preserve-permissions  # 保留权限
--exclude=PATTERN  # 排除文件

zip - ZIP压缩

# 压缩
zip archive.zip file1 file2           # 压缩文件
zip -r archive.zip directory/         # 递归压缩
zip -q archive.zip *.txt              # 静默模式
zip -e archive.zip sensitive/         # 加密压缩

# 解压
unzip archive.zip                     # 解压到当前目录
unzip archive.zip -d /target/         # 解压到指定目录
unzip -l archive.zip                  # 列出内容
unzip -o archive.zip                  # 覆盖已存在的文件

# 常用选项
-r, --recursive        # 递归处理
-q, --quiet            # 静默模式
-d, --dest             # 指定目标目录
-e, --encrypt          # 加密
-p, --password         # 指定密码

其他压缩工具

# gzip - 最常用
gzip file.txt                    # 压缩
gunzip file.txt.gz               # 解压
gzip -k file.txt                 # 压缩并保留原文件
gzip -d file.txt.gz              # 解压
gzip -9 file.txt                 # 最大压缩率
gzip -1 file.txt                 # 最快速度

# bzip2 - 更高压缩率
bzip2 file.txt
bunzip2 file.txt.bz2

# xz - 最高压缩率
xz file.txt
unxz file.txt.xz

# 7z
7z a archive.7z files/           # 压缩
7z x archive.7z                   # 解压

磁盘管理

df - 磁盘空间使用

# 基本用法
df                         # 显示所有文件系统
df -h                      # 人类可读格式
df -T                      # 显示文件系统类型
df -i                      # 显示inode使用情况
df -a                      # 显示所有文件系统
df -h /home                # 显示指定挂载点

# 示例输出
$ df -h
Filesystem      Size  Used Avail Use% Mounted on
tmpfs           1.6G  1.3M  1.6G   1% /dev/shm
/dev/sda1       100G   50G   45G  53% /
tmpfs           1.6G   80K  1.6G   1% /dev
tmpfs           320M  1.5M  319M   1% /run

du - 目录空间使用

# 基本用法
du                      # 显示当前目录及子目录大小
du -h                   # 人类可读格式
du -sh                  # 只显示总大小
du -sh *                # 显示各子项大小
du -h --max-depth=1     # 限制深度
du -c                   # 显示总计
du -a                    # 显示所有文件
du -m                    # 以MB为单位

# 实用示例
du -sh /var/log         # 查看日志目录大小
du -h /home | sort -h   # 按大小排序
find /home -type f -exec du -h {} + | sort -h

mount/umount - 挂载管理

# 查看挂载
mount                    # 显示所有挂载
mount | grep /dev/sda    # 查看特定设备
findmnt                  # 树形显示挂载关系
findmnt /dev/sdb1        # 查看特定挂载

# 挂载设备
sudo mount /dev/sdb1 /mnt/usb
sudo mount -o ro /dev/sdb1 /mnt/usb    # 只读挂载
sudo mount -t ntfs /dev/sdb1 /mnt/win  # 指定文件系统
sudo mount -a            # 挂载fstab中的所有设备

# 卸载设备
sudo umount /mnt/usb
sudo umount -l /mnt/usb   # 懒卸载
sudo umount -f /mnt/usb    # 强制卸载

# 常用挂载选项
ro          # 只读
rw          # 读写
remount     # 重新挂载
bind        # 绑定挂载

课后练习

实践任务

练习使用 ls -la 查看各种文件类型
创建目录结构 ~/projects/{src,bin,lib,docs} 并在每个目录创建测试文件
使用 find 命令搜索 /var/log 中最近7天修改的 .log 文件
创建压缩包并练习各种解压选项
使用 df -h 和 du -sh 分析磁盘使用情况
创建一个符号链接指向 /var/log 并观察链接行为

下一篇预告：我们将学习Linux用户与权限管理，理解如何安全地管理系统用户和文件权限。

用户与权限管理

Mon, 05 Jan 2026 00:00:00 +0000

Linux权限模型概述

Linux是一个多用户操作系统，权限管理是系统安全的核心。理解用户、组和文件权限是Linux系统管理的基础。

┌─────────────────────────────────────────────────────────────┐
│                   Linux 权限模型                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   用户 (UID) ──→ 属于组 (GID) ──→ 对文件有权限               │
│                                                             │
│   ┌─────────┐    ┌─────────┐    ┌─────────────────┐        │
│   │ 文件所有者│───→│ 文件组  │───→│ 其他用户(others) │        │
│   │ (owner) │    │ (group) │    │     (others)    │        │
│   └─────────┘    └─────────┘    └─────────────────┘        │
│                                                             │
│   每类用户都有: 读(r) 写(w) 执行(x) 三种权限                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

用户账户

用户类型

Linux系统中有三种类型的用户账户：

类型	UID范围	说明
root用户	0	超级管理员，拥有最高权限
系统用户	1-999 (CentOS/RHEL) / 1-99 (Debian/Ubuntu)	守护进程和服务运行账户
普通用户	1000+ (CentOS/RHEL) / 1000+ (Debian/Ubuntu)	日常使用账户

用户配置文件

/etc/passwd - 用户账户信息

# 格式: 用户名:密码占位符:UID:GID:注释:主目录:登录Shell
$ cat /etc/passwd

root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
user:x:1000:1000:John Doe:/home/user:/bin/bash

密码字段

现代系统中，密码已迁移到 /etc/shadow 文件，这里用 x 占位。

/etc/shadow - 用户密码信息

# 格式: 用户名:加密密码:最后修改时间:最小天数:最大天数:警告天数:失效天数:保留
$ sudo cat /etc/shadow

root:$6$mJx...:19000:0:99999:7:::
user:$6$randomsalt$hashedpassword:19000:0:99999:7:::

字段	说明	示例值
加密密码	使用SHA-512加密，`!`或`*`表示锁定	`$6$...`
最后修改时间	密码最后修改日期（1970年起天数）	19000
最小天数	密码修改最小间隔	0
最大天数	密码有效期	99999
警告天数	密码过期前警告天数	7
失效天数	密码过期后账户失效天数	空

/etc/group - 用户组信息

# 格式: 组名:组密码:GID:成员列表
$ cat /etc/group

root:x:0:
sudo:x:27:user1,user2
www-data:x:33:
user:x:1000:

用户管理命令

useradd - 创建用户

# 基本语法
sudo useradd [选项] 用户名

# 创建新用户（带完整参数）
sudo useradd -m \                    # 创建主目录
     -c "John Doe" \                 # 注释/全名
     -s /bin/bash \                  # 登录Shell
     -G sudo,www-data \              # 附加组
     -u 1500 \                       # 指定UID
     john

# 创建系统用户（无主目录，不分配登录Shell）
sudo useradd -r -s /usr/sbin/nologin mysql

# 创建带过期日期的用户
sudo useradd -e 2026-12-31 tempuser

# 创建用户并指定密码
echo "password" | sudo passwd username --stdin

常用选项：

选项	说明
`-m`	创建主目录
`-M`	不创建主目录
`-d 目录`	指定主目录
`-s Shell`	指定登录Shell
`-g 组`	指定主组
`-G 组列表`	指定附加组
`-u UID`	指定UID
`-e 日期`	账户过期日期
`-f 天数`	密码过期后账户失效天数
`-r`	创建系统用户

usermod - 修改用户

# 修改用户属性
sudo usermod -l newname oldname       # 重命名用户
sudo usermod -d /new/home -m user     # 移动主目录
sudo usermod -s /bin/zsh user         # 改变Shell
sudo usermod -aG group1,group2 user   # 添加到附加组
sudo usermod -e 2026-12-31 user       # 设置过期日期
sudo usermod -L user                  # 锁定账户
sudo usermod -U user                  # 解锁账户
sudo usermod -u 2000 user             # 更改UID

# 锁定/解锁用户
sudo passwd -l username               # 锁定
sudo passwd -u username               # 解锁

添加用户到组

usermod -aG groupname username - -a 表示追加，-G 指定组列表

userdel - 删除用户

# 删除用户（保留主目录）
sudo userdel username

# 删除用户及主目录
sudo userdel -r username

# 强制删除（即使用户已登录）
sudo userdel -f username

passwd - 密码管理

# 设置当前用户密码
passwd

# 设置其他用户密码（需要root）
sudo passwd username

# 修改密码策略
sudo passwd -n 7 username             # 最小使用天数
sudo passwd -x 90 username            # 最大使用天数
sudo passwd -w 7 username             # 警告天数
sudo passwd -i 30 username            # 失效宽限期

# 锁定/解锁
sudo passwd -l username               # 锁定
sudo passwd -u username               # 解锁

# 查看密码状态
sudo passwd -S username
# 输出：username P 01/01/2026 7 90 7 30
# P=有密码, NP=无密码, L=锁定

chage - 密码策略管理

# 查看密码策略
sudo chage -l username

# 设置账户过期日期
sudo chage -E 2026-12-31 username

# 设置密码过期策略
sudo chage -m 7 username              # 最小天数
sudo chage -M 90 username             # 最大天数
sudo chage -W 14 username             # 警告天数
sudo chage -I 30 username             # 过期宽限期

# 交互式修改
sudo chage username

查看用户信息

# 查看当前用户
whoami                    # 显示用户名
id                        # 显示UID、GID和所属组
id username               # 查看指定用户信息

# 查看已登录用户
who                       # 当前登录用户
w                         # 详细信息
who -a                    # 所有用户
last                      # 登录历史
lastlog                   # 所有账户最后登录
lastb                     # 失败的登录尝试

用户组管理

组配置文件

# /etc/group 格式
# 组名:组密码:GID:成员列表

$ cat /etc/group
root:x:0:
adm:x:4:user,syslog
cdrom:x:24:user
sudo:x:27:user1,user2
www-data:x:33:
user:x:1000:
docker:x:998:user

组管理命令

groupadd - 创建组

# 创建新组
sudo groupadd developers

# 创建系统组（低GID）
sudo groupadd -r systemgroup

# 指定GID
sudo groupadd -g 1500 mygroup

groupmod - 修改组

# 重命名组
sudo groupmod -n newname oldname

# 更改GID
sudo groupmod -g 2000 mygroup

groupdel - 删除组

# 删除组（用户主组无法直接删除）
sudo groupdel mygroup

gpasswd - 组密码管理

# 设置组密码
sudo gpasswd groupname

# 添加成员
sudo gpasswd -a user groupname

# 删除成员
sudo gpasswd -d user groupname

# 设置管理员
sudo gpasswd -A adminuser groupname

groups - 查看用户组

# 查看当前用户所属组
groups

# 查看指定用户所属组
groups username

文件权限

权限概述

每个文件和目录都有三组权限：

┌─────────────────────────────────────────────────────────────┐
│                   文件权限结构                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   -rw-r--r--  1  user group  4096  Jan  4 10:00  file.txt   │
│   ││││││││                                                   │
│   │││││││└─ 其他用户权限 (others) r--                       │
│   ││││││└── 组权限 (group) r--                             │
│   │││││└─── 所有者权限 (owner) rw-                         │
│   ││││└──── 文件类型 (-)                                  │
│   │││└───── 执行权限数                                    │
│   ││└────── 写权限数                                      │
│   │└─────── 读权限数                                      │
│   └──────── 文件类型标识符                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

权限类型

权限	符号	数值	对文件含义	对目录含义
读 (Read)	`r`	4	可以读取文件内容	可以列出目录内容
写 (Write)	`w`	2	可以修改文件内容	可以在目录中创建/删除文件
执行 (Execute)	`x`	1	可以执行文件	可以进入目录并访问文件

权限组合

┌────────────────────────────────────────────────────────────┐
│                  权限数值组合                               │
├────────────────────────────────────────────────────────────┤
│                                                            │
│   rwx = 4 + 2 + 1 = 7   完全控制                           │
│   rw- = 4 + 2     = 6   读取和写入                         │
│   r-x = 4 + 1     = 5   读取和执行                         │
│   r-- = 4         = 4   只读                               │
│   -wx = 2 + 1     = 3   写入和执行                         │
│   -w- = 2         = 2   只写                               │
│   --x = 1         = 1   只执行                             │
│   --- = 0         = 0   无权限                             │
│                                                            │
└────────────────────────────────────────────────────────────┘

常用权限示例

权限	数值	用途
`777`	`rwxrwxrwx`	所有人完全控制（谨慎使用）
`755`	`rwxr-xr-x`	所有者完全控制，其他人读和执行
`750`	`rwxr-x---`	所有者完全控制，组读和执行
`700`	`rwx------`	所有者完全控制
`644`	`rw-r--r--`	所有者读写，其他人读
`600`	`rw-------`	所有者读写
`600`	`rw-------`	所有者读写（SSH密钥）
`400`	`r--------`	仅所有者读取（敏感文件）

chmod - 改变权限

符号模式

# 语法: chmod [who][+/-/=][权限] 文件

# who: u(用户) g(组) o(其他) a(所有)
# operator: +(添加) -(移除) =(设置)
# permissions: r(读) w(写) x(执行)

# 示例
chmod u+x script.sh              # 给所有者添加执行权限
chmod g-w file.txt               # 移除组的写权限
chmod o+r file.txt               # 给其他用户添加读权限
chmod a+x script.sh              # 给所有人添加执行权限

# 组合
chmod u+rwx,g+rx,o+r file       # 所有者rwx，组rx，其他人r
chmod u=rwx,g=rx,o=r file       # 精确设置

# 移除所有权限
chmod a-rwx file                 # 移除所有权限

数字模式

# 八进制数字设置权限
chmod 755 file                   # rwxr-xr-x
chmod 644 file                   # rw-r--r--
chmod 700 file                   # rwx------
chmod 600 file                   # rw-------

# 目录递归设置
chmod -R 755 directory/          # 递归设置目录及子文件

# 保留目录执行权限
chmod -R u+rwX,go+rX directory/ # 大写X只给目录加执行权限

特殊权限

SUID (Set User ID)

当文件设置了SUID位，执行该文件时会以文件所有者的身份运行。

# SUID显示为所有者执行位的s
$ ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root 52K Jan 15  2024 /usr/bin/passwd
#                        ^ 所有者有s表示有SUID

# 设置SUID
chmod u+s file
chmod 4755 file                  # 4表示SUID

安全注意

SUID可能造成安全风险，应谨慎使用。passwd等系统命令需要SUID权限才能修改/etc/shadow。

SGID (Set Group ID)

文件SGID：执行时以文件所属组身份运行目录SGID：新创建的文件继承目录的组

# SGID显示为组执行位的s
$ ls -ld /var/shared
drwxrwsr-x 2 root group 4096 Jan  4 10:00 /var/shared
#                         ^ 组有s表示有SGID

# 设置SGID
chmod g+s directory/
chmod 2755 directory/            # 2表示SGID

Sticky Bit

目录设置Sticky Bit后，只有文件所有者可以删除或重命名该目录下的文件。

# Sticky Bit显示为其他用户执行位的t
$ ls -ld /tmp
drwxrwxrwt 15 root root 4096 Jan  4 10:00 /tmp
#                        ^ t表示Sticky Bit

# 设置Sticky Bit
chmod +t /tmp
chmod 1777 /tmp                   # 1表示Sticky Bit

特殊权限数值

┌────────────────────────────────────────────────────────────┐
│                  特殊权限数值                              │
├────────────────────────────────────────────────────────────┤
│                                                            │
│   SUID = 4    (chmod 4755 file)                           │
│   SGID = 2    (chmod 2755 file)                           │
│   Sticky = 1  (chmod 1777 directory)                      │
│                                                            │
│   示例:                                                    │
│   chmod 4755 = SUID + rwxr-xr-x                            │
│   chmod 2755 = SGID + rwxr-xr-x                            │
│   chmod 6755 = SUID + SGID + rwxr-xr-x                     │
│   chmod 3775 = SGID + Sticky + rwxr-xr-x                   │
│                                                            │
└────────────────────────────────────────────────────────────┘

chown - 改变所有者

基本用法

# 改变文件所有者
sudo chown user file

# 改变文件所有者和组
sudo chown user:group file
sudo chown user.group file       # 同上
sudo chown :group file           # 只改变组

# 改变目录及内容（递归）
sudo chown -R user:group directory/

# 保持组继承
sudo chown -R user: directory/    # 使用冒号保持原组

# 改变符号链接（默认更改目标）
sudo chown -h user link           # 更改链接本身

示例

# 将web目录授权给www-data用户
sudo chown -R www-data:www-data /var/www/html

# 恢复root所有
sudo chown -R root:root /var/www/html

# 仅改变组
sudo chown :developers project/

# 更改文件所有者并设置权限
sudo chown user:user file && chmod 644 file

ACL - 访问控制列表

ACL提供了比传统权限更细粒度的控制。

查看ACL

# 查看文件ACL
getfacl file

# 输出示例
# file: file
# owner: user
# group: group
# user::rw-
# user:john:rw-
# group::r--
# group:developers:rw-
# mask::rw-
# other::r--

设置ACL

# 设置用户ACL
setfacl -m u:username:rx file         # 给用户设置读和执行
setfacl -m u:username:rw file        # 给用户设置读写

# 设置组ACL
setfacl -m g:groupname:rx directory/

# 设置默认ACL（目录继承）
setfacl -m d:u:username:rx directory/

# 设置mask
setfacl -m m:rw file

# 删除ACL
setfacl -x u:username file           # 删除用户ACL
setfacl -x g:groupname file          # 删除组ACL
setfacl -b file                       # 删除所有ACL

ACL权限计算

有效权限 = 最小(ACL规则权限, ACL mask)

如果mask是r--，即使用户ACL设置为rwx，
有效权限也只有r--

权限实战

Web服务器权限

# Apache/Nginx目录权限
sudo chown -R www-data:www-data /var/www/html
sudo find /var/www/html -type d -exec chmod 755 {} \;
sudo find /var/www/html -type f -exec chmod 644 {} \;

# 上传目录需要写权限
sudo chmod 775 /var/www/html/uploads
sudo chmod g+s /var/www/html/uploads   # 新文件继承组

SSH密钥权限

# 私钥权限
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_rsa
chmod 644 ~/.ssh/id_rsa.pub
chmod 600 ~/.ssh/authorized_keys

数据库目录权限

# MySQL
sudo chown -R mysql:mysql /var/lib/mysql
sudo chmod -R 755 /var/lib/mysql

# PostgreSQL
sudo chown -R postgres:postgres /var/lib/postgresql
sudo chmod -R 700 /var/lib/postgresql

sudo权限管理

visudo安全编辑

# 编辑sudoers文件
sudo visudo

# 语法检查（编辑后运行）
sudo visudo -c

sudoers配置示例

# 允许用户执行所有命令
username ALL=(ALL:ALL) ALL

# 允许用户无密码执行特定命令
username ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart apache2

# 允许组执行所有命令
%developers ALL=(ALL:ALL) ALL

# 允许sudo组（标准Debian/Ubuntu）
%sudo ALL=(ALL:ALL) ALL

# 允许用户从特定主机登录
username server1=(ALL:ALL) ALL

# 免密码sudo
username ALL=(ALL) NOPASSWD: ALL

安全建议

永远使用 visudo 编辑sudoers文件
使用特定的命令而不是ALL
避免使用NOPASSWD，除非必要

系统用户管理最佳实践

创建标准用户

# 1. 创建用户并设置基本属性
sudo useradd -m -s /bin/bash -G sudo,www-data,developers username

# 2. 设置密码
sudo passwd username

# 3. 配置sudo权限
sudo visudo
# 添加: username ALL=(ALL:ALL) ALL

# 4. 设置SSH访问（如需要）
mkdir /home/username/.ssh
chmod 700 /home/username/.ssh
chmod 600 /home/username/.ssh/authorized_keys
chown -R username:username /home/username/.ssh

用户审计

# 检查可疑登录
sudo lastlog | grep "Never"
sudo last -f /var/log/btmp

# 检查sudo使用
sudo cat /var/log/auth.log | grep sudo

# 检查谁使用sudo
sudo grep sudo /var/log/auth.log

课后练习

实践任务

创建一个新用户，设置完整信息并配置密码过期策略
创建一个开发组，将用户添加到该组
练习使用chmod和chown设置各种权限
尝试设置SUID、SGID和Sticky Bit权限
使用ACL为不同用户设置不同的文件访问权限
配置用户sudo权限并测试

下一篇预告：我们将学习Shell与命令行基础，掌握Linux命令行操作的核心技能。

Shell与命令行基础

Tue, 06 Jan 2026 00:00:00 +0000

Shell概述

什么是Shell？

Shell是Linux系统的命令解释器，它提供了用户与内核交互的界面。用户通过Shell输入命令，内核执行后返回结果。

┌─────────────────────────────────────────────────────────────┐
│                    Shell 工作原理                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   用户 ──→ Shell ──→ 内核 ──→ 硬件                          │
│              ↑         ↓                                    │
│              └──── 响应结果 ────┘                            │
│                                                             │
│   常见Shell类型:                                            │
│   ├── bash   - Bourne Again Shell (最常用)                  │
│   ├── zsh    - Z Shell (功能强大)                           │
│   ├── fish   - Friendly Interactive Shell (易用)           │
│   ├── sh     - Bourne Shell (POSIX标准)                     │
│   └── dash   - Debian Almquist Shell (快速)                │
│                                                             │
└─────────────────────────────────────────────────────────────┘

什么是Bash？

Bash (Bourne Again Shell) 是Linux最常用的Shell，提供了命令补全、历史记录、别名等功能。

# 查看当前使用的Shell
echo $SHELL
# 输出: /bin/bash

# 查看可用的Shell
cat /etc/shells
# 输出:
# /bin/sh
# /bin/bash
# /usr/bin/bash
# /bin/rbash
# /usr/bin/rbash
# /bin/zsh
# /usr/bin/zsh

# 切换Shell
chsh -s /bin/zsh

终端基础

终端快捷键

┌─────────────────────────────────────────────────────────────┐
│                   常用终端快捷键                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   【光标移动】                                              │
│   Ctrl + A / E          移动到行首/行尾                     │
│   Alt  + B / F          按单词移动                         │
│   Ctrl + ← / →          按单词移动（某些终端）              │
│                                                             │
│   【字符编辑】                                              │
│   Ctrl + U              删除光标前内容                     │
│   Ctrl + K              删除光标后内容                     │
│   Ctrl + W              删除光标前单词                      │
│   Alt  + D              删除光标后单词                      │
│   Ctrl + Y              粘贴刚才删除的内容                  │
│   Ctrl + T              交换光标前后字符                     │
│   Alt  + T              交换光标前后单词                     │
│                                                             │
│   【命令执行】                                              │
│   Ctrl + C              终止当前命令                        │
│   Ctrl + Z              挂起当前命令                        │
│   Ctrl + D              退出当前Shell/EOF                   │
│   Ctrl + L              清屏                                │
│   Ctrl + R              反向搜索历史                        │
│   Ctrl + S              暂停输出                            │
│   Ctrl + Q              恢复输出                            │
│                                                             │
│   【Tab补全】                                              │
│   Tab                   自动补全                            │
│   Tab  Tab              显示所有可能选项                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘

历史命令

# 查看历史记录
history

# 搜索历史命令
Ctrl + R                          # 反向搜索
(reverse-i-search)`':            # 输入搜索内容

# 执行历史命令
!n                                # 执行第n条命令
!!                                # 执行上一条命令
!-1                               # 执行上一条命令
!string                           # 执行最近以string开头的命令
!?string                          # 执行包含string的命令

# 历史展开
!$                                # 上条命令的最后一个参数
!^                                # 上条命令的第一个参数
!*                                # 上条命令的所有参数
!:n                               # 上条命令的第n个参数
!n:p                              # 显示但不执行第n条命令

# 历史管理
history -c                        # 清空历史
history -d 100                    # 删除第100条
HISTTIMEFORMAT="%Y-%m-%d %H:%M:%S "  # 添加时间戳

基础命令

echo - 输出文本

# 基本输出
echo "Hello, Linux!"
echo Hello World

# 转义字符
echo -e "Line1\nLine2"            # 换行
echo -e "Tab\tHere"               # 制表符
echo -e "Color \e[31mRed\e[0m"     # 彩色输出

# 输出到文件
echo "content" > file.txt         # 覆盖
echo "content" >> file.txt        # 追加

# 输出变量
echo $HOME
echo $PATH
echo "User: $USER, Home: $HOME"

# 不输出换行
echo -n "No newline"

printf - 格式化输出

# 格式化输出
printf "%s\n" "Hello"
printf "%d %s\n" 2026 "Linux"
printf "%-10s %-5d\n" Name 25

# 格式化说明符
%s    字符串
%d    整数
%f    浮点数
%x    十六进制
%o    八进制
%05d  补零整数
%8.2f 宽度8位小数2位

date - 日期时间

# 显示日期
date
date "+%Y-%m-%d %H:%M:%S"
date "+%Y%m%d_%H%M%S"

# 格式化选项
%Y    年 (2026)
%m    月 (01-12)
%d    日 (01-31)
%H    时 (00-23)
%M    分 (00-59)
%S    秒 (00-59)
%a    星期缩写 (Mon)
%A    星期全称 (Monday)
%j    年内天数 (001-366)
%U    年内周数

# 设置日期时间（需要root）
sudo date -s "2026-01-06 10:00:00"

# 计算日期
date -d "next Monday"
date -d "yesterday"
date -d "3 days ago"
date -d "+1 week"
date -d "+1 month"
date -d "2026-01-01 + 30 days"

环境变量

# 查看变量
echo $HOME
echo $USER
echo $PATH
echo $PWD
echo $SHELL
echo $LANG
echo $HOSTNAME

# 查看所有环境变量
printenv
env
set

# 设置变量（临时）
export VAR_NAME="value"
VAR_NAME="value"

# 永久设置（用户级）
vim ~/.bashrc
export PATH="$PATH:/new/path"
source ~/.bashrc

# 永久设置（系统级）
sudo vim /etc/environment

文件操作命令

cat - 查看文件

# 基本用法
cat file.txt                      # 显示文件内容
cat file1.txt file2.txt          # 合并显示
cat file1.txt > combined.txt     # 合并写入

# 行号显示
cat -n file.txt                  # 显示行号
cat -b file.txt                  # 非空行编号
cat -s file.txt                  # 多行空行压缩为一行

# 查看不可打印字符
cat -A file.txt                  # 显示Tab($)、行尾(^M$)

# 反向显示
tac file.txt                      # 从最后一行向前显示

less/more - 分页查看

# less - 强大的分页器
less file.txt
less -N file.txt                 # 显示行号
less -S file.txt                 # 行截断
less +/pattern file.txt          # 搜索并跳转到匹配

# less内部命令
/pattern       向下搜索
?pattern       向上搜索
n/N            下一个/上一个匹配
q              退出
g/G           跳转到行
Ctrl+F/B      向下/上滚动一屏
d/u           向下/上滚动半屏

# more - 简单分页
more file.txt
more -10 file.txt                # 每屏10行
more +20 file.txt                # 从第20行开始

head/tail - 文件头尾

# head - 显示文件开头
head file.txt                    # 默认10行
head -n 20 file.txt              # 指定行数
head -c 100 file.txt             # 指定字节数

# tail - 显示文件结尾
tail file.txt                    # 默认10行
tail -n 20 file.txt              # 指定行数
tail -f file.txt                 # 实时追踪文件更新
tail -F file.txt                 # 追踪重命名后的文件
tail -f /var/log/syslog         # 监控系统日志

# 组合使用
head -n 100 file.txt | tail -n 50  # 50-100行
sed -n '50,100p' file.txt           # 50-100行

wc - 统计

# 基本统计
wc file.txt                      # 行数 字数 字节数 文件名
wc -l file.txt                   # 只显示行数
wc -w file.txt                   # 只显示单词数
wc -c file.txt                   # 只显示字节数
wc -m file.txt                   # 只显示字符数

# 统计目录/文件
find . -type f -name "*.txt" | wc -l

管道与重定向

管道 (|)

管道将前一个命令的输出作为后一个命令的输入。

# 语法: command1 | command2 | command3

# 示例
ls -la /etc | grep nginx          # 查找nginx相关
cat /var/log/syslog | grep error  # 查找错误日志
ps aux | grep python              # 查找Python进程
ls -lh | sort -k5 -h              # 按文件大小排序
history | grep apt                # 查找apt历史

重定向

┌─────────────────────────────────────────────────────────────┐
│                    重定向符号                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   >          输出重定向（覆盖）                             │
│   >>         输出重定向（追加）                             │
│   <          输入重定向                                     │
│   << EOF    文本内嵌输入（here document)                   │
│   2>         错误重定向                                     │
│   &>         标准输出和错误重定向                           │
│   2>&1       错误重定向至标准输出                           │
│                                                             │
└─────────────────────────────────────────────────────────────┘

# 输出重定向
echo "Hello" > file.txt           # 覆盖
echo "World" >> file.txt          # 追加

# 输入重定向
wc -l < file.txt                 # 从文件读取输入

# 错误重定向
ls /nonexistent 2> error.txt     # 错误信息写入文件
ls /nonexistent 2>/dev/null      # 丢弃错误信息

# 同时重定向
command > output.txt 2>&1        # 标准输出和错误都保存
command &> all.txt               # 同上（更简洁）

# here document
cat << EOF > file.txt
第一行内容
第二行内容
变量: $HOME
EOF

# here string
cat <<< "string input"

tee - 同时输出到文件和屏幕

# 基本用法
echo "content" | tee file.txt

# 追加模式
echo "more" | tee -a file.txt

# 管道中复制
command1 | tee file.txt | command2

文本处理基础

grep - 文本搜索

# 基本搜索
grep "pattern" file.txt

# 选项
grep -i "pattern" file.txt       # 忽略大小写
grep -r "pattern" directory/      # 递归搜索
grep -n "pattern" file.txt       # 显示行号
grep -c "pattern" file.txt       # 计数
grep -v "pattern" file.txt       # 反向匹配
grep -l "pattern" *.txt          # 只显示文件名
grep -o "pattern" file.txt       # 只显示匹配部分

# 正则表达式
grep "^root" /etc/passwd         # 行首匹配
grep "bash$" /etc/passwd         # 行尾匹配
grep "roo." /etc/passwd           # 任意单字符
grep "ro*" /etc/passwd            # 零或多个o
grep "ro\{2\}" /etc/passwd        # 恰好2个o

# 扩展正则
grep -E "root|admin" file.txt    # 或匹配
grep -E "ro+t" file.txt          # 一个或多个o
grep -E "ro?t" file.txt          # 零或一个o

# 多个模式
grep -e "pattern1" -e "pattern2" file.txt
grep -E "pattern1|pattern2" file.txt
grep "pattern1\|pattern2" file.txt

sed - 文本流编辑器

# 基本语法
sed [options] 'command' file

# 替换
sed 's/old/new/' file.txt         # 替换每行第一个
sed 's/old/new/g' file.txt       # 替换所有
sed 's/old/new/2' file.txt        # 每行第二个
sed 's/old/new/gi' file.txt      # 忽略大小写

# 替换并保存
sed -i 's/old/new/g' file.txt    # 直接修改文件
sed -i.bak 's/old/new/g' file.txt # 备份后修改

# 地址定位
sed '1s/old/new/' file.txt       # 第1行
sed '$s/old/new/' file.txt       # 最后一行
sed '1,5s/old/new/g' file.txt    # 1-5行
sed '/pattern/s/old/new/g' file.txt # 匹配行
sed '5,/pattern/s/old/new/g' file.txt # 5行到匹配行

# 多命令
sed -e 's/old1/new1/' -e 's/old2/new2/' file.txt

# 删除
sed '/pattern/d' file.txt        # 删除匹配行
sed '1,5d' file.txt              # 删除1-5行
sed '/^$/d' file.txt             # 删除空行

# 打印
sed -n '5p' file.txt             # 打印第5行
sed -n '1,10p' file.txt          # 打印1-10行
sed -n '/pattern/p' file.txt    # 打印匹配行

awk - 文本分析工具

# 基本语法
awk 'pattern {action}' file

# 打印列
awk '{print $1}' file.txt        # 打印第1列
awk '{print $1,$3}' file.txt     # 打印1、3列
awk '{print $NF}' file.txt       # 打印最后一列
awk '{print $(NF-1)}' file.txt   # 打印倒数第二列

# 分隔符
awk -F: '{print $1}' /etc/passwd # 以:分隔
awk -F'[, ]' '{print $2}' file   # 多分隔符

# 内置变量
NR    当前记录数（行号）
NF    当前记录字段数
$0    整行内容
$1-$n 各列内容
FS    字段分隔符
OFS   输出字段分隔符

# 条件
awk '/pattern/ {print $1}' file.txt
awk '$3 > 100 {print $0}' file.txt
awk 'NR==5 {print $0}' file.txt
awk 'NR>=5 && NR<=10 {print}' file.txt

# 计算
awk '{sum+=$2} END {print sum}' file.txt
awk '{count++} END {print count}' file.txt

# BEGIN/END
awk 'BEGIN {print "Start"} {print} END {print "End"}' file.txt

cut - 剪切列

# 剪切字符
cut -c 1-10 file.txt             # 1-10字符
cut -c 1,3,5 file.txt            # 1,3,5字符
cut -c -10 file.txt             # 前10字符
cut -c 10- file.txt             # 10字符之后

# 剪切字段
cut -d: -f1 /etc/passwd          # 以:分隔，取第1字段
cut -d' ' -f1-3 file.txt        # 以空格分隔，取1-3字段
cut -d: -f1,3 /etc/passwd        # 取1,3字段

# 配合管道
echo $PATH | tr ':' '\n' | cut -d/ -f3-

其他常用命令

sort - 排序

# 基本排序
sort file.txt                    # 默认按ASCII排序
sort -r file.txt                 # 反向排序
sort -u file.txt                 # 去重排序

# 数值排序
sort -n numbers.txt             # 数值排序
sort -h sizes.txt                # 人类可读数字（1K, 2M）
sort -n -r file.txt             # 降序数值

# 按字段排序
sort -t: -k3 -n /etc/passwd     # 以:分隔，按第3字段排序

# 其他选项
sort -f file.txt                # 忽略大小写
sort -R file.txt                # 随机排序
sort -o output.txt input.txt    # 结果写入文件

uniq - 去重

# 基本用法
uniq file.txt                   # 去重相邻行
sort file.txt | uniq            # 先排序再去重

# 统计
uniq -c file.txt                # 显示重复次数
uniq -d file.txt                # 只显示重复行
uniq -u file.txt                # 只显示不重复行

# 比较字段
uniq -f 1 file.txt              # 跳过前1字段比较
uniq -w 10 file.txt             # 只比较前10字符

tr - 字符转换

# 基本替换
echo "hello" | tr 'a-z' 'A-Z'    # 转大写
echo "HELLO" | tr 'A-Z' 'a-z'    # 转小写

# 删除字符
echo "hello123" | tr -d '0-9'    # 删除数字
echo "hello" | tr -d 'aeiou'     # 删除元音

# 压缩字符
echo "hellooo" | tr -s 'o'       # 压缩重复o
echo "a    b  c" | tr -s ' '     # 压缩空格

# 字符集
tr '[:lower:]' '[:upper:]'
tr '[:digit:]' 'N'

xargs - 参数构建

# 基本用法
echo "file1 file2 file3" | xargs rm

# 逐行处理
cat files.txt | xargs -I {} cp {} /backup/

# 指定分隔符
echo "file1,file2,file3" | xargs -d ',' cp -t /backup/

# 并行执行
echo "1 2 3 4" | xargs -n1 -P4 command

# 组合命令
find . -name "*.log" | xargs rm -f
ls *.txt | xargs -I {} gzip {}

dirname/basename - 路径处理

# 获取目录名
dirname /home/user/docs/file.txt
# 输出: /home/user/docs

# 获取文件名
basename /home/user/docs/file.txt
# 输出: file.txt

# 去除扩展名
basename /home/user/file.txt .txt
# 输出: file

# 组合使用
for f in *.txt; do
    dir=$(dirname "$f")
    base=$(basename "$f")
    echo "Dir: $dir, File: $base"
done

命令组合技巧

&& 和 ||

# && - 前一个成功才执行后一个
cd /tmp && rm *.tmp

# || - 前一个失败才执行后一个
cd /tmp || echo "Cannot cd to /tmp"

# 组合
cd /tmp && rm *.tmp || echo "No .tmp files or error"

命令替换

# $() 方式（推荐）
current_date=$(date +%Y%m%d)
files=$(ls -1)

# `` 方式（兼容老版本）
current_date=`date +%Y%m%d`

# 在命令中使用
cp file.txt "backup_$(date +%Y%m%d).txt"
tar czf "backup_$(hostname)_$(date +%F).tar.gz" /home

算术运算

# expr
result=$(expr 10 + 5)
result=$(expr 10 \* 5)           # 乘法需转义

# $[]
result=$[10 + 5]
result=$[10 * 5]

# let
let "result = 10 + 5"
let "result = $1 * $2"

# bc（浮点数）
echo "scale=2; 10 / 3" | bc
echo "sqrt(100)" | bc -l

命令序列

# 分号分隔，无视成功与否
cd /tmp; ls; cd ~

# 大括号，需在同一行
{ cd /tmp; ls; } > output.txt

# 子Shell
(cd /tmp && rm *.tmp)           # 不影响当前目录

课后练习

实践任务

练习使用各种终端快捷键（特别是Ctrl+R历史搜索）
创建一个带时间戳的备份脚本：backup_$(date +%Y%m%d).tar.gz
使用管道组合命令分析 /var/log/syslog
练习sed替换、awk统计功能
用grep配合正则表达式查找passwd文件中的用户信息
创建一个命令行别名：alias ll='ls -lah'

下一篇预告：我们将学习文本处理三剑客——grep、sed、awk的进阶用法。

文本处理三剑客

Wed, 07 Jan 2026 00:00:00 +0000

文本处理工具概述

Linux的文本处理三剑客（grep、sed、awk）是系统管理中最强大的工具。掌握它们可以高效完成日志分析、文本处理、数据提取等任务。

┌─────────────────────────────────────────────────────────────┐
│                  文本处理三剑客                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   grep  ─── 文本搜索，模式匹配                              │
│   ├── 功能: 查找字符串                                      │
│   ├── 擅长: 正则表达式匹配、文本过滤                        │
│   └── 家族: grep, egrep, fgrep, zgrep                      │
│                                                             │
│   sed   ─── 流编辑器，增删改查                              │
│   ├── 功能: 文本替换、修改、删除                             │
│   ├── 擅长: 批量替换、按行处理                              │
│   └── 特点: 非交互式编辑，自动处理                          │
│                                                             │
│   awk   ─── 报告生成器，数据提取                            │
│   ├── 功能: 模式扫描、字段处理                              │
│   ├── 擅长: 格式化输出、报表生成                            │
│   └── 特点: 完整的编程语言                                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

grep 高级用法

正则表达式基础

# 字符类
[abc]       匹配 a、b 或 c
[^abc]      匹配除了 a、b、c 之外的字符
[a-z]       匹配小写字母
[A-Z]       匹配大写字母
[0-9]       匹配数字

# 预定义字符类
[:alpha:]   字母
[:digit:]   数字
[:alnum:]   字母和数字
[:space:]   空白字符
[:upper:]   大写字母
[:lower:]   小写字母

# 量词
*           零个或多个
+           一个或多个
?           零个或一个
{n}         恰好n个
{n,}        n个或更多
{n,m}       n到m个

# 位置锚点
^           行首
$           行尾
\<          词首
\>          词尾
\b          词边界

# 特殊字符
.           任意单个字符
|           或
()          分组
\           转义

grep选项详解

# 基本选项
-i, --ignore-case         # 忽略大小写
-v, --invert-match        # 反向匹配
-n, --line-number         # 显示行号
-c, --count               # 计数匹配行
-l, --files-with-matches  # 只显示文件名
-L, --files-without-match # 显示不匹配的文件名
-h, --no-filename         # 不显示文件名
-H, --with-filename       # 显示文件名（默认）
-o, --only-matching       # 只显示匹配部分
-b, --byte-offset         # 显示字节偏移
-A, --after-context=N     # 显示匹配后N行
-B, --before-context=N    # 显示匹配前N行
-C, --context=N           # 显示前后N行

# 正则选项
-E, --extended-regexp    # 扩展正则
-G, --basic-regexp       # 基本正则（默认）
-P, --perl-regexp        # Perl正则
-F, --fixed-strings       # 固定字符串（非正则）
-f, --file=FILE           # 从文件读取模式

# 其他选项
-e, --regexp=PATTERN     # 指定多个模式
-w, --word-regexp         # 整词匹配
-x, --line-regexp         # 整行匹配
-q, --quiet, --silent      # 静默模式
--color=auto              # 颜色高亮
-r, -R, --recursive       # 递归搜索

grep实战案例

# 1. 日志分析
# 查找错误日志
grep -i "error" /var/log/syslog
grep -E "error|warning|critical" /var/log/syslog

# 排除某些行
grep "error" /var/log/syslog | grep -v "debug"

# 统计错误数量
grep -c "error" /var/log/syslog

# 2. 配置文件分析
# 查找注释和空行
grep -v '^#' /etc/nginx/nginx.conf | grep -v '^$'

# 查找生效的配置
grep -E '^[^#]*' /etc/nginx/nginx.conf

# 3. IP地址提取
grep -oE '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' access.log

# 4. 进程分析
ps aux | grep nginx | grep -v grep
ps -ef | grep "[n]ginx"

# 5. 用户分析
grep -E "^root:|^admin:" /etc/passwd
grep -E "bash$|sh$" /etc/passwd

# 6. URL提取
grep -oE 'https?://[^[:space:]]+' access.log

# 7. 邮件地址提取
grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' emails.txt

# 8. 日期时间匹配
grep -E '[0-9]{4}-[0-9]{2}-[0-9]{2}' logs.txt
grep -E '[0-9]{2}:[0-9]{2}:[0-9]{2}' logs.txt

grep与管道配合

# 监控日志
tail -f /var/log/syslog | grep --line-buffered "error"

# 分析命令输出
df -h | grep -E "^/dev"

# 组合多个条件
ps aux | grep python | grep -v grep | awk '{print $2}'

# 去重计数
cat access.log | grep "200" | awk '{print $7}' | sort | uniq -c | sort -rn

grep家族

# grep - 基本正则
grep "pattern" file

# egrep / grep -E - 扩展正则
egrep "pattern1|pattern2" file
grep -E "one|two|three" file

# fgrep / grep -F - 固定字符串（更快）
fgrep "exact.string" file
grep -F "exact.string" file

# zgrep - 压缩文件搜索
zgrep "pattern" file.gz

# agrep - 近似匹配
agrep "patter" file

sed 高级用法

sed工作原理

┌─────────────────────────────────────────────────────────────┐
│                    sed 工作流程                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   输入文件 ──→ 读取一行 ──→ 执行命令 ──→ 输出行 ──→ 下一行  │
│                                                             │
│   默认行为: 输入行会原样输出到屏幕，处理的行会变化           │
│   -n 禁用自动输出，配合p显示                                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

sed命令详解

# 替换命令 s
s/old/new/           # 替换第一个匹配
s/old/new/g          # 全局替换
s/old/new/2          # 每行第二个匹配
s/old/new/I          # 忽略大小写
s/old/new/gi         # 全局忽略大小写

# 分隔符选择（当替换内容含/时）
s|/old/path|/new/path|g
s#old#new#g

# 替换修饰符
s/old/new/p          # 打印替换后的行
s/old/new/w file     # 写入到文件
s/old/new/e          # 执行命令（GNU sed）

# 其他命令
d                    # 删除
p                    # 打印
a\text               # 追加文本
i\text               # 插入文本
c\text               # 替换整行
r file               # 读取文件
w file               # 写入文件
y/old/new/           # 字符转换
q                    # 退出
n/N                  # 下一行
}                    # 命令组结束

# 分支和测试
b label              # 跳转到标签
t label              # 测试替换成功则跳转

# hold和pattern空间
h/H                  # 复制/追加到hold
g/G                  # 复制/追加到pattern
x                    # 交换空间

sed地址模式

# 无地址 - 处理所有行
sed 's/old/new/' file

# 单地址 - 处理指定行
sed '5s/old/new/' file         # 第5行
sed '5!s/old/new/' file       # 除了第5行

# 地址范围
sed '1,10s/old/new/' file     # 1-10行
sed '10,$s/old/new/' file     # 10行到最后

# 正则匹配地址
sed '/pattern/s/old/new/' file     # 匹配的行
sed '/pattern/!s/old/new/' file    # 不匹配的行

# 步进
sed '~2s/old/new/' file       # 从第2行开始，每隔1行
sed '1~2s/old/new/' file      # 奇数行

# 组合
sed '1,/pattern/s/old/new/' file
sed '1,/pattern/{s/old/new/;s/old2/new2/}' file

sed实战案例

# 1. 文本替换
# 基本替换
sed 's/foo/bar/' file.txt

# 全局替换
sed 's/foo/bar/g' file.txt

# 多重替换
sed -e 's/foo/bar/g' -e 's/baz/qux/g' file.txt

# 2. 删除操作
# 删除空行
sed '/^$/d' file.txt

# 删除注释
sed '/^#/d' config.txt
sed '/^[[:space:]]*#/d' config.txt    # 含空格的注释

# 删除特定行
sed '5d' file.txt                     # 删除第5行
sed '1,3d' file.txt                   # 删除1-3行
sed '/pattern/d' file.txt             # 删除匹配行

# 3. 插入和追加
# 在第5行前插入
sed '5i\Inserted line' file.txt

# 在第5行后追加
sed '5a\Appended line' file.txt

# 在匹配行前插入
sed '/pattern/i\Before line' file.txt

# 在匹配行后追加
sed '/pattern/a\After line' file.txt

# 4. 替换整行
sed '/pattern/c\Replacement line' file.txt

# 5. 打印操作
sed -n '5p' file.txt                  # 只打印第5行
sed -n '1,10p' file.txt              # 打印1-10行
sed -n '/pattern/p' file.txt         # 只打印匹配行
sed -n '10q;p' file.txt              # 打印前10行

# 6. 大小写转换（GNU sed）
sed 's/[a-z]/\U&/g' file.txt         # 转大写
sed 's/[A-Z]/\L&/g' file.txt         # 转小写
sed '1,10s/\b\(.\)/\U\1/g' file.txt # 首字母大写

# 7. 字段操作
sed 's/\t/,/g' file.txt              # Tab转逗号
sed 's/ /_/g' file.txt               # 空格转下划线

# 8. 备份并修改
sed -i.bak 's/old/new/g' file.txt
sed -i~ 's/old/new/g' file.txt       # 备份为file.txt~

# 9. 读取和写入
sed '5r /etc/hosts' file.txt         # 在第5行后插入hosts内容
sed '1w newfile.txt' file.txt        # 写入第1行到新文件
sed -n 'w output.txt' file.txt      # 写入所有到新文件

# 10. 多行处理
sed 'N;s/foo\nbar/baz/;P;D' file.txt  # 合并两行处理

sed高级技巧

# 反向行
sed '1!G;h;$!d' file.txt

# 行号添加
sed = file.txt | sed 'N;s/\n/\t/'

# 提取奇偶行
sed 'n;d' file.txt                   # 奇数行
sed '1d;n;d' file.txt               # 偶数行

# 交换行
sed -e '1!G;h;$!d' file.txt

# 单词首字母大写
sed 's/\b\(.\)/\u\1/g' file.txt

# 四则运算
echo "10+5" | sed 's/+/ + /' | bc

# 提取子串
echo "abc123def" | sed 's/.*\([0-9]\+\).*/\1/'

# 循环处理
sed ':a;N;$!ba;s/\n/ /g' file.txt   # 所有行合并为一行

awk 高级用法

awk工作原理

┌─────────────────────────────────────────────────────────────┐
│                    awk 工作流程                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   BEGIN { 初始化 }                                          │
│         ↓                                                   │
│   ┌─────────────────────────────────────────┐               │
│   │  逐行读取文件                             │               │
│   │  分解为字段 $1, $2, ..., $NF              │               │
│   │  依次匹配模式                             │               │
│   │  执行匹配模式对应的动作                   │               │
│   └─────────────────────────────────────────┘               │
│         ↓                                                   │
│   END { 收尾处理 }                                           │
│                                                             │
└─────────────────────────────────────────────────────────────┘

awk内置变量

# 记录和字段变量
$0              当前整行
$1-$n           各字段
NF              当前行字段数
NR              当前记录号（行号）
FNR             当前文件记录号
ARGC            命令行参数数量
ARGV            命令行参数数组

# 文件和字段分隔符
FS              输入字段分隔符（默认空格）
OFS             输出字段分隔符（默认空格）
ORS             输出记录分隔符（默认换行）
RS              输入记录分隔符（默认换行）
RT              记录终止符

# 路径信息
FILENAME        当前输入文件名
SUBSEP          数组下标分隔符

# 数值格式化
OFMT            数字输出格式（默认%.6g）
CONVFMT         数字转换格式（默认%.6g）

awk格式化输出

# print语句
awk '{print $1, $2}' file.txt        # 空格分隔
awk '{print $1 "\t" $2}' file.txt  # Tab分隔
awk '{print $1, $2, $3}' file.txt   # 逗号分隔

# printf语句（可格式化）
awk '{printf "%-10s %5d\n", $1, $2}' file.txt

# printf格式符
%s      字符串
%d      十进制整数
%f      浮点数
%x      十六进制
%o      八进制
%e      科学计数法
%5d     右对齐宽度5
%-5d    左对齐宽度5
%05d    补零宽度5
%6.2f   宽度6小数2位

awk模式和动作

# 空模式 - 匹配所有行
awk '{print $0}' file.txt

# 正则模式
awk '/pattern/' file.txt
awk '$3 ~ /regex/' file.txt         # 字段匹配
awk '$3 !~ /regex/' file.txt        # 字段不匹配

# 比较模式
awk '$3 > 100' file.txt
awk '$1 == "exact"' file.txt
awk '$2 != "value"' file.txt

# 逻辑模式
awk '$3 > 50 && $4 < 100' file.txt
awk '$2 == "A" || $2 == "B"' file.txt
awk 'NR == 5' file.txt
awk 'NR >= 5 && NR <= 10' file.txt

# 范围模式
awk '/start/,/end/' file.txt
awk 'NR==1,/pattern/' file.txt

# BEGIN/END
awk 'BEGIN {print "Start"} {print} END {print "End"}' file.txt

awk数组

# 基本数组
awk '{arr[$1]++} END {for (i in arr) print i, arr[i]}' file.txt

# 关联数组
awk '{
    if (!($2 in seen)) {
        seen[$2] = 1
        print $2
    }
}' file.txt

# 二维数组（模拟）
awk '{
    arr[$1,$2] = $3
} END {
    for (i in arr) {
        split(i, tmp, SUBSEP)
        print tmp[1], tmp[2], arr[i]
    }
}' file.txt

# 删除数组元素
delete arr[$1]
delete arr

# 数组函数
length(arr)          # 数组长度
sort(arr)            # 排序（数值索引）
asort(arr)           # 排序值
split(string, arr, sep)  # 字符串分割

awk函数

# 字符串函数
length(str)              # 字符串长度
split(str, arr, sep)     # 分割字符串
substr(str, start, len)  # 提取子串
index(str, substr)       # 子串位置
match(str, regex)        # 正则匹配
sub(regex, repl, str)     # 替换第一个
gsub(regex, repl, str)   # 全局替换
tolower(str)             # 转小写
toupper(str)             # 转大写
sprintf(fmt, ...)        # 格式化

# 数学函数
sin(x), cos(x), sqrt(x)
int(x), rand(), srand(x)
exp(x), log(x), log10(x)

# 时间函数
systime()                # Unix时间戳
strftime(fmt, time)      # 格式化时间

# 用户自定义函数
awk 'function add(a, b) { return a + b }
     {print add($1, $2)}' file.txt

awk实战案例

# 1. 日志分析
# 统计访问量
awk '{print $7}' access.log | sort | uniq -c | sort -rn | head -20

# 统计HTTP状态码
awk '{print $9}' access.log | sort | uniq -c

# 计算流量
awk '{sum+=$10} END {print sum/1024/1024 " MB"}' access.log

# 2. 数据统计
# 求和
awk '{sum+=$2} END {print sum}' data.txt

# 平均值
awk '{sum+=$2; count++} END {print sum/count}' data.txt

# 最大最小值
awk 'BEGIN {max=0} {if($2>max) max=$2} END {print max}' data.txt

# 3. 文本处理
# 列求和
awk -F',' '{sum+=$3} END {print sum}' data.csv

# 字段重新排版
awk -F: '{printf "%-15s %-10s %s\n", $1, $5, $7}' /etc/passwd

# 4. 条件统计
# 统计满足条件的行
awk '$3 > 100 {count++} END {print count}' data.txt

# 分组统计
awk '{count[$1]++} END {for (g in count) print g, count[g]}' data.txt

# 5. 数据验证
# 检查空行
awk 'NF==0 {count++} END {print "Empty lines:", count}' file.txt

# 检查重复
awk 'seen[$0]++ {print "Duplicate:", $0}' file.txt

# 6. 文件处理
# 合并文件
awk 'FNR==1 && NR!=1 {next} {print}' file1.txt file2.txt

# 跨行处理
awk 'BEGIN{RS=""} {print $1, $NF}' file.txt

# 7. 报表生成
awk 'BEGIN {
    print "==========================="
    print "       Sales Report"
    print "==========================="
    printf "%-20s %10s %10s\n", "Product", "Qty", "Amount"
    print "---------------------------"
}
{sum[$1]+=$2*$3}
END {
    for (p in sum) {
        printf "%-20s %10d %10.2f\n", p, count[p], sum[p]
    }
}' sales.txt

三剑客组合使用

管道组合

# 日志分析综合
cat access.log | \
    grep "2026-01-06" | \
    awk '$9 == 200 {ips[$1]++} END {for (i in ips) print i, ips[i]}' | \
    sort -k2 -rn | \
    head -10

# 系统状态分析
ps aux | \
    grep -v grep | \
    awk '/nginx/ {cpu[$2]=$3; mem[$2]=$4} END {for(p in cpu) print p, cpu[p]"%", mem[p]"%"}'

# 文件内容处理
cat data.csv | \
    grep -v "^#" | \
    awk -F, '$3 > 100 {print $1","$2","$3}' | \
    sort -t, -k3 -n

脚本实例

#!/bin/bash
# 日志分析脚本

LOG_FILE=${1:-/var/log/syslog}
OUTPUT_DIR="./report"

mkdir -p "$OUTPUT_DIR"

# 1. 统计错误级别
echo "=== Error Level Statistics ===" > "$OUTPUT_DIR/stats.txt"
grep -i "error\|critical\|alert\|emerg" "$LOG_FILE" | \
    awk '{print $5}' | sort | uniq -c | sort -rn >> "$OUTPUT_DIR/stats.txt"

# 2. 统计IP访问量
echo -e "\n=== Top 20 IPs ===" >> "$OUTPUT_DIR/stats.txt"
awk '{print $1}' "$LOG_FILE" | sort | uniq -c | sort -rn | head -20 >> "$OUTPUT_DIR/stats.txt"

# 3. 统计访问路径
echo -e "\n=== Top 20 Pages ===" >> "$OUTPUT_DIR/stats.txt"
awk '{print $7}' "$LOG_FILE" | sort | uniq -c | sort -rn | head -20 >> "$OUTPUT_DIR/stats.txt"

echo "Report generated: $OUTPUT_DIR/stats.txt"

课后练习

实践任务

使用grep正则提取 /etc/passwd 中的用户名和Shell
用sed批量替换配置文件中的旧IP为新IP
用awk统计 Apache/Nginx 访问日志的各状态码数量
编写脚本分析系统日志，找出错误和警告
用三剑客组合从日志中提取并统计访问最多的URL

下一篇预告：我们将学习进程与服务管理，掌握Linux系统监控和控制技能。

进程与服务管理

Thu, 08 Jan 2026 00:00:00 +0000

进程基础

什么是进程？

进程是运行中的程序实例，是Linux系统资源分配的基本单位。每个进程都有一个唯一的PID（进程ID）。

┌─────────────────────────────────────────────────────────────┐
│                    进程与程序                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   程序 ──→ 静态代码文件，存储在磁盘上                        │
│             例: /bin/bash, /usr/bin/nginx                   │
│                                                             │
│   进程 ──→ 动态运行的实例，内存中执行                        │
│             例: PID 1234, 分配CPU时间、内存                  │
│                                                             │
│   线程 ──→ 进程内的执行单元，共享进程资源                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘

进程类型

类型	说明	特性
前台进程	与终端关联，占用终端	可交互
后台进程	不占用终端，启动时加 `&`	不可交互
守护进程(Daemon)	系统服务，脱离终端运行	自动启动
僵尸进程(Zombie)	进程已终止但未回收	占用PID
孤儿进程(Orphan)	父进程退出，子进程被init收养	正常运行

进程状态

┌─────────────────────────────────────────────────────────────┐
│                    进程状态转换                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   新建 → 就绪 → 运行 → 阻塞 → 终止                           │
│              ↑       ↓       ↓                              │
│              └──←────┘       ↓                              │
│                            → 僵尸                           │
│                                                             │
│   状态码:                                                   │
│   R - 运行中（Running/Runnable）                            │
│   S - 可中断睡眠（Interruptible Sleep）                      │
│   D - 不可中断睡眠（Uninterruptible Sleep）                  │
│   Z - 僵尸（Zombie）                                        │
│   T - 停止（Stopped/Traced）                                │
│   X - 死亡（Dead）                                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

进程查看命令

ps - 进程快照

# BSD风格
ps aux                           # 显示所有进程（含其他用户）
ps -ef                           # 标准格式显示
ps -eLf                          # 显示线程
ps -eo pid,ppid,user,%cpu,%mem,cmd  # 自定义列

# Unix风格
ps -p 1234                       # 查看指定PID
ps --ppid 1234                   # 查看指定进程的子进程
ps -U username                   # 查看用户进程
ps -G groupname                  # 查看组进程

# 常用组合
ps aux | grep nginx              # 查找nginx进程
ps -ef | grep "[p]ython"         # 排除grep自身
ps --sort=-%cpu | head           # 按CPU排序
ps --sort=-%mem | head           # 按内存排序

# 树形显示
ps -ef --forest                  # 显示进程树
pstree                           # 树形显示（需安装psmisc）
pstree -p                        # 显示PID
pstree -u username              # 显示用户进程树

top/htop - 动态监控

# top - 实时进程监控
top                              # 启动top
top -d 5                         # 每5秒刷新
top -p 1234                      # 监控指定PID
top -u username                  # 只显示用户进程
top -b -n 10 > top.log           # 批处理模式输出

# top快捷键
h/?          帮助
q            退出
z            彩色显示
x/y          高亮排序列/字段
P            按CPU排序
M            按内存排序
T            按时间排序
k            终止进程
r            重新设置优先级
u            过滤用户
n            设置显示进程数
l            显示/隐藏负载
t/m          显示/隐藏CPU/内存
1            显示所有CPU核心
W            保存配置

# htop - 更友好的监控（需安装）
sudo apt install htop

htop                               # 启动
htop -d 10                        # 10秒刷新
htop -u username                  # 过滤用户
htop -p 1234,5678                # 监控指定PID

# htop快捷键
F1-?      帮助
F2       设置
F3       搜索进程
F4       过滤
F5       树形显示
F6       排序
F7/F8    降低/提高优先级
F9       发送信号
F10      退出

# htop配色方案
htop -t                          # 显示进程树
htop -s MEM                      # 按内存排序启动

其他进程命令

# pgrep - 按名称搜索进程
pgrep nginx                      # 返回PID
pgrep -l nginx                   # 显示名称
pgrep -u root nginx              # root用户的nginx进程
pgrep -f "nginx.*8080"           # 匹配完整命令行

# pidof - 获取进程PID
pidof nginx                      # 精确匹配程序名
pidof -s nginx                   # 只返回一个PID
pidof -x script.sh              # 查找脚本进程

# pkill - 按名终止进程
pkill nginx                      # 终止所有nginx
pkill -u user nginx              # 终止用户的nginx
pkill -9 nginx                   # 强制终止
pkill -f "python.*server"       # 匹配命令行

# killall - 按名终止所有进程
killall nginx
killall -i nginx                 # 交互确认
killall -9 nginx                 # 强制终止
killall -u user nginx            # 终止用户进程
killall --older-than 1h nginx   # 终止1小时前的进程

进程控制

发送信号

# 常用信号
kill -l                          # 列出所有信号

# 信号列表
1) SIGHUP       挂起，重读配置
2) SIGINT       中断（Ctrl+C）
3) SIGQUIT      退出（Ctrl+\）
9) SIGKILL      强制终止
15) SIGTERM     优雅终止（默认）
18) SIGCONT     继续运行
19) SIGSTOP     暂停
20) SIGTSTP     挂起（Ctrl+Z）

# 使用示例
kill 1234                        # 发送TERM信号
kill -9 1234                     # 强制终止
kill -SIGTERM 1234               # 使用名称
kill -s TERM 1234                # 同上
kill -l 15                       # 查看信号15名称

作业控制

# 后台运行
command &                        # 后台运行
nohup command &                  # 忽略挂起信号
nohup command > output.log &     # 输出重定向

# jobs - 查看作业
jobs                              # 列出所有作业
jobs -l                          # 显示PID
jobs -p                          # 只显示PGID
jobs -r                          # 只显示运行的
jobs -s                          # 只显示停止的

# fg/bg - 前后台切换
fg                               # 恢复最近后台作业
fg %1                            # 恢复作业1
fg %nginx                        # 恢复包含nginx的作业
bg                               # 让停止的作业在后台继续
bg %2                            # 后台运行作业2

# Ctrl+Z - 挂起当前作业
Ctrl+Z                           # 挂起当前作业

nohup与screen

# nohup - 持久运行
nohup ./script.sh &                   # 后台运行
nohup ./script.sh > output.log 2>&1 & # 重定向输出
echo "password" | nohup command &      # 提供输入

# screen - 虚拟终端
sudo apt install screen

screen -S mysession              # 创建命名会话
screen -ls                      # 列出所有会话
screen -r mysession             # 恢复会话
Ctrl+A D                       # 分离会话
Ctrl+A N                       # 新窗口
Ctrl+A W                       # 窗口列表
Ctrl+A K                       # 关闭窗口
Ctrl+A [                       # 复制/滚动模式

# tmux - 更强大的终端管理器（推荐）
sudo apt install tmux

tmux new -s mysession           # 创建会话
tmux ls                         # 列出会话
tmux attach -t mysession        # 连接会话
tmux detach                     # 分离

# tmux快捷键（前缀Ctrl+B）
d              分离
c              新窗口
%              左右分屏
"              上下分屏
o              切换面板
x              关闭面板
z              最大化面板
[              复制模式

服务管理

systemd 概述

systemd是现代Linux系统的主流服务管理器。

┌─────────────────────────────────────────────────────────────┐
│                    systemd 架构                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   systemd ──→ systemctl ──→ 服务单元                        │
│                │                                           │
│         ┌──────┴──────┐                                    │
│         ↓             ↓                                    │
│      service        socket                                │
│      timer          path                                  │
│      mount          swap                                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

systemctl 基础命令

# 启动和停止
sudo systemctl start nginx           # 启动服务
sudo systemctl stop nginx           # 停止服务
sudo systemctl restart nginx        # 重启服务
sudo systemctl reload nginx         # 重载配置

# 查看状态
sudo systemctl status nginx         # 显示详细状态
sudo systemctl is-active nginx     # 检查是否运行
sudo systemctl is-enabled nginx    # 检查是否开机启动
sudo systemctl show nginx           # 显示服务属性

# 开机启动
sudo systemctl enable nginx         # 开机启动
sudo systemctl disable nginx       # 禁用开机启动
sudo systemctl mask nginx          # 屏蔽服务（禁止启动）
sudo systemctl unmask nginx        # 取消屏蔽

# 查看服务列表
systemctl list-units --type=service --all           # 所有服务
systemctl list-units --type=service --state=running # 运行中的
systemctl list-dependencies nginx                   # 依赖关系
systemctl list-unit-files                            # 单元文件

# 查看日志
sudo journalctl -u nginx               # 服务日志
sudo journalctl -u nginx --since today  # 今日日志
sudo journalctl -u nginx -f             # 实时日志
sudo journalctl -xe                    # 系统日志

服务单元文件

# 位置
/etc/systemd/system/       # 系统服务
/usr/lib/systemd/system/    # 软件包服务
~/.config/systemd/user/     # 用户服务

# 示例：nginx.service
[Unit]
Description=The nginx HTTP and reverse proxy server
Documentation=http://nginx.org/en/docs/
After=network.target remote-fs.target nss-lookup.target

[Service]
Type=forking
PIDFile=/run/nginx.pid
ExecStartPre=/usr/sbin/nginx -t
ExecStart=/usr/sbin/nginx
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

init.d 脚本（旧式）

# SysVinit 服务
/etc/init.d/nginx start
/etc/init.d/nginx stop
/etc/init.d/nginx restart
/etc/init.d/nginx status

# update-rc.d（Debian/Ubuntu）
sudo update-rc.d nginx defaults
sudo update-rc.d nginx enable
sudo update-rc.d nginx disable
sudo update-rc.d -f nginx remove

# chkconfig（CentOS/RHEL）
sudo chkconfig nginx on
sudo chkconfig nginx off
sudo chkconfig --list nginx

服务依赖管理

# 查看依赖
systemctl list-dependencies nginx

# 反向依赖
systemctl list-dependencies --reverse nginx

# 重新加载systemd
sudo systemctl daemon-reload

# 重新加载配置
sudo systemctl reload daemon-reload

资源监控

CPU监控

# top
top
# 按P排序查看CPU使用

# mpstat（需安装sysstat）
sudo apt install sysstat
mpstat                         # 每CPU统计
mpstat -P ALL 1 5              # 每1秒，共5次

# iostat
iostat -c                      # 只显示CPU

# lscpu
lscpu                          # CPU详细信息

内存监控

# free
free                            # 基本信息
free -h                         # 人类可读
free -m                         # 以MB为单位
free -s 5                       # 每5秒刷新
watch -n 1 free -h              # 实时监控

# 输出解释
# total    总内存
# used     已使用（含缓存）
# free     完全空闲
# available 实际可用（含缓存回收）

磁盘I/O监控

# iostat
iostat                          # 基本统计
iostat -x                       # 详细统计
iostat -d 1 5                   # 每秒，共5次
iostat -p sda                   # 单个设备

# iotop
sudo apt install iotop
sudo iotop                       # 实时I/O
sudo iotop -o                    # 只显示活动进程
sudo iotop -b -n 5              # 批处理模式

# ioping
sudo ioping /dev/sda1           # 测试磁盘延迟

网络监控

# iftop
sudo apt install iftop
sudo iftop -i eth0               # 监控接口

# nethogs
sudo apt install nethogs
sudo nethogs eth0               # 按进程网络使用

# ss - Socket统计
ss -tulnp                       # 所有监听端口
ss -tn                         # TCP连接
ss -un                         # UDP连接
ss -p                          # 显示进程
ss state established           # 已建立连接

综合监控工具

# glances（推荐）
sudo apt install glances
glances                          # 启动
glances -t 2                     # 2秒刷新
glances -c @remote_ip           # 远程监控

# nmon
sudo apt install nmon
nmon                            # 交互式监控

# dstat
sudo apt install dstat
dstat                          # 综合统计
dstat -cdngy                    # CPU、磁盘、网络、内存、负载

进程优先级

nice值

# nice值范围：-20（高优先级）到 19（低优先级）
# 默认nice值：0

# 启动时设置优先级
nice -n 10 command              # 低优先级启动
nice -n -10 command             # 高优先级启动（需root）
nice -n 19 ./backup.sh         # 后台备份设为低优先级

# 查看进程nice值
ps -eo pid,ni,cmd

renice - 调整优先级

# 调整运行中的进程
sudo renice -n 10 -p 1234       # 设置PID 1234为nice=10
sudo renice -n 10 -u username    # 调整用户所有进程
sudo renice -n 10 -g groupname   # 调整组进程

# top中调整
# 启动top后按r，输入PID和新的PR值

real-time priority

# 查看调度策略
ps -eo pid,policy,cmd

# SCHEDULER类型
# NORMAL/SCHED_OTHER: 普通调度
# FIFO: 实时FIFO
# RR: 实时轮询

# 设置实时优先级
sudo chrt -f 50 -p 1234         # FIFO，优先级50
sudo chrt -r 50 -p 1234         # RR，优先级50

课后练习

实践任务

使用 ps、top、htop 查看系统进程
启动nginx服务，练习 systemctl start/stop/status
创建后台任务，使用 jobs 和 fg/bg 进行控制
使用 screen 创建持久会话，运行长时间任务
分析日志找出占用CPU/内存最高的进程
编写脚本监控服务状态，服务停止时自动重启

下一篇预告：我们将学习软件包管理，掌握apt、yum/dnf的使用方法。

软件包管理完全指南

Fri, 09 Jan 2026 00:00:00 +0000

软件包管理概述

Linux软件包管理系统负责软件的安装、更新、卸载和依赖管理。

┌─────────────────────────────────────────────────────────────┐
│                  Linux 软件包系统                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ┌─────────────────────────────────────────────────────┐   │
│   │                    软件包格式                        │   │
│   ├─────────────────────────────────────────────────────┤   │
│   │  .deb  ─── Debian/Ubuntu/Mint                       │   │
│   │  .rpm  ─── Red Hat/CentOS/Fedora/SUSE              │   │
│   │  .pkg.tar.zst ─── Arch Linux                        │   │
│   └─────────────────────────────────────────────────────┘   │
│                                                             │
│   ┌─────────────────────────────────────────────────────┐   │
│   │                    包管理器                         │   │
│   ├─────────────────────────────────────────────────────┤   │
│   │  apt/dpkg    ─── Debian系                          │   │
│   │  yum/dnf     ─── Red Hat系                          │   │
│   │  pacman      ─── Arch Linux                         │   │
│   │  zypper      ─── openSUSE                           │   │
│   └─────────────────────────────────────────────────────┘   │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Debian/Ubuntu: APT

APT基础

APT (Advanced Package Tool) 是Debian系发行版的包管理前端。

# 更新软件包列表
sudo apt update

# 升级所有可升级的软件包
sudo apt upgrade
sudo apt full-upgrade       # 处理依赖变化（可能删除包）

# 安装更新
sudo apt update && sudo apt upgrade -y

安装软件

# 安装单个软件
sudo apt install nginx

# 安装多个软件
sudo apt install nginx postgresql redis-server

# 指定版本安装
sudo apt install nginx=1.18.0

# 重新安装
sudo apt install --reinstall nginx

# 从本地.deb安装
sudo dpkg -i package.deb
sudo apt install ./package.deb    # 自动处理依赖

卸载软件

# 移除软件包（保留配置）
sudo apt remove nginx

# 完全移除（包括配置）
sudo apt purge nginx
sudo apt --purge remove nginx

# 移除不需要的依赖
sudo apt autoremove

# 清理缓存
sudo apt clean                    # 清空本地缓存
sudo apt autoclean               # 清理过时的包
sudo apt-get clean               # 同apt clean

搜索和查看

# 搜索软件包
apt search nginx
apt-cache search nginx
apt-cache search "^nginx.*$"

# 查看软件包信息
apt show nginx
apt-cache show nginx

# 查看软件包详情
apt-cache showpkg nginx          # 显示版本和依赖
apt-cache policy nginx           # 显示可用版本
apt list --upgradable           # 列出可升级包
apt list --installed            # 列出已安装

dpkg直接管理

# 安装.deb包
sudo dpkg -i package.deb

# 列出已安装
dpkg -l                         # 所有已安装
dpkg -l nginx                   # 指定包
dpkg -l | grep "^ii"            # 正常安装的包

# 查看文件属于哪个包
dpkg -S /bin/ls                  # 显示包含ls的包
dpkg -L nginx                   # 列出nginx安装的文件

# 查看.deb包信息
dpkg -I package.deb             # 显示包信息
dpkg --contents package.deb    # 列出包内容

# 配置损坏的包
sudo dpkg --configure -a

# 强制安装/卸载
sudo dpkg --force-depends -i package.deb
sudo dpkg --force-overwrite -i package.deb

高级APT配置

# 查看依赖关系
apt-cache depends nginx         # nginx依赖
apt-cache rdepends nginx        # 依赖nginx的包

# 下载包（不安装）
apt download nginx              # 下载到当前目录
apt source nginx                # 下载源码包

# 修复依赖问题
sudo apt -f install             # 修复依赖
sudo dpkg --configure -a        # 配置所有包

# 锁定版本
sudo apt-mark hold nginx        # 锁定当前版本
sudo apt-mark unhold nginx      # 解除锁定
apt-mark showhold              # 显示锁定的包

APT源配置

# 源配置文件
/etc/apt/sources.list
/etc/apt/sources.list.d/*.list

# 阿里云镜像
sudo sed -i 's/cn.archive.ubuntu.com/mirrors.aliyun.com/g' /etc/apt/sources.list

# 清华镜像
sudo sed -i 's/cn.archive.ubuntu.com/mirrors.tuna.tsinghua.edu.cn/g' /etc/apt/sources.list

# 添加PPA（Personal Package Archive）
sudo add-apt-repository ppa:nginx/stable
sudo add-apt-repository -r ppa:nginx/stable    # 删除PPA

Red Hat/CentOS: YUM/DNF

YUM基础

# 安装
sudo yum install nginx
sudo yum install nginx-1.20.1                # 指定版本
sudo yum localinstall package.rpm            # 本地安装

# 卸载
sudo yum remove nginx
sudo yum erase nginx                         # 完全移除

# 更新
sudo yum update
sudo yum update nginx                        # 更新指定包
sudo yum check-update                        # 检查可更新

# 清理
sudo yum clean all                           # 清空缓存
sudo yum makecache                           # 重建缓存

DNF基础

DNF (Dandified YUM) 是YUM的下一代版本，Fedora默认使用。

# 安装
sudo dnf install nginx
sudo dnf install @httpd                      # 安装组

# 卸载
sudo dnf remove nginx

# 更新
sudo dnf upgrade
sudo dnf upgrade --refresh                   # 强制刷新

# 历史
dnf history                                  # 查看操作历史
dnf history undo 5                          # 撤销第5个操作
dnf history redo 5                          # 重做第5个操作

YUM/DNF搜索和查看

# 搜索
yum search nginx
dnf search nginx
yum search all nginx                        # 全文搜索

# 信息
yum info nginx
dnf info nginx

# 列表
yum list installed
yum list available
yum list updates
dnf list --installed
dnf list --extras                           # 不在源中的已安装包

# 文件查询
yum provides /etc/nginx/nginx.conf
yum whatprovides "*bin/nginx"

YUM/DNF组管理

# 组列表
yum grouplist
yum groups list
dnf group list

# 安装组
yum groupinstall "Development Tools"
yum install @'Basic Web Server'
dnf group install "Web Server"

# 更新组
yum groupupdate "Development Tools"

# 删除组
yum groupremove "Development Tools"

RPM直接管理

# 安装
sudo rpm -ivh package.rpm                   # 安装并显示进度
sudo rpm -ivh --nodeps package.rpm          # 忽略依赖
sudo rpm -ivh --force package.rpm           # 强制安装

# 卸载
sudo rpm -e package-name                    # 卸载
sudo rpm -e --nodeps package-name          # 忽略依赖

# 查询
rpm -qa                                     # 所有已安装
rpm -qa | grep nginx                        # 查找包
rpm -qi nginx                               # 包信息
rpm -ql nginx                               # 文件列表
rpm -qc nginx                               # 配置文件
rpm -qd nginx                               # 文档文件
rpm -qf /usr/sbin/nginx                     # 文件属于哪个包
rpm -qR nginx                               # 依赖

YUM/DNF源配置

# 源位置
/etc/yum.repos.d/*.repo
/etc/dnf/dnf.conf

# EPEL源（CentOS/RHEL）
sudo yum install epel-release

# 阿里云镜像
sudo yum install -y wget
sudo wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

# 清理重建缓存
sudo yum clean all
sudo yum makecache

Arch Linux: Pacman

# 安装
sudo pacman -S nginx                        # 安装
sudo pacman -Syu                            # 同步并升级
sudo pacman -S extra/nginx nginx-debug     # 从不同仓库

# 卸载
sudo pacman -R nginx                        # 移除
sudo pacman -Rs nginx                       # 移除及依赖
sudo pacman -Rdd nginx                      # 强制移除（忽略依赖）

# 搜索
pacman -Ss nginx                            # 搜索
pacman -Qs nginx                            # 已安装搜索
pacman -Si nginx                            # 仓库信息
pacman -Qi nginx                            # 本地信息
pacman -Ql nginx                            # 文件列表

# 清理
sudo pacman -Sc                             # 清理未安装的缓存
sudo pacman -Scc                            # 清理所有缓存

# 组
pacman -Qg                                   # 已安装组
pacman -Sg base                              # base组包列表
sudo pacman -S base base-devel              # 安装组

Snap通用包管理

Snap是Canonical开发的跨发行版包管理系统。

# 安装
sudo snap install nginx

# 查找
snap find nginx
snap find --name nginx                      # 精确名称

# 信息
snap info nginx
snap list                                   # 已安装列表
snap connections nginx                       # 接口连接

# 更新
snap refresh                                # 更新所有snap包
snap refresh nginx                          # 更新指定
snap refresh --channel=stable nginx         # 切换频道

# 卸载
sudo snap remove nginx
sudo snap remove --revision=123 nginx      # 移除特定版本

# 其他
snap revert nginx                           # 回滚
snap disable nginx                          # 禁用
snap enable nginx                           # 启用

Flatpak通用包管理

# 安装
flatpak install flathub org.mozilla.firefox

# 查找
flatpak search firefox

# 信息
flatpak info org.mozilla.firefox
flatpak list                                 # 已安装
flatpak list --app                          # 只显示应用

# 更新
flatpak update
flatpak update org.mozilla.firefox

# 卸载
flatpak uninstall org.mozilla.firefox
flatpak uninstall --unused                  # 清理未使用的运行时

# 权限
flatpak run --share=network --socket=x11 org.mozilla.firefox

综合对比

功能	apt	yum/dnf	pacman	snap
安装	`apt install`	`yum install`	`pacman -S`	`snap install`
卸载	`apt remove`	`yum remove`	`pacman -Rs`	`snap remove`
更新列表	`apt update`	`yum check-update`	`pacman -Sy`	-
升级	`apt upgrade`	`yum upgrade`	`pacman -Syu`	`snap refresh`
搜索	`apt search`	`yum search`	`pacman -Ss`	`snap find`
查看	`apt show`	`yum info`	`pacman -Si`	`snap info`
清缓存	`apt clean`	`yum clean all`	`pacman -Scc`	`snap clean`

课后练习

实践任务

配置国内镜像源加速apt/yum
使用apt/dnf安装nginx，配置开机启动
练习软件包的搜索、安装、卸载流程
使用dpkg/rpm查看.deb/.rpm包信息
了解snap和flatpak的使用场景

下一篇预告：我们将学习网络配置与管理，掌握Linux网络设置和诊断技能。

网络配置与管理

Sat, 10 Jan 2026 00:00:00 +0000

网络基础

网络配置文件

# Debian/Ubuntu
/etc/network/interfaces          # 网络接口配置
/etc/netplan/*.yaml              # Netplan配置
/etc/resolv.conf                 # DNS配置
/etc/hosts                       # 主机名解析
/etc/hostname                    # 主机名

# CentOS/RHEL
/etc/sysconfig/network           # 基础网络配置
/etc/sysconfig/network-scripts/ifcfg-*   # 网卡配置
/etc/resolv.conf                # DNS配置

# 通用
/etc/services                    # 端口服务映射
/proc/sys/net/ipv4/ip_forward    # IP转发

网络接口命名

传统命名：eth0, eth1, wlan0
新式命名：enp0s3, ens33, wlpn0s0

命名规则：
en ── 以太网 (ethernet)
wl ── 无线 (wlan)
ww ── 广域网 (wwan)

后面：
p ── 总线接口 (pci bus)
s ── 插槽 (slot)
n ── 物理位置编号

ip命令

ip 是现代Linux推荐的网络配置工具。

地址管理

# 查看IP信息
ip addr                          # 显示所有地址
ip addr show                     # 同上
ip addr show eth0                # 显示指定接口

# 简写
ip a

# 添加地址
sudo ip addr add 192.168.1.100/24 dev eth0
sudo ip addr add 192.168.1.100/24 dev eth0 label eth0:1

# 删除地址
sudo ip addr del 192.168.1.100/24 dev eth0

接口管理

# 查看接口
ip link show                     # 显示所有接口
ip link show up                  # 只显示活跃接口

# 启用/禁用接口
sudo ip link set eth0 up
sudo ip link set eth0 down

# 修改MAC地址
sudo ip link set eth0 down
sudo ip link set eth0 address aa:bb:cc:dd:ee:ff
sudo ip link set eth0 up

# 设置MTU
sudo ip link set eth0 mtu 9000

路由管理

# 查看路由表
ip route                         # 显示路由
ip route show

# 添加路由
sudo ip route add default via 192.168.1.1 dev eth0
sudo ip route add 10.0.0.0/8 via 192.168.1.254 dev eth0
sudo ip route add 172.16.0.0/16 via 192.168.1.1 dev eth0

# 删除路由
sudo ip route del default
sudo ip route del 10.0.0.0/8

# 路由策略
ip rule                          # 路由策略表
sudo ip rule add from 192.168.1.0/24 table local

邻居管理（ARP）

# 查看ARP表
ip neigh show
ip neighbor

# 添加ARP条目
sudo ip neigh add 192.168.1.1 lladdr aa:bb:cc:dd:ee:ff dev eth0

# 删除ARP条目
sudo ip neigh del 192.168.1.1 dev eth0

ifconfig命令

# 查看网络信息
ifconfig
ifconfig eth0

# 启用/禁用
sudo ifconfig eth0 up
sudo ifconfig eth0 down

# 设置IP
sudo ifconfig eth0 192.168.1.100 netmask 255.255.255.0
sudo ifconfig eth0 broadcast 192.168.1.255

# 设置MAC
sudo ifconfig eth0 hw ether aa:bb:cc:dd:ee:ff

# 设置MTU
sudo ifconfig eth0 mtu 9000

网络配置示例

静态IP配置

Ubuntu (Netplan)

# /etc/netplan/01-netcfg.yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      dhcp4: no
      addresses:
        - 192.168.1.100/24
      gateway4: 192.168.1.1
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4
        search:
          - example.com

# 应用配置
sudo netplan apply
sudo netplan try              # 测试配置

Ubuntu (interfaces)

# /etc/network/interfaces
auto eth0
iface eth0 inet static
    address 192.168.1.100
    netmask 255.255.255.0
    gateway 192.168.1.1
    dns-nameservers 8.8.8.8 8.8.4.4
    dns-search example.com

CentOS/RHEL

# /etc/sysconfig/network-scripts/ifcfg-eth0
TYPE=Ethernet
BOOTPROTO=static
NAME=eth0
DEVICE=eth0
ONBOOT=yes
IPADDR=192.168.1.100
NETMASK=255.255.255.0
GATEWAY=192.168.1.1
DNS1=8.8.8.8
DNS2=8.8.4.4

DHCP配置

# Netplan DHCP
network:
  version: 2
  ethernets:
    eth0:
      dhcp4: yes
      dhcp6: yes

# CentOS DHCP
# /etc/sysconfig/network-scripts/ifcfg-eth0
TYPE=Ethernet
BOOTPROTO=dhcp
NAME=eth0
DEVICE=eth0
ONBOOT=yes

多IP配置

# 临时添加第二IP
sudo ip addr add 192.168.1.101/24 dev eth0 label eth0:0

# 永久配置 - Ubuntu
# /etc/network/interfaces
auto eth0:0
iface eth0:0 inet static
    address 192.168.1.101
    netmask 255.255.255.0

DNS配置

resolv.conf

# /etc/resolv.conf
nameserver 8.8.8.8
nameserver 8.8.4.4
nameserver 1.1.1.1
search example.com

# 搜索域
search local domain corp

hosts文件

# /etc/hosts
127.0.0.1   localhost
127.0.1.1   hostname
192.168.1.100   server1.example.com server1
192.168.1.101   server2.example.com server2

# IPv6
::1     ip6-localhost ip6-loopback
fe00::0 ip6-localnet

DNS查询

# dig
dig example.com
dig @8.8.8.8 example.com      # 指定DNS服务器
dig +short example.com         # 简短输出
dig +trace example.com         # 追踪DNS解析

# nslookup
nslookup example.com
nslookup example.com 8.8.8.8

# host
host example.com
host -a example.com
host 93.184.216.34            # 反向查询

网络诊断工具

ping - 连通性测试

# 基本用法
ping example.com
ping 192.168.1.1

# 常用选项
ping -c 4 example.com         # 发送4个包
ping -i 2 example.com          # 2秒间隔
ping -w 10 example.com          # 运行10秒
ping -W 5 example.com          # 等待5秒超时
ping -s 1000 example.com       # 1000字节数据
ping -f example.com            # flood模式（需root）
ping -6 example.com            # IPv6

# 示例
ping -c 3 -i 2 example.com

traceroute - 路由追踪

# 追踪路由
traceroute example.com
traceroute -n example.com     # 不解析域名
traceroute -m 15 example.com   # 最大15跳
traceroute -w 3 example.com    # 等待超时3秒

# 工具变体
traceroute6 example.com        # IPv6
tracepath example.com          # 无需root
mtr example.com               # 实时追踪（推荐）

netstat - 网络统计

# 常用选项
netstat -a                     # 所有连接
netstat -at                     # TCP连接
netstat -au                     # UDP连接
netstat -l                      # 监听端口
netstat -lt                     # TCP监听
netstat -lu                     # UDP监听
netstat -p                      # 显示进程
netstat -n                      # 数字显示
netstat -r                      # 路由表
netstat -i                      # 接口统计
netstat -s                      # 协议统计

# 组合使用
netstat -tulnp                  # 监听端口及进程
netstat -an | grep ESTABLISHED # 活动连接
netstat -an | grep :80          # 80端口连接
netstat -anp | grep TIME_WAIT  # TIME_WAIT状态

ss - Socket统计

# 基本用法
ss -a                     # 所有
ss -l                     # 监听
ss -t                     # TCP
ss -u                     # UDP
ss -p                     # 进程
ss -n                     # 数字

# 状态过滤
ss -t state established
ss -t state time-wait
ss -t state listening

# 组合
ss -tulnp                 # 监听端口
ss -tunap                 # 所有带进程
ss -o state fin-wait-1   # 特定状态

# 常用状态
ss -t state time-wait | wc -l

nc/netcat - 网络瑞士军刀

# 端口扫描
nc -zv example.com 80 443 22
nc -zv 192.168.1.1 1-1000

# 连接测试
nc -zv example.com 80
echo "GET / HTTP/1.0\r\n\r\n" | nc example.com 80

# 传输文件
nc -l 1234 > file.txt              # 接收端
nc -N 192.168.1.1 1234 < file.txt  # 发送端

# 简单聊天
nc -l 1234                         # 端1
nc 192.168.1.1 1234                # 端2

# 端口转发
nc -l 8080 | nc example.com 80

# 其他
nc -zv -w 3 example.com 80         # 超时3秒

curl - HTTP客户端

# 基本请求
curl https://example.com
curl -X GET https://example.com
curl -X POST https://example.com -d "data=xxx"

# 头部
curl -I https://example.com       # HEAD请求
curl -v https://example.com       # 详细输出
curl -H "User-Agent: Mozilla" https://example.com

# 保存
curl -o output.html https://example.com
curl -O https://example.com/file.tar.gz

# 表单
curl -F "file=@upload.txt" https://example.com/upload
curl -X POST -d "name=value" https://example.com/api

# Cookie
curl -b cookies.txt https://example.com
curl -c cookies.txt https://example.com

# 代理
curl -x http://proxy:8080 https://example.com

wget - 下载工具

# 基本下载
wget https://example.com/file.tar.gz
wget -O output.tar.gz https://example.com/file.tar.gz

# 后台下载
wget -b https://example.com/large-file.zip

# 断点续传
wget -c https://example.com/large-file.zip

# 递归下载
wget -r -l 2 https://example.com/

# 其他选项
wget -q                    # 静默
wget --user=user --password=pass https://example.com
wget -e https_proxy=http://proxy:8080 https://example.com

网络诊断实战

常见故障排查

# 1. 检查物理连接
ip link show
ethtool eth0
mii-tool eth0

# 2. 检查IP配置
ip addr show
ip route show

# 3. 测试本地网关
ping 192.168.1.1

# 4. 测试DNS
ping example.com
nslookup example.com

# 5. 测试外网
ping 8.8.8.8
ping google.com

# 6. 检查端口
netstat -tulnp
ss -tulnp
lsof -i :80

# 7. 检查防火墙
sudo iptables -L -n
sudo ufw status
sudo firewall-cmd --list-all

网络性能测试

# 带宽测试
sudo apt install iperf3
# 服务端
iperf3 -s
# 客户端
iperf3 -c server_ip

# 快速测试
wget -O /dev/null http://speedtest.telia.telerik.se/1MB.bin

网卡绑定

# 查看 bonding 模块
modinfo bonding

# 配置 bond0 - /etc/network/interfaces
auto bond0
iface bond0 inet static
    address 192.168.1.100
    netmask 255.255.255.0
    gateway 192.168.1.1
    slaves eth0 eth1
    bond-mode 802.3ad
    bond-miimon 100
    bond-lacp-rate 1

课后练习

实践任务

使用 ip 和 ifconfig 查看网络配置
配置静态IP地址
使用 dig 和 nslookup 进行DNS查询
使用 traceroute 和 ping 排查网络问题
使用 netstat/ss 分析网络连接
配置hosts文件实现自定义域名解析

下一篇预告：我们将学习SSH远程管理，掌握安全远程连接技能。

SSH远程管理

Sun, 11 Jan 2026 00:00:00 +0000

SSH基础

什么是SSH？

SSH（Secure Shell）是一种加密网络协议，用于安全地远程登录和传输数据。

┌─────────────────────────────────────────────────────────────┐
│                    SSH 工作原理                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Client ────────── SSH加密隧道 ────────── Server          │
│                                                             │
│   ├── 密钥交换 (Key Exchange)                               │
│   ├── 身份验证 (Password/Key)                               │
│   └── 数据加密传输 (AES, ChaCha20)                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

SSH配置文件

# 用户配置文件
~/.ssh/config

# 用户公钥
~/.ssh/id_rsa.pub           # RSA公钥
~/.ssh/id_ed25519.pub       # Ed25519公钥（推荐）
~/.ssh/id_ecdsa.pub         # ECDSA公钥

# 用户私钥
~/.ssh/id_rsa               # RSA私钥
~/.ssh/id_ed25519           # Ed25519私钥（推荐）
~/.ssh/id_ecdsa             # ECDSA私钥

# 系统配置
/etc/ssh/sshd_config        # SSH服务器配置
/etc/ssh/ssh_config         # SSH客户端默认配置
/etc/ssh/ssh_host_*         # 服务器主机密钥

基本连接

密码登录

# 基本语法
ssh username@hostname
ssh username@192.168.1.100
ssh -p 2222 username@hostname   # 指定端口

# 首次连接会显示指纹确认
The authenticity of host 'hostname' can't be established.
ECDSA key fingerprint is SHA256:xxxxx.
Are you sure you want to continue connecting (yes/no/[fingerprint])?

SSH密钥登录

# 1. 生成密钥对
ssh-keygen -t ed25519 -C "your_email@example.com"
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

# 2. 选择存储位置（默认~/.ssh/）
Enter file in which to save the key (/home/user/.ssh/id_ed25519): 

# 3. 设置密码（可选但推荐）
Enter passphrase (empty for no passphrase):
Enter same passphrase again:

# 4. 复制公钥到服务器
ssh-copy-id username@hostname
ssh-copy-id -i ~/.ssh/id_ed25519.pub username@hostname

# 5. 登录测试
ssh username@hostname

SSH配置文件

# ~/.ssh/config
Host alias
    HostName hostname.example.com
    User username
    Port 22
    IdentityFile ~/.ssh/id_ed25519
    ForwardAgent yes

Host server1
    HostName 192.168.1.100
    User admin
    Port 2222
    IdentityFile ~/.ssh/id_rsa

Host server2
    HostName 192.168.1.101
    User root
    IdentityFile ~/.ssh/id_ed25519
    ServerAliveInterval 60
    ServerAliveCountMax 3

Host *
    AddKeysToAgent yes
    UseKeychain yes
    IdentitiesOnly yes

# 使用别名连接
ssh alias
ssh server1
ssh server2

SSH密钥管理

密钥类型对比

类型	密钥大小	安全性	兼容性	推荐
RSA	2048-4096	高	最好	⭐⭐
Ed25519	256	最高	良好	⭐⭐⭐
ECDSA	256-521	高	良好	⭐⭐

密钥操作

# 查看现有密钥
ls -la ~/.ssh/
cat ~/.ssh/id_ed25519.pub

# 添加密钥到ssh-agent
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
ssh-add -l                    # 列出已加载的密钥

# macOS Keychain集成
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

# 修改密钥密码
ssh-keygen -p -f ~/.ssh/id_ed25519

# 导出公钥
ssh-keygen -y -f ~/.ssh/id_ed25519

authorized_keys管理

# 查看服务器的authorized_keys
cat ~/.ssh/authorized_keys

# 允许多个密钥
ssh-rsa AAAAB3NzaC1... key1
ssh-rsa AAAAB3NzaC1... key2
ssh-ed25519 AAAAC3Nza... key3

# 设置正确权限
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

SSH服务器配置

sshd_config详解

# /etc/ssh/sshd_config

# 基本设置
Port 22
ListenAddress 0.0.0.0
Protocol 2

# 认证设置
PermitRootLogin no              # 禁止root登录
PubkeyAuthentication yes        # 启用公钥认证
PasswordAuthentication yes      # 启用密码认证（建议关闭）
PermitEmptyPasswords no         # 禁止空密码
MaxAuthTries 3                  # 最大尝试次数
MaxSessions 10                  # 最大会话数

# 安全设置
ClientAliveInterval 300          # 客户端存活检测（秒）
ClientAliveCountMax 3           # 检测次数
LoginGraceTime 60               # 登录宽限期（秒）
StrictHostKeyChecking ask       # 主机密钥检查
X11Forwarding yes              # X11转发

# 日志
SyslogFacility AUTH
LogLevel INFO

# 子系统
Subsystem sftp /usr/lib/openssh/sftp-server

# 允许用户/组
AllowUsers user1 user2
AllowGroups sshusers

# 禁止用户/组
DenyUsers baduser
DenyGroups badgroup

安全加固配置

# 创建sshd配置备份
sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak

# 编辑配置
sudo vim /etc/ssh/sshd_config

# 推荐的安全配置
Port 2222
PermitRootLogin no
PubkeyAuthentication yes
PasswordAuthentication no
MaxAuthTries 3
ClientAliveInterval 300
ClientAliveCountMax 2
X11Forwarding no
AllowUsers username

# 重新加载配置
sudo systemctl restart sshd
sudo systemctl reload sshd

SSH密钥登录测试

# 1. 确保公钥已复制
ssh-copy-id -p 2222 username@hostname

# 2. 测试密钥登录
ssh -p 2222 username@hostname

# 3. 禁用密码登录后，确保密钥登录正常

SSH高级用法

文件传输

# scp - 安全复制
scp file.txt username@hostname:/path/        # 上传
scp username@hostname:/path/file.txt .     # 下载
scp -r folder/ username@hostname:/path/    # 递归复制

# 常用选项
scp -P 2222 file.txt username@hostname:/path/
scp -i ~/.ssh/key.pem file.txt username@hostname:/path/
scp -p file.txt username@hostname:/path/    # 保留属性
scp -v file.txt username@hostname:/path/    # 详细输出

# rsync - 增量同步
rsync -avz -e "ssh -p 2222" folder/ username@hostname:/path/
rsync -avz --delete folder/ username@hostname:/path/
rsync -avz --exclude='*.log' folder/ username@hostname:/path/

rsync高级选项

# 常用选项
rsync -a               # 归档模式（保留权限、时间等）
rsync -v               # 详细输出
rsync -z               # 压缩传输
rsync -n               # 预演（不实际传输）
rsync -P               # 显示进度，保留部分文件
rsync --delete        # 删除目标中多余的文件
rsync --exclude       # 排除文件
rsync --progress      # 显示进度

# 示例
rsync -avzP -e "ssh -p 2222" /local/path/ user@host:/remote/path/

sftp - SSH文件传输

# 启动sftp
sftp username@hostname
sftp -P 2222 username@hostname

# 交互命令
sftp> help
sftp> pwd                    # 远程当前目录
sftp> lpwd                   # 本地当前目录
sftp> ls                    # 列出远程文件
sftp> lls                   # 列出本地文件
sftp> cd /path              # 切换远程目录
sftp> lcd /path             # 切换本地目录

# 传输命令
sftp> get remote.txt        # 下载
sftp> get remote.txt local.txt  # 下载并重命名
sftp> put local.txt         # 上传
sftp> put *.txt /remote/    # 上传多个

# 批处理
sftp -b commands.txt username@hostname

端口转发

本地端口转发

# 语法：ssh -L local_port:destination:destination_port jump_host
ssh -L 8080:localhost:80 username@server

# 访问远程服务器的MySQL
ssh -L 3306:localhost:3306 username@remoteserver

# 本地访问内网服务
ssh -L 9000:internal_server:80 jump_server

远程端口转发

# 语法：ssh -R remote_port:destination:destination_port jump_host
ssh -R 8080:localhost:80 username@server

# 让远程访问本地服务
ssh -R 80:localhost:3000 username@server

# 反向代理
ssh -fNR 8080:localhost:80 username@gateway

动态端口转发（SOCKS代理）

# 创建SOCKS代理
ssh -D 1080 username@hostname

# 浏览器配置SOCKS代理
# localhost:1080

# 命令行使用代理
curl --socks5 localhost:1080 https://example.com

跳板机连接

# 直接跳板
ssh -J username@jump_server username@target_server

# 多级跳板
ssh -J user1@jump1,user2@jump2 target_server

# ProxyJump配置
Host target
    HostName target_server
    User username
    ProxyJump jump_server

# 通过配置文件
Host internal-server
    HostName 192.168.1.100
    ProxyJump user@gateway.com

SSH Agent

# 启动agent
eval "$(ssh-agent -s)"

# 添加密钥
ssh-add ~/.ssh/id_ed25519
ssh-add ~/.ssh/id_rsa

# 查看已加载密钥
ssh-add -l

# macOS添加到Keychain
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

# SSH Agent转发
ssh -A username@hostname

# 配置自动使用
# ~/.ssh/config
Host *
    ForwardAgent yes

SCP/SFTP命令速查

# SCP命令
scp file.txt user@host:/path/          # 上传
scp user@host:/path/file.txt .         # 下载
scp -r /local/dir/ user@host:/path/    # 目录
scp -P 2222                             # 端口

# SFTP命令
sftp user@host                          # 连接
get file.txt                           # 下载
put file.txt                           # 上传
mget *.txt                             # 多下载
mput *.txt                             # 多上传

SSH实战案例

远程执行命令

# 单命令
ssh username@hostname "ls -la /var/log"

# 多命令
ssh username@hostname "cd /var/log && tail -f syslog"

# 本地脚本在远程执行
cat script.sh | ssh username@hostname "bash -s"

# here-document方式
ssh username@hostname << 'ENDSSH'
cd /home/user
./deploy.sh
ENDSSH

保持连接活跃

# 客户端配置 - ~/.ssh/config
ServerAliveInterval 60
ServerAliveCountMax 3

# 服务器配置 - /etc/ssh/sshd_config
ClientAliveInterval 60
ClientAliveCountMax 3

# SSH隧道保持
ssh -o ServerAliveInterval=60 -N -L 8080:localhost:80 hostname

远程备份脚本

#!/bin/bash
# backup.sh

REMOTE_USER="backup"
REMOTE_HOST="backup.server.com"
REMOTE_PATH="/backups"
LOCAL_PATH="/home/user/data"

# 创建tar包
BACKUP_FILE="backup_$(date +%Y%m%d_%H%M%S).tar.gz"
tar -czf "$BACKUP_FILE" "$LOCAL_PATH"

# 传输
scp -P 2222 "$BACKUP_FILE" "$REMOTE_USER@$REMOTE_HOST:$REMOTE_PATH/"

# 清理本地
rm "$BACKUP_FILE"

# 远程清理（保留最近7天）
ssh -p 2222 "$REMOTE_USER@$REMOTE_HOST" "find $REMOTE_PATH -name 'backup_*.tar.gz' -mtime +7 -delete"

SSH故障排查

# 1. 检查服务状态
sudo systemctl status sshd

# 2. 检查端口监听
sudo ss -tlnp | grep ssh

# 3. 测试连接
ssh -v username@hostname          # 详细输出
ssh -vv username@hostname         # 更详细

# 4. 检查防火墙
sudo ufw status
sudo iptables -L -n | grep ssh

# 5. 检查日志
sudo journalctl -u sshd -f
sudo tail -f /var/log/auth.log

# 6. 检查SELinux（CentOS/RHEL）
sudo getsebool ssh_sysadm_login

# 7. 常见问题
# - 密钥权限错误
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_*
chmod 644 ~/.ssh/id_*.pub

# - 目录权限错误
chmod 700 ~/
chmod 700 ~/.ssh

课后练习

实践任务

生成SSH密钥对，配置无密码登录
配置SSH客户端配置文件，使用别名连接
加固SSH服务器配置
使用scp/rsync传输文件
配置SSH端口转发访问内网服务
编写自动化备份脚本

下一篇预告：我们将学习防火墙配置，掌握iptables、firewalld和ufw的使用。

防火墙配置

Mon, 12 Jan 2026 00:00:00 +0000

防火墙概述

防火墙是网络安全的第一道防线，用于控制进出网络流量。

┌─────────────────────────────────────────────────────────────┐
│                    防火墙工作原理                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   入站请求 ──→ 防火墙 ──→ 规则匹配                          │
│                        │                                    │
│              ┌─────────┼─────────┐                         │
│              ↓         ↓         ↓                          │
│            ACCEPT   DROP     REJECT                        │
│              │         │         │                          │
│              ↓         ↓         ↓                          │
│            允许通过   丢弃无响应   拒绝返回                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘

iptables

基础概念

┌─────────────────────────────────────────────────────────────┐
│                  iptables 架构                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Tables ──→ Chains ──→ Rules                              │
│                                                             │
│   Tables:                                                   │
│   ├── filter ── 数据包过滤（默认）                          │
│   ├── nat ──── 网络地址转换                                 │
│   ├── mangle ── 数据包修改                                 │
│   └── raw ──── 连接跟踪 exemptions                          │
│                                                             │
│   Chains (filter表):                                       │
│   ├── INPUT ─── 目标为本机的包                              │
│   ├── OUTPUT ── 源自本机的包                                │
│   ├── FORWARD ── 需要转发的包                              │
│   └── (PREROUTING, POSTROUTING in nat/mangle)              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

基本命令

# 查看规则
sudo iptables -L                        # 列出所有规则
sudo iptables -L -n                     # 数字格式
sudo iptables -L -n -v                  # 详细输出
sudo iptables -L INPUT                  # 指定链
sudo iptables -t nat -L                # nat表
sudo iptables -L -n --line-numbers      # 显示行号

# 追加规则 -A
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT

# 插入规则 -I
sudo iptables -I INPUT 1 -p tcp --dport 22 -j ACCEPT

# 删除规则 -D
sudo iptables -D INPUT -p tcp --dport 22 -j ACCEPT
sudo iptables -D INPUT 3               # 删除第3条

# 替换规则 -R
sudo iptables -R INPUT 3 -p tcp --dport 22 -j ACCEPT

# 清空规则 -F
sudo iptables -F                       # 清空filter表
sudo iptables -F INPUT                 # 清空INPUT链
sudo iptables -t nat -F               # 清空nat表

# 设置默认策略 -P
sudo iptables -P INPUT DROP
sudo iptables -P FORWARD DROP
sudo iptables -P OUTPUT ACCEPT

常用规则

# 允许已建立连接的包
sudo iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# 允许本地回环
sudo iptables -A INPUT -i lo -j ACCEPT

# 允许SSH (端口22)
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT

# 允许HTTP/HTTPS
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# 允许ping
sudo iptables -A INPUT -p icmp --icmp-type echo-request -j ACCEPT

# 允许特定IP访问
sudo iptables -A INPUT -s 192.168.1.100 -j ACCEPT

# 允许端口范围
sudo iptables -A INPUT -p tcp --dport 1000:2000 -j ACCEPT

# 拒绝并返回错误
sudo iptables -A INPUT -p tcp --dport 3306 -j REJECT

# 丢弃（无响应）
sudo iptables -A INPUT -p tcp --dport 3306 -j DROP

连接状态

┌─────────────────────────────────────────────────────────────┐
│                  连接状态                                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   NEW         ── 新建连接请求                               │
│   ESTABLISHED  ── 已建立的连接                              │
│   RELATED     ── 关联的连接（如FTP数据连接）                  │
│   INVALID     ── 无效的连接状态                              │
│   UNTRACKED  ── 未被跟踪的连接                              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

NAT配置

# 开启IP转发
echo 1 | sudo tee /proc/sys/net/ipv4/ip_forward
sudo sysctl -w net.ipv4.ip_forward=1

# 永久开启IP转发
echo "net.ipv4.ip_forward = 1" | sudo tee -a /etc/sysctl.conf

# SNAT（源地址转换）- 伪装
sudo iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j MASQUERADE

# DNAT（目标地址转换）- 端口转发
sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -i eth0 -j DNAT --to-destination 192.168.1.100:8080

# 端口重定向
sudo iptables -t nat -A PREROUTING -p tcp --dport 8080 -j REDIRECT --to-port 80

保存和恢复

# Debian/Ubuntu - 保存规则
sudo apt install iptables-persistent
sudo netfilter-persistent save

# CentOS/RHEL
sudo service iptables save
sudo systemctl restart iptables

# 手动保存
sudo iptables-save > /etc/iptables.rules

# 恢复规则
sudo iptables-restore < /etc/iptables.rules

# 开机自动加载
# /etc/network/interfaces
iface eth0 inet static
    pre-up iptables-restore < /etc/iptables.rules

iptables脚本示例

#!/bin/bash
# firewall.sh - iptables配置脚本

# 清空现有规则
sudo iptables -F
sudo iptables -X
sudo iptables -t nat -F
sudo iptables -t nat -X

# 设置默认策略
sudo iptables -P INPUT DROP
sudo iptables -P FORWARD DROP
sudo iptables -P OUTPUT ACCEPT

# 允许本地回环
sudo iptables -A INPUT -i lo -j ACCEPT

# 允许已建立连接
sudo iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# 允许SSH
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT

# 允许HTTP/HTTPS
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# 允许ping
sudo iptables -A INPUT -p icmp --icmp-type echo-request -j ACCEPT

# 允许特定IP段
sudo iptables -A INPUT -s 192.168.1.0/24 -j ACCEPT

# 日志Drop的包
sudo iptables -A INPUT -m limit --limit 5/min -j LOG --log-prefix "iptables-dropped: " --log-level 4

# 丢弃其他所有
sudo iptables -A INPUT -j DROP

echo "Firewall rules applied successfully!"

firewalld (CentOS/RHEL/Fedora)

基本概念

┌─────────────────────────────────────────────────────────────┐
│                  firewalld 概念                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Zones ── 预定义规则集合                                   │
│   ├── drop          ── 丢弃所有                            │
│   ├── block         ── 拒绝所有                            │
│   ├── public        ── 公共区域                            │
│   ├── external      ── 外部网络                           │
│   ├── dmz           ── DMZ区域                            │
│   ├── work          ── 工作区域                           │
│   ├── home          ── 家庭区域                           │
│   ├── internal      ── 内部网络                           │
│   └── trusted       ── 信任区域                           │
│                                                             │
│   Services ── 预定义服务                                   │
│   └── ssh, dhcpv6-client, samba, http, https, ...         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

基本命令

# 查看状态
sudo firewall-cmd --state
sudo systemctl status firewalld

# 查看默认zone
sudo firewall-cmd --get-default-zone

# 查看活动zone
sudo firewall-cmd --get-active-zones

# 查看zone信息
sudo firewall-cmd --zone=public --list-all

# 查看所有可用zone
sudo firewall-cmd --get-zones

# 查看所有服务
sudo firewall-cmd --get-services

运行时配置

# 设置默认zone
sudo firewall-cmd --set-default-zone=public

# 添加服务
sudo firewall-cmd --zone=public --add-service=ssh
sudo firewall-cmd --zone=public --add-service=http
sudo firewall-cmd --zone=public --add-service=https

# 移除服务
sudo firewall-cmd --zone=public --remove-service=http

# 添加端口
sudo firewall-cmd --zone=public --add-port=8080/tcp
sudo firewall-cmd --zone=public --add-port=1000-2000/tcp

# 移除端口
sudo firewall-cmd --zone=public --remove-port=8080/tcp

# 允许IP/网段
sudo firewall-cmd --zone=public --add-source=192.168.1.0/24
sudo firewall-cmd --zone=public --add-rich-rule='rule family="ipv4" source address="192.168.1.100" accept'

永久配置

# 永久生效（需reload）
sudo firewall-cmd --permanent --zone=public --add-service=http
sudo firewall-cmd --permanent --zone=public --add-port=8080/tcp
sudo firewall-cmd --reload

# 或者使用 --add-service --zone=public --permanent

# 查看永久配置
sudo firewall-cmd --permanent --zone=public --list-all

# 移除永久配置
sudo firewall-cmd --permanent --zone=public --remove-service=http
sudo firewall-cmd --reload

富规则（Rich Rules）

# 允许特定IP的所有连接
sudo firewall-cmd --zone=public --add-rich-rule='rule family="ipv4" source address="192.168.1.100" accept'

# 允许特定IP访问特定端口
sudo firewall-cmd --zone=public --add-rich-rule='rule family="ipv4" source address="192.168.1.100" port port="3306" protocol="tcp" accept'

# 拒绝特定IP
sudo firewall-cmd --zone=public --add-rich-rule='rule family="ipv4" source address="10.0.0.0/8" reject'

# 端口转发
sudo firewall-cmd --zone=external --add-masquerade
sudo firewall-cmd --zone=external --add-forward-port=port=80:proto=tcp:toport=8080:toaddr=192.168.1.100

# 日志记录
sudo firewall-cmd --zone=public --add-rich-rule='rule service name="ssh" log prefix="SSH Access: " level="info" accept'

# 查看所有富规则
sudo firewall-cmd --list-rich-rules

direct规则

# 直接添加iptables规则
sudo firewall-cmd --direct --add-rule ipv4 filter INPUT 0 -p tcp --dport 22 -j ACCEPT

# 查看direct规则
sudo firewall-cmd --direct --get-all-rules

# 移除direct规则
sudo firewall-cmd --direct --remove-rule ipv4 filter INPUT 0 -p tcp --dport 22 -j ACCEPT

UFW (Ubuntu/Debian)

基本命令

# 查看状态
sudo ufw status
sudo ufw status verbose

# 启用/禁用
sudo ufw enable
sudo ufw disable

# 默认策略
sudo ufw default deny incoming    # 拒绝入站
sudo ufw default allow outgoing   # 允许出站
sudo ufw default deny forward     # 拒绝转发

# 重置
sudo ufw reset

允许/拒绝规则

# 允许服务
sudo ufw allow ssh
sudo ufw allow http
sudo ufw allow https

# 允许端口
sudo ufw allow 22/tcp
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 1000:2000/tcp     # 端口范围

# 允许应用
sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'

# 拒绝端口
sudo ufw deny 3306/tcp

# 允许特定IP
sudo ufw allow from 192.168.1.100
sudo ufw allow from 192.168.1.0/24

# 特定IP访问特定端口
sudo ufw allow from 192.168.1.100 to any port 22
sudo ufw allow from 192.168.1.100 to any port 3306 proto tcp

# 删除规则
sudo ufw delete allow ssh
sudo ufw delete allow 22/tcp
sudo ufw delete numbered         # 按编号删除

高级配置

# 限制连接（防止暴力破解）
sudo ufw limit ssh
sudo ufw limit 22/tcp

# 日志
sudo ufw logging on
sudo ufw logging off
sudo ufw logging low
sudo ufw logging medium
sudo ufw logging high

# 查看规则
sudo ufw status numbered
sudo ufw show listening         # 监听端口
sudo ufw show builtins           # 默认规则

# 编辑规则文件
sudo vim /etc/ufw/applications.d/openssh-server

UFW配置文件

# /etc/default/ufw
ENABLED=yes
DEFAULT_INPUT_CHAIN="DROP"
DEFAULT_OUTPUT_CHAIN="ACCEPT"
DEFAULT_FORWARD_CHAIN="DROP"
DEFAULT_APPLICATION_POLICY="SKIP"

# /etc/ufw/ufw.conf
ENABLED=yes
LOGLEVEL=low

# /etc/ufw/user.rules - 用户规则
# /etc/ufw/user6.rules - IPv6规则

对比总结

功能	iptables	firewalld	ufw
适用发行版	通用	RHEL/CentOS/Fedora	Ubuntu/Debian
配置方式	命令/脚本	命令/区域	命令
持久化	iptables-save/restore	默认持久	默认持久
语法复杂度	高	中	低
学习曲线	陡峭	平缓	平缓

课后练习

实践任务

启用防火墙，只开放SSH、HTTP、HTTPS
配置UFW/firewalld，只允许特定IP访问SSH
使用iptables配置NAT网关
配置端口转发
编写自动化防火墙脚本
测试防火墙规则有效性

下一篇预告：我们将学习Shell脚本基础，掌握自动化运维技能。

Shell脚本基础

Tue, 13 Jan 2026 00:00:00 +0000

Shell脚本概述

什么是Shell脚本？

Shell脚本是将多个Shell命令组合成一个可执行文件的文本文件，用于自动化重复性任务。

┌─────────────────────────────────────────────────────────────┐
│                    第一个Shell脚本                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   #!/bin/bash                                               │
│   # 我的第一个脚本                                          │
│                                                             │
│   echo "Hello, World!"                                     │
│   echo "Today is $(date +%Y-%m-%d)"                        │
│                                                             │
└─────────────────────────────────────────────────────────────┘

脚本创建与执行

# 创建脚本
vim script.sh

# 添加执行权限
chmod +x script.sh

# 执行脚本
./script.sh
bash script.sh           # 不需要执行权限

# 执行方式
sh script.sh            # 用sh执行
bash script.sh          # 用bash执行
source script.sh         # 在当前shell执行（会加载变量）
. script.sh              # 同source

Shebang

#!/bin/bash             # Bash脚本
#!/bin/sh               # POSIX脚本
#!/usr/bin/env bash     # 跨平台方式
#!/bin/bash -x          # 调试模式
#!/bin/bash -e          # 遇错即停

变量

变量基础

# 定义变量
name="Linux"
version=6.1
pi=3.14159

# 使用变量
echo $name
echo ${name}
echo "Welcome to ${name}!"

# 读取用户输入
read -p "Enter your name: " name
echo "Hello, $name"

# 只读变量
readonly PI=3.14159
declare -r CONST="constant"

# 删除变量
unset name

变量类型

# 字符串
str1="Hello"
str2='World'              # 单引号不解析变量
str3="Value: $str1"      # 双引号解析变量

# 数字
num1=100
num2=$((10 + 5))         # 算术运算
num3=$((num1 * 2))

# 数组
arr=(one two three four)
arr[0]="first"
echo ${arr[0]}
echo ${arr[@]}           # 所有元素
echo ${#arr[@]}          # 数组长度

# 关联数组
declare -A capitals
capitals["China"]="Beijing"
capitals["Japan"]="Tokyo"
echo ${capitals[China]}

特殊变量

$0          # 脚本名称
$1-$9       # 第1-9个参数
${10}       # 第10个参数
$#          # 参数个数
$@          # 所有参数（独立）
$*          # 所有参数（合并）
$?          # 上个命令的退出状态
$$          # 当前进程ID
$!          # 上个后台进程ID
$-          # 当前set的选项

环境变量

# 查看环境变量
env
printenv
echo $PATH

# 设置环境变量
export VAR="value"
VAR="value" && export VAR

# 追加到PATH
export PATH="$PATH:/new/path"

# 删除环境变量
unset VAR

条件判断

test命令

# 文件测试
[ -f file.txt ]          # 是普通文件
[ -d dir ]                # 是目录
[ -e file ]               # 存在
[ -r file ]               # 可读
[ -w file ]               # 可写
[ -x file ]               # 可执行
[ -L file ]               # 是符号链接
[ file1 -nt file2 ]      # file1比file2新
[ file1 -ot file2 ]      # file1比file2旧

# 字符串测试
[ -z "$str" ]            # 字符串为空
[ -n "$str" ]            # 字符串非空
[ "$s1" = "$s2" ]        # 相等
[ "$s1" != "$s2" ]       # 不等

# 数值测试
[ $n1 -eq $n2 ]          # 等于
[ $n1 -ne $n2 ]          # 不等
[ $n1 -gt $n2 ]          # 大于
[ $n1 -ge $n2 ]          # 大于等于
[ $n1 -lt $n2 ]          # 小于
[ $n1 -le $n2 ]          # 小于等于

# 逻辑操作
[ -f file ] && [ -r file ]
[ -f file ] || [ -d file ]
[ ! -f file ]

if语句

# 基本语法
if [ condition ]; then
    commands
fi

# if-else
if [ -f "$file" ]; then
    echo "File exists"
else
    echo "File not found"
fi

# if-elif-else
if [ "$score" -ge 90 ]; then
    echo "A"
elif [ "$score" -ge 80 ]; then
    echo "B"
elif [ "$score" -ge 70 ]; then
    echo "C"
else
    echo "D"
fi

# 嵌套if
if [ -f "$file" ]; then
    if [ -r "$file" ]; then
        cat "$file"
    else
        echo "Not readable"
    fi
fi

高级条件

# 使用[[ ]]（推荐）
[[ -f file ]]                    # 文件存在
[[ -z "$str" ]]                  # 字符串为空
[[ "$str" =~ pattern ]]          # 正则匹配
[[ "$str" == *pattern* ]]        # 通配符匹配

# 正则表达式
if [[ "$email" =~ ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]; then
    echo "Valid email"
fi

# 组合条件
[[ -f file && -r file ]]         # AND
[[ -f file || -d file ]]         # OR
[[ ! -f file ]]                  # NOT

case语句

# 基本语法
case $variable in
    pattern1)
        commands
        ;;
    pattern2)
        commands
        ;;
    *)
        default commands
        ;;
esac

# 示例
case $1 in
    start)
        echo "Starting..."
        ;;
    stop)
        echo "Stopping..."
        ;;
    restart)
        echo "Restarting..."
        ;;
    *)
        echo "Usage: $0 {start|stop|restart}"
        exit 1
        ;;
esac

# 模式匹配
case $fruit in
    apple|banana)      # 或
        echo "Common fruit"
        ;;
    *)
        echo "Other"
        ;;
esac

循环

for循环

# 基本语法
for item in list; do
    echo $item
done

# C风格for循环
for ((i=0; i<10; i++)); do
    echo $i
done

# 遍历数组
arr=(one two three)
for item in "${arr[@]}"; do
    echo $item
done

# 遍历文件
for file in *.txt; do
    echo "Processing $file"
done

# 遍历目录
for dir in /home/*/; do
    echo "User directory: $dir"
done

# 读取文件行
while IFS= read -r line; do
    echo "$line"
done < file.txt

while循环

# 基本语法
while [ condition ]; do
    commands
done

# 读取用户输入
while true; do
    read -p "Enter a number (q to quit): " num
    [ "$num" = "q" ] && break
    echo $((num * 2))
done

# 读取文件
while IFS= read -r line; do
    echo "$line"
done < file.txt

# 计数器
count=0
while [ $count -lt 10 ]; do
    echo $count
    ((count++))
done

until循环

# 条件为false时继续
until [ condition ]; do
    commands
done

# 示例：等待服务启动
until curl -s http://localhost:8080 > /dev/null; do
    echo "Waiting for service..."
    sleep 2
done
echo "Service is ready!"

循环控制

# break - 跳出循环
for i in {1..10}; do
    if [ $i -eq 5 ]; then
        break
    fi
    echo $i
done

# continue - 跳过本次迭代
for i in {1..10}; do
    if [ $i -eq 5 ]; then
        continue
    fi
    echo $i
done

# 嵌套循环
for i in {1..3}; do
    for j in {1..3}; do
        if [ $j -eq 2 ]; then
            break 2    # 跳出两层循环
        fi
        echo "$i-$j"
    done
done

函数

函数定义

# 基本语法
function_name() {
    commands
    return value
}

# 或
function function_name {
    commands
    return value
}

# 示例
greet() {
    echo "Hello, $1!"
}
greet "World"

# 返回值
get_sum() {
    local sum=$(( $1 + $2 ))
    return $sum    # 只能返回0-255
}
get_sum 10 20
echo $?            # 获取返回值

函数参数

# 通过位置参数传递
my_func() {
    echo "Arg 1: $1"
    echo "Arg 2: $2"
    echo "All args: $@"
    echo "Arg count: $#"
}
my_func "hello" "world"

# 返回值方式
get_result() {
    local result="computed value"
    echo "$result"
}
result=$(get_result)

函数库

# common.sh - 函数库文件
#!/bin/bash

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
}

error() {
    echo "[ERROR] $1" >&2
}

check_file() {
    if [ ! -f "$1" ]; then
        error "File not found: $1"
        return 1
    fi
    return 0
}

# 使用函数库
source ./common.sh
log "Starting script"
check_file "/path/to/file" || exit 1

局部变量

# 局部变量
my_function() {
    local var="local"
    echo $var
}

# 全局变量
global_var="I'm global"

算术运算

# $(( ))
echo $((10 + 5))            # 15
echo $((10 - 5))            # 5
echo $((10 * 5))            # 50
echo $((10 / 5))            # 2
echo $((10 % 3))            # 1
echo $((10 ** 2))           # 100 (幂运算)

# 复合赋值
((i++))
((i--))
((i+=5))
((i-=5))
((i*=2))
((i/=2))

# expr命令
expr 10 + 5
expr 10 \* 5               # 乘法需要转义

# bc计算器（浮点数）
echo "scale=2; 10 / 3" | bc
echo "sqrt(100)" | bc -l

字符串处理

# 字符串长度
str="Hello World"
echo ${#str}

# 字符串切片
echo ${str:0}               # Hello World
echo ${str:6}               # World
echo ${str:0,5}             # Hello
echo ${str: -5}             # World (注意空格)

# 字符串替换
echo ${str/hello/hi}        # 替换第一个
echo ${str//o/O}            # 替换所有

# 删除子串
echo ${str#H*o}             # 从开头删除最短匹配
echo ${str##H*o}           # 从开头删除最长匹配
echo ${str%o*d}            # 从结尾删除最短匹配
echo ${str%%o*d}           # 从结尾删除最长匹配

# 字符串转换
echo ${str,,}              # 转小写
echo ${str^^}              # 转大写

数组操作

# 定义数组
arr=(one two three four)
arr[0]="first"
arr+=("five")              # 添加元素

# 访问元素
echo ${arr[0]}
echo ${arr[@]}             # 所有元素
echo ${!arr[@]}            # 所有索引

# 数组长度
echo ${#arr[@]}

# 切片
echo ${arr[@]:1:2}         # 从索引1开始，取2个

# 关联数组
declare -A user
user["name"]="John"
user["email"]="john@example.com"

脚本调试

# 选项
set -x              # 显示执行的命令
set -v              # 显示原始输入
set -e              # 命令失败时退出
set -u              # 使用未定义变量时报错
set -n              # 检查语法但不执行
set -o pipefail    # 管道中任何命令失败都退出

# 在脚本中使用
#!/bin/bash
set -x              # 调试开启
commands
set +x              # 调试关闭

# 检测错误
set -euo pipefail
# -e: 遇错退出
# -u: 未定义变量报错
# -o pipefail: 管道失败报错

实战脚本

系统信息脚本

#!/bin/bash
# system_info.sh - 系统信息报告

set -euo pipefail

echo "=================================="
echo "       System Information"
echo "=================================="
echo

# 主机名
echo "Hostname: $(hostname)"
echo "Uptime: $(uptime -p)"
echo

# 系统信息
echo "OS: $(lsb_release -ds 2>/dev/null || cat /etc/os-release | grep PRETTY_NAME)"
echo "Kernel: $(uname -r)"
echo "Architecture: $(uname -m)"
echo

# CPU
echo "CPU: $(grep 'model name' /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/^ *//')"
echo "CPU Cores: $(nproc)"
echo

# 内存
free -h | grep Mem | awk '{printf "Memory: %s / %s\n", $3, $2}'
echo

# 磁盘
df -h | grep -E '^/dev/' | awk '{printf "Disk %s: %s / %s (Used: %s)\n", $1, $3, $2, $5}'
echo

# 网络
echo "IP Addresses:"
ip -4 addr show | grep inet | awk '{printf "  %s\n", $2}'
echo

# Top 5 进程
echo "Top 5 Processes by Memory:"
ps aux --sort=-%mem | head -6 | tail -5 | awk '{printf "  %s %s%% %s\n", $11, $4, $6}'

备份脚本

#!/bin/bash
# backup.sh - 自动备份脚本

set -euo pipefail

# 配置
SOURCE_DIRS="/home /etc /var/www"
BACKUP_DIR="/backup"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="backup_${DATE}.tar.gz"
RETENTION_DAYS=7

# 创建备份目录
mkdir -p "$BACKUP_DIR"

# 创建备份
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
}

log "Starting backup..."

tar -czf "${BACKUP_DIR}/${BACKUP_FILE}" $SOURCE_DIRS 2>/dev/null

# 验证备份
if [ -f "${BACKUP_DIR}/${BACKUP_FILE}" ]; then
    SIZE=$(du -h "${BACKUP_DIR}/${BACKUP_FILE}" | cut -f1)
    log "Backup completed: ${BACKUP_FILE} (${SIZE})"
else
    log "ERROR: Backup failed!"
    exit 1
fi

# 清理旧备份
find "$BACKUP_DIR" -name "backup_*.tar.gz" -mtime +${RETENTION_DAYS} -delete
log "Old backups cleaned (older than ${RETENTION_DAYS} days)"

log "Backup finished successfully!"

课后练习

实践任务

编写一个计算器脚本，支持加减乘除运算
编写一个日志分析脚本，统计日志中的错误数量
编写一个批量文件处理脚本
创建包含多个函数的函数库
使用set -x调试脚本
编写完整的系统信息报告脚本

下一篇预告：我们将学习Shell脚本进阶，掌握正则表达式、函数高级用法和数组操作。

Shell脚本进阶

Wed, 14 Jan 2026 00:00:00 +0000

正则表达式

基本正则（BRE）

# 字符类
[abc]           # 匹配 a, b, 或 c
[^abc]          # 匹配除 a, b, c 外的字符
[a-z]           # 匹配小写字母
[A-Z]           # 匹配大写字母
[0-9]           # 匹配数字
[a-zA-Z0-9]     # 字母或数字

# 预定义字符类
[[:alpha:]]     # 字母
[[:digit:]]     # 数字
[[:alnum:]]     # 字母数字
[[:space:]]     # 空白字符
[[:upper:]]     # 大写字母
[[:lower:]]     # 小写字母

# 量词
*               # 零个或多个
\{n\}           # 恰好n个
\{n,\}          # n个或更多
\{n,m\}         # n到m个
.               # 任意单个字符

# 位置锚点
^               # 行首
$               # 行尾
\<              # 词首
\>              # 词尾

扩展正则（ERE）

# egrep 或 grep -E 使用
grep -E "pattern" file

# 量词
+               # 一个或多个
?               # 零个或一个
{n}             # 恰好n个
{n,}            # n个或更多
{n,m}           # n到m个

# 或运算
|               # 或
(abc|def)       # abc 或 def

常用正则模式

# IP地址
[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}
# 或
[0-9]{1,3}(\.[0-9]{1,3}){3}

# 邮箱
[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}

# URL
https?://[a-zA-Z0-9.-]+(/[a-zA-Z0-9._~:/?#\[\]@!$&'()*+,;=-]*)?

# 日期 YYYY-MM-DD
[0-9]{4}-[0-9]{2}-[0-9]{2}

# 时间 HH:MM:SS
[0-9]{2}:[0-9]{2}:[0-9]{2}

# 手机号（中国大陆）
1[3-9][0-9]{9}

# MAC地址
([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}

sed正则

# 基础替换
sed 's/old/new/' file

# 邮箱添加链接
sed -E 's/([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/<a href="mailto:\1">\1<\/a>/g' file

# 提取IP
ifconfig | grep -oE '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+'

# 清理日志时间戳
sed -E 's/^[A-Z][a-z]{2} [0-9]+ [0-9]{2}:[0-9]{2}:[0-9]{2} //' logfile

awk正则

# 正则匹配
awk '/pattern/ {print}' file
awk '$3 ~ /regex/ {print}' file
awk '$3 !~ /regex/ {print}' file

# 提取邮箱
awk -F',' '{for(i=1;i<=NF;i++) if($i ~ /@/) print $i}' file

# 验证IP格式
awk -F. '$1>=0 && $1<=255 && $2>=0 && $2<=255 && $3>=0 && $3<=255 && $4>=0 && $4<=255' file

数组进阶

数组基础回顾

# 定义数组
arr=(one two three)
arr[0]="first"
declare -a arr=(one two three)
declare -A arr=([key1]="value1" [key2]="value2")

# 访问
${arr[0]}           # 单个元素
${arr[@]}           # 所有元素
${!arr[@]}          # 所有索引
${#arr[@]}          # 数组长度

数组切片

arr=(zero one two three four five)

# 切片
${arr[@]:1:3}       # one two three
${arr[@]:2}         # two three four five
${arr[@]::3}        # zero one two

# 替换
${arr[@]/one/ONE}   # ONE two three four five
${arr[@]//[aeiou]/} # 移除元音

数组操作

# 追加元素
arr+=(four five)
arr=( "${arr[@]}" "new" )

# 删除元素
unset arr[2]                # 删除索引2
arr=( "${arr[@]}" )         # 重建数组

# 数组去重
arr=( $(printf '%s\n' "${arr[@]}" | sort -u) )

# 数组反转
arr=( "$(echo "${arr[@]}" | tac -s' ')" )
# 或
reverse() {
    local arr=("$@")
    local n=${#arr[@]}
    for ((i=n-1; i>=0; i--)); do
        echo "${arr[i]}"
    done
}

关联数组

# 定义
declare -A user
user[name]="John"
user[email]="john@example.com"
user[age]=30

# 遍历
for key in "${!user[@]}"; do
    echo "$key: ${user[$key]}"
done

# 按键排序遍历
for key in $(echo "${!user[@]}" | tr ' ' '\n' | sort); do
    echo "$key: ${user[$key]}"
done

# 键值对输出
printf '%s=%s\n' "${!user[@]}" "${user[@]}"

二维数组（模拟）

# 声明
declare -A matrix

# 赋值
for i in {0..2}; do
    for j in {0..2}; do
        matrix[$i,$j]=$((i * 3 + j + 1))
    done
done

# 访问
echo ${matrix[1,2]}

# 遍历
for key in "${!matrix[@]}"; do
    IFS=',' read -r i j <<< "$key"
    echo "matrix[$i,$j] = ${matrix[$key]}"
done | sort -t'[' -k2 -n

函数进阶

返回值

# return 限制（0-255）
check() {
    if [ "$1" -gt 10 ]; then
        return 0
    else
        return 1
    fi
}

# 使用echo返回字符串
get_date() {
    date +"%Y-%m-%d %H:%M:%S"
}
current=$(get_date)

# 返回多个值
get_stats() {
    local min=$1
    local max=$1
    local sum=0
    for val in "$@"; do
        ((val < min)) && min=$val
        ((val > max)) && max=$val
        ((sum+=val))
    done
    echo "$min $max $sum"
}

read min max sum <<< $(get_stats 5 2 8 1 9)
echo "Min: $min, Max: $max, Sum: $sum"

局部变量与全局变量

global_var="I'm global"

test_scope() {
    local local_var="I'm local"
    global_var="Modified global"
    echo "Inside: $global_var"
    echo "Inside: $local_var"
}

test_scope
echo "Outside: $global_var"
echo "Outside: $local_var"    # 空

递归函数

# 阶乘
factorial() {
    local n=$1
    if [ $n -le 1 ]; then
        echo 1
    else
        local prev=$(factorial $((n-1)))
        echo $((n * prev))
    fi
}
factorial 5    # 120

# 斐波那契
fib() {
    local n=$1
    if [ $n -le 1 ]; then
        echo $n
    else
        local a=$(fib $((n-1)))
        local b=$(fib $((n-2)))
        echo $((a + b))
    fi
}

# 目录递归
list_recursive() {
    local dir=${1:-.}
    for item in "$dir"/*; do
        if [ -d "$item" ]; then
            echo "DIR: $item"
            list_recursive "$item"
        else
            echo "FILE: $item"
        fi
    done
}

函数库

# colors.sh
#!/bin/bash

# 颜色代码
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

log_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1" >&2
}

progress_bar() {
    local percent=$1
    local width=50
    local filled=$((width * percent / 100))
    printf "\r["
    printf "%${filled}s" | tr ' ' '='
    printf "%$((width - filled))s" | tr ' ' '-'
    printf "] %3d%%" "$percent"
}

# string_utils.sh
#!/bin/bash

trim() {
    local var="$*"
    var="${var#"${var%%[![:space:]]*}"}"
    var="${var%"${var##*[![:space:]]}"}"
    echo "$var"
}

to_lower() {
    echo "$@" | tr '[:upper:]' '[:lower:]'
}

to_upper() {
    echo "$@" | tr '[:lower:]' '[:upper:]'
}

starts_with() {
    [[ "$1" == "$2"* ]]
}

ends_with() {
    [[ "$1" == *"$2" ]]
}

# date_utils.sh
#!/bin/bash

timestamp() {
    date +"%Y-%m-%d %H:%M:%S"
}

timestamp_file() {
    date +"%Y%m%d_%H%M%S"
}

date_add_days() {
    date -d "$1 + $2 days" +"%Y-%m-%d"
}

date_diff() {
    local d1=$(date -d "$1" +%s)
    local d2=$(date -d "$2" +%s)
    echo $(( (d1 - d2) / 86400 ))
}

# 使用函数库
#!/bin/bash
source ./colors.sh
source ./string_utils.sh
source ./date_utils.sh

log_info "Starting process..."
log_success "Completed!"

命名空间（模拟）

# 使用前缀模拟命名空间
namespace::init() {
    declare -gA namespace__data
}

namespace::set() {
    namespace__data[$1]="$2"
}

namespace::get() {
    echo "${namespace__data[$1]}"
}

namespace::delete() {
    unset namespace__data[$1]
}

namespace::clear() {
    declare -gA namespace__data
}

namespace::keys() {
    echo "${!namespace__data[@]}"
}

namespace::values() {
    echo "${namespace__data[@]}"
}

高级I/O

here文档

# 基本语法
cat << EOF
Content line 1
Content line 2
Variable: $var
Command: $(date)
EOF

# 禁止变量替换
cat << 'EOF'
Variable: $var
EOF

# 缩进（使用-）
cat <<- EOF
    Indented content
    More content
EOF

# 写入文件
cat << EOF > file.txt
Line 1
Line 2
EOF

# 追加
cat << EOF >> file.txt
Line 3
EOF

here字符串

# 基本用法
cat <<< "Hello World"
read -r var <<< "some value"

# 变量赋值
read -r city <<< "New York"
echo $city    # New York

read高级用法

# 读取字段到数组
read -a words <<< "one two three four"
echo "${words[0]}"    # one

# 超时读取
read -t 5 -p "Enter value: " value

# 分隔符
IFS=':' read -r user pass uid gid comment home shell <<< "root:x:0:0:root:/root:/bin/bash"

# 不转义反斜杠
IFS= read -r line < file

# 读取密码
read -s -p "Password: " password

文件描述符

# 标准文件描述符
# 0 - 标准输入 (stdin)
# 1 - 标准输出 (stdout)
# 2 - 标准错误 (stderr)

# 重定向
command > file          # stdout到文件
command 2> file         # stderr到文件
command > file 2>&1     # 两者都到文件
command &> file         # 同上（更简洁）
command &>> file        # 追加

# 管道错误处理
set -o pipefail

# tee重定向
command | tee file.txt
command | tee -a file.txt        # 追加

# 交换stdout和stderr
command 3>&1 1>&2 2>&3

# 临时重定向
echo "message" > /dev/null 2>&1

进程替换

# 语法
<(command)
>(command)

# 示例
diff <(sort file1) <(sort file2)
while IFS= read -r line; do
    echo "$line"
done < <(grep "pattern" file)

# 替换变量
cat <(echo "header"; cat file) <(echo "footer")

高级技巧

命令执行超时

# 使用timeout
timeout 10 command
timeout 5s ./slow_script.sh

# 自定义超时函数
timeout_handler() {
    local timeout=$1
    shift
    "$@" &
    local pid=$!
    (
        sleep $timeout
        kill -0 $pid 2>/dev/null && kill -TERM $pid
    ) &
    local timer=$!
    wait $pid
    local status=$?
    kill -0 $timer 2>/dev/null && kill $timer
    return $status
}

信号处理

#!/bin/bash
# trap.sh

trap 'echo "Received SIGINT"; exit 1' INT
trap 'echo "Received SIGTERM"; cleanup; exit' TERM

cleanup() {
    echo "Cleaning up..."
    # 清理操作
    rm -f /tmp/lock
}

# 忽略信号
trap '' TSTP    # 忽略 Ctrl+Z
trap '' QUIT   # 忽略 Ctrl+\
trap '' HUP    # 忽略挂起

# 调试模式
trap 'echo "DEBUG: $LINENO: $BASH_COMMAND"' DEBUG
trap 'echo "EXIT: exiting with code $?"' EXIT

进度显示

#!/bin/bash

progress() {
    local current=$1
    local total=$2
    local width=40
    local percent=$((current * 100 / total))
    local completed=$((width * current / total))
    local remaining=$((width - completed))
    
    printf "\r["
    printf "%${completed}s" | tr ' ' '='
    printf "%${remaining}s" | tr ' ' '-'
    printf "] %3d%%" "$percent"
    
    [ $current -eq $total ] && echo
}

# 使用示例
total=100
for i in $(seq 1 $total); do
    progress $i $total
    sleep 0.05
done

并行处理

# 后台并行
for i in {1..10}; do
    process_item $i &
done
wait

# xargs并行
cat items.txt | xargs -P 4 -I {} process {}

# GNU parallel
sudo apt install parallel
cat items.txt | parallel -P 4 process {}

# 限制并发数
semaphore=0
max_jobs=4

run_job() {
    local job=$1
    (
        process "$job"
        ((semaphore--))
    ) &
    ((semaphore++))
}

for item in items; do
    while [ $semaphore -ge $max_jobs ]; do
        wait -n
    done
    run_job "$item"
done
wait

实战案例

日志分析脚本

#!/bin/bash
# analyze_logs.sh

set -euo pipefail

# 配置
LOG_FILE=${1:-/var/log/syslog}
OUTPUT_DIR="./report"

# 函数
log() {
    echo "[$(date '+%H:%M:%S')] $1"
}

analyze_errors() {
    log "Analyzing errors..."
    grep -iE "error|fail|critical" "$LOG_FILE" | \
        awk '{print $5}' | \
        sort | uniq -c | sort -rn | head -10
}

analyze_ip() {
    log "Analyzing IP addresses..."
    grep -oE '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' "$LOG_FILE" | \
        sort | uniq -c | sort -rn | head -10
}

analyze_requests() {
    log "Analyzing requests..."
    awk '{print $7}' "$LOG_FILE" | \
        sort | uniq -c | sort -rn | head -20
}

generate_report() {
    mkdir -p "$OUTPUT_DIR"
    
    {
        echo "==================================="
        echo "    Log Analysis Report"
        echo "    Generated: $(date)"
        echo "==================================="
        echo
        echo "Top 10 Errors:"
        analyze_errors
        echo
        echo "Top 10 IP Addresses:"
        analyze_ip
        echo
        echo "Top 20 Requests:"
        analyze_requests
    } > "$OUTPUT_DIR/report_$(date +%Y%m%d_%H%M%S).txt"
    
    log "Report generated!"
}

# 主程序
log "Starting log analysis..."
generate_report
log "Analysis complete!"

课后练习

实践任务

编写正则表达式验证邮箱、手机号、IP地址
创建包含多个函数的工具库
编写支持参数的日志分析脚本
实现带超时和信号处理的脚本
使用并行处理优化脚本性能
编写完整的系统监控脚本

下一篇预告：我们将学习Shell脚本实战，通过真实案例掌握自动化运维技能。

Shell脚本实战

Thu, 15 Jan 2026 00:00:00 +0000

实战案例概述

本章将展示真实生产环境中常用的Shell脚本案例，涵盖系统监控、日志处理、数据备份、自动化部署等场景。

系统监控脚本

主机健康监控

#!/bin/bash
# health_check.sh - 系统健康状态监控

set -uo pipefail

# 配置
ALERT_THRESHOLD_CPU=80
ALERT_THRESHOLD_MEM=90
ALERT_THRESHOLD_DISK=85
ALERT_EMAIL="admin@example.com"
SLACK_WEBHOOK=""  # 可选Slack通知

# 颜色
RED='\033[0;31m'
YELLOW='\033[1;33m'
GREEN='\033[0;32m'
NC='\033[0m'

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
}

check_cpu() {
    local usage=$(top -bn1 | grep "Cpu(s)" | awk '{print int($2)}')
    log "CPU Usage: ${usage}%"
    
    if [ "$usage" -gt "$ALERT_THRESHOLD_CPU" ]; then
        echo -e "${RED}ALERT: CPU usage is ${usage}% (threshold: ${ALERT_THRESHOLD_CPU}%)${NC}"
        return 1
    fi
    echo -e "${GREEN}CPU: OK${NC}"
    return 0
}

check_memory() {
    local mem_used=$(free | grep Mem | awk '{printf "%.0f", $3/$2 * 100}')
    log "Memory Usage: ${mem_used}%"
    
    if [ "$mem_used" -gt "$ALERT_THRESHOLD_MEM" ]; then
        echo -e "${RED}ALERT: Memory usage is ${mem_used}% (threshold: ${ALERT_THRESHOLD_MEM}%)${NC}"
        return 1
    fi
    echo -e "${GREEN}Memory: OK${NC}"
    return 0
}

check_disk() {
    local disk_usage=$(df -h / | tail -1 | awk '{print int($5)}')
    log "Disk Usage: ${disk_usage}%"
    
    if [ "$disk_usage" -gt "$ALERT_THRESHOLD_DISK" ]; then
        echo -e "${RED}ALERT: Disk usage is ${disk_usage}% (threshold: ${ALERT_THRESHOLD_DISK}%)${NC}"
        return 1
    fi
    echo -e "${GREEN}Disk: OK${NC}"
    return 0
}

check_load() {
    local load=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
    local cores=$(nproc)
    log "Load Average: $load (cores: $cores)"
}

check_services() {
    local services=("nginx" "mysql" "sshd" "docker")
    local failed=()
    
    for svc in "${services[@]}"; do
        if systemctl is-active --quiet "$svc" 2>/dev/null; then
            echo -e "${GREEN}[$svc] Running${NC}"
        else
            echo -e "${RED}[$svc] Not Running${NC}"
            failed+=("$svc")
        fi
    done
    
    [ ${#failed[@]} -gt 0 ] && return 1
    return 0
}

check_process_count() {
    local total=$(ps aux | wc -l)
    log "Total processes: $total"
    
    if [ "$total" -gt 500 ]; then
        echo -e "${YELLOW}WARNING: High process count ($total)${NC}"
    fi
}

send_alert() {
    local message="$1"
    
    # 邮件通知
    if [ -n "$ALERT_EMAIL" ]; then
        echo "$message" | mail -s "[Alert] $(hostname) Health Check" "$ALERT_EMAIL"
    fi
    
    # Slack通知
    if [ -n "$SLACK_WEBHOOK" ]; then
        curl -s -X POST -H 'Content-type: application/json' \
            --data "{\"text\":\"$message\"}" "$SLACK_WEBHOOK"
    fi
}

# 主程序
main() {
    log "=== Starting Health Check ==="
    
    local status=0
    
    check_cpu || status=1
    check_memory || status=1
    check_disk || status=1
    check_load
    check_process_count
    echo
    check_services || status=1
    
    log "=== Health Check Complete ==="
    
    if [ $status -eq 1 ]; then
        log "ALERTS DETECTED!"
        send_alert "Health check failed on $(hostname)"
        exit 1
    fi
    
    exit 0
}

main "$@"

服务可用性监控

#!/bin/bash
# service_monitor.sh - 服务可用性监控

set -uo pipefail

# 配置
SERVICES=(
    "nginx:http://localhost:80"
    "mysql:tcp://localhost:3306"
    "redis:tcp://localhost:6379"
    "api:http://localhost:8080/api/health"
)
ALERT_EMAIL="admin@example.com"

check_http() {
    local url=$1
    local code=$(curl -s -o /dev/null -w "%{http_code}" --max-time 10 "$url")
    
    if [ "$code" = "200" ] || [ "$code" = "301" ] || [ "$code" = "302" ]; then
        echo "OK (HTTP $code)"
        return 0
    else
        echo "FAILED (HTTP $code)"
        return 1
    fi
}

check_tcp() {
    local host=$(echo "$1" | sed 's|tcp://||' | cut -d: -f1)
    local port=$(echo "$1" | sed 's|tcp://||' | cut -d: -f2)
    
    if timeout 5 bash -c "echo > /dev/tcp/$host/$port" 2>/dev/null; then
        echo "OK"
        return 0
    else
        echo "FAILED"
        return 1
    fi
}

main() {
    local failed=()
    
    echo "=== Service Monitor ==="
    
    for item in "${SERVICES[@]}"; do
        IFS=':' read -r name url <<< "$item"
        echo -n "[$name] "
        
        if [[ "$url" == http* ]]; then
            result=$(check_http "$url")
        else
            result=$(check_tcp "$url")
        fi
        
        echo "$result"
        [[ "$result" != OK* ]] && failed+=("$name")
    done
    
    if [ ${#failed[@]} -gt 0 ]; then
        echo "FAILED SERVICES: ${failed[*]}"
        # 发送告警
        echo "Service ${failed[*]} failed on $(hostname)" | \
            mail -s "[ALERT] Service Down" "$ALERT_EMAIL"
        exit 1
    fi
    
    exit 0
}

main "$@"

日志处理脚本

日志轮转与清理

#!/bin/bash
# log_rotation.sh - 日志轮转与清理

set -uo pipefail

# 配置
LOG_DIRS=("/var/log/nginx" "/var/log/mysql" "/var/log/app")
RETENTION_DAYS=30
MAX_SIZE_MB=100
COMPRESS_AFTER_DAYS=7

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
}

rotate_log() {
    local logfile=$1
    local timestamp=$(date +%Y%m%d_%H%M%S)
    
    if [ ! -f "$logfile" ]; then
        return
    fi
    
    # 检查文件大小
    local size_mb=$(du -m "$logfile" | cut -f1)
    
    if [ "$size_mb" -gt "$MAX_SIZE_MB" ]; then
        log "Rotating $logfile (size: ${size_mb}MB)"
        
        # 重命名
        mv "$logfile" "${logfile%.log}.${timestamp}.log"
        
        # 通知服务重新打开日志
        if [[ "$logfile" == *nginx* ]]; then
            nginx -s reopen 2>/dev/null || true
        fi
        
        # 创建新空文件
        touch "$logfile"
        chmod 644 "$logfile"
    fi
}

compress_old_logs() {
    local logdir=$1
    
    find "$logdir" -type f -name "*.log" -mtime +"$COMPRESS_AFTER_DAYS" \
        ! -name "*.gz" -exec gzip {} \;
}

cleanup_old_logs() {
    local logdir=$1
    
    find "$logdir" -type f \( -name "*.log" -o -name "*.gz" \) \
        -mtime +"$RETENTION_DAYS" -delete
    
    log "Cleaned logs older than $RETENTION_DAYS days in $logdir"
}

main() {
    log "=== Log Rotation Started ==="
    
    for dir in "${LOG_DIRS[@]}"; do
        if [ -d "$dir" ]; then
            log "Processing $dir"
            
            # 轮转大日志
            for logfile in "$dir"/*.log; do
                [ -f "$logfile" ] && rotate_log "$logfile"
            done
            
            # 压缩旧日志
            compress_old_logs "$dir"
            
            # 清理过期日志
            cleanup_old_logs "$dir"
        else
            log "WARNING: Directory $dir not found"
        fi
    done
    
    log "=== Log Rotation Complete ==="
}

main "$@"

日志实时分析

#!/bin/bash
# log_analyzer.sh - 实时日志分析

set -uo pipefail

# 配置
LOG_FILE=${1:-/var/log/nginx/access.log}
THRESHOLD_RPS=100

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
}

analyze_status_codes() {
    echo "=== Status Codes ==="
    awk '{print $9}' "$LOG_FILE" | sort | uniq -c | sort -rn
}

analyze_top_ips() {
    echo "=== Top 10 IPs ==="
    awk '{print $1}' "$LOG_FILE" | sort | uniq -c | sort -rn | head -10
}

analyze_top_pages() {
    echo "=== Top 10 Pages ==="
    awk '{print $7}' "$LOG_FILE" | sort | uniq -c | sort -rn | head -10
}

analyze_response_time() {
    echo "=== Response Time Stats ==="
    awk -F'"' '{print $(NF-1)}' "$LOG_FILE" | \
        awk '{sum+=$1; count++} END {print "Avg:", sum/count "ms"}'
}

analyze_errors() {
    echo "=== Error Analysis ==="
    awk '$9 >= 500 {print $7, $9}' "$LOG_FILE" | sort | uniq -c | sort -rn
}

realtime_monitor() {
    echo "=== Real-time Monitoring (Ctrl+C to stop) ==="
    tail -f "$LOG_FILE" | while read line; do
        # 统计最近一分钟请求数
        :
    done
}

generate_report() {
    local report_file="report_$(date +%Y%m%d_%H%M%S).txt"
    
    {
        echo "=== Log Analysis Report ==="
        echo "Generated: $(date)"
        echo "Log file: $LOG_FILE"
        echo
        
        analyze_status_codes
        echo
        analyze_top_ips
        echo
        analyze_top_pages
        echo
        analyze_errors
    } > "$report_file"
    
    log "Report saved to $report_file"
}

main() {
    case "${1:-report}" in
        report)
            generate_report
            ;;
        status)
            analyze_status_codes
            ;;
        ips)
            analyze_top_ips
            ;;
        pages)
            analyze_top_pages
            ;;
        errors)
            analyze_errors
            ;;
        *)
            echo "Usage: $0 {report|status|ips|pages|errors}"
            exit 1
            ;;
    esac
}

main "$@"

备份脚本

数据库备份

#!/bin/bash
# mysql_backup.sh - MySQL数据库备份

set -uo pipefail

# 配置
MYSQL_HOST=${MYSQL_HOST:-localhost}
MYSQL_PORT=${MYSQL_PORT:-3306}
MYSQL_USER=${MYSQL_USER:-backup}
MYSQL_PASSWORD=${MYSQL_PASSWORD:-}
BACKUP_DIR=${BACKUP_DIR:-/backup/mysql}
RETENTION_DAYS=${RETENTION_DAYS:-7}
DATABASES=${DATABASES:-"--all-databases"}

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
}

backup_database() {
    local db=$1
    local timestamp=$(date +%Y%m%d_%H%M%S)
    local backup_file="${BACKUP_DIR}/${db}_${timestamp}.sql.gz"
    
    log "Backing up database: $db"
    
    if mysqldump -h "$MYSQL_HOST" -P "$MYSQL_PORT" -u "$MYSQL_USER" \
        -p"${MYSQL_PASSWORD}" --single-transaction --quick "$db" | \
        gzip > "$backup_file"; then
        
        local size=$(du -h "$backup_file" | cut -f1)
        log "Backup completed: $backup_file ($size)"
        
        # 验证备份
        if gunzip -t "$backup_file" 2>/dev/null; then
            log "Backup verified: $db"
        else
            log "ERROR: Backup verification failed for $db"
            return 1
        fi
    else
        log "ERROR: Backup failed for $db"
        return 1
    fi
}

cleanup_old_backups() {
    log "Cleaning backups older than $RETENTION_DAYS days..."
    find "$BACKUP_DIR" -name "*.sql.gz" -mtime +"$RETENTION_DAYS" -delete
    log "Cleanup completed"
}

restore_database() {
    local backup_file=$1
    local db_name=$2
    
    log "Restoring $db_name from $backup_file..."
    
    gunzip -c "$backup_file" | mysql -h "$MYSQL_HOST" -P "$MYSQL_PORT" \
        -u "$MYSQL_USER" -p"${MYSQL_PASSWORD}" "$db_name"
    
    log "Restore completed"
}

main() {
    mkdir -p "$BACKUP_DIR"
    
    case "${1:-backup}" in
        backup)
            log "=== MySQL Backup Started ==="
            
            if [ "$DATABASES" = "--all-databases" ]; then
                backup_file="${BACKUP_DIR}/all_databases_$(date +%Y%m%d_%H%M%S).sql.gz"
                log "Backing up all databases..."
                
                mysqldump -h "$MYSQL_HOST" -P "$MYSQL_PORT" \
                    -u "$MYSQL_USER" -p"${MYSQL_PASSWORD}" \
                    --all-databases --single-transaction --quick | \
                    gzip > "$backup_file"
                
                log "All databases backed up to $backup_file"
            else
                for db in $DATABASES; do
                    backup_database "$db"
                done
            fi
            
            cleanup_old_backups
            log "=== MySQL Backup Complete ==="
            ;;
            
        restore)
            if [ -z "${2:-}" ] || [ -z "${3:-}" ]; then
                echo "Usage: $0 restore <backup_file> <database>"
                exit 1
            fi
            restore_database "$2" "$3"
            ;;
            
        list)
            ls -lh "$BACKUP_DIR"/*.sql.gz 2>/dev/null || echo "No backups found"
            ;;
            
        *)
            echo "Usage: $0 {backup|restore|list}"
            exit 1
            ;;
    esac
}

main "$@"

文件系统备份

#!/bin/bash
# fs_backup.sh - 文件系统增量备份

set -uo pipefail

# 配置
SOURCE_DIRS=("/home" "/etc" "/var/www")
BACKUP_DIR="/backup/fs"
REMOTE_HOST="backup-server"
REMOTE_PATH="/backup"
RETENTION_DAYS=30
EXCLUDE_FILE="/etc/backup_exclude.txt"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
}

create_backup() {
    local timestamp=$(date +%Y%m%d_%H%M%S)
    local backup_name="backup_${timestamp}"
    local backup_path="${BACKUP_DIR}/${backup_name}"
    local exclude_opts=""
    
    mkdir -p "$backup_path"
    
    # 生成排除选项
    if [ -f "$EXCLUDE_FILE" ]; then
        exclude_opts="--exclude-from=$EXCLUDE_FILE"
    fi
    
    for dir in "${SOURCE_DIRS[@]}"; do
        if [ -d "$dir" ]; then
            local basename=$(basename "$dir")
            log "Backing up $dir..."
            
            tar -czf "${backup_path}/${basename}.tar.gz" \
                -C "$(dirname "$dir")" \
                $exclude_opts \
                "$(basename "$dir")" 2>/dev/null || true
        fi
    done
    
    # 创建备份信息
    {
        echo "Backup Date: $(date)"
        echo "Source Dirs: ${SOURCE_DIRS[*]}"
        echo "Hostname: $(hostname)"
    } > "${backup_path}/backup_info.txt"
    
    log "Local backup created: $backup_path"
    
    # 复制到远程
    if [ -n "$REMOTE_HOST" ]; then
        log "Copying to remote host..."
        rsync -avz --progress "$backup_path/" \
            "${REMOTE_HOST}:${REMOTE_PATH}/" || \
            log "WARNING: Remote backup failed"
    fi
    
    # 创建压缩包
    cd "$BACKUP_DIR"
    tar -czf "${backup_name}.tar.gz" "$backup_name"
    rm -rf "$backup_name"
    
    log "Final backup: ${backup_path}.tar.gz"
}

cleanup_old_backups() {
    log "Cleaning backups older than $RETENTION_DAYS days..."
    
    find "$BACKUP_DIR" -name "backup_*.tar.gz" -mtime +"$RETENTION_DAYS" -exec rm -v {} \;
    
    log "Cleanup completed"
}

verify_backup() {
    local backup_file=$1
    
    log "Verifying backup: $backup_file"
    
    if tar -tzf "$backup_file" > /dev/null 2>&1; then
        log "Backup verified: $backup_file"
        return 0
    else
        log "ERROR: Backup verification failed: $backup_file"
        return 1
    fi
}

restore_backup() {
    local backup_file=$1
    local restore_dir=${2:-/}
    
    log "Restoring from $backup_file to $restore_dir..."
    
    tar -xzf "$backup_file" -C "$restore_dir"
    
    log "Restore completed"
}

main() {
    mkdir -p "$BACKUP_DIR"
    
    case "${1:-backup}" in
        backup)
            log "=== Filesystem Backup Started ==="
            create_backup
            cleanup_old_backups
            log "=== Backup Complete ==="
            ;;
            
        restore)
            if [ -z "${2:-}" ]; then
                echo "Usage: $0 restore <backup_file> [restore_dir]"
                exit 1
            fi
            verify_backup "$2"
            restore_backup "$2" "${3:-/}"
            ;;
            
        verify)
            if [ -z "${2:-}" ]; then
                echo "Usage: $0 verify <backup_file>"
                exit 1
            fi
            verify_backup "$2"
            ;;
            
        list)
            ls -lh "$BACKUP_DIR"/backup_*.tar.gz 2>/dev/null
            ;;
            
        *)
            echo "Usage: $0 {backup|restore|verify|list}"
            exit 1
            ;;
    esac
}

main "$@"

自动化部署脚本

应用部署脚本

#!/bin/bash
# deploy.sh - 应用自动化部署脚本

set -uo pipefail

# 配置
APP_NAME="myapp"
APP_DIR="/opt/${APP_NAME}"
REPO_URL="git@github.com:org/${APP_NAME}.git"
REPO_BRANCH="main"
DEPLOY_USER="deploy"
ENVIRONMENT=${1:-staging}
CONFIG_DIR="/etc/${APP_NAME}"

# 颜色
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

log() {
    echo -e "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
}

error() {
    echo -e "${RED}[ERROR] $1${NC}" >&2
}

success() {
    echo -e "${GREEN}[SUCCESS] $1${NC}"
}

backup_current() {
    if [ -d "$APP_DIR" ]; then
        local backup_dir="/tmp/${APP_NAME}_backup_$(date +%Y%m%d_%H%M%S)"
        log "Backing up current deployment..."
        cp -a "$APP_DIR" "$backup_dir"
        success "Backup created: $backup_dir"
    fi
}

clone_or_pull() {
    if [ -d "$APP_DIR/.git" ]; then
        log "Pulling latest changes..."
        cd "$APP_DIR"
        sudo -u "$DEPLOY_USER" git pull origin "$REPO_BRANCH"
    else
        log "Cloning repository..."
        sudo -u "$DEPLOY_USER" git clone -b "$REPO_BRANCH" "$REPO_URL" "$APP_DIR"
    fi
}

install_dependencies() {
    log "Installing dependencies..."
    
    cd "$APP_DIR"
    
    if [ -f "package.json" ]; then
        npm install --production
    fi
    
    if [ -f "requirements.txt" ]; then
        pip install -r requirements.txt
    fi
    
    if [ -f "composer.json" ]; then
        composer install --no-dev
    fi
}

run_migrations() {
    log "Running database migrations..."
    
    if [ -f "manage.py" ]; then
        python manage.py migrate --noinput
    fi
    
    if [ -f "migrations.sh" ]; then
        ./migrations.sh
    fi
}

symlink_config() {
    log "Updating configuration..."
    
    if [ -d "$CONFIG_DIR" ]; then
        ln -sf "$CONFIG_DIR/${ENVIRONMENT}.env" "$APP_DIR/.env"
        ln -sf "$CONFIG_DIR/nginx.conf" "$APP_DIR/deploy/nginx.conf"
    fi
}

restart_services() {
    log "Restarting services..."
    
    sudo systemctl restart "${APP_NAME}.service" || true
    sudo systemctl restart nginx
}

health_check() {
    log "Running health check..."
    
    local max_attempts=30
    local attempt=0
    
    while [ $attempt -lt $max_attempts ]; do
        if curl -sf "http://localhost:8080/health" > /dev/null 2>&1; then
            success "Health check passed!"
            return 0
        fi
        
        attempt=$((attempt + 1))
        sleep 2
    done
    
    error "Health check failed after $max_attempts attempts"
    return 1
}

rollback() {
    error "Deployment failed! Rolling back..."
    
    if [ -d "/tmp/${APP_NAME}_backup_"* ]; then
        local backup_dir=$(ls -td /tmp/${APP_NAME}_backup_* | head -1)
        rm -rf "$APP_DIR"
        cp -a "$backup_dir" "$APP_DIR"
        restart_services
        success "Rollback completed"
    fi
}

main() {
    log "=== Deployment Started: ${APP_NAME} to ${ENVIRONMENT} ==="
    
    # 检查root权限
    if [ "$EUID" -ne 0 ]; then
        error "This script must be run as root"
        exit 1
    fi
    
    trap rollback ERR
    
    backup_current
    clone_or_pull
    install_dependencies
    symlink_config
    run_migrations
    restart_services
    
    if health_check; then
        success "Deployment completed successfully!"
    else
        rollback
        exit 1
    fi
    
    log "=== Deployment Finished ==="
}

main "$@"

定时任务设置

Crontab配置

# 编辑crontab
crontab -e

# 常用格式
# * * * * * command
# │ │ │ │ │
# │ │ │ │ └── 星期 (0-7, 0和7是周日)
# │ │ │ └──── 月份 (1-12)
# │ │ └────── 日 (1-31)
# │ └──────── 时 (0-23)
# └───────── 分 (0-59)

# 示例
# 每分钟执行
* * * * * /path/to/script.sh

# 每小时第5分钟
5 * * * * /path/to/script.sh

# 每天凌晨3点
0 3 * * * /path/to/backup.sh

# 每周日凌晨2点
0 2 * * 0 /path/to/weekly_task.sh

# 每月1日凌晨1点
0 1 1 * * /path/to/monthly_task.sh

# 每5分钟执行
*/5 * * * * /path/to/monitor.sh

# 特定时间范围
0 9-17 * * 1-5 /path/to/business_hours.sh

# 系统crontab
sudo vim /etc/crontab
sudo vim /etc/cron.daily/
sudo vim /etc/cron.hourly/

cron管理

# 查看crontab
crontab -l

# 查看系统cron
ls -la /etc/cron.d/

# 删除crontab
crontab -r

# 备份crontab
crontab -l > crontab_backup.txt

# 恢复crontab
crontab crontab_backup.txt

# 查看cron日志
grep CRON /var/log/syslog
journalctl -u cron

课后练习

实践任务

根据实际环境修改并运行健康检查脚本
配置数据库备份脚本的定时任务
实现一套完整的日志分析脚本
编写自动化部署脚本并配置CI/CD
配置日志轮转的cron任务

下一篇预告：我们将学习系统安全加固，掌握Linux安全防护技能。

系统安全加固

Fri, 16 Jan 2026 00:00:00 +0000

安全加固概述

Linux系统安全需要从多个层面进行防护，包括账户安全、服务安全、网络安全、文件系统安全等。

┌─────────────────────────────────────────────────────────────┐
│                    安全加固层次                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   应用层 ── 服务配置、Web安全                                │
│   用户层 ── 账户策略、权限控制                               │
│   网络层 ── 防火墙、SSH安全                                  │
│   内核层 ── 内核参数、SELinux                               │
│   文件层 ── 权限、ACL、SUID管理                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

账户安全

密码策略

# 安装libpam-pwquality
sudo apt install libpam-pwquality

# /etc/security/pwquality.conf
minlen = 12                    # 最小长度
dcredit = -1                   # 至少1位数字
ucredit = -1                   # 至少1位大写
lcredit = -1                   # 至少1位小写
ocredit = -1                   # 至少1位特殊字符
maxrepeat = 2                  # 最多连续相同字符
difok = 3                      # 与旧密码至少3个字符不同

# /etc/login.defs
PASS_MAX_DAYS 90               # 密码最长使用天数
PASS_MIN_DAYS 7                # 密码最小使用天数
PASS_WARN_AGE 7                # 密码过期警告天数

账户锁定

# 锁定账户
sudo passwd -l username

# 解锁账户
sudo passwd -u username

# 强制首次登录改密码
sudo chage -d 0 username

# 查看账户状态
sudo chage -l username

# 自动锁定（连续失败5次后锁定30分钟）
sudo apt install libpam-cracklib

# /etc/pam.d/common-auth 添加
auth required pam_tally2.so onerr=fail deny=5 unlock_time=1800

清理无用账户

# 查看所有账户
cut -d: -f1 /etc/passwd

# 检查可登录账户
grep -E "^(root|ubuntu|admin):" /etc/passwd

# 删除不需要的系统账户
sudo userdel games
sudo userdel lp
sudo userdel news
sudo userdel uucp
sudo userdel ftp

# 禁用guest账户（Ubuntu）
sudo passwd -l guest
sudo rm -rf /home/guest

sudo权限审计

# 查看sudoers配置
sudo visudo -c

# 查看用户sudo权限
sudo -l -U username

# 查看sudo使用日志
sudo grep sudo /var/log/auth.log | tail -50
sudo cat /var/log/auth.log | grep "sudoers"

# 允许特定命令
username ALL=(ALL) /usr/bin/systemctl status nginx
username ALL=(ALL) /usr/bin/systemctl restart nginx, /usr/bin/systemctl stop nginx
username ALL=(ALL) NOPASSWD: /bin/systemctl restart network

文件系统安全

重要文件权限

# 设置关键文件权限
sudo chmod 600 /etc/shadow
sudo chmod 644 /etc/passwd
sudo chmod 644 /etc/group
sudo chmod 600 /etc/gshadow
sudo chmod 000 /etc/shadow-

# SSH密钥权限
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
chmod 600 ~/.ssh/id_rsa
chmod 644 ~/.ssh/id_rsa.pub

# 审计SUID文件
find / -perm -4000 -type f 2>/dev/null

# 移除不必要的SUID
sudo chmod -s /usr/bin/passwd        # 注意：passwd需要保留SUID
sudo chmod -s /usr/bin/sudo
sudo chmod -s /usr/bin/chfn
sudo chmod -s /usr/bin/newgrp
sudo chmod -s /usr/bin/gpasswd

文件系统挂载选项

# /etc/fstab 配置
# noexec - 禁止执行程序
# nosuid - 忽略SUID位
# nodev - 禁止设备文件

# /tmp 分区
tmpfs /tmp tmpfs defaults,noexec,nosuid,nodev 0 0

# /var/tmp
/tmp /var/tmp none bind,noexec,nosuid,nodev 0 0

# 检查当前挂载
mount | grep noexec
mount | grep nosuid

目录访问控制

# 设置目录权限
chmod 750 /home
chmod 700 /root
chmod 755 /var/log

# ACL配置
setfacl -m u:apache:rx /var/log/httpd
setfacl -m g:developers:rw /project

# 默认ACL
setfacl -m d:o::--- /secure_dir
setfacl -m d:g:group:rx /shared_dir

服务安全

禁用不必要的服务

# 列出所有服务
systemctl list-unit-files --type=service --state=enabled

# 禁用不需要的服务
sudo systemctl disable telnet
sudo systemctl disable rsh
sudo systemctl disable rlogin
sudo systemctl disable vsftpd
sudo systemctl disable cups
sudo systemctl disable bluetooth

# 停止服务
sudo systemctl stop cups
sudo systemctl stop bluetooth

服务配置检查

# Apache安全配置
sudo vim /etc/apache2/conf-available/security.conf

# 设置
ServerTokens Prod
ServerSignature Off
TraceEnable Off
Header set X-Content-Type-Options: "nosniff"
Header set X-Frame-Options: "DENY"
Header set X-XSS-Protection: "1; mode=block"

# Nginx安全配置
sudo vim /etc/nginx/nginx.conf

# 添加
add_header X-Frame-Options "DENY";
add_header X-Content-Type-Options "nosniff";
add_header X-XSS-Protection "1; mode=block";
add_header Referrer-Policy "no-referrer-when-downgrade";

数据库安全

# MySQL安全初始化
sudo mysql_secure_installation

# PostgreSQL安全配置
sudo vim /etc/postgresql/*/main/pg_hba.conf

# 本地使用md5，其他拒绝
local   all             all                                     md5
host    all             all             127.0.0.1/32            md5
host    all             all             ::1/128                 md5
host    all             all             0.0.0.0/0                reject

# 重载配置
sudo systemctl reload postgresql

网络安全

内核参数加固

# /etc/sysctl.conf

# IP转发（按需开启）
net.ipv4.ip_forward = 0                    # 关闭转发
net.ipv6.conf.all.forwarding = 0

# ICMP设置
net.ipv4.icmp_echo_ignore_broadcasts = 1    # 忽略广播ping
net.ipv4.icmp_ignore_bogus_error_responses = 1
net.ipv4.icmp_ratelimit = 100

# TCP加固
net.ipv4.tcp_syncookies = 1                 # SYN flood防护
net.ipv4.tcp_syn_retries = 2
net.ipv4.tcp_synack_retries = 2
net.ipv4.tcp_max_syn_backlog = 8192

# 禁用源路由
net.ipv4.conf.all.accept_source_route = 0
net.ipv6.conf.all.accept_source_route = 0

# 禁用ICMP重定向
net.ipv4.conf.all.accept_redirects = 0
net.ipv6.conf.all.accept_redirects = 0

# 禁用发送重定向
net.ipv4.conf.all.send_redirects = 0

# 禁用路由记录
net.ipv4.conf.all.accept_source_route = 0

# 日志可疑包
net.ipv4.conf.all.log_martians = 1
net.ipv4.conf.default.log_martians = 1

# 应用配置
sudo sysctl -p

网络访问控制

# /etc/hosts.allow
sshd: 192.168.1.0/24, 10.0.0.0/8
mysqld: 127.0.0.1

# /etc/hosts.deny
ALL: ALL

# 应用配置
sudo systemctl restart sshd
sudo systemctl restart mysql

SSH安全加固

# /etc/ssh/sshd_config 安全配置

# 基础设置
Port 2222
Protocol 2
ListenAddress 0.0.0.0

# 认证设置
PermitRootLogin no
PubkeyAuthentication yes
PasswordAuthentication no
PermitEmptyPasswords no
MaxAuthTries 3
MaxSessions 10

# 安全设置
ClientAliveInterval 300
ClientAliveCountMax 2
LoginGraceTime 60
StrictModes yes
UsePrivilegeSeparation sandbox

# 允许用户
AllowUsers user1 user2

# 超时设置
ClientAliveInterval 600
ClientAliveCountMax 3

# X11转发
X11Forwarding no

# 重启SSH
sudo systemctl restart sshd

日志审计

配置审计日志

# /etc/rsyslog.conf

# 记录所有auth日志
auth.* /var/log/auth.log
authpriv.* /var/log/auth.log

# 记录cron
cron.* /var/log/cron.log

# 记录内核
kern.* /var/log/kern.log

# 远程日志收集
*.* @@logserver.example.com:514

# 重启服务
sudo systemctl restart rsyslog

auditd配置

# 安装
sudo apt install auditd

# /etc/audit/auditd.conf
log_file = /var/log/audit/audit.log
max_log_file = 100
max_log_file_action = ROTATE
space_left = 75
space_left_action = SYSLOG
admin_space_left = 50
admin_space_left_action = SUSPEND
disk_full_action = SUSPEND
disk_error_action = SUSPEND

# 添加审计规则
sudo vim /etc/audit/rules.d/audit.rules

# 监控配置文件变更
-w /etc/passwd -p wa -k identity
-w /etc/shadow -p wa -k identity
-w /etc/group -p wa -k identity
-w /etc/gshadow -p wa -k identity

# 监控网络配置
-w /etc/sysctl.conf -p wa -k system_mod
-w /etc/network/ -p wa -k network

# 监控SSH配置
-w /etc/ssh/sshd_config -p wa -k sshd_config

# 监控敏感命令
-a always,exit -F arch=b64 -S execve -F path=/usr/bin/wget -k command_wget
-a always,exit -F arch=b64 -S execve -F path=/usr/bin/curl -k command_curl

# 重新加载规则
sudo auditctl -R /etc/audit/rules.d/audit.rules

# 查看审计日志
sudo aureport -au | head -20    # 认证事件
sudo aureport -f | head -20     # 文件访问
sudo aureport -t today          # 今日报告
sudo ausearch -k sshd_config    # 搜索特定key

SELinux配置

# CentOS/RHEL SELinux配置
# 检查状态
sestatus
getenforce

# 模式
# Enforcing - 强制执行
# Permissive - 仅记录
# Disabled - 禁用

# 临时设置
sudo setenforce Enforcing
sudo setenforce Permissive

# 永久设置
sudo vim /etc/selinux/config
SELINUX=enforcing
SELINUXTYPE=targeted

# 管理布尔值
semanage boolean -l | grep httpd
setsebool -P httpd_can_network_connect 1

# 管理端口
semanage port -l | grep http
semanage port -a -t http_port_t -p tcp 8080

# 查看日志
sudo tail -f /var/log/audit/audit.log | grep denied
sudo sealert -a /var/log/audit/audit.log

安全扫描

Lynis安全审计

# 安装
sudo apt install lynis

# 运行审计
sudo lynis audit system

# 只显示警告
sudo lynis audit system --quick

# 输出到文件
sudo lynis audit system > lynis_report.txt

RKHunter检测

# 安装
sudo apt install rkhunter

# 配置
sudo vim /etc/rkhunter.conf

# 更新数据库
sudo rkhunter --update
sudo rkhunter --propupd

# 运行检查
sudo rkhunter --checkall

# 只显示警告
sudo rkhunter --checkall --rwo

ClamAV病毒扫描

# 安装
sudo apt install clamav clamav-daemon

# 更新病毒库
sudo systemctl stop clamav-freshclam
sudo freshclam
sudo systemctl start clamav-freshclam

# 扫描
sudo clamscan -r /home
sudo clamscan -r /home --remove=yes
sudo clamscan -r / --exclude-dir=/sys --exclude-dir=/proc

安全检查清单

┌─────────────────────────────────────────────────────────────┐
│                    安全检查清单                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   □ 更改默认SSH端口                                          │
│   □ 禁用root直接登录                                        │
│   □ 配置SSH密钥认证                                         │
│   □ 设置强密码策略                                          │
│   □ 禁用不必要的账户                                        │
│   □ 配置sudo权限审计                                        │
│   □ 设置SUID文件监控                                        │
│   □ 配置防火墙规则                                          │
│   □ 关闭不必要的服务                                         │
│   □ 配置内核安全参数                                         │
│   □ 启用审计日志                                            │
│   □ 定期安全更新                                            │
│   □ 备份重要数据                                            │
│   □ 配置入侵检测                                            │
│   □ 网络安全扫描                                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘

课后练习

实践任务

配置密码复杂度策略
加固SSH配置，禁用密码登录
配置系统审计规则
使用lynis进行安全审计
配置内核安全参数
建立完整的安全加固脚本

下一篇预告：我们将学习性能监控与优化，掌握系统调优技能。

性能监控与优化

Sat, 17 Jan 2026 00:00:00 +0000

性能监控概述

Linux性能优化需要从CPU、内存、磁盘I/O、网络等多个维度进行分析和调优。

┌─────────────────────────────────────────────────────────────┐
│                    性能监控维度                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   CPU ── 利用率、负载、上下文切换                           │
│   Memory ── 物理内存、Swap、缓存                            │
│   Disk ── I/O读写、吞吐量、IOPS                             │
│   Network ── 带宽、延迟、连接数                              │
│   Process ── CPU/内存占用、线程数                           │
│                                                             │
└─────────────────────────────────────────────────────────────┘

CPU监控

CPU信息查看

# 查看CPU详细信息
lscpu

# /proc/cpuinfo
cat /proc/cpuinfo

# CPU型号
grep "model name" /proc/cpuinfo | head -1

# CPU核心数
nproc                          # 逻辑核心
lscpu | grep "^CPU(s):"        # 同上

CPU使用率

# top命令
top
top -b -n 5                    # 批处理模式，5次采样
top -Hp <pid>                  # 线程视图

# 按CPU排序
top -o %CPU

# htop（推荐）
htop
htop -d 10                     # 10秒刷新
htop -s PERCENT_CPU           # 按CPU排序

# mpstat（需安装sysstat）
mpstat                         # 每CPU统计
mpstat -P ALL 1 5             # 每1秒，共5次

# pidstat
pidstat -p <pid> 1            # 进程统计
pidstat -r <pid> 1            # 内存统计
pidstat -d <pid> 1            # I/O统计

系统负载

# uptime
uptime

# 负载解读
# 负载: 0.46 0.30 0.25
#      1分钟  5分钟 15分钟

# 平均负载 = CPU等待队列长度
# 理想值: < CPU核心数
# 如果4核CPU负载为8，说明有8个进程等待CPU

# 查看核心数
nproc

# 实时监控负载
watch -n 1 uptime

进程CPU分析

# 高CPU进程
ps aux --sort=-%cpu | head -20

# 线程CPU
ps -eLo pid,lwp,nlwp,pcpu,comm | sort -k3 -rn | head -20

# CPU使用时间
ps -eo pid,comm,time --sort=-time | head -20

# 查找高CPU进程
top -bn1 | grep "^%Cpu" && top -bn1 | awk 'NR>7 {print $0}' | sort -k9 -rn | head -10

内存监控

内存信息

# 内存使用概况
free
free -h                        # 人类可读
free -m                        # 以MB为单位
free -g                        # 以GB为单位

# 详细内存信息
cat /proc/meminfo

# MemAvailable vs MemFree
# MemFree: 完全空闲
# MemAvailable: 实际可用（含可回收缓存）

内存分析

# 按内存排序进程
ps aux --sort=-%mem | head -20

# smem（需安装）
sudo apt install smem
smem
smem --sort=mem --reverse

# 内存泄漏检测
valgrind --leak-check=full ./program

# vmstat
vmstat 1 5                     # 每秒1次，共5次
vmstat -d                      # 磁盘I/O
vmstat -m                      # 内存分配统计

Swap监控

# 查看Swap
swapon -s
cat /proc/swaps

# Swap使用
free -h | grep Swap

# 监控Swap
watch -n 1 free -h

# swappiness调整
# 范围 0-100，值越高越积极使用Swap
cat /proc/sys/vm/swappiness
sudo sysctl vm.swappiness=10
echo "vm.swappiness=10" | sudo tee -a /etc/sysctl.conf

缓存与缓冲

# 查看内存分配
cat /proc/meminfo | grep -E "Cached|Buffers|Dirty|Writeback"

# 清理缓存（谨慎）
sudo sync
sudo echo 3 | sudo tee /proc/sys/vm/drop_caches

# dirty参数
# dirty_ratio: 触发强制回写的脏页百分比
# dirty_background_ratio: 后台回写阈值
cat /proc/sys/vm/dirty_ratio
cat /proc/sys/vm/dirty_background_ratio

磁盘I/O监控

磁盘信息

# 查看磁盘分区
lsblk
fdisk -l
blkid

# 磁盘空间
df -h
df -hT                         # 显示文件系统类型

# inode使用
df -i

I/O统计

# iostat
iostat                         # 基本统计
iostat -x                      # 扩展统计
iostat -d 1 5                  # 每秒1次，共5次
iostat -dxk                    # KB为单位

# 关键指标
# %util: 设备利用率，>80%表示I/O瓶颈
# r/s, w/s: 每秒读写次数
# rkB/s, wkB/s: 每秒读写KB
# avgrq-sz: 平均请求大小
# avgqu-sz: 平均队列长度
# await: 平均I/O等待时间
# svctm: 平均服务时间

# iotop
sudo iotop                     # 实时I/O
sudo iotop -o                  # 只显示活动进程
sudo iotop -b -n 3             # 批处理模式

文件系统使用

# du命令
du -h                          # 当前目录
du -sh *                        # 各子项大小
du -sh /var/log                 # 指定目录
du -h --max-depth=1            # 限制深度
du -h | sort -rh               # 按大小排序

# 大文件查找
find / -type f -size +100M -exec ls -lh {} \;
find / -type f -exec du -h {} + | sort -rh | head -20

I/O调度

# 查看I/O调度器
cat /sys/block/sda/queue/scheduler

# 可用调度器
# cfq       - 完全公平队列（传统）
# deadline  - 期限调度（数据库优化）
# noop     - 无操作（SSD推荐）
# mq-deadline - 多队列期限

# 修改调度器
echo deadline | sudo tee /sys/block/sda/queue/scheduler

# 永久修改 - /etc/default/grub
GRUB_CMDLINE_LINUX="elevator=deadline"
sudo update-grub

网络监控

网络统计

# 网卡信息
ip addr show
ifconfig

# 网卡流量
ip -s link show eth0
ip -s -s link show eth0        # 更详细

# 实时流量
watch -n 1 ip -s link show eth0

# ss命令
ss -tulnp                      # 监听端口
ss -s                          # 汇总统计
ss -ti                         # TCP信息
ss -tan | awk '{print $4}' | grep -E ":(80|443)$" | sort | uniq -c

# netstat（已弃用）
netstat -i                      # 接口统计
netstat -s                      # 协议统计

带宽测试

# iperf3
# 服务端
iperf3 -s

# 客户端
iperf3 -c server_ip
iperf3 -c server_ip -t 30      # 30秒测试
iperf3 -c server_ip -P 4       # 4个并行连接

# speedtest-cli
sudo apt install speedtest-cli
speedtest-cli
speedtest-cli --simple         # 简单输出

网络延迟

# ping
ping -c 10 example.com

# 路由追踪
traceroute example.com
tracepath example.com

# mtr（实时追踪）
mtr example.com
mtr -r example.com             # 报告模式

性能分析工具

top命令详解

# top界面解读
top - 15:30:45 up 30 days,  3:22,  2 users,  load average: 0.52, 0.58, 0.59
Tasks: 245 total,   1 running, 244 sleeping,   0 stopped,   0 zombie
%Cpu(s): 15.3 us,  2.1 sy,  0.0 ni, 82.0 id,  0.3 wa,  0.0 hi,  0.3 si,  0.0 st
MiB Mem :  16384.0 total,   2345.6 free,   8200.0 used,   5838.4 buff/cache
MiB Swap:   2048.0 total,   1024.0 free,   1024.0 used,   5432.0 avail Mem

# 快捷键
P - 按CPU排序
M - 按内存排序
T - 按时间排序
k - 终止进程
r - 调整优先级
u - 过滤用户
1 - 显示所有CPU
c - 显示完整命令
x - 高亮排序列
b - 高亮当前行
z - 彩色/单色

vmstat

# vmstat输出
vmstat 1

# procs: 进程
# r: 运行中（等待CPU）
# b: 阻塞（等待I/O）

# memory: 内存
# swapd: Swap使用
# free: 空闲
# buff: 缓冲
# cache: 缓存

# swap: Swap I/O
# si: Swap换入
# so: Swap换出

# io: I/O
# bi: 块设备接收
# bo: 块设备发送

# system:
# in: 中断
# cs: 上下文切换

# cpu:
# us: 用户态
# sy: 系统态
# id: 空闲
# wa: I/O等待

sar

# 安装sysstat
sudo apt install sysstat

# 启用历史收集
sudo systemctl enable sysstat
sudo systemctl start sysstat

# CPU统计
sar -u 1 3                    # 每秒1次，3次
sar -P ALL 1 1                # 每CPU统计

# 内存统计
sar -r 1 3
sar -R 1 3                    # 内存页

# Swap统计
sar -S 1 3

# I/O统计
sar -b 1 3                    # 块设备
sar -d 1 3                    # 每设备

# 网络统计
sar -n DEV 1 3                # 网络设备
sar -n TCP,ETCP 1 3           # TCP连接
sar -n SOCK 1 3               # Socket

# 历史数据
sar -u -f /var/log/sa/sa10    # 查看指定日期

系统优化

内核参数调优

# /etc/sysctl.conf 优化配置

# 文件描述符
fs.file-max = 6553600
fs.nr_open = 6553600

# 内存
vm.swappiness = 10
vm.dirty_ratio = 15
vm.dirty_background_ratio = 5
vm.overcommit_memory = 1
vm.max_map_count = 262144

# 网络
net.core.somaxconn = 65535
net.core.netdev_max_backlog = 65535
net.ipv4.tcp_max_syn_backlog = 65535
net.ipv4.tcp_fin_timeout = 15
net.ipv4.tcp_keepalive_time = 300
net.ipv4.tcp_keepalive_probes = 5
net.ipv4.tcp_keepalive_intvl = 15

# 生效
sudo sysctl -p
sudo sysctl -a                 # 查看所有参数

进程优化

# 调整进程优先级
nice -n 10 command             # 降低优先级
renice -n 10 -p <pid>          # 调整运行中进程

# CPU亲和性
taskset -c 0,1 command         # 指定CPU核心
taskset -cp 0,1 <pid>          # 绑定进程

# 限制进程资源
ulimit -n 65535               # 文件描述符
ulimit -u 4096                # 用户进程数

应用优化示例

# Nginx优化
# /etc/nginx/nginx.conf
worker_processes auto;
worker_rlimit_nofile 65535;

events {
    worker_connections 65535;
    multi_accept on;
    use epoll;
}

http {
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;
    client_max_body_size 100M;
}

# MySQL优化
# /etc/mysql/mysql.conf.d/mysqld.cnf
[mysqld]
innodb_buffer_pool_size = 12G
innodb_log_file_size = 2G
max_connections = 2000
table_open_cache = 4000
query_cache_type = 1
query_cache_size = 128M
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 2

课后练习

实践任务

使用top、htop分析系统性能
使用iostat分析磁盘I/O瓶颈
使用sar收集系统历史数据
优化内核参数提升性能
分析并优化Nginx/MySQL配置

后续教程预告：日志管理、备份恢复、Docker容器、Kubernetes入门、故障排查、内核调优…

日志管理与分析

Sun, 18 Jan 2026 00:00:00 +0000

日志系统概述

Linux使用rsyslog作为系统日志服务，配合journald提供统一的日志管理。

┌─────────────────────────────────────────────────────────────┐
│                    Linux 日志系统                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   应用 ──→ syslog/journlad ──→ /var/log/*                 │
│                    │                                        │
│         ┌─────────┴─────────┐                              │
│         ↓                   ↓                               │
│     journalctl          rsyslog                            │
│         │                   │                               │
│      二进制日志           文本日志                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

rsyslog配置

基础配置

# /etc/rsyslog.conf

# 模块
module(load="imuxsock")        # 本地日志
module(load="imklog")         # 内核日志
module(load="imudp")          # UDP接收
module(load="imtcp")          # TCP接收

# 规则格式
# facility.priority   action

# facility: auth, authpriv, cron, daemon, kern, lpr, mail, news, syslog, user, uucp, local0-7
# priority: debug, info, notice, warning, warn, err, error, crit, alert, emerg

# 示例规则
*.info;mail.none;authpriv.none;cron.none    /var/log/messages
authpriv.*                                      /var/log/secure
mail.*                                          -/var/log/maillog
cron.*                                          /var/log/cron
*.emerg                                         :omusrmsg:*

远程日志

# 发送端 - /etc/rsyslog.conf
*.* @@logserver.example.com:514

# 接收端配置
# /etc/rsyslog.conf
module(load="imudp")
input(type="imudp" port="514")

module(load="imtcp")
input(type="imtcp" port="514")

# 模板（格式化日志）
template(name="RemoteLogs" type="string" string="/var/log/remote/%HOSTNAME%/%PROGRAMNAME%.log")

# 应用模板
*.* ?RemoteLogs

# 重启服务
sudo systemctl restart rsyslog

journald配置

systemd日志

# 查看日志
journalctl                          # 所有日志
journalctl -xe                     # 带上下文
journalctl -f                      # 实时跟踪
journalctl -b                      # 本次启动
journalctl -b -1                   # 上次启动
journalctl --since "1 hour ago"
journalctl --since "2026-01-01" --until "2026-01-02"
journalctl -u nginx.service        # 指定服务
journalctl -u nginx.service -u mysql.service
journalctl -p err                  # 指定级别

# 分页显示
journalctl --no-pager

# 显示最新
journalctl -n 50                   # 最近50条
journalctl -n 50 --no-pager

# 显示完整消息
journalctl -o verbose

# 磁盘使用
journalctl --disk-usage

# 清理旧日志
journalctl --vacuum-time=7d       # 保留7天
journalctl --vacuum-size=500M      # 保留500M

journald配置

# /etc/systemd/journald.conf

[Journal]
Storage=persistent                 # 持久化存储
# Storage=volatile                  # 内存存储
# Storage=none                       # 不存储

Compress=yes
SystemMaxUse=500M                  # 最大磁盘占用
SystemMaxFileSize=50M              # 单文件最大
MaxRetentionSec=30day              # 最大保留时间

RateLimitInterval=1s
RateLimitBurst=1000

ForwardToSyslog=yes                # 转发到rsyslog
ForwardToKMsg=no
ForwardToConsole=no

MaxLevelKMsg=warning
MaxLevelSyslog=debug
MaxLevelConsole=info
MaxLevelStore=warning

日志文件位置

# 常见日志文件
/var/log/messages           # 通用系统消息
/var/log/syslog            # 系统日志
/var/log/auth.log          # 认证日志
/var/log/secure            # 安全日志
/var/log/maillog           # 邮件日志
/var/log/cron             # 计划任务日志
/var/log/dmesg             # 启动时内核消息
/var/log/kern.log          # 内核日志
/var/log/dpkg.log          # 包安装日志
/var/log/yum.log           # yum日志

# 应用日志
/var/log/nginx/access.log
/var/log/nginx/error.log
/var/log/apache2/access.log
/var/log/apache2/error.log
/var/log/mysql/error.log
/var/log/mysql/slow.log

日志分析工具

logwatch

# 安装
sudo apt install logwatch

# 配置
sudo vim /etc/logwatch/conf/logwatch.conf

# 每天报告
sudo cp /usr/share/logwatch/default.conf/logwatch.conf /etc/logwatch/conf/

# 运行
logwatch --output mail --mailto admin@example.com
logwatch --detail high --mailto admin@example.com
logwatch --service nginx --detail high

logrotate

# /etc/logrotate.conf
# 全局配置
weekly
rotate 4
create
dateext
compress
include /etc/logrotate.d/

# 特定配置 - /etc/logrotate.d/nginx
/var/log/nginx/*.log {
    daily
    missingok
    rotate 14
    compress
    delaycompress
    notifempty
    create 0640 www-data adm
    sharedscripts
    postrotate
        [ -f /var/run/nginx.pid ] && kill -USR1 `cat /var/run/nginx.pid`
    endscript
}

awk分析

# Apache访问统计
awk '{print $7}' /var/log/apache2/access.log | \
    sort | uniq -c | sort -rn | head -20

# Nginx错误分析
awk '$4 ~ /error/ {print $0}' /var/log/nginx/error.log

# SSH登录统计
grep "Accepted" /var/log/auth.log | \
    awk '{print $11}' | sort | uniq -c | sort -rn

# 失败登录尝试
grep "Failed password" /var/log/auth.log | \
    awk '{print $11, $13}' | sort | uniq -c | sort -rn | head -20

实时日志监控

# tail -f
tail -f /var/log/syslog
tail -f /var/log/nginx/access.log

# 多文件监控
tail -f /var/log/syslog /var/log/nginx/error.log

# 过滤+监控
tail -f /var/log/syslog | grep -i error

# multitail
sudo apt install multitail
multitail /var/log/syslog /var/log/nginx/error.log

日志集中管理

ELK Stack

┌─────────────────────────────────────────────────────────────┐
│                    ELK架构                                  │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   应用 ──→ Filebeat ──→ Logstash ──→ Elasticsearch          │
│                                     ↓                       │
│                                     ↓                       │
│                                     ↓                       │
│                                  Kibana ←─ 查询展示         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Filebeat配置

# /etc/filebeat/filebeat.yml
filebeat.inputs:
- type: log
  enabled: true
  paths:
    - /var/log/*.log
    - /var/log/nginx/*.log
  fields:
    type: system
  fields_under_root: true

output.elasticsearch:
  hosts: ["elasticsearch:9200"]
  index: "logs-%{+yyyy.MM.dd}"

processors:
  - add_host_metadata:
      when.not.contains.tags: forwarded
  - add_cloud_metadata: ~

Loki + Promtail

# promtail-local-config.yaml
server:
  http_listen_port: 9080
  grpc_listen_port: 0

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
- job_name: system
  static_configs:
  - targets:
      - localhost
    labels:
      job: syslog
      __path__: /var/log/*log

课后练习

实践任务

配置远程日志收集
使用journalctl分析服务日志
配置logrotate自动轮转
使用awk分析Apache/Nginx日志
配置日志告警规则

备份与恢复

Mon, 19 Jan 2026 00:00:00 +0000

备份策略

备份类型

┌─────────────────────────────────────────────────────────────┐
│                    备份类型                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   完全备份 ── 备份所有数据                                  │
│   差异备份 ── 备份自上次完全备份以来的变化                  │
│   增量备份 ── 备份自上次任何备份以来的变化                  │
│                                                             │
│   完全 ──→ 差异 ──→ 差异 ──→ 差异                          │
│   完全 ──→ 增量 ──→ 增量 ──→ 增量                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

备份工具对比

工具	类型	特点
tar	文件	简单、通用
rsync	文件	增量、同步
duplicity	文件	加密、去重
Bacula	企业	完整方案
Amanda	企业	磁带支持
LVM快照	系统	即时快照

文件备份

tar备份

# 完全备份
tar -czvf /backup/home_$(date +%Y%m%d).tar.gz /home

# 排除文件
tar -czvf backup.tar.gz /home \
    --exclude='/home/*/.cache' \
    --exclude='*.tmp'

# 备份列表文件
tar -czvf backup.tar.gz -T /tmp/backup_list.txt

# 解压
tar -xzvf backup.tar.gz -C /restore/path

# 验证备份
tar -tzf backup.tar.gz | head
tar -dvf backup.tar.gz

rsync同步

# 本地同步
rsync -avz /src/ /dst/
rsync -avz --delete /src/ /dst/

# 远程同步
rsync -avz -e ssh /src/ user@host:/dst/
rsync -avz -e "ssh -p 2222" /src/ user@host:/dst/

# 增量同步
rsync -avz --link-dest=/backup/daily.0 /src/ /backup/daily.1/

# 常用选项
rsync -avz           # 归档、压缩
rsync -P             # 显示进度、保留部分文件
rsync --dry-run      # 预演
rsync --exclude       # 排除
rsync --bwlimit       # 限速

增量备份脚本

#!/bin/bash
# incremental_backup.sh

SRC="/home"
DST="/backup"
DATE=$(date +%Y%m%d_%H%M%S)

# 创建备份目录
mkdir -p "$DST/daily"

# 保留最近7天
KEEP=7

# 完全备份（每周日）
if [ $(date +%u) -eq 7 ]; then
    echo "Full backup..."
    rsync -av --delete "$SRC/" "$DST/weekly/full_$DATE/"
else
    # 增量备份
    echo "Incremental backup..."
    rsync -av --delete --link-dest="$DST/daily/previous" \
        "$SRC/" "$DST/daily/incremental_$DATE/"
fi

# 更新previous链接
rm -f "$DST/daily/previous"
cp -al "$DST/daily/incremental_$DATE/" "$DST/daily/previous"

# 清理旧备份
find "$DST/daily" -maxdepth 1 -type d -mtime +$KEEP -exec rm -rf {} \;

数据库备份

MySQL备份

# 完全备份
mysqldump -u root -p --all-databases > all_databases.sql

# 指定数据库
mysqldump -u root -p database_name > database_name.sql

# 带DROP TABLE
mysqldump -u root -p --add-drop-table database_name > database_name.sql

# 只备份表结构
mysqldump -u root -p --no-data database_name > structure.sql

# 压缩备份
mysqldump -u root -p database_name | gzip > backup.sql.gz

# 远程备份
mysqldump -h remote_host -u root -p database_name | gzip > backup.sql.gz

# 恢复
mysql -u root -p database_name < backup.sql
gunzip < backup.sql.gz | mysql -u root -p database_name

PostgreSQL备份

# 完全备份
pg_dump -U postgres database_name > backup.sql

# 压缩备份
pg_dump -U postgres database_name | gzip > backup.sql.gz

# 远程备份
pg_dump -h remote_host -U postgres database_name | gzip > backup.sql.gz

# 全量备份
pg_dumpall -U postgres > all_databases.sql

# 自定义格式（推荐）
pg_dump -Fc -U postgres database_name > backup.dump

# 恢复
psql -U postgres database_name < backup.sql
pg_restore -d database_name -U postgres backup.dump

系统快照

LVM快照

# 创建LVM快照
sudo lvcreate -L 10G -s -n home_snapshot /dev/vg00/lv_home

# 挂载快照
sudo mkdir -p /mnt/snapshot
sudo mount -o ro /dev/vg00/home_snapshot /mnt/snapshot

# 从快照恢复
sudo umount /mnt/snapshot
sudo lvconvert --merge /dev/vg00/home_snapshot

# 删除快照
sudo lvremove /dev/vg00/home_snapshot

系统镜像

# 使用dd备份整个磁盘
sudo dd if=/dev/sda of=/backup/disk.img bs=4M status=progress

# 压缩镜像
sudo dd if=/dev/sda | gzip > /backup/disk.img.gz

# 恢复到磁盘
sudo gzip -dc /backup/disk.img.gz | sudo dd of=/dev/sda

# 备份分区
sudo dd if=/dev/sda1 of=/backup/partition.img bs=4M status=progress

课后练习

实践任务

配置rsync自动备份
编写MySQL备份脚本
创建LVM快照
配置定时备份任务

Docker容器基础

Tue, 20 Jan 2026 00:00:00 +0000

Docker概述

什么是Docker？

Docker是一个开源的容器化平台，用于构建、部署和运行应用程序。

┌─────────────────────────────────────────────────────────────┐
│                    虚拟机 vs 容器                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   虚拟机:                                                   │
│   ┌────┐ ┌────┐ ┌────┐                                   │
│   │App │ │App │ │App │ ← 每个VM都有独立OS                  │
│   ├────┤ ├────┤ ├────┤                                   │
│   │ OS │ │ OS │ │ OS │                                   │
│   ├────┤ ├────┤ ├────┤                                   │
│   │ VM │ │ VM │ │ VM │                                   │
│   └────┘ └────┘ └────┘                                   │
│                                                             │
│   容器:                                                     │
│   ┌────┐ ┌────┐ ┌────┐                                   │
│   │App │ │App │ │App │ ← 共享宿主机OS                     │
│   ├────┤ ├────┤ ├────┤                                   │
│   │ C  │ │ C  │ │ C  │                                   │
│   └────┘ └────┘ └────┘                                   │
│   ┌─────────────────────────────┐                         │
│   │         Docker Engine        │                         │
│   ├─────────────────────────────┤                         │
│   │         Host OS              │                         │
│   └─────────────────────────────┘                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Docker核心概念

镜像（Image）  ──→  容器（Container）  ──→  仓库（Registry）
模板，只读        运行实例              存储和分发镜像

安装Docker

# Ubuntu/Debian
sudo apt update
sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# 启动Docker
sudo systemctl start docker
sudo systemctl enable docker

# 添加用户到docker组
sudo usermod -aG docker $USER
newgrp docker

Docker基础命令

镜像管理

# 拉取镜像
docker pull ubuntu:22.04
docker pull nginx:latest
docker pull mysql:8.0

# 列出镜像
docker images
docker image ls
docker images -a

# 删除镜像
docker rmi ubuntu:22.04
docker rmi $(docker images -q)          # 删除所有

# 构建镜像
docker build -t myapp:1.0 .
docker build -t myapp:1.0 -f Dockerfile.prod .

# 镜像历史
docker history nginx:latest

容器管理

# 运行容器
docker run ubuntu:22.04
docker run -it ubuntu:22.04 /bin/bash    # 交互式
docker run -d nginx                        # 后台运行
docker run --name mynginx nginx           # 命名容器

# 列出容器
docker ps                                # 运行中的
docker ps -a                             # 所有容器
docker ps -l                              # 最近容器

# 容器操作
docker start nginx                       # 启动
docker stop nginx                        # 停止
docker restart nginx                     # 重启
docker pause nginx                       # 暂停
docker unpause nginx                     # 恢复
docker rm nginx                          # 删除
docker rm $(docker ps -aq)               # 删除所有容器

# 进入容器
docker exec -it nginx /bin/bash
docker exec -u root nginx bash

# 查看日志
docker logs nginx
docker logs -f nginx                     # 跟踪日志
docker logs --tail 100 nginx            # 最近100行

# 容器信息
docker inspect nginx
docker stats nginx                       # 资源使用
docker port nginx                        # 端口映射

网络管理

# 网络列表
docker network ls

# 创建网络
docker network create mynetwork

# 连接容器到网络
docker network connect mynetwork nginx

# 容器网络模式
docker run --network host nginx          # host模式
docker run --network none nginx         # none模式
docker run --network mynetwork nginx     # 自定义网络

Dockerfile

# 基础镜像
FROM ubuntu:22.04

# 维护者
MAINTAINER John Doe <john@example.com>

# 安装系统包
RUN apt-get update && apt-get install -y \
    nginx \
    curl \
    vim \
    && rm -rf /var/lib/apt/lists/*

# 设置环境变量
ENV APP_ENV=production
ENV PORT=8080

# 工作目录
WORKDIR /app

# 复制文件
COPY . /app/
COPY package*.json /app/

# 暴露端口
EXPOSE 8080

# 运行命令
CMD ["python", "app.py"]
# 或
ENTRYPOINT ["python", "app.py"]

多阶段构建

# 第一阶段：构建
FROM golang:1.20 AS builder
WORKDIR /build
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o app

# 第二阶段：运行
FROM alpine:3.18
COPY --from=builder /build/app /app/
WORKDIR /app
CMD ["./app"]

Docker Compose

# docker-compose.yml
version: '3.8'

services:
  web:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DB_HOST=db
      - DB_PASSWORD=secret
    depends_on:
      - db
    networks:
      - frontend
      - backend

  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: myapp
    volumes:
      - db_data:/var/lib/mysql
    networks:
      - backend

  redis:
    image: redis:7-alpine
    networks:
      - backend

volumes:
  db_data:

networks:
  frontend:
  backend:

# 启动服务
docker-compose up
docker-compose up -d                 # 后台运行
docker-compose up --build             # 重新构建

# 管理服务
docker-compose ps
docker-compose logs -f web
docker-compose stop
docker-compose down
docker-compose down -v               # 删除卷

# 扩展服务
docker-compose up -d --scale web=3

课后练习

实践任务

安装Docker并验证
运行第一个容器
编写Dockerfile构建应用镜像
使用Docker Compose部署应用栈

Kubernetes入门

Wed, 21 Jan 2026 00:00:00 +0000

Kubernetes概述

Kubernetes（K8s）是一个开源的容器编排平台，用于自动化容器化应用的部署、扩展和管理。

┌─────────────────────────────────────────────────────────────┐
│                    Kubernetes架构                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ┌─────────────────────────────────────────────────────┐   │
│   │                   Control Plane                     │   │
│   │  ┌──────────┐ ┌──────────┐ ┌──────────┐           │   │
│   │  │ kube-    │ │ kube-   │ │ etcd     │           │   │
│   │  │ apiserver│ │ scheduler│ │          │           │   │
│   │  └──────────┘ └──────────┘ └──────────┘           │   │
│   │  ┌──────────┐                                    │   │
│   │  │kube-controller│                               │   │
│   │  └──────────┘                                    │   │
│   └─────────────────────────────────────────────────────┘   │
│                                                             │
│   ┌─────────────────────────────────────────────────────┐   │
│   │                     Worker Nodes                    │   │
│   │  ┌──────────┐ ┌──────────┐ ┌──────────┐           │   │
│   │  │ kubelet  │ │ kube-proxy│ │ Container │           │   │
│   │  └──────────┘ └──────────┘ │ Runtime  │           │   │
│   │                            └──────────┘           │   │
│   └─────────────────────────────────────────────────────┘   │
│                                                             │
└─────────────────────────────────────────────────────────────┘

核心概念

Pod

# Pod定义
apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.24
    ports:
    - containerPort: 80
    resources:
      limits:
        memory: "128Mi"
        cpu: "500m"
      requests:
        memory: "64Mi"
        cpu: "250m"

Deployment

# Deployment定义
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.24
        ports:
        - containerPort: 80

Service

# Service定义
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: ClusterIP
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80

kubectl命令

# 集群信息
kubectl cluster-info
kubectl get nodes
kubectl describe node <node-name>

# Pod操作
kubectl get pods
kubectl get pods -o wide
kubectl describe pod <pod-name>
kubectl logs <pod-name>
kubectl exec -it <pod-name> -- /bin/bash

# Deployment操作
kubectl get deployments
kubectl apply -f deployment.yaml
kubectl rollout status deployment/nginx-deployment
kubectl rollout undo deployment/nginx-deployment

# Service操作
kubectl get services
kubectl expose deployment/nginx --type=LoadBalancer --port=80

# 缩放
kubectl scale deployment/nginx --replicas=5

# 删除
kubectl delete -f deployment.yaml

课后练习

实践任务

了解K8s核心概念
使用kubectl操作集群
部署第一个应用

常见问题排查

Thu, 22 Jan 2026 00:00:00 +0000

故障排查方法论

┌─────────────────────────────────────────────────────────────┐
│                    故障排查流程                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   1. 收集信息 ──→ 症状是什么？                            │
│   2. 分析原因 ──→ 可能的原因？                            │
│   3. 定位问题 ──→ 缩小范围，找到根因                      │
│   4. 解决问题 ──→ 实施修复                                │
│   5. 验证结果 ──→ 确认问题解决                            │
│   6. 总结经验 ──→ 记录教训                                │
│                                                             │
└─────────────────────────────────────────────────────────────┘

无法启动问题

引导问题

# 检查引导日志
dmesg | grep -i error
journalctl -b -1                  # 上次启动日志

# 检查引导分区
fdisk -l
blkid
mount /dev/sda1 /mnt
cat /mnt/boot/grub/grub.cfg

# 重建GRUB
sudo update-grub
sudo grub-install /dev/sda

服务启动失败

# 查看失败服务
systemctl --failed
journalctl -xe

# 单独启动测试
systemctl start nginx
systemctl status nginx

网络问题

连接诊断

# 检查网络状态
ip addr show
ip link show
ip route show

# 检查DNS
cat /etc/resolv.conf
nslookup example.com

# 测试连通性
ping 8.8.8.8
ping google.com
traceroute google.com

常见问题

# IP配置丢失
sudo systemctl restart networking

# DNS不生效
sudo systemd-resolve --flush-caches
sudo systemctl restart systemd-resolved

# 网卡 DOWN
sudo ip link set eth0 up

服务问题

服务不响应

# 检查服务状态
systemctl status nginx
journalctl -u nginx -n 50

# 检查端口占用
ss -tlnp | grep :80
lsof -i :80

# 检查防火墙
sudo ufw status
sudo iptables -L -n

性能问题

# 资源检查
top
htop
free -h
df -h
iostat -x 1

# 进程分析
ps aux --sort=-%cpu | head
ps aux --sort=-%mem | head

# 网络连接
ss -s
netstat -anp | grep ESTABLISHED

磁盘问题

空间不足

# 查找大文件
du -sh /*
du -h --max-depth=1 /var
find / -type f -size +100M

# 清理日志
journalctl --vacuum-size=100M
find /var/log -name "*.gz" -mtime +30 -delete

# 清理缓存
sudo apt clean
sudo yum clean all

文件系统错误

# 检查磁盘
df -h
mount

# 文件系统检查
sudo fsck /dev/sda1

# 修复（需卸载）
sudo umount /dev/sda1
sudo fsck -f /dev/sda1

课后练习

实践任务

模拟并解决网络问题
排查服务启动失败
处理磁盘空间不足

内核参数调优

Fri, 23 Jan 2026 00:00:00 +0000

内核概述

内核参数位置

# 运行时参数
/proc/sys/

# 永久配置
/etc/sysctl.conf
/etc/sysctl.d/*.conf

常用参数

# 网络参数
sysctl net.ipv4.tcp_tw_reuse
sysctl net.core.somaxconn
sysctl net.ipv4.tcp_max_syn_backlog

# 内存参数
sysctl vm.swappiness
sysctl vm.overcommit_memory
sysctl vm.max_map_count

# 文件参数
sysctl fs.file-max
sysctl fs.inotify.max_user_watches

优化配置

网络优化

# /etc/sysctl.d/99-network.conf
net.core.somaxconn = 65535
net.core.netdev_max_backlog = 65535
net.ipv4.tcp_max_syn_backlog = 65535
net.ipv4.tcp_fin_timeout = 15
net.ipv4.tcp_keepalive_time = 300
net.ipv4.tcp_keepalive_probes = 5
net.ipv4.tcp_keepalive_intvl = 15
net.ipv4.tcp_tw_reuse = 1
net.ipv4.ip_local_port_range = 1024 65535

内存优化

# /etc/sysctl.d/99-memory.conf
vm.swappiness = 10
vm.dirty_ratio = 15
vm.dirty_background_ratio = 5
vm.overcommit_memory = 1
vm.max_map_count = 262144
vm.pagecache = 30

文件系统优化

# /etc/sysctl.d/99-fs.conf
fs.file-max = 6553600
fs.nr_open = 6553600
fs.inotify.max_user_watches = 524288
fs.aio-max-nr = 1048576

应用配置

# 使配置生效
sudo sysctl -p /etc/sysctl.d/99-network.conf

# 查看所有配置
sysctl -a

# 查看已修改的参数
sysctl -a | grep -v "=" | sort

课后练习

实践任务

分析当前内核参数
根据业务需求优化网络参数
测试优化效果

XFS 文件系统修复指南：诊断、恢复与最佳实践

Wed, 15 Apr 2026 00:00:00 +0000

XFS 文件系统修复指南：诊断、恢复与最佳实践

文档信息

适用系统： RHEL 7/8/9 · CentOS 7/8 · Rocky Linux · AlmaLinux · Ubuntu 20.04+
内核要求： Linux Kernel ≥ 3.10（XFS v5 需 ≥ 3.16）
阅读时间： 约 25 分钟

1. XFS 基础与损坏原因

1.1 XFS 核心架构

XFS 是 SGI 于 1993 年开发的高性能 64 位日志型文件系统，RHEL 7 起成为默认文件系统。其核心结构如下：

XFS 磁盘布局
┌─────────────────────────────────────────────────────────┐
│  Superblock (SB)  │  主超级块，记录文件系统元数据           │
├─────────────────────────────────────────────────────────┤
│  AG 0             │  Allocation Group 0（含独立 SB 副本） │
│    ├─ AGF          │  空闲空间 B+Tree 根                  │
│    ├─ AGI          │  inode B+Tree 根                    │
│    └─ AGFL         │  空闲列表                           │
├─────────────────────────────────────────────────────────┤
│  AG 1 ... AG N    │  每个 AG 独立管理，支持并行 I/O        │
├─────────────────────────────────────────────────────────┤
│  Internal Log     │  日志区（或外部日志设备）               │
└─────────────────────────────────────────────────────────┘

关键概念：

概念	说明
AG（Allocation Group）	分配组，XFS 的并发单元，大文件系统通常有数十至数百个 AG
Superblock	记录块大小、AG 数量、UUID、特性标志等关键元数据
B+Tree	XFS 广泛使用 B+Tree 管理空闲空间、inode、目录项
日志（Log）	保证元数据操作的原子性，损坏日志是 XFS 最常见故障
inode	文件元数据节点，默认 512 字节（XFS v5 可更大）

1.2 损坏的常见原因

磁盘损坏根因分类

硬件层面
  ├─ 存储设备突然断电（最常见）
  ├─ 坏块（Bad Sector）/ 硬件 ECC 错误
  ├─ RAID 控制器故障或缓存数据丢失
  └─ 磁盘固件 Bug / 写入中途掉电

系统层面
  ├─ 内核崩溃（Kernel Panic）时文件系统未 umount
  ├─ 强制 kill -9 正在写入的进程
  ├─ 虚拟机快照回滚导致文件系统不一致
  └─ 时间戳回退（NTP 跳变）

操作层面
  ├─ 误操作 dd / mkfs 覆盖分区
  ├─ 分区调整（resize）操作中断
  └─ 文件系统挂载参数不当（如关闭日志 nobarrier）

2. 损坏诊断与症状识别

2.1 系统日志快速排查

第一步：查看内核日志，识别 I/O 错误：

# 查看最近的文件系统错误
dmesg | grep -iE "xfs|error|corruption|ioerror" | tail -50

# 查看系统日志（systemd）
journalctl -k -p err --since "1 hour ago" | grep -i xfs

# 查看 /var/log/messages（RHEL/CentOS）
grep -i "xfs\|filesystem" /var/log/messages | tail -100

# 实时监控内核日志
dmesg -w | grep -i xfs

典型 XFS 错误消息解读：

# 日志损坏（最常见）
XFS (sdb1): log mount/recovery failed: error -5
XFS (sdb1): Log I/O Error Detected. Shutting down filesystem

# 元数据校验失败（XFS v5 CRC）
XFS (sdb1): Metadata CRC error detected at xfs_agf_read_verify
XFS (sdb1): Corruption detected. Unmounting filesystem

# inode 损坏
XFS (sdb1): corrupt dinode 12345678, ... Unmounting filesystem

# 超级块损坏
XFS (sdb1): bad magic number
XFS (sdb1): SB validate failed with error -22

2.2 文件系统状态检查

# 查看挂载状态
mount | grep xfs
df -hT | grep xfs

# 检查文件系统是否以只读模式重新挂载（损坏的典型表现）
dmesg | grep "remounting read-only"

# 查看块设备信息
lsblk -f
blkid /dev/sdXN

# 检查磁盘 SMART 状态
smartctl -a /dev/sdX
smartctl -t short /dev/sdX   # 触发快速自检

2.3 xfs_check 快速检测

注意

xfs_check 在大文件系统上极慢，已被废弃，推荐使用 xfs_repair -n。

# 只读模式检查（不修复），适合快速确认是否存在问题
xfs_repair -n /dev/sdXN

# 输出解读：
# "No modify flag set, skipping phase X" → 正常，表示只读模式
# "would have fixed ..." → 发现问题，需要实际修复
# "Metadata corruption detected" → 元数据损坏

2.4 故障严重程度评估

级别	症状	建议行动
轻微	文件系统只读重挂、日志需重放	`xfs_repair` 通常可自动修复
中等	部分 inode 损坏、目录项丢失	`xfs_repair` 修复 + 备份恢复丢失文件
严重	超级块损坏、AG 头部损坏	使用备份超级块恢复 + `xfs_repair`
极严重	多 AG 损坏、日志区物理损坏	需结合底层工具 + 数据恢复

3. 修复前必读：黄金原则

数据安全警告

这些原则关乎数据安全，请在操作前逐条确认。

原则一：先备份，再修复

# 对损坏分区做完整镜像（哪怕分区已损坏）
# dd 会跳过读取错误并继续，conv=noerror,sync 填充坏块为零
dd if=/dev/sdXN of=/backup/disk-image.img bs=4M conv=noerror,sync status=progress

# 使用 ddrescue（推荐，比 dd 更强的坏块处理）
ddrescue -d -r3 /dev/sdXN /backup/disk-image.img /backup/rescue.log

# 验证镜像可读
file /backup/disk-image.img
xfs_repair -n /backup/disk-image.img   # 在镜像上先测试

原则二：修复前必须卸载

# XFS 必须在卸载状态下修复（不能在线修复损坏）
umount /dev/sdXN

# 若设备忙，查找并终止占用进程
fuser -mv /mount/point
lsof | grep /mount/point
fuser -k /mount/point   # 强制终止（谨慎）

# 若无法卸载（根分区），进入单用户模式或救援模式
systemctl rescue
# 或通过 LiveCD/LiveUSB 启动

原则三：根分区修复必须离线

# 根分区（/）无法在运行时卸载
# 方法 1：进入救援模式（systemd）
systemctl rescue

# 方法 2：编辑 GRUB，追加 single 或 emergency 启动参数
# 在 GRUB 选项行末尾加：rd.break 或 init=/bin/bash

# 方法 3：使用同发行版 LiveCD 启动后操作

# 方法 4：设置 /etc/fstab 的 fsck 顺序（xfs 通常不自动 fsck）
# XFS 会在挂载时自动重放日志，无需 fsck

原则四：记录操作日志

# 所有修复操作务必记录，便于回溯
script /tmp/xfs-repair-$(date +%Y%m%d-%H%M%S).log
# ... 执行修复操作 ...
exit

4. 核心工具详解

4.1 工具速查

工具	用途	风险等级
`xfs_repair`	文件系统元数据检查与修复	中（会修改文件系统）
`xfs_db`	底层调试、结构查看与手动修改	高（直接操作底层结构）
`xfs_metadump`	导出元数据用于离线分析	低（只读导出）
`xfs_mdrestore`	从 metadump 恢复元数据	中
`xfs_logprint`	解析并打印 XFS 日志内容	低（只读）
`xfs_growfs`	在线扩展文件系统	中
`xfs_freeze`	冻结/解冻文件系统（用于一致性快照）	低
`xfs_info`	查看文件系统参数	低（只读）
`ddrescue`	坏块磁盘镜像恢复	低（源盘只读）

4.2 安装工具包

# RHEL/CentOS/Rocky
yum install -y xfsprogs xfsdump gddrescue

# Ubuntu/Debian
apt install -y xfsprogs xfsdump gddrescue

# 验证安装
xfs_repair -V
xfs_db -V

5. xfs_repair 完整修复流程

xfs_repair 是 XFS 的主要修复工具，采用多阶段检查机制。

5.1 修复阶段说明

xfs_repair 工作阶段

Phase 1: 找到并验证文件系统超级块
Phase 2: 检查 AG 头部结构（AGF / AGI / AGFL）
Phase 3: 扫描 AG 中的 inode，检查 inode 结构
Phase 4: 清理并重建 inode 链接计数
Phase 5: 检查并修复各 inode 的内容（目录/数据块）
Phase 6: 检查目录连接性（确保所有 inode 可达）
Phase 7: 重建 AG 空闲列表
Phase 8: 验证并清理磁盘配额信息（若有）

关键阶段：
- Phase 2 失败 → AG 头部损坏，可能需要备份超级块
- Phase 3 失败 → inode 严重损坏
- Phase 6 产生 lost+found → 有孤立文件

5.2 标准修复步骤

Step 1：只读预检（不修改磁盘）

# 强烈建议先执行只读检查，了解损坏程度
xfs_repair -n /dev/sdXN 2>&1 | tee /tmp/xfs-check.log

# 分析输出
grep -E "ERROR|CORRUPT|would|bad|lost" /tmp/xfs-check.log | head -50

Step 2：执行修复

# 标准修复（最常用）
xfs_repair /dev/sdXN 2>&1 | tee /tmp/xfs-repair.log

# 修复过程中的关键输出说明：
# "Phase X - ..." → 进度正常
# "ERROR: ..." → 发现错误（通常会自动修复）
# "fixed ..." → 已修复
# "disconnected inode XXXXXXXX, moving to lost+found" → 孤立 inode
# "would move inode ... to lost+found" → （-n 模式，实际会处理）

Step 3：强制重置日志（日志损坏时）

# 当 xfs_repair 提示日志损坏，无法正常修复时
# ⚠️ 此操作会丢失未提交的事务（通常可接受）
xfs_repair -L /dev/sdXN 2>&1 | tee /tmp/xfs-repair-L.log

-L 参数说明

强制清零日志，会丢失日志中尚未提交的元数据变更。对于已损坏的文件系统，这通常是必要的，代价是可能丢失最近几秒内的写操作。

Step 4：使用备份超级块修复

# 当主超级块损坏时，使用备份超级块
# 首先找到所有备份超级块的位置
xfs_db -c "sb 0" -c "print" /dev/sdXN   # 查看 agcount 和 agblocks

# 或使用 xfs_repair 自动探测备份超级块
xfs_repair -o ag_stride=<agblocks> /dev/sdXN

# 指定备份超级块位置（AG 编号，从 1 开始）
xfs_repair -b <blocksize> -f -o bhash=<size> /dev/sdXN

# 更简单的方式：让 xfs_repair 自动寻找
xfs_repair /dev/sdXN
# 若失败，尝试：
xfs_repair -v /dev/sdXN   # 详细模式，显示更多信息

Step 5：验证修复结果

# 修复完成后再次只读检查
xfs_repair -n /dev/sdXN

# 若无错误输出，尝试挂载
mount /dev/sdXN /mnt/recovery

# 验证文件系统完整性
ls -la /mnt/recovery/
ls -la /mnt/recovery/lost+found/   # 查看是否有孤立文件

# 查看文件系统信息
xfs_info /mnt/recovery
df -hT /mnt/recovery

5.3 xfs_repair 常用参数

# -n        只读检查，不修改文件系统（Dry Run）
xfs_repair -n /dev/sdXN

# -L        强制清零日志（日志损坏时使用）
xfs_repair -L /dev/sdXN

# -v        详细输出
xfs_repair -v /dev/sdXN

# -d        允许在挂载状态下运行（危险！仅用于根分区单用户模式）
xfs_repair -d /dev/sdXN

# -e        遇到错误立即退出（不尝试修复）
xfs_repair -e /dev/sdXN

# -f        将设备视为普通文件（用于镜像文件修复）
xfs_repair -f /path/to/image.img

# -m <mb>   限制内存使用量（MB），大文件系统修复时可能需要
xfs_repair -m 2048 /dev/sdXN

# -t <secs> 进度报告间隔（秒）
xfs_repair -t 30 /dev/sdXN

# -P        禁用预取（Prefetch），减少内存使用
xfs_repair -P /dev/sdXN

# 组合使用示例
xfs_repair -v -t 30 /dev/sdXN 2>&1 | tee /tmp/repair-$(date +%Y%m%d%H%M%S).log

6. xfs_db 底层调试

xfs_db 是 XFS 的底层调试工具，允许直接查看和修改文件系统结构。高风险，非必要不直接修改。

6.1 只读探查（安全操作）

# 以只读模式启动（推荐）
xfs_db -r /dev/sdXN

# 常用只读命令
xfs_db -r -c "sb" /dev/sdXN              # 查看超级块
xfs_db -r -c "sb 0" -c "print" /dev/sdXN # 打印主超级块内容
xfs_db -r -c "agf 0" -c "print" /dev/sdXN# 查看 AG 0 的空闲块头
xfs_db -r -c "agi 0" -c "print" /dev/sdXN# 查看 AG 0 的 inode 头

# 查看文件系统 UUID
xfs_db -r -c "uuid" /dev/sdXN

# 查看标志位
xfs_db -r -c "sb 0" -c "print features_incompat" /dev/sdXN

6.2 超级块关键字段解读

xfs_db -r -c "sb 0" -c "print" /dev/sdXN
# 重点字段：
# magicnum  = 0x58465342      → 必须为 "XFSB"，否则超级块损坏
# blocksize = 4096            → 块大小（通常 4096 字节）
# dblocks   = XXXXXX          → 数据块总数
# agcount   = XX              → AG 总数
# agblocks  = XXXXXX          → 每个 AG 的块数
# logstart  = XXXXXX          → 日志起始块（内部日志）
# uuid      = XXXXXXXX-...    → 文件系统 UUID
# inprogress = 0              → 必须为 0，为 1 表示修复未完成
# versionnum = ...            → 版本号（v5 特性需要 >= 5）

6.3 查找备份超级块

# 列出所有 AG 的超级块位置
xfs_db -r /dev/sdXN
  sb 0
  print agblocks    # 记下 agblocks 的值，例如 2621440

# 备份超级块位于每个 AG 的第一个块：
# AG 0: block 0 (主超级块)
# AG 1: block agblocks * 1
# AG 2: block agblocks * 2
# ...

# 快速列出所有备份超级块块号
xfs_db -r -c "sb 0" -c "print agblocks agcount" /dev/sdXN
# 假设 agblocks=2621440, agcount=8
# 备份 SB 位于块：2621440, 5242880, 7864320, ...

# 验证备份超级块
xfs_db -r -c "fsblock 2621440" -c "type sb" -c "print" /dev/sdXN

6.4 使用 metadump 导出元数据

# 导出元数据（不含用户数据，可安全传输给专家分析）
xfs_metadump /dev/sdXN /tmp/metadata-$(date +%Y%m%d).xfsdump

# 在另一系统恢复元数据进行分析
xfs_mdrestore /tmp/metadata.xfsdump /tmp/restored-image.img

# 在恢复镜像上进行无损调试
xfs_db -r /tmp/restored-image.img

7. 日志（Journal）恢复

XFS 日志损坏是最常见的故障类型，处理方式如下：

7.1 检查日志状态

# 打印日志内容（只读）
xfs_logprint /dev/sdXN

# 查看日志配置
xfs_info /dev/sdXN | grep -i log

# 检查日志是否干净
xfs_db -r -c "sb 0" -c "print" /dev/sdXN | grep -E "logstart|logblocks|logbsize"

7.2 日志损坏的典型表现

# 挂载时报错
mount: /dev/sdXN: can't read superblock
XFS: log mount/recovery failed: error -5

# xfs_repair 输出
ERROR: The filesystem has valuable metadata changes in a log which needs to
       be replayed.  Mount the filesystem to replay the log, and unmount it
       before re-running xfs_repair.

# 无法挂载也无法重放时
XFS: log mount/recovery failed

7.3 日志恢复步骤

# Step 1: 尝试正常挂载（自动重放日志）
mount /dev/sdXN /mnt/test

# Step 2: 若挂载失败，尝试忽略日志挂载（会丢失未完成事务）
mount -o norecovery,ro /dev/sdXN /mnt/test

# Step 3: 若仍失败，用 xfs_repair 重放日志
xfs_repair /dev/sdXN

# Step 4: 若 xfs_repair 提示日志不可恢复，强制清零
# ⚠️ 最后手段，确保已有备份
xfs_repair -L /dev/sdXN

# Step 5: 确认日志已清理
xfs_logprint /dev/sdXN | head -20
# 正常输出: "no log records"

7.4 外部日志设备

# 若使用外部日志设备（-l 参数挂载的文件系统）
mount -o logdev=/dev/sdYN /dev/sdXN /mnt/test

# xfs_repair 指定外部日志
xfs_repair -l /dev/sdYN /dev/sdXN

# 强制清零外部日志
xfs_repair -l /dev/sdYN -L /dev/sdXN

8. 数据恢复策略

8.1 lost+found 目录处理

xfs_repair 会将无法确定归属的 inode 放入 lost+found：

# 挂载后查看 lost+found
ls -la /mnt/recovery/lost+found/

# lost+found 中的文件命名规则：
# #INODE_NUMBER（例如 #12345678）

# 尝试识别文件类型
file /mnt/recovery/lost+found/*

# 对文本文件，查看内容推断用途
head -5 /mnt/recovery/lost+found/\#12345678

# 批量识别
for f in /mnt/recovery/lost+found/*; do
    echo "=== $f ==="
    file "$f"
    head -2 "$f" 2>/dev/null || echo "[binary file]"
done

8.2 使用 PhotoRec / TestDisk 恢复用户数据

当 XFS 元数据严重损坏，文件无法通过 xfs_repair 恢复时，使用数据雕刻工具：

# 安装
yum install -y testdisk   # RHEL/CentOS
apt install -y testdisk   # Ubuntu

# TestDisk：修复分区表、恢复分区
testdisk /dev/sdX

# PhotoRec：按文件头特征恢复文件（不依赖文件系统）
photorec /dev/sdXN
# → 选择分区 → 选择文件类型 → 选择输出目录 → 开始恢复
# ⚠️ PhotoRec 恢复的文件无原始文件名，需手动整理

8.3 挂载只读镜像进行恢复

# 将磁盘镜像以 loop 方式挂载（只读，安全）
losetup -r -f /backup/disk-image.img
losetup -a   # 查看 loop 设备编号，例如 /dev/loop0

# 修复镜像（不影响原始磁盘）
xfs_repair -f /backup/disk-image.img

# 挂载修复后的镜像
mount -o loop,ro /backup/disk-image.img /mnt/recovery

# 从镜像中拷贝数据
rsync -avH /mnt/recovery/ /data/restored/

9. 特殊场景处理

9.1 根分区（/）损坏修复

# 方案 1：进入 Emergency 模式
# 在 GRUB 启动参数末尾添加：
systemd.unit=emergency.target

# 进入 emergency shell 后
mount -o remount,ro /
xfs_repair /dev/sdaN   # 根分区设备

# 方案 2：使用 LiveCD
# 1. 从 LiveCD 启动
# 2. 识别根分区
lsblk -f
# 3. 修复
xfs_repair /dev/sdaN
# 4. 验证并重启
mount /dev/sdaN /mnt && ls /mnt

9.2 LVM 上的 XFS 修复

# 激活 LVM 卷组
vgscan
vgchange -ay

# 查看逻辑卷
lvdisplay
lvs

# 卸载并修复
umount /dev/vg0/lv_data
xfs_repair /dev/vg0/lv_data

# 若 LVM 元数据也损坏，先修复 LVM
vgcfgrestore -f /etc/lvm/backup/vg0 vg0

9.3 加密分区（LUKS）上的 XFS 修复

# 解锁 LUKS 容器
cryptsetup luksOpen /dev/sdXN xfs_crypt

# 修复内层 XFS
xfs_repair /dev/mapper/xfs_crypt

# 修复完成后关闭
cryptsetup luksClose xfs_crypt

9.4 NFS 导出的 XFS 修复

# 取消所有 NFS 导出
exportfs -ua

# 确认无客户端连接
netstat -an | grep :2049
showmount -a

# 卸载并修复
umount /export/data
xfs_repair /dev/sdXN

# 重新挂载并恢复导出
mount /dev/sdXN /export/data
exportfs -a

9.5 容器/虚拟机环境

# Docker 数据目录（通常为 /var/lib/docker）
# 先停止 Docker
systemctl stop docker

# 修复
xfs_repair /dev/sdXN   # Docker 所在分区

# 若 Docker 使用 overlay2，修复后可能需要重建层
systemctl start docker
docker system prune   # 清理损坏的 layer（会删除所有停止的容器和未使用镜像）

10. 预防性维护

10.1 挂载参数优化

# /etc/fstab 推荐配置
# 格式：设备  挂载点  类型  选项  dump  fsck优先级

# 数据盘（高性能）
/dev/sdXN  /data  xfs  defaults,noatime,nodiratime  0  0

# 重要数据盘（强一致性）
/dev/sdXN  /critical  xfs  defaults,noatime,barrier  0  0

# 参数说明：
# noatime      → 不更新访问时间，减少写 I/O
# nodiratime   → 不更新目录访问时间
# barrier      → 写屏障（默认开启，确保掉电安全）
# nobarrier    → ⚠️ 禁用写屏障（SSD/RAID 带 BBU 时可提升性能，但增加风险）
# logbufs=8    → 增大日志缓冲数（高并发写入场景）
# allocsize=   → 预分配大小（流式写入场景）

10.2 监控脚本

#!/bin/bash
# /usr/local/bin/xfs-health-check.sh
# 建议加入 crontab 每日执行

LOGFILE="/var/log/xfs-health-$(date +%Y%m%d).log"
ALERT_EMAIL="ops@example.com"

echo "=== XFS Health Check $(date) ===" >> "$LOGFILE"

# 检查所有 XFS 分区
while IFS= read -r line; do
    device=$(echo "$line" | awk '{print $1}')
    mountpoint=$(echo "$line" | awk '{print $3}')

    echo "Checking $device ($mountpoint)..." >> "$LOGFILE"

    # 检查 dmesg 中的 XFS 错误
    errors=$(dmesg | grep "XFS.*$device" | grep -i "error\|corrupt" | wc -l)
    if [ "$errors" -gt 0 ]; then
        msg="WARNING: $errors XFS errors found for $device"
        echo "$msg" >> "$LOGFILE"
        echo "$msg" | mail -s "XFS Alert on $(hostname)" "$ALERT_EMAIL"
    fi

    # 检查文件系统使用率
    usage=$(df -h "$mountpoint" | awk 'NR==2 {print $5}' | tr -d '%')
    if [ "$usage" -gt 90 ]; then
        msg="WARNING: $mountpoint is ${usage}% full"
        echo "$msg" >> "$LOGFILE"
        echo "$msg" | mail -s "XFS Disk Space Alert on $(hostname)" "$ALERT_EMAIL"
    fi

done < <(mount | grep "type xfs")

echo "=== Check Complete ===" >> "$LOGFILE"

# 添加到 crontab
echo "0 2 * * * root /usr/local/bin/xfs-health-check.sh" > /etc/cron.d/xfs-health
chmod 644 /etc/cron.d/xfs-health

10.3 定期备份策略

# 使用 xfsdump 进行增量备份（XFS 原生备份工具）
# Level 0 = 全量备份
xfsdump -l 0 -f /backup/data-full-$(date +%Y%m%d).dump /data

# Level 1 = 基于上次 Level 0 的增量
xfsdump -l 1 -f /backup/data-incr-$(date +%Y%m%d).dump /data

# 恢复
xfsrestore -f /backup/data-full-20260101.dump /mnt/restore

# 查看 dump 信息
xfsdump -I   # 列出所有历史 dump 记录

10.4 UPS 与写缓存配置

# 查看磁盘写缓存状态
hdparm -W /dev/sdX

# 对无 BBU 的 RAID 控制器，禁用磁盘写缓存
hdparm -W0 /dev/sdX

# 对有 BBU 的 RAID 控制器，可以启用（通过控制器管理界面）

# SSD 检查是否支持 FUA（强制单元访问）
cat /sys/block/sda/queue/fua

10.5 内核参数调优

# /etc/sysctl.d/99-xfs.conf

# 增大脏数据回写阈值（减少突发 I/O）
vm.dirty_ratio = 10
vm.dirty_background_ratio = 5

# 增大脏数据最大驻留时间（秒）
vm.dirty_expire_centisecs = 3000
vm.dirty_writeback_centisecs = 500

# 应用
sysctl -p /etc/sysctl.d/99-xfs.conf

11. 参考资料

资源	说明
	XFS 内核 Wiki，架构与设计文档
	`man 8 xfs_repair` 完整参数说明
	底层调试工具完整文档
	RHEL 官方文件系统管理指南
	常见问题解答
	GNU ddrescue 官方文档
	数据恢复工具官方文档

快速参考卡

XFS 修复速查

【诊断】
  dmesg | grep -i xfs                   # 查看内核错误
  xfs_repair -n /dev/sdXN               # 只读检查

【标准修复流程】
  1. umount /dev/sdXN                   # 卸载
  2. dd/ddrescue → 备份镜像             # 备份
  3. xfs_repair /dev/sdXN               # 修复
  4. xfs_repair -n /dev/sdXN            # 验证
  5. mount /dev/sdXN /mnt               # 挂载验证

【日志损坏】
  xfs_repair -L /dev/sdXN               # 强制清零日志（最后手段）

【超级块损坏】
  xfs_db -r -c "sb 0" -c "print" /dev/sdXN   # 查看超级块
  xfs_repair /dev/sdXN                        # 自动找备份超级块

【孤立文件】
  ls /mnt/lost+found/                   # 查看孤立 inode

【镜像修复】
  xfs_repair -f /path/to/image.img      # 在镜像上修复

总结

XFS 修复的核心原则是 “备份优先，只读验证，最后动手”。xfs_repair 能处理绝大多数场景，日志损坏时配合 -L 参数，超级块损坏时利用 AG 备份副本恢复。任何操作前务必用 ddrescue 备份原始磁盘镜像，这是数据安全的最后防线。

Linux 完全指南

Thu, 01 Jan 2026 00:00:00 +0000

Linux 完全指南

课程简介

本系列教程将带你从零基础开始，系统掌握Linux操作系统的各个方面，最终成为Linux高手。

学习路径总览

阶段	内容	难度
入门篇	Linux基础概念、系统安装、桌面环境	⭐
基础篇	文件系统、用户权限、Shell命令	⭐⭐
进阶篇	网络配置、进程管理、软件包管理	⭐⭐⭐
高级篇	Shell脚本、系统服务、性能优化	⭐⭐⭐⭐
精通篇	安全加固、容器技术、故障排查	⭐⭐⭐⭐⭐

完整教程目录

第一部分：入门基础

- 了解Linux历史、发行版及安装
- GNOME/KDE等桌面环境使用

第二部分：核心基础

- Linux文件系统层次结构
- 用户、组、文件权限
- Bash Shell入门
- grep、sed、awk高级用法

第三部分：系统管理

- 进程监控、服务控制
- apt、yum、dnf使用

第四部分：网络管理

- IP配置、网络诊断工具
- 安全远程连接
- iptables、firewalld、ufw

第五部分：Shell编程

- 变量、条件、循环
- 函数、数组、正则
- 自动化运维案例

第六部分：高级主题

- 加固策略与最佳实践
- 系统调优技巧
- 系统日志配置与分析
- 数据备份策略

第七部分：容器与虚拟化

- 容器技术入门
- 容器编排

第八部分：故障排查

- 系统故障诊断
- 系统核心优化

教程特点

学习建议

每篇教程都配有实践练习，建议在虚拟机中反复练习
养成查看man手册的习惯，这是最重要的学习资源
遇到问题时，先尝试独立解决，再寻求帮助

前提条件

无需任何Linux基础，但需具备基本的计算机操作能力
建议准备一台Linux虚拟机（推荐Ubuntu或CentOS）用于实践

教程特色

系统化学习路径，从基础到精通
大量实战案例，学以致用
丰富的命令速查表
详细的配置示例

祝你学习愉快！

愿你在Linux的世界里不断探索，成为真正的技术高手！

Linux 完全指南

Thu, 01 Jan 2026 00:00:00 +0000

Linux 完全指南

课程简介

本系列教程将带你从零基础开始，系统掌握Linux操作系统的各个方面，最终成为Linux高手。

学习路径总览

阶段	内容	难度
入门篇	Linux基础概念、系统安装、桌面环境	⭐
基础篇	文件系统、用户权限、Shell命令	⭐⭐
进阶篇	网络配置、进程管理、软件包管理	⭐⭐⭐
高级篇	Shell脚本、系统服务、性能优化	⭐⭐⭐⭐
精通篇	安全加固、容器技术、故障排查	⭐⭐⭐⭐⭐

完整教程目录

第一部分：入门基础

- 了解Linux历史、发行版及安装
- GNOME/KDE等桌面环境使用

第二部分：核心基础

- Linux文件系统层次结构
- 用户、组、文件权限
- Bash Shell入门
- grep、sed、awk高级用法

第三部分：系统管理

- 进程监控、服务控制
- apt、yum、dnf使用

第四部分：网络管理

- IP配置、网络诊断工具
- 安全远程连接
- iptables、firewalld、ufw

第五部分：Shell编程

- 变量、条件、循环
- 函数、数组、正则
- 自动化运维案例

第六部分：高级主题

- 加固策略与最佳实践
- 系统调优技巧
- 系统日志配置与分析
- 数据备份策略

第七部分：容器与虚拟化

- 容器技术入门
- 容器编排

第八部分：故障排查

- 系统故障诊断
- 系统核心优化

教程特点

学习建议

每篇教程都配有实践练习，建议在虚拟机中反复练习
养成查看man手册的习惯，这是最重要的学习资源
遇到问题时，先尝试独立解决，再寻求帮助

前提条件

无需任何Linux基础，但需具备基本的计算机操作能力
建议准备一台Linux虚拟机（推荐Ubuntu或CentOS）用于实践

教程特色

系统化学习路径，从基础到精通
大量实战案例，学以致用
丰富的命令速查表
详细的配置示例

祝你学习愉快！

愿你在Linux的世界里不断探索，成为真正的技术高手！