实验室 4: 高级系统和进程监控¶

目标¶

完成本实验室后，您将能够

使用高级工具查看和管理进程
诊断和调试系统调用
使用高级 CLI 工具查看和设置进程优先级
查看和设置进程的自定义调度策略
分析系统和应用程序性能

完成本实验室的预计时间：90 分钟

简介¶

本实验室中的命令涵盖了 Linux 中的更广泛的进程管理、系统监控和资源控制范围。它们为您的系统管理员技能库增加了更多深度和多样性。

这些练习涵盖了额外的 Linux 命令和概念，提供进程管理、资源监控和高级控制的实践经验。

练习 1¶

fuser¶

Linux 中的 fuser 命令用于识别使用文件或套接字的进程。它可以作为文件相关进程管理和冲突解决的有用辅助工具。

创建模拟文件使用的脚本¶

首先，创建一个我们要访问的空测试文件。输入
```
touch ~/testfile.txt
```

创建我们将用来模拟对 testfile.txt 访问的脚本。输入

cat > ~/simulate_file_usage.sh << EOF
#!/bin/bash
tail -f ~/testfile.txt
EOF

使脚本可执行。输入
```
chmod +x ~/simulate_file_usage.sh
```
启动脚本。输入
```
~/simulate_file_usage.sh &
```

识别访问文件的进程¶

识别使用或访问 testfile.txt 的进程，运行
```
fuser ~/testfile.txt
```
使用 -v 选项探索其他 fuser 选项。输入
```
fuser -v ~/testfile.txt
```
完成对 testfile.txt 和 simulate_file_usage.sh 的操作。现在可以删除这些文件了。输入
```
kill %1
rm ~/testfile.txt ~/simulate_file_usage.sh
```

识别访问 TCP/UDP 端口的进程¶

使用 fuser 命令识别访问服务器上 TCP 端口 22 的进程。输入
```
sudo fuser 22/tcp
```

练习 2¶

`perf`¶

perf 是一个用于分析 Linux 中系统和应用程序性能的通用工具。它可以提供额外的洞察力，有助于性能调整。

安装 `perf`¶

如果您的服务器上没有安装 perf 应用程序，请安装它。输入
```
sudo dnf -y install perf
```
bc 应用程序是一个命令行高精度计算器。在本练习中，bc 将用于模拟高 CPU 负载。如果您的服务器上尚未安装 bc，请使用以下命令进行安装：
```
sudo dnf -y install bc
```

创建用于生成 CPU 负载的脚本¶

创建一个 CPU 负载脚本，并通过运行以下命令使其可执行：

cat > ~/generate_cpu_load.sh << EOF
#!/bin/bash

# Check if the number of decimal places is passed as an argument
if [ "$#" -ne 1 ]; then
  echo "Usage: $0 <number_of_decimal_places>"
  exit 1
fi

# Calculate Pi to the specified number of decimal places
for i in {1..10}; do echo "scale=$1; 4*a(1)" | bc -l; done

EOF
chmod +x ~/generate_cpu_load.sh

提示

generate_cpu_load.sh 脚本是一个简单的工具，它通过将 Pi (π) 计算到高精度来生成 CPU 负载。相同的计算将执行 10 次。该脚本接受一个整数作为参数，用于指定计算 Pi 的小数位数。

模拟额外的 CPU 负载¶

让我们运行一个简单的测试，并将 Pi 计算到 50 位小数。通过输入以下命令运行该脚本：
```
~/generate_cpu_load.sh 50 & 
```
重新运行该脚本，但使用 perf 记录脚本的性能，以分析 CPU 使用率和其他指标。输入以下命令：
```
 ./generate_cpu_load.sh 1000  &  perf record -p $! sleep 5
```
提示
perf record 命令中的 sleep 5 选项定义了 perf 收集 generate_cpu_load.sh 脚本生成的 CPU 负载的性能数据的时间窗口。它允许 perf 记录系统性能指标 5 秒，然后自动停止。

分析性能数据并监控实时事件¶

使用 perf report 命令查看性能数据报告，以了解 CPU 和内存使用模式。输入以下命令：
```
sudo perf report
```
您可以使用各种键盘键进一步探索报告。输入 q 退出 perf 报告查看器界面。
观察/捕获 40 秒的实时 CPU 缓存事件，以识别潜在的性能瓶颈。输入以下命令：
```
sudo perf stat -e cache-references,cache-misses sleep 40
```

记录系统的全面性能¶

捕获可用于额外分析的系统范围的性能数据。输入以下命令：
```
sudo perf record -a sleep 10
```
探索特定的事件计数器。计算特定的事件，例如 CPU 周期，以评估给定脚本或应用程序的性能。让我们用基本的 find 命令进行测试，输入以下命令：
```
sudo perf stat -e cycles find /proc
```
做同样的事情，但使用 ./generate_cpu_load.sh 脚本。计算特定的事件，例如 CPU 周期，以评估 ./generate_cpu_load.sh 脚本的性能。输入以下命令：
```
sudo perf stat -e cycles ./generate_cpu_load.sh 500
```
输出
```
...<SNIP>...
3.141592653589793238462643383279502884197169399375105820974944592307\
81640628620899862803482534211.....

Performance counter stats for './generate_cpu_load.sh 500':

  1,670,638,886      cycles

     0.530479014 seconds time elapsed

     0.488580000 seconds user
     0.034628000 seconds sys
```
注意
以下是 perf stat 命令的最终示例输出的细分：
1,670,638,886 cycles: 这表示在脚本执行期间消耗的 CPU 周期总数。每个周期代表 CPU 指令执行中的一个步骤。
0.530479014 seconds time elapsed: 这是从脚本执行开始到结束的总经过实际时间（或挂钟时间）。此持续时间包括所有类型的等待（例如等待磁盘 I/O 或系统调用）。
0.488580000 seconds user: 这是用户模式下花费的 CPU 时间。此时间不包括明确花费在执行系统级任务上的时间。
0.034628000 seconds sys: 这是内核或系统模式下花费的 CPU 时间。这包括 CPU 代表脚本执行系统调用或执行其他系统级任务所花费的时间。
使用 perf 工具已完成。确保任何后台脚本都处于干净的工作环境中。
```
kill %1
```

练习 3¶

`strace`¶

strace 用于诊断和调试 Linux 中的系统调用交互。

创建一个用于探索 `strace` 的脚本¶

创建一个名为 strace_script.sh 的简单脚本，并使其可执行。输入以下命令：

cat > ~/strace_script.sh << EOF
#!/bin/bash
while true; do
  date
  sleep 1
done
EOF
chmod +x ~/strace_script.sh

在正在运行的进程上使用 `strace`¶

运行该脚本并附加 strace。输入以下命令：
```
~/strace_script.sh &
```
在另一个终端中找到 strace_script.sh 进程的 PID。将 PID 存储在一个名为 MYPID 的变量中。我们将为此使用 pgrep 命令，方法是运行以下命令：
```
export MYPID=$(pgrep strace_script) ; echo $MYPID
```
输出
```
4006301
```
开始跟踪脚本的系统调用，以了解它如何与内核交互。通过输入以下命令将 strace 附加到正在运行的脚本进程：
```
sudo strace -p $MYPID
```
通过输入 Ctrl+C 分离或停止 strace 进程。
可以通过关注特定的系统调用（例如 open 和 read）来过滤 strace 输出，以分析它们的行为。尝试对 open 和 read 系统调用执行此操作。输入以下命令：
```
sudo strace -e trace=open,read -p $MYPID
```
当您完成尝试解读 strace 输出后，通过输入 Ctrl+C 停止 strace 进程。
将输出重定向到一个文件，以便以后分析，这可以帮助诊断问题。通过运行以下命令将 strace 输出保存到一个文件中：
```
sudo strace -o strace_output.txt -p $MYPID
```

分析系统调用的频率¶

总结系统调用计数，以识别进程最常用的系统调用。通过附加 timeout 命令，仅对 10 秒执行此操作。输入以下命令：

sudo timeout 10 strace -c -p $MYPID

我们的示例系统显示了如下所示的摘要报告输出：

输出

strace: Process 4006301 attached
strace: Process 4006301 detached
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
89.59    0.042553        1182        36        18 wait4
7.68    0.003648         202        18           clone
1.67    0.000794           5       144           rt_sigprocmask
0.45    0.000215           5        36           rt_sigaction
0.36    0.000169           9        18           ioctl
0.25    0.000119           6        18           rt_sigreturn
------ ----------- ----------- --------- --------- ----------------
100.00    0.047498         175       270        18 total

终止脚本并删除创建的任何文件。

kill $MYPID
rm ~/strace_script.sh ~/strace_output.txt

练习 4¶

`atop`¶

atop 提供了系统性能的全面视图，涵盖了各种资源指标。

启动和探索 `atop`¶

如果您的服务器上尚未安装 atop 应用程序，请安装它。输入以下命令：
```
sudo dnf -y install atop
```
通过输入以下命令运行 atop：
```
sudo atop
```
在 atop 界面中，您可以通过按键盘上的特定键来探索各种 atop 指标。
使用 'm'、'd' 或 'n' 在内存、磁盘或网络视图之间切换。观察资源是如何实时使用的。
以 2 秒的自定义间隔监控系统性能，允许更细致地查看系统活动。输入以下命令：
```
sudo atop 2
```
在不同的资源视图之间切换，以关注系统性能的特定方面。
生成系统活动的日志文件报告，以每 60 秒捕获一次数据，共 3 次。输入以下命令：
```
sudo atop -w /tmp/atop_log 60 3
```
上一条命令完成之后，您可以花时间查看保存日志的二进制文件。要读取保存的日志文件，请输入以下命令：
```
sudo atop -r /tmp/atop_log   
```
清理工作环境，删除生成的任何日志或文件。
```
sudo rm /tmp/atop_log
```

练习 5¶

`numactl`¶

这是一种用于多处理的计算机内存设计/架构，它通过考虑内存相对于处理器的物理位置来提高内存访问速度。在基于 NUMA 的系统中，多个处理器（或 CPU 内核）在物理上分组，每个组都有其本地内存。

numactl 应用程序管理 NUMA 策略，优化基于 NUMA 的系统的性能。

安装 `numactl`¶

如果您的服务器上尚未安装 numactl 应用程序，请安装它。输入以下命令：
```
sudo dnf -y install numactl
```

创建一个内存密集型脚本¶

创建一个简单的脚本，以帮助在您的服务器上模拟内存密集型工作负载。输入以下命令：

cat > ~/memory_intensive.sh << EOF
  #!/bin/bash

  awk 'BEGIN{for(i=0;i<1000000;i++)for(j=0;j<1000;j++);}{}'
  EOF
  chmod +x ~/memory_intensive.sh

使用 `numactl`¶

使用 numactl 运行该脚本，输入以下命令：
```
numactl --membind=0 ~/memory_intensive.sh
```
如果您的系统有多个可用的 NUMA 节点，您可以通过以下方式在多个 NUMA 节点上运行该脚本：
```
numactl --cpunodebind=0,1 --membind=0,1 ~/memory_intensive.sh
```
显示 NUMA 节点的内存分配
```
numactl --show
```
通过运行以下命令将内存绑定到特定节点：
```
numactl --membind=0 ~/memory_intensive.sh
```
通过删除脚本清理您的工作环境。
```
rm ~/memory_intensive.sh
```

练习 6¶

`iotop`¶

iotop 命令监控进程和线程的磁盘 I/O（输入/输出）使用情况。它提供与 top 命令类似的实时信息，专门用于磁盘 I/O。这使得它对于诊断由磁盘活动引起的系统速度变慢至关重要。

安装 `iotop`¶

如果尚未安装 iotop 实用程序，请安装它。输入以下命令：
```
sudo dnf -y install iotop
```

使用 `iotop` 监控磁盘 I/O¶

在默认的交互模式下运行 iotop 命令，无需任何选项。输入以下命令：
```
sudo iotop
```
观察各种进程的实时磁盘 I/O 使用情况。使用它来识别当前正在从磁盘读取或写入磁盘的进程。
输入 q 退出 iotop。

在非交互模式下使用 `iotop`¶

在批处理模式 (-b) 下运行 iotop，以获取非交互式的、一次性的 I/O 使用情况视图。-n 10 选项告诉 iotop 在退出之前获取 10 个样本。
```
sudo iotop -b -n 10
```
iotop 可以过滤特定进程的 I/O。使用 ps 命令或 iotop 显示识别系统中的进程 ID (PID)。然后，为该特定 PID 过滤 iotop 输出。例如，通过运行以下命令，为 sshd 进程的 PID 进行过滤：
```
sudo iotop -p $(pgrep sshd | head -1)
```
iotop 的 -o 选项可用于显示执行实际 I/O 的进程或线程，而不是显示所有进程或线程。通过运行以下命令仅显示 I/O 进程：
```
sudo iotop -o
```
讨论
讨论磁盘 I/O 对整体系统性能的影响，以及 iotop 等工具如何帮助优化系统。

练习 7¶

`cgroups`¶

控制组 (cgroups) 提供了一种在 Linux 中组织、限制和优先排序进程资源使用的机制。

本练习演示了与 cgroup v2 文件系统的直接交互。

探索 `cgroup` 文件系统¶

使用 ls 命令探索 cgroup 文件系统的内容和结构。输入以下命令：
```
ls /sys/fs/cgroup/
```
再次使用 ls 命令列出 cgroup 文件系统下的 *.slice 文件夹。输入以下命令：
```
ls -d /sys/fs/cgroup/*.slice
```
带有 .slice 后缀的文件夹通常在 systemd 中用于表示系统资源的一个切片。这些是由 systemd 管理的标准 cgroups，用于组织和管理系统进程。

创建一个自定义的 `cgroup`¶

在 /sys/fs/cgroup 文件系统下创建一个名为 "exercise_group" 的目录。这个新文件夹将容纳本练习剩余部分所需的控制组结构。通过输入以下命令使用 mkdir 命令：
```
sudo mkdir -p /sys/fs/cgroup/exercise_group
```
列出 /sys/fs/cgroup/exercise_group 结构下的文件和目录。输入以下命令：
```
sudo ls /sys/fs/cgroup/exercise_group/
```
输出显示了由 cgroup 子系统自动创建的文件和目录，用于管理和监控 cgroup 的资源。

设置新的内存资源限制¶

让我们设置一个内存资源限制，将内存使用量限制为 4096 字节（4kB）。要将 cgroup 中的进程限制为最多使用 4kB 的内存，请输入以下命令：
```
echo 4096 | sudo tee /sys/fs/cgroup/exercise_group/memory.max
```
确认内存限制已设置。输入以下命令：
```
cat /sys/fs/cgroup/exercise_group/memory.max
```

创建 memory_stress 测试脚本¶

使用dd命令创建一个简单的可执行脚本，用于测试内存资源限制。输入以下内容：
bash cat > ~/memory_stress.sh << EOF #!/bin/bash dd if=/dev/zero of=/tmp/stress_test bs=10M count=2000 EOF chmod +x ~/memory_stress.sh

运行并将进程/脚本添加到内存`cgroup`¶

启动memory_stress.sh，捕获其PID并将其添加到cgroup.procs。输入以下内容：
```
~/memory_stress.sh &
echo $! | sudo tee /sys/fs/cgroup/exercise_group/cgroup.procs
```
/sys/fs/cgroup/exercise_group/cgroup.procs文件可用于添加或查看特定cgroup中进程的PID（进程ID）。将PID写入此文件会将~/memory_stress.sh脚本进程分配到exercise_group cgroup。
由于该进程已超过了cgroup的内存限制，因此前面的命令将很快结束，无法完成。您可以在另一个终端中运行以下journalctl命令，以查看错误发生时的信息。输入以下内容：
```
journalctl -xe -f  | grep -i memory
```
提示
如果您知道进程的PID，可以通过运行以下ps命令快速查看进程的大致内存使用情况：
```
pidof <PROCESS_NAME> | xargs ps -o pid,comm,rss
```
此输出将显示以KB为单位的常驻集大小（RSS），表示进程在特定时间点使用的内存。当进程的RSS值超过cgroup的memory.max值指定的内存限制时，内核或cgroup本身可能会对该进程执行内存管理策略。根据系统配置，系统可能会采取以下措施：限制进程的内存使用，终止进程，或触发内存不足（OOM）事件。

设置新的CPU资源限制¶

限制脚本仅使用一个CPU核心10%的资源。输入以下内容：
```
echo 10000 | sudo tee /sys/fs/cgroup/exercise_group/cpu.max
```
10000代表CPU带宽限制。它设置为单个CPU核心的总容量的10%。
确认CPU限制已设置。输入以下内容：
```
cat /sys/fs/cgroup/exercise_group/cpu.max
```

创建CPU压力测试脚本¶

创建脚本并设置可执行权限，以生成高CPU使用率。输入以下内容：
```
cat > ~/cpu_stress.sh << EOF
#!/bin/bash
exec yes > /dev/null
EOF
chmod +x ~/cpu_stress.sh
```
注意
yes > /dev/null是一个简单的命令，它会产生高CPU负载。

运行并将进程/脚本添加到CPU `cgroup`¶

运行脚本并立即将其PID添加到cgroup，输入以下内容：

~/cpu_stress.sh &
echo $! | sudo tee /sys/fs/cgroup/exercise_group/cgroup.procs

确认进程CPU使用情况资源控制¶

检查进程的CPU使用率。
```
pidof yes | xargs top -b -n 1 -p
```
输出将显示yes进程的实时CPU使用率。yes的%CPU应根据cgroup配置限制（例如，如果限制设置为10000，则约为10%）。
为exercise_group cgroup设置并尝试其他cpu.max值，然后观察每次在控制组中重新运行~/cpu_stress.sh脚本的效果。

识别和选择主存储设备¶

主存储设备可以是设置I/O资源限制的目标。Linux系统上的存储设备具有主设备号和次设备号，可用于唯一识别它们。

首先，让我们创建一组辅助变量，用于检测和存储服务器上主存储设备的设备号。输入以下内容：

primary_device=$(lsblk | grep disk | awk '{print $1}' | head -n 1)
primary_device_num=$(ls -l /dev/$primary_device | awk '{print $5, $6}' | sed 's/,/:/')

显示$primary_device_num变量的值。输入以下内容：

echo "Primary Storage Device Number: $primary_device_num"

主设备号和次设备号应与您在此ls输出中看到的一致
```
  ls -l /dev/$primary_device
```

设置新的I/O资源限制¶

将exercise_group cgroup下读写进程的I/O操作设置为1 MB/s。输入以下内容：

echo "$primary_device_num rbps=1048576 wbps=1048576" | \
sudo tee /sys/fs/cgroup/exercise_group/io.max

确认I/O限制已设置。输入以下内容：
```
cat /sys/fs/cgroup/exercise_group/io.max
```

创建I/O压力测试进程¶

启动dd进程以创建一个名为/tmp/io_stress的大文件。此外，捕获并将dd进程的PID存储到名为MYPID的变量中。输入以下内容：
```
dd if=/dev/zero of=/tmp/io_stress bs=10M count=500 oflag=dsync \
& export MYPID=$!
```

将进程/脚本添加到I/O `cgroup`¶

将上一个dd进程的PID添加到exercise_group控制cgroup。输入以下内容：
```
echo $MYPID | sudo tee /sys/fs/cgroup/exercise_group/cgroup.procs
```

确认进程I/O使用情况资源控制¶

通过执行以下命令检查进程的I/O使用率：
```
iotop -p $MYPID
```

输出将显示io_stress.sh进程的I/O读写速度，根据限制，该速度不应超过1 MB/s。

删除`cgroups`¶

输入以下命令以结束任何后台进程，删除不再需要的cgroup并删除/tmp/io_stress文件。
```
kill %1
sudo rmdir /sys/fs/cgroup/exercise_group/
sudo rm -rf /tmp/io_stress
```

练习 8¶

`taskset`¶

CPU亲和性将特定进程或线程绑定到多核系统中的特定CPU核心。本练习演示了在Linux中使用taskset设置或检索进程的CPU亲和性的方法。

使用`taskset`探索CPU亲和性¶

使用lscpu列出系统上的可用CPU。输入以下内容：
```
lscpu | grep "On-line"
```
让我们使用dd工具创建一个示例进程，并将它的PID存储在MYPID变量中。输入以下内容：
```
dd if=/dev/zero of=/dev/null & export MYPID="$!"
echo $MYPID
```
检索dd进程的当前亲和性。输入以下内容：
```
taskset -p $MYPID
```
输出
```
pid 1211483's current affinity mask: f
```
输出显示了PID为1211483（$MYPID）的进程的CPU亲和性掩码，以十六进制格式表示。在我们的示例系统上，显示的亲和性掩码是“f”，这通常意味着进程可以在任何CPU核心上运行。
注意
CPU亲和性掩码“f”表示所有CPU核心都启用的配置。在十六进制表示法中，“f”对应于二进制值“1111”。二进制表示中的每个位都对应于一个CPU核心，其中“1”表示核心已启用且可供进程运行。
因此，在四核CPU上，使用掩码“f”
核心 0：已启用核心 1：已启用核心 2：已启用核心 3：已启用

设置/更改CPU亲和性¶

将dd进程的CPU亲和性设置为单个CPU（CPU 0）。输入以下内容：

taskset -p 0x1 $MYPID

输出

pid 1211483's current affinity mask: f
pid 1211483's new affinity mask: 1

通过运行以下命令验证更改
```
taskset -p $MYPID
```
输出显示了PID为$MYPID的进程的CPU亲和性掩码。亲和性掩码以十进制表示为“1”，转换为二进制为“1”。这意味着进程当前绑定到CPU核心0。
现在，将dd进程的CPU亲和性设置为多个CPU（CPU 0和1）。输入以下内容：
```
taskset -p 0x3 $MYPID
```
发出正确的tasksel命令以验证最新的更改。
```
taskset -p $MYPID
```
在我们的演示4核CPU服务器上，输出显示进程的CPU亲和性掩码为“3”（以十进制表示）。这转换为二进制的“11”。
提示
十进制“3”在二进制中为“11”（或0011）。每个二进制数字对应于一个CPU核心：核心 0、核心 1、核心 2、核心 3（从右到左）。第四位和第三位（从右数）的数字“1”表示进程可以在核心 0 和 1 上运行。因此，“3”表示进程绑定到CPU核心 0 和 1。
在另一个终端中启动top或htop实用程序，并在您对进程尝试不同的taskset配置时观察是否有任何有趣的东西。
全部完成。使用它的PID（$MYPID）杀死dd进程。

练习 9¶

`systemd-run`¶

systemd-run命令创建并启动用于运行命令或进程的临时服务单元。它也可以在临时范围单元、路径、套接字或计时器触发服务单元中运行程序。

本练习演示了如何在systemd中使用systemd-run创建临时服务单元。

将命令作为临时服务运行¶

使用systemd-run将简单的sleep 300命令作为临时systemd服务运行。输入以下内容：
```
systemd-run --unit=mytransient.service --description="Example Service" sleep 300
```
使用systemctl status检查临时服务的运行状态。输入以下内容：
```
systemctl status mytransient.service
```

为临时服务设置内存资源限制¶

使用systemd-run的--property参数将临时进程的最大内存使用量限制为200M。输入以下内容：
```
systemd-run --unit=mylimited.service --property=MemoryMax=200M sleep 300
```
查看相应cgroup文件系统下的进程，以验证设置。输入以下内容：
```
sudo cat /sys/fs/cgroup/system.slice/mytransient.service/memory.max
```
提示
systemd.resource-control是systemd框架中的一个配置或管理实体（概念），旨在控制和分配系统资源给进程和服务。systemd.exec是systemd中的一个组件，负责定义执行命令的执行环境。要查看使用systemd-run时可以调整的各种设置（属性），请查看systemd.resource-control和systemd.exec手册页。您将在其中找到有关MemoryMax、CPUAccounting、IOWeight等属性的文档。

为临时服务设置CPU资源限制¶

让我们创建一个名为“myrealtime.service”的临时systemd单元。使用特定的循环轮询（rr）调度策略和优先级运行myrealtime.service。输入以下内容：
```
systemd-run --unit=myrealtime.service \
--property=CPUSchedulingPolicy=rr --property=CPUSchedulingPriority=50 sleep 300
```
查看myrealtime.service的状态。此外，将主[sleep] PID捕获/存储到MYPID变量中。输入以下内容：
```
MYPID=$(systemctl status myrealtime.service   |  awk '/Main PID/ {print $3}')
```

在服务仍在运行时验证其CPU调度策略。输入以下内容：

chrt  -p $MYPID
pid 2553792's current scheduling policy: SCHED_RR
pid 2553792's current scheduling priority: 50

创建临时计时器单元¶

创建一个简单的计时器单元，它运行一个简单的echo命令。--on-active=2m选项将计时器设置为在计时器单元变为活动后2分钟触发。输入以下内容：
```
systemd-run --on-active=2m --unit=mytimer.timer \
--description="Example Timer" echo "Timer triggered"
```
计时器将从单元激活的时间开始倒计时，并在2分钟后触发指定的操作。
查看刚刚创建的计时器单元的详细信息/状态。输入以下内容：
```
systemctl status mytimer.timer
```

停止并清理临时 `systemd` 单位¶

输入以下命令以确保为本练习启动的各种临时服务/进程已正确停止并从您的系统中删除。输入

systemctl stop mytransient.service
systemctl stop mylimited.service
systemctl stop myrealtime.service
systemctl stop mytimer.timer

练习 10¶

`schedtool`¶

本练习演示了如何使用 schedtool 来理解和操作 Rocky Linux 中的进程调度。我们还将创建一个脚本，用于为此目的模拟进程。

安装 `schedtool`¶

如果您的服务器上尚未安装 schedtool 应用程序，请安装它。输入
```
sudo dnf -y install schedtool
```

创建模拟进程脚本¶

创建一个脚本，用于生成 CPU 负载以进行测试。输入

cat > ~/cpu_load_generator.sh << EOF
#!/bin/bash
while true; do
     openssl speed > /dev/null 2>&1
     openssl speed > /dev/null 2>&1

done
EOF
chmod +x ~/cpu_load_generator.sh

在后台启动脚本。输入
```
~/cpu_load_generator.sh & echo $!
```
捕获 cpu_load_generator.sh 脚本中启动的主要 openssl 进程的 PID。将 PID 存储在名为 MYPID 的变量中。输入
```
export  MYPID=$(pidof openssl) ; echo $MYPID
```

使用 `schedtool` 检查当前调度策略¶

使用 schedtool 命令显示 PID 为 $MYPID 的进程的调度信息。输入

schedtool $MYPID

输出

PID 2565081: PRIO   0, POLICY N: SCHED_NORMAL  , NICE   0, AFFINITY 0xf

使用 `schedtool` 修改调度策略¶

将进程的调度策略和优先级分别更改为 FIFO 和 10。输入
```
sudo schedtool -F -p 10 $!
```
查看更改的效果。输入
```
schedtool $MYPID
```
将进程的调度策略和优先级分别更改为轮询或 SCHED_RR (RR) 和 50。输入
```
  sudo schedtool -R -p 50 $MYPID
```
查看更改的效果。输入
```
schedtool $MYPID
```
将进程的调度策略更改为空闲或 SCHED_IDLEPRIO (D)。输入
```
sudo schedtool -D $MYPID
```
查看更改的效果。
最后，将进程的调度策略重置回原始默认值 SCHED_NORMAL (N 或其他)。输入
```
sudo schedtool -N $MYPID
```

终止并清理 `cpu_load_generator.sh` 进程¶

全部完成。终止脚本并删除 cpu_load_generator.sh 脚本。
```
kill $MYPID
rm ~/cpu_load_generator.sh
```

作者：Wale Soyinka

贡献者：Steven Spencer、Ganna Zhrynova

实验室 4: 高级系统和进程监控¶

目标¶

简介¶

练习 1¶

fuser¶

创建模拟文件使用的脚本¶

识别访问文件的进程¶

识别访问 TCP/UDP 端口的进程¶

练习 2¶

perf¶

安装 perf¶

创建用于生成 CPU 负载的脚本¶

模拟额外的 CPU 负载¶

分析性能数据并监控实时事件¶

记录系统的全面性能¶

练习 3¶

strace¶

创建一个用于探索 strace 的脚本¶

在正在运行的进程上使用 strace¶

分析系统调用的频率¶

练习 4¶

atop¶

启动和探索 atop¶

练习 5¶

numactl¶

安装 numactl¶