探索 AlmaLinux 性能极限 从内核调优到资源管理的全方位实战指南

引言：为什么需要关注 AlmaLinux 性能调优？

AlmaLinux 作为 CentOS 的继任者，继承了 RHEL 的稳定性和企业级特性。在生产环境中，无论是运行高并发 Web 服务、数据库集群还是容器化应用，系统性能都直接影响业务体验和成本。本文将从内核参数调优、CPU/内存/磁盘 I/O 优化、网络性能提升到容器环境优化，提供一套完整的实战指南。

---

第一章：内核参数调优

1.1 内核参数调优基础

Linux 内核参数控制着系统资源的分配和使用方式。通过调整 /proc/sys/ 下的参数，可以优化系统行为。

1.1.1 常用调优工具

# 查看当前内核参数
sysctl -a | grep <关键词>

# 临时修改参数（重启失效）
sysctl -w net.core.somaxconn=65535

# 永久修改参数（写入配置文件）
echo "net.core.somaxconn = 65535" >> /etc/sysctl.conf
sysctl -p  # 立即生效

1.2 网络性能调优

1.2.1 TCP/IP 栈优化

对于高并发 Web 服务器，需要调整 TCP 连接队列和缓冲区大小：

# /etc/sysctl.conf 配置示例
# 增大 TCP 连接队列
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535

# 优化 TCP 缓冲区
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216

# 启用 TCP Fast Open
net.ipv4.tcp_fastopen = 3

# 减少 TIME_WAIT 连接
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 30

# 增大端口范围
net.ipv4.ip_local_port_range = 1024 65535

1.2.2 网络性能测试

使用 iperf3 测试网络吞吐量：

# 在服务器端启动
iperf3 -s

# 在客户端测试
iperf3 -c <服务器IP> -t 30 -P 10  # 10个并行连接测试30秒

1.3 内存管理调优

1.3.1 虚拟内存参数

# /etc/sysctl.conf 内存优化配置
# 减少交换倾向，优先使用物理内存
vm.swappiness = 10

# 优化内存回收策略
vm.vfs_cache_pressure = 50

# 增大内存映射文件限制
vm.max_map_count = 262144

# 调整脏页写回策略
vm.dirty_ratio = 15
vm.dirty_background_ratio = 5
vm.dirty_expire_centisecs = 3000
vm.dirty_writeback_centisecs = 500

1.3.2 大页内存（HugePages）配置

对于数据库等内存密集型应用，启用大页内存可以减少 TLB miss：

# 计算需要的大页数量（以 2MB 大页为例）
# 假设需要 64GB 大页内存
HUGEPAGES_COUNT=$((64 * 1024 / 2))

# 临时设置
echo $HUGEPAGES_COUNT > /proc/sys/vm/nr_hugepages

# 永久设置（/etc/sysctl.conf）
vm.nr_hugepages = 32768

# 验证大页状态
cat /proc/meminfo | grep Huge

# 在应用中使用大页（以 PostgreSQL 为例）
# postgresql.conf
# huge_pages = on
# shared_buffers = 16GB  # 需要与大页大小对齐

1.4 I/O 调度器优化

1.4.1 选择合适的 I/O 调度器

# 查看当前调度器
cat /sys/block/sda/queue/scheduler

# 设置调度器（根据硬件类型选择）
# SSD/NVMe: none 或 noop
# HDD: deadline 或 bfq
echo noop > /sys/block/sda/queue/scheduler

# 永久设置（通过 udev 规则）
cat > /etc/udev/rules.d/60-ioscheduler.rules << 'EOF'
ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/rotational}=="0", ATTR{queue/scheduler}="noop"
ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/rotational}=="1", ATTR{queue/scheduler}="deadline"
EOF

1.4.2 I/O 性能监控

# 使用 iostat 监控磁盘 I/O
iostat -x 1  # 每秒刷新，显示扩展统计信息

# 使用 iotop 查看进程级 I/O
sudo iotop -o

# 使用 blktrace 跟踪块设备操作
blktrace -d /dev/sda -o trace
blkparse -i trace.blktrace.0 -o trace.txt

---

第二章：CPU 性能优化

2.1 CPU 调度策略

2.1.1 CPU 亲和性（Affinity）

将进程绑定到特定 CPU 核心，减少上下文切换：

# 查看 CPU 信息
lscpu

# 使用 taskset 绑定进程到 CPU 核心
# 绑定进程 PID 1234 到 CPU 0-3
taskset -cp 0-3 1234

# 启动时绑定进程
taskset -c 0-3 /path/to/application

# 使用 numactl 进行 NUMA 节点绑定
numactl --cpunodebind=0 --membind=0 /path/to/application

2.1.2 CPU 调度器选择

AlmaLinux 默认使用 CFS（完全公平调度器），但可以调整：

# 查看当前调度器
cat /sys/kernel/debug/sched/debug 2>/dev/null | head -20

# 调整 CFS 参数（/etc/sysctl.conf）
# 减少调度延迟
kernel.sched_latency_ns = 10000000  # 10ms
kernel.sched_min_granularity_ns = 1000000  # 1ms
kernel.sched_wakeup_granularity_ns = 1000000  # 1ms

# 对于实时任务，可以使用 SCHED_FIFO
# 需要 root 权限
chrt -f -p 99 <PID>  # 设置 FIFO 调度，优先级 99

2.2 多线程应用优化

2.2.1 线程池配置

对于高并发应用，合理配置线程池大小：

# Python 示例：使用 concurrent.futures
import concurrent.futures
import psutil

def get_optimal_thread_count():
    """根据 CPU 核心数和负载计算最优线程数"""
    cpu_count = psutil.cpu_count()
    # I/O 密集型：2-4倍 CPU 核心数
    # CPU 密集型：等于 CPU 核心数
    return cpu_count * 2

# 创建线程池
with concurrent.futures.ThreadPoolExecutor(
    max_workers=get_optimal_thread_count()
) as executor:
    # 提交任务
    futures = [executor.submit(process_task, i) for i in range(100)]
    # 处理结果
    for future in concurrent.futures.as_completed(futures):
        result = future.result()

2.2.2 NUMA 感知编程

对于多路服务器，NUMA 感知至关重要：

// C 示例：NUMA 感知内存分配
#include <numa.h>
#include <numaif.h>
#include <stdio.h>

void numa_aware_allocation() {
    // 检查 NUMA 支持
    if (numa_available() < 0) {
        printf("NUMA not available\n");
        return;
    }
    
    // 获取当前节点
    int node = numa_node_of_cpu(sched_getcpu());
    printf("Current NUMA node: %d\n", node);
    
    // 在特定节点分配内存
    void *ptr = numa_alloc_onnode(1024 * 1024, node);  // 1MB
    if (ptr == NULL) {
        printf("Allocation failed\n");
        return;
    }
    
    // 绑定内存到节点
    unsigned long nodemask = 1 << node;
    mbind(ptr, 1024 * 1024, MPOL_BIND, &nodemask, 64, 0);
    
    // 使用内存...
    
    // 释放
    numa_free(ptr, 1024 * 1024);
}

2.3 CPU 性能监控

2.3.1 使用 perf 进行性能分析

# 安装 perf
sudo dnf install perf

# 记录 CPU 性能事件
perf record -g -p <PID> sleep 30

# 生成报告
perf report

# 实时监控 CPU 使用率
perf stat -e cycles,instructions,cache-misses -p <PID> sleep 10

# 分析热点函数
perf record -F 99 -g -- sleep 30
perf script | flamegraph.pl > flamegraph.svg

2.3.2 使用 htop 和 mpstat

# htop 交互式监控
htop

# mpstat 多核 CPU 统计
mpstat -P ALL 1

# 查看每个 CPU 核心的使用情况
cat /proc/stat | grep '^cpu[0-9]'

---

第三章：内存管理优化

3.1 内存使用分析

3.1.1 内存使用情况监控

# 查看内存使用详情
free -h
cat /proc/meminfo

# 使用 smem 按进程统计内存
smem -s rss -r

# 使用 pmap 查看进程内存映射
pmap -x <PID>

3.1.2 内存泄漏检测

# 使用 valgrind 检测 C/C++ 程序内存泄漏
valgrind --leak-check=full --show-leak-kinds=all ./your_program

# 使用 mtrace 进行内存跟踪
export MALLOC_TRACE=/tmp/mtrace.log
./your_program
mtrace your_program /tmp/mtrace.log

# 使用 heaptrack 进行堆分析（需要安装）
heaptrack ./your_program
heaptrack_gui heaptrack.your_program.12345.gz

3.2 内存压缩与交换优化

3.2.1 zswap 配置

zswap 是一种内核级内存压缩技术，可以减少交换延迟：

# 检查 zswap 是否可用
cat /proc/sys/kernel/zswap/enabled

# 启用 zswap（临时）
echo 1 > /proc/sys/kernel/zswap/enabled

# 指定压缩算法（zstd 通常比 lzo 更好）
echo zstd > /proc/sys/kernel/zswap/compressor

# 设置最大压缩比例（默认 2:1）
echo 2 > /proc/sys/kernel/zswap/max_pool_percent

# 永久启用（/etc/default/grub）
GRUB_CMDLINE_LINUX_DEFAULT="... zswap.enabled=1 zswap.compressor=zstd zswap.max_pool_percent=20"

# 更新 GRUB 并重启
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
sudo reboot

3.2.2 交换分区优化

# 创建交换文件（如果需要更多交换空间）
dd if=/dev/zero of=/swapfile bs=1M count=8192  # 8GB
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile

# 永久添加到 fstab
echo '/swapfile none swap sw 0 0' >> /etc/fstab

# 调整交换倾向（vm.swappiness）
# 值越低，越倾向于使用物理内存
# 0-10: 尽可能避免交换
# 60: 默认值
# 100: 积极交换
sysctl vm.swappiness=10

3.3 应用级内存优化

3.3.1 Java 应用内存优化

# JVM 内存参数示例（/etc/default/tomcat）
JAVA_OPTS="-Xms4g -Xmx4g -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:+UnlockExperimentalVMOptions -XX:+UseCGroupMemoryLimitForHeap"

# 使用 jstat 监控 GC
jstat -gcutil <PID> 1000

# 使用 jmap 生成堆转储
jmap -dump:format=b,file=heap.hprof <PID>

# 使用 jconsole 或 jvisualvm 监控
jconsole <PID>

3.3.2 Python 应用内存优化

# 使用 memory_profiler 分析内存使用
# 安装：pip install memory_profiler

from memory_profiler import profile

@profile
def memory_intensive_function():
    # 创建大列表
    large_list = [i for i in range(1000000)]
    # 处理数据
    processed = [x * 2 for x in large_list]
    return processed

# 使用 gc 模块控制垃圾回收
import gc

# 禁用自动垃圾回收
gc.disable()

# 手动触发垃圾回收
gc.collect()

# 设置垃圾回收阈值
gc.set_threshold(700, 10, 10)

---

第四章：磁盘 I/O 优化

4.1 文件系统选择与优化

4.1.1 文件系统性能对比

文件系统	适用场景	性能特点
XFS	大文件、高并发	优秀的大文件性能，适合数据库
ext4	通用场景	稳定，适合大多数应用
Btrfs	快照、压缩	支持快照和压缩，但性能略低
ZFS	数据存储、RAID	强大的数据完整性，但内存消耗大

4.1.2 XFS 文件系统优化

# 创建 XFS 文件系统时优化参数
mkfs.xfs -f -i size=512 -l size=128m -d agcount=4 /dev/sdb1

# 挂载时优化参数
mount -o noatime,nodiratime,allocsize=64m /dev/sdb1 /data

# 永久挂载（/etc/fstab）
/dev/sdb1 /data xfs noatime,nodiratime,allocsize=64m 0 0

# 调整 XFS 日志大小（对于大文件操作）
xfs_admin -L 128m /dev/sdb1

4.1.3 ext4 文件系统优化

# 创建 ext4 时优化
mkfs.ext4 -E stride=128,stripe-width=256 -O extent,uninit_bg /dev/sdb1

# 挂载优化
mount -o noatime,nodiratime,data=writeback /dev/sdb1 /data

# 调整日志大小
tune2fs -J size=128 /dev/sdb1

# 调整保留空间（默认 5%）
tune2fs -m 1 /dev/sdb1  # 保留 1% 空间给 root

4.2 I/O 调度器深度优化

4.2.1 不同调度器的适用场景

# 查看所有可用调度器
cat /sys/block/*/queue/scheduler

# 设置调度器（根据硬件类型）
# SSD/NVMe: none 或 noop（避免不必要的排序）
# HDD: deadline 或 bfq（减少寻道时间）

# 对于 NVMe SSD，使用 none 调度器
echo none > /sys/block/nvme0n1/queue/scheduler

# 对于 HDD，使用 deadline 调度器
echo deadline > /sys/block/sda/queue/scheduler

# 调整 deadline 参数（/etc/udev/rules.d/60-ioscheduler.rules）
# 增加读写超时
echo 500 > /sys/block/sda/queue/iosched/read_expire
echo 5000 > /sys/block/sda/queue/iosched/write_expire

4.2.2 使用 fio 进行 I/O 性能测试

# 安装 fio
sudo dnf install fio

# 随机读测试
fio --name=randread --ioengine=libaio --direct=1 --rw=randread --bs=4k --size=1G --numjobs=1 --runtime=30 --group_reporting

# 顺序写测试
fio --name=seqwrite --ioengine=libaio --direct=1 --rw=write --bs=1M --size=10G --numjobs=1 --runtime=30 --group_reporting

# 混合读写测试（模拟数据库负载）
fio --name=mixed --ioengine=libaio --direct=1 --rw=randrw --rwmixread=70 --bs=8k --size=10G --numjobs=4 --runtime=60 --group_reporting

# 生成测试配置文件
cat > fio-test.fio << 'EOF'
[global]
ioengine=libaio
direct=1
runtime=60
group_reporting

[randread]
rw=randread
bs=4k
size=1G
numjobs=4

[seqwrite]
rw=write
bs=1M
size=10G
numjobs=1

[mixed]
rw=randrw
rwmixread=70
bs=8k
size=10G
numjobs=4
EOF

fio fio-test.fio

4.3 RAID 配置优化

4.3.1 硬件 RAID 优化

# 查看 RAID 卡信息
lspci | grep -i raid
megacli -AdpAllInfo -aALL

# 调整 RAID 卡缓存策略
# 写缓存策略（Write-Back vs Write-Through）
megacli -LDSetProp -Cached -WB -Direct -a0  # 启用写回缓存

# 调整预读策略
megacli -LDSetProp -RAID -Cached -a0  # 启用预读

# 调整缓存大小（如果支持）
megacli -LDSetProp -Cached -CachedPd -a0

4.3.2 软件 RAID（mdadm）优化

# 创建 RAID 10
mdadm --create /dev/md0 --level=10 --raid-devices=4 /dev/sd[b-e]

# 优化 RAID 10 参数
echo 1024 > /sys/block/md0/md/stripe_cache_size  # 增加条带缓存

# 调整 RAID 重建速度
echo 50000 > /sys/block/md0/md/sync_speed_min  # 最小重建速度（KB/s）
echo 200000 > /sys/block/md0/md/sync_speed_max  # 最大重建速度（KB/s）

# 监控 RAID 状态
cat /proc/mdstat
mdadm --detail /dev/md0

---

第五章：网络性能优化

5.1 网络栈深度调优

5.1.1 TCP 参数优化

# /etc/sysctl.conf 网络优化配置
# 增大 TCP 连接队列
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535

# 优化 TCP 缓冲区
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216

# 启用 TCP Fast Open
net.ipv4.tcp_fastopen = 3

# 减少 TIME_WAIT 连接
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 30

# 增大端口范围
net.ipv4.ip_local_port_range = 1024 65535

# TCP 拥塞控制算法选择
# cubic: 默认，适合大多数场景
# bbr: Google 的 BBR 算法，适合高延迟网络
net.ipv4.tcp_congestion_control = bbr

# 启用 TCP 拥塞窗口缩放
net.ipv4.tcp_window_scaling = 1

5.1.2 网络接口优化

# 查看网卡信息
ethtool eth0

# 调整网卡参数
# 启用多队列（RSS）
ethtool -L eth0 combined 8  # 设置 8 个队列

# 调整接收/发送缓冲区
ethtool -G eth0 rx 4096 tx 4096

# 启用 TCP Segmentation Offload (TSO)
ethtool -K eth0 tso on

# 启用 Generic Receive Offload (GRO)
ethtool -K eth0 gro on

# 启用 Large Receive Offload (LRO)
ethtool -K eth0 lro on

# 永久设置（创建 udev 规则）
cat > /etc/udev/rules.d/99-network.rules << 'EOF'
ACTION=="add", SUBSYSTEM=="net", KERNEL=="eth*", RUN+="/usr/bin/ethtool -L %k combined 8"
ACTION=="add", SUBSYSTEM=="net", KERNEL=="eth*", RUN+="/usr/bin/ethtool -G %k rx 4096 tx 4096"
ACTION=="add", SUBSYSTEM=="net", KERNEL=="eth*", RUN+="/usr/bin/ethtool -K %k tso on gro on"
EOF

5.2 网络性能测试

5.2.1 使用 iperf3 进行吞吐量测试

# 服务器端
iperf3 -s -p 5201

# 客户端测试
# 单线程测试
iperf3 -c <服务器IP> -p 5201 -t 30

# 多线程测试（模拟高并发）
iperf3 -c <服务器IP> -p 5201 -t 30 -P 10

# 反向测试（服务器到客户端）
iperf3 -c <服务器IP> -p 5201 -t 30 -R

# 使用 UDP 测试
iperf3 -c <服务器IP> -p 5201 -t 30 -u -b 1G

5.2.2 使用 netperf 进行延迟测试

# 安装 netperf
sudo dnf install netperf

# 服务器端
netserver

# 客户端测试
# TCP 流测试
netperf -H <服务器IP> -t TCP_STREAM

# TCP 请求/响应测试
netperf -H <服务器IP> -t TCP_RR

# UDP 流测试
netperf -H <服务器IP> -t UDP_STREAM

5.3 网络监控工具

5.3.1 实时网络监控

# 使用 nload 查看实时带宽
nload

# 使用 iftop 查看连接级流量
iftop -i eth0

# 使用 iptraf-ng 查看详细统计
iptraf-ng

# 使用 ss 查看连接状态
ss -tunap

# 使用 netstat 查看网络统计
netstat -s

5.3.2 网络流量分析

# 使用 tcpdump 捕获流量
tcpdump -i eth0 -w capture.pcap

# 使用 Wireshark 分析（需要图形界面）
wireshark capture.pcap

# 使用 tshark 命令行分析
tshark -r capture.pcap -z "io,stat,1"

# 使用 bmon 查看带宽使用情况
bmon

---

第六章：容器环境优化

6.1 Docker 容器优化

6.1.1 Docker 守护进程优化

# 编辑 Docker 守护进程配置
cat > /etc/docker/daemon.json << 'EOF'
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  },
  "storage-driver": "overlay2",
  "storage-opts": [
    "overlay2.override_kernel_check=true"
  ],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "default-ulimits": {
    "nofile": {
      "Name": "nofile",
      "Hard": 65536,
      "Soft": 65536
    }
  },
  "live-restore": true,
  "max-concurrent-downloads": 3,
  "max-concurrent-uploads": 3,
  "registry-mirrors": ["https://mirror.gcr.io"]
}
EOF

# 重启 Docker
systemctl restart docker

6.1.2 容器资源限制

# 运行容器时限制资源
docker run -d \
  --name myapp \
  --cpus="2" \
  --memory="4g" \
  --memory-swap="8g" \
  --memory-swappiness=0 \
  --restart=unless-stopped \
  myimage:latest

# 使用 cgroup 限制（更精细的控制）
docker run -d \
  --name myapp \
  --cpu-quota=50000 \
  --cpu-period=100000 \
  --memory="4g" \
  --memory-reservation="3g" \
  --memory-swap="8g" \
  --kernel-memory="512m" \
  myimage:latest

6.1.3 容器网络优化

# 使用 host 网络模式（减少网络开销）
docker run -d --network host myimage:latest

# 使用 macvlan 网络（直接暴露容器到物理网络）
docker network create -d macvlan \
  --subnet=192.168.1.0/24 \
  --gateway=192.168.1.1 \
  -o parent=eth0 macvlan0

docker run -d --network macvlan0 --ip=192.168.1.100 myimage:latest

# 使用 bridge 网络并优化
docker network create \
  --driver bridge \
  --subnet=172.18.0.0/16 \
  --gateway=172.18.0.1 \
  --opt com.docker.network.bridge.name=mybridge \
  --opt com.docker.network.bridge.enable_icc=true \
  --opt com.docker.network.bridge.enable_ip_masquerade=true \
  --opt com.docker.network.bridge.mtu=9000 \
  mybridge

6.2 Kubernetes 优化

6.2.1 节点优化

# 调整 kubelet 参数
cat > /etc/systemd/system/kubelet.service.d/10-kubeadm.conf << 'EOF'
[Service]
Environment="KUBELET_EXTRA_ARGS=--max-pods=110 --system-reserved=cpu=500m,memory=1Gi --kube-reserved=cpu=500m,memory=1Gi --eviction-hard=nodefs.available<10%,nodefs.inodesFree<5%,imagefs.available<15%,memory.available<100Mi"
EOF

# 调整内核参数（/etc/sysctl.conf）
# 为 Kubernetes 优化
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.conf.all.rp_filter = 0
net.ipv4.conf.default.rp_filter = 0
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.secure_redirects = 0
net.ipv4.conf.default.secure_redirects = 0
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0

6.2.2 Pod 资源优化

# Kubernetes Pod 资源配置示例
apiVersion: v1
kind: Pod
metadata:
  name: optimized-app
spec:
  containers:
  - name: app
    image: myapp:latest
    resources:
      requests:
        memory: "256Mi"
        cpu: "250m"
      limits:
        memory: "512Mi"
        cpu: "500m"
    # 资源限制策略
    securityContext:
      capabilities:
        drop:
        - ALL
      readOnlyRootFilesystem: true
      runAsNonRoot: true
      runAsUser: 1000
    # 健康检查
    livenessProbe:
      httpGet:
        path: /health
        port: 8080
      initialDelaySeconds: 30
      periodSeconds: 10
    readinessProbe:
      httpGet:
        path: /ready
        port: 8080
      initialDelaySeconds: 5
      periodSeconds: 5
  # 节点选择器
  nodeSelector:
    workload: "high-performance"
  # 亲和性规则
  affinity:
    podAntiAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        podAffinityTerm:
          labelSelector:
            matchExpressions:
            - key: app
              operator: In
              values:
              - myapp
          topologyKey: "kubernetes.io/hostname"

6.2.3 CNI 插件优化

# 使用 Cilium 作为 CNI（高性能网络）
# 安装 Cilium
kubectl create -f https://raw.githubusercontent.com/cilium/cilium/main/install/kubernetes/quick-install.yaml

# 配置 Cilium 优化
cat > cilium-config.yaml << 'EOF'
apiVersion: v1
kind: ConfigMap
metadata:
  name: cilium-config
  namespace: kube-system
data:
  # 启用 eBPF 优化
  enable-bpf-masquerade: "true"
  enable-host-legacy-routing: "false"
  # 调整连接跟踪
  conntrack-gc-interval: "0s"
  # 启用带宽管理
  enable-bandwidth-manager: "true"
  # 调整资源限制
  bpf-ct-global-tcp-max: "1000000"
  bpf-ct-global-any-max: "500000"
EOF

---

第七章：监控与告警

7.1 系统监控工具

7.1.1 Prometheus + Grafana 监控栈

# 安装 Prometheus
sudo dnf install prometheus

# 配置 Prometheus（/etc/prometheus/prometheus.yml）
cat > /etc/prometheus/prometheus.yml << 'EOF'
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'node'
    static_configs:
      - targets: ['localhost:9100']
  - job_name: 'docker'
    static_configs:
      - targets: ['localhost:9323']
  - job_name: 'kubernetes'
    kubernetes_sd_configs:
    - role: pod
      namespaces:
        names:
        - default
EOF

# 安装 Node Exporter
sudo dnf install node_exporter

# 启动服务
systemctl enable --now prometheus node_exporter

7.1.2 使用 cAdvisor 监控容器

# 运行 cAdvisor
docker run \
  --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:ro \
  --volume=/sys:/sys:ro \
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --publish=8080:8080 \
  --detach=true \
  --name=cadvisor \
  gcr.io/cadvisor/cadvisor:latest

7.2 日志管理

7.2.1 使用 ELK Stack

# 使用 Docker Compose 部署 ELK
cat > docker-compose.yml << 'EOF'
version: '3'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.5.0
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
    ports:
      - "9200:9200"
    volumes:
      - esdata:/usr/share/elasticsearch/data

  logstash:
    image: docker.elastic.co/logstash/logstash:8.5.0
    ports:
      - "5044:5044"
    volumes:
      - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf

  kibana:
    image: docker.elastic.co/kibana/kibana:8.5.0
    ports:
      - "5601:5601"
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200

volumes:
  esdata:
EOF

# 启动
docker-compose up -d

7.3 告警配置

7.3.1 使用 Alertmanager

# 配置 Alertmanager（/etc/prometheus/alertmanager.yml）
cat > /etc/prometheus/alertmanager.yml << 'EOF'
global:
  smtp_smarthost: 'smtp.gmail.com:587'
  smtp_from: 'alert@yourdomain.com'
  smtp_auth_username: 'your-email@gmail.com'
  smtp_auth_password: 'your-password'

route:
  group_by: ['alertname']
  group_wait: 10s
  group_interval: 10s
  repeat_interval: 1h
  receiver: 'email'

receivers:
- name: 'email'
  email_configs:
  - to: 'admin@yourdomain.com'
    subject: 'Alert: {{ .GroupLabels.alertname }}'
    body: |
      {{ range .Alerts }}
      Alert: {{ .Annotations.summary }}
      Description: {{ .Annotations.description }}
      {{ end }}
EOF

---

第八章：实战案例

8.1 高并发 Web 服务器优化

8.1.1 Nginx 优化配置

# /etc/nginx/nginx.conf
user nginx;
worker_processes auto;  # 自动设置为 CPU 核心数
worker_rlimit_nofile 65536;  # 每个 worker 进程的最大文件描述符

events {
    worker_connections 65536;  # 每个 worker 的最大连接数
    use epoll;  # 使用 epoll 事件模型
    multi_accept on;  # 一次接受多个连接
}

http {
    # 基础配置
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    keepalive_requests 1000;
    
    # 缓冲区优化
    client_body_buffer_size 128k;
    client_max_body_size 10m;
    client_header_buffer_size 1k;
    large_client_header_buffers 4 8k;
    
    # Gzip 压缩
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types
        text/plain
        text/css
        text/xml
        text/javascript
        application/javascript
        application/xml+rss
        application/json;
    
    # 隐藏版本号
    server_tokens off;
    
    # 限制请求
    limit_req_zone $binary_remote_addr zone=one:10m rate=10r/s;
    
    # 日志优化
    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for"';
    
    access_log /var/log/nginx/access.log main buffer=32k flush=1m;
    error_log /var/log/nginx/error.log warn;
    
    # 虚拟主机配置
    server {
        listen 80;
        server_name _;
        
        # 限制并发连接
        limit_conn one 10;
        
        # 位置配置
        location / {
            root /usr/share/nginx/html;
            index index.html index.htm;
            
            # 启用 HTTP/2
            http2 on;
            
            # 启用 Brotli 压缩（需要安装模块）
            # brotli on;
            # brotli_comp_level 6;
            # brotli_types text/plain text/css text/xml text/javascript application/javascript application/xml+rss application/json;
        }
        
        # 静态文件缓存
        location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ {
            expires 30d;
            add_header Cache-Control "public, immutable";
        }
    }
}

8.1.2 PHP-FPM 优化

; /etc/php-fpm.d/www.conf
[www]
user = nginx
group = nginx

; 进程管理
pm = dynamic
pm.max_children = 50
pm.start_servers = 10
pm.min_spare_servers = 5
pm.max_spare_servers = 30
pm.max_requests = 500

; 内存限制
php_admin_value[memory_limit] = 256M
php_admin_value[post_max_size] = 10M
php_admin_value[upload_max_filesize] = 10M

; 慢日志
request_slowlog_timeout = 5s
slowlog = /var/log/php-fpm/slow.log

; 进程空闲时间
pm.process_idle_timeout = 10s

; 最大执行时间
max_execution_time = 30
request_terminate_timeout = 30

8.2 数据库服务器优化

8.2.1 PostgreSQL 优化

# /var/lib/pgsql/data/postgresql.conf
# 内存配置
shared_buffers = 16GB  # 通常为总内存的 25%
effective_cache_size = 48GB  # 通常为总内存的 75%
work_mem = 64MB  # 每个查询的排序内存
maintenance_work_mem = 1GB  # 维护操作内存

# 日志配置
log_min_duration_statement = 1000  # 记录慢查询
log_checkpoints = on
log_connections = on
log_disconnections = on
log_lock_waits = on

# 检查点配置
checkpoint_timeout = 15min
max_wal_size = 4GB
min_wal_size = 1GB

# 并发配置
max_connections = 200
shared_preload_libraries = 'pg_stat_statements'

# 启用并行查询
max_parallel_workers_per_gather = 4
max_parallel_workers = 8

# 启用 WAL 归档（用于备份）
archive_mode = on
archive_command = 'cp %p /var/lib/pgsql/wal_archive/%f'

8.2.2 MySQL 优化

# /etc/my.cnf.d/server.cnf
[mysqld]
# 内存配置
innodb_buffer_pool_size = 16G  # 通常为总内存的 70-80%
innodb_buffer_pool_instances = 8  # 缓冲池实例数
innodb_log_file_size = 2G
innodb_log_buffer_size = 64M

# I/O 配置
innodb_flush_log_at_trx_commit = 2  # 平衡性能与数据安全
innodb_flush_method = O_DIRECT  # 绕过文件系统缓存
innodb_file_per_table = ON

# 并发配置
innodb_thread_concurrency = 0  # 自动调整
innodb_read_io_threads = 8
innodb_write_io_threads = 8

# 查询缓存（MySQL 8.0 已移除，此处为旧版本）
# query_cache_type = 1
# query_cache_size = 64M

# 连接配置
max_connections = 200
thread_cache_size = 50
table_open_cache = 2000

# 慢查询日志
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 2

# 日志配置
log_bin = /var/log/mysql/mysql-bin.log
binlog_format = ROW
expire_logs_days = 7

8.3 容器化应用优化

8.3.1 多阶段构建优化 Dockerfile

# 多阶段构建示例
# 第一阶段：构建阶段
FROM golang:1.19-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main .

# 第二阶段：运行阶段
FROM alpine:3.17
WORKDIR /app
# 安装必要的工具（最小化）
RUN apk --no-cache add ca-certificates tzdata
# 复制构建产物
COPY --from=builder /app/main .
# 设置非 root 用户
RUN addgroup -g 1001 appgroup && \
    adduser -D -u 1001 -G appgroup appuser
USER appuser
# 暴露端口
EXPOSE 8080
# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health || exit 1
# 启动命令
CMD ["./main"]

8.3.2 Kubernetes 资源优化配置

# Kubernetes Deployment 优化配置
apiVersion: apps/v1
kind: Deployment
metadata:
  name: optimized-app
  labels:
    app: optimized-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: optimized-app
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: optimized-app
    spec:
      # 节点选择器
      nodeSelector:
        workload: "high-performance"
      
      # 亲和性规则
      affinity:
        # Pod 亲和性
        podAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchExpressions:
                - key: app
                  operator: In
                  values:
                  - optimized-app
              topologyKey: "kubernetes.io/hostname"
        
        # 节点亲和性
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: node-type
                operator: In
                values:
                - compute-optimized
      
      # 容忍度
      tolerations:
      - key: "dedicated"
        operator: "Equal"
        value: "compute"
        effect: "NoSchedule"
      
      # 容器配置
      containers:
      - name: app
        image: myapp:latest
        imagePullPolicy: IfNotPresent
        
        # 资源限制
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "1Gi"
            cpu: "1000m"
        
        # 环境变量
        env:
        - name: JAVA_OPTS
          value: "-Xms512m -Xmx512m -XX:+UseG1GC"
        
        # 端口
        ports:
        - containerPort: 8080
          name: http
        
        # 健康检查
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5
          failureThreshold: 3
        
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
          timeoutSeconds: 3
          failureThreshold: 3
        
        # 生命周期钩子
        lifecycle:
          postStart:
            exec:
              command: ["/bin/sh", "-c", "echo 'Container started' > /tmp/start.log"]
          preStop:
            exec:
              command: ["/bin/sh", "-c", "sleep 30"]  # 给应用 30 秒优雅关闭
        
        # 安全上下文
        securityContext:
          capabilities:
            drop:
            - ALL
          readOnlyRootFilesystem: true
          runAsNonRoot: true
          runAsUser: 1000
        
        # 挂载卷
        volumeMounts:
        - name: config
          mountPath: /etc/app/config
          readOnly: true
      
      # 初始化容器
      initContainers:
      - name: init-db
        image: busybox:1.28
        command: ['sh', '-c', 'until nslookup db; do echo waiting for db; sleep 2; done;']
      
      # 卷配置
      volumes:
      - name: config
        configMap:
          name: app-config

---

第九章：性能调优最佳实践

9.1 调优流程

1. 基准测试：使用 sysbench、fio、iperf3 等工具建立性能基线
2. 监控分析：使用 perf、vmstat、iostat、netstat 等工具分析瓶颈
3. 参数调整：根据分析结果调整内核参数和应用配置
4. 验证测试：重新运行基准测试，验证调优效果
5. 持续监控：部署监控系统，持续跟踪性能变化

9.2 常见性能问题排查

9.2.1 CPU 使用率高

# 1. 查看哪个进程占用 CPU
top -p $(pgrep -d',' -f <process_name>)

# 2. 使用 perf 分析 CPU 热点
perf top -p <PID>

# 3. 检查上下文切换
vmstat 1
# 或
pidstat -w -p <PID> 1

# 4. 检查中断
cat /proc/interrupts

9.2.2 内存不足

# 1. 查看内存使用详情
cat /proc/meminfo

# 2. 查看进程内存使用
smem -s rss -r

# 3. 检查交换空间使用
vmstat 1
# 或
free -h

# 4. 检查内存泄漏
valgrind --leak-check=full ./your_program

9.2.3 I/O 瓶颈

# 1. 查看磁盘 I/O
iostat -x 1

# 2. 查看进程 I/O
iotop -o

# 3. 检查文件系统
df -h
# 或
du -sh /var/lib/* | sort -hr

# 4. 检查 RAID 状态
cat /proc/mdstat
# 或
megacli -LDInfo -Lall -aALL

9.2.4 网络问题

# 1. 查看网络连接
ss -tunap
# 或
netstat -tunap

# 2. 查看网络流量
iftop -i eth0
# 或
nload

# 3. 检查丢包
netstat -s | grep -i "drop"
# 或
cat /proc/net/dev

# 4. 检查网络延迟
ping -c 10 <目标IP>
# 或
mtr <目标IP>

9.3 性能调优工具箱

工具	用途	安装命令
sysbench	综合性能测试	sudo dnf install sysbench
fio	I/O 性能测试	sudo dnf install fio
iperf3	网络吞吐量测试	sudo dnf install iperf3
perf	CPU 性能分析	sudo dnf install perf
vmstat	虚拟内存统计	sudo dnf install sysstat
iostat	I/O 统计	sudo dnf install sysstat
netstat	网络统计	sudo dnf install net-tools
ss	套接字统计	sudo dnf install iproute
htop	交互式进程监控	sudo dnf install htop
iotop	I/O 进程监控	sudo dnf install iotop
iftop	网络流量监控	sudo dnf install iftop
nload	实时带宽监控	sudo dnf install nload
smem	内存使用统计	sudo dnf install smem
pmap	进程内存映射	sudo dnf install psmisc
valgrind	内存泄漏检测	sudo dnf install valgrind
heaptrack	堆分析	sudo dnf install heaptrack
strace	系统调用跟踪	sudo dnf install strace
ltrace	库函数跟踪	sudo dnf install ltrace
tcpdump	网络抓包	sudo dnf install tcpdump
wireshark	网络分析	sudo dnf install wireshark
tshark	命令行网络分析	sudo dnf install wireshark-cli
bmon	带宽监控	sudo dnf install bmon
iptraf-ng	网络统计	sudo dnf install iptraf-ng
nmon	综合监控	sudo dnf install nmon
dstat	综合监控	sudo dnf install dstat
sar	系统活动报告	sudo dnf install sysstat
pidstat	进程统计	sudo dnf install sysstat
mpstat	多核 CPU 统计	sudo dnf install sysstat
numactl	NUMA 控制	sudo dnf install numactl
taskset	CPU 亲和性	sudo dnf install util-linux
chrt	实时调度	sudo dnf install util-linux
blktrace	块设备跟踪	sudo dnf install blktrace
blkparse	块设备解析	sudo dnf install blktrace
bpftrace	eBPF 跟踪	sudo dnf install bpftrace
bcc	eBPF 工具集	sudo dnf install bcc-tools
prometheus	监控系统	sudo dnf install prometheus
node_exporter	节点监控	sudo dnf install node_exporter
cadvisor	容器监控	docker run ...
grafana	可视化	sudo dnf install grafana
alertmanager	告警管理	sudo dnf install alertmanager

---

第十章：总结

AlmaLinux 性能调优是一个持续的过程，需要根据具体业务场景和硬件配置进行调整。本文从内核参数、CPU、内存、磁盘 I/O、网络、容器环境等多个维度提供了详细的调优指南和实战案例。

关键要点：

1. 基准测试先行：任何调优前都应建立性能基线
2. 监控驱动优化：使用监控工具识别瓶颈，针对性调整
3. 渐进式调整：每次只调整一个参数，验证效果后再继续
4. 文档化：记录所有调整和效果，便于回滚和复盘
5. 持续优化：性能调优不是一次性工作，需要持续监控和调整

推荐的调优顺序：

1. 应用层优化：优化应用代码和配置
2. 系统层优化：调整内核参数和系统配置
3. 硬件层优化：升级硬件或调整硬件配置
4. 架构层优化：考虑分布式架构或负载均衡

通过本文的指南，您应该能够系统地优化 AlmaLinux 系统的性能，满足不同业务场景的需求。记住，没有”一刀切”的调优方案，最佳实践是结合监控数据和业务需求，找到最适合您环境的配置。