So begrenzen Sie die CPU-Nutzung mit CPULimit unter Ubuntu Linux

Der cpulimit-Befehl ist dafür konzipiert, die CPU-Nutzung eines bestimmten Prozesses unter Linux zu beschränken, um sicherzustellen, dass sie einen definierten Schwellenwert nicht überschreitet. Dies kann besonders nützlich sein, um Systemressourcen zu verwalten und zu verhindern, dass ein einzelner Prozess die CPU-Zeit monopolisiert, was die Gesamtleistung des Systems beeinträchtigen könnte. Durch die Angabe des gewünschten CPU-Nutzungsgrenzwerts als Prozentsatz können Benutzer Einschränkungen für laufende Prozesse anwenden oder neue unter kontrolliertem CPU-Verbrauch starten. Das Tool sendet SIGSTOP- und SIGCONT-Signale an den Zielprozess, pausiert und setzt ihn fort, um das festgelegte Nutzungslimit aufrechtzuerhalten.

1 Vorbemerkung

Dieses Tutorial wurde unter Ubuntu 24.04 getestet, funktioniert jedoch auch auf älteren Ubuntu-Versionen.

2 CPULimit-Installation

Zunächst müssen wir cpulimit wie folgt installieren:

sudo apt update sudo apt install cpulimit

3 Begrenzung der CPU-Nutzung

Jetzt werden wir das Dienstprogramm zur Begrenzung der CPU-Nutzung überprüfen. Dazu werden wir zunächst die CPU-Nutzung ohne CPUlimit überprüfen und dann CPUlimit implementieren, um es zu bewerten. Lassen Sie es uns anhand eines Beispiels verdeutlichen.

1. Hier ist ein Beispiel, wie Sie Ihre CPU mit einer Anwendung auf einer Single-Core-CPU nutzen:

dd if=/dev/zero of=/dev/null &

Dann werden wir die CPU-Nutzung mit dem Befehl überprüfen:

top

top - 11:24:18 up 49 min, 1 user, load average: 0.94, 1.02, 1.79 Tasks: 249 total, 2 running, 247 sleeping, 0 stopped, 0 zombie %Cpu(s): 13.4 us, 11.6 sy, 0.0 ni, 74.9 id, 0.0 wa, 0.1 hi, 0.0 si, 0.0 st KiB Mem: 1010540 total, 271652 used, 738888 free, 21760 buffers KiB Swap: 1048572 total, 0 used, 1048572 free. 158204 cached Mem PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 1850 root 20 0 7224 616 520 R 100.0 0.1 1:20.33 dd 1851 root 20 0 24952 1756 1180 R 0.3 0.2 0:00.03 top 1 root 20 0 33480 2776 1456 S 0.0 0.3 0:05.31 init 2 root 20 0 0 0 0 S 0.0 0.0 0:00.01 kthreadd

Wie wir sehen können, ist die CPU-Nutzung auf 100% gestiegen. Jetzt werden wir cpulimit verwenden, um die CPU-Nutzung zu begrenzen. Wir können diesen Prozess mit dem Befehl fg in den Vordergrund bringen und mit CTRL+C abbrechen.

fg

Jetzt können wir cpulimit testen, um zu sehen, ob es das tut, was es soll. Lassen Sie es uns wie folgt testen:

cpulimit -l 30 dd if=/dev/zero of=/dev/null &

root@server1:~# cpulimit -l 30 dd if=/dev/zero of=/dev/null &

[1] 1852

root@server1:~# Prozess 1853 erkannt

[1]+ Done cpulimit -l 30 dd if=/dev/zero of=/dev/null

root@server1:~#

Jetzt werden wir die CPU-Nutzung mit dem Befehl top überprüfen:

top

top - 11:30:54 up 55 min, 1 user, load average: 0.20, 0.58, 1.34

Tasks: 250 total, 2 running, 247 sleeping, 1 stopped, 0 zombie

%Cpu(s): 4.5 us, 4.1 sy, 0.0 ni, 91.4 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st

KiB Mem: 1010540 total, 271944 used, 738596 free, 21816 buffers

KiB Swap: 1048572 total, 0 used, 1048572 free. 158212 cached Mem

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND

1853 root 20 0 7224 612 520 T 33.8 0.1 0:35.53 dd

1 root 20 0 33480 2776 1456 S 0.0 0.3 0:05.37 init

2 root 20 0 0 0 0 S 0.0 0.0 0:00.01 kthreadd

3 root 20 0 0 0 0 S 0.0 0.0 0:00.02 ksoftirqd/0

4 root 20 0 0 0 0 S 0.0 0.0 0:00.00 kworker/0:0 Jetzt können Sie sehen, dass die CPU-Nutzung von 100% auf 33.8% gesenkt wurde, fast 30%. Wir haben also erfolgreich das Dienstprogramm cpulimit überprüft, das die CPU-Nutzung in einer Single-Core-Ubuntu-Distribution begrenzen kann.

1. Hier ist ein Beispiel, wie Sie Ihre CPU mit einer Anwendung auf einer Multi-Core-CPU nutzen:

Um Ihre CPU-Kerne zu überprüfen, verwenden Sie den Befehl:

nproc In meinem Fall war die Anzahl der CPU-Kerne 4.
Jetzt werden wir die CPU-Nutzung ohne cpulimit in allen 4 Kernen für die Anwendung wie folgt überprüfen:

for j in `seq 1 4`; do dd if=/dev/zero of=/dev/null & done Es wird der Befehl ausgeführt, der alle Kerne nutzt und die Ausgabe wie folgt ergibt:

root@server1:~# for j in seq 1 4; do dd if=/dev/zero of=/dev/null & done

[1] 1263

[2] 1264

[3] 1265

[4] 1266

root@server1:~#

Jetzt überprüfen Sie die CPU-Nutzung mit dem Befehl top:

top

top - 11:47:45 up 4 min, 1 user, load average: 3.63, 1.53, 0.57

Tasks: 290 total, 5 running, 285 sleeping, 0 stopped, 0 zombie

%Cpu0 : 48.3 us, 51.3 sy, 0.0 ni, 0.0 id, 0.0 wa, 0.3 hi, 0.0 si, 0.0 st

%Cpu1 : 47.8 us, 52.2 sy, 0.0 ni, 0.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st

%Cpu2 : 53.3 us, 46.4 sy, 0.0 ni, 0.0 id, 0.0 wa, 0.3 hi, 0.0 si, 0.0 st

%Cpu3 : 52.0 us, 48.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st

KiB Mem: 1010540 total, 209712 used, 800828 free, 20276 buffers

KiB Swap: 1048572 total, 0 used, 1048572 free. 93632 cached Mem

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND

1263 root 20 0 7224 612 520 R 100.0 0.1 2:21.40 dd

1264 root 20 0 7224 616 520 R 100.0 0.1 2:21.41 dd

1265 root 20 0 7224 612 520 R 99.0 0.1 2:21.03 dd

1266 root 20 0 7224 616 520 R 98.0 0.1 2:20.82 dd

1281 root 20 0 104416 3992 2920 S 1.0 0.4 0:00.03 sshd

1283 root 20 0 104416 3988 2920 S 1.0 0.4 0:00.03 sshd

1279 root 20 0 104556 4008 2924 S 0.7 0.4 0:00.08 sshd Der dd-Befehl verbraucht fast 100% CPU aller Kerne. Als nächstes werden wir den Befehl mit dem cpulimit-Dienstprogramm überprüfen. Dazu beenden Sie die vorherigen Spuren des dd-Befehls wie folgt:

killall dd root@server1:~# killall dd

[1] Terminated dd if=/dev/zero of=/dev/null

[3]- Terminated dd if=/dev/zero of=/dev/null

[2]- Terminated dd if=/dev/zero of=/dev/null

[4]+ Terminated dd if=/dev/zero of=/dev/null

root@server1:~#

Jetzt verwenden Sie cpulimit mit demselben Befehl wie folgt:

for j in `seq 1 4`; do cpulimit -l 20 dd if=/dev/zero of=/dev/null & done root@server1:~# for j in seq 1 4; do cpulimit -l 20 dd if=/dev/zero of=/dev/null & done

[1] 1429

[2] 1430

[3] 1431

[4] 1432

root@server1:~# Prozess 1434 erkannt

Prozess 1433 erkannt

Prozess 1437 erkannt

Prozess 1439 erkannt

[1] Done cpulimit -l 20 dd if=/dev/zero of=/dev/null

[2] Done cpulimit -l 20 dd if=/dev/zero of=/dev/null

[3]- Done cpulimit -l 20 dd if=/dev/zero of=/dev/null

[4]+ Done cpulimit -l 20 dd if=/dev/zero of=/dev/null

root@server1:~#

Jetzt überprüfen Sie die CPU-Nutzung mit dem cpulimit-Dienstprogramm.

top

top - 11:59:10 up 16 min, 2 users, load average: 0.47, 0.71, 0.81

Tasks: 256 total, 2 running, 251 sleeping, 3 stopped, 0 zombie

%Cpu0 : 2.0 us, 2.0 sy, 0.0 ni, 96.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st

%Cpu1 : 26.2 us, 22.8 sy, 0.0 ni, 50.7 id, 0.0 wa, 0.3 hi, 0.0 si, 0.0 st

%Cpu2 : 14.0 us, 12.3 sy, 0.0 ni, 73.8 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st

%Cpu3 : 13.3 us, 11.6 sy, 0.0 ni, 75.1 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st

KiB Mem: 1010540 total, 204064 used, 806476 free, 20408 buffers

KiB Swap: 1048572 total, 0 used, 1048572 free. 98340 cached Mem

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND

1433 root 20 0 7224 612 520 T 28.2 0.1 0:12.00 dd

1439 root 20 0 7224 616 520 R 26.6 0.1 0:12.13 dd

1434 root 20 0 7224 612 520 T 25.3 0.1 0:11.97 dd

1437 root 20 0 7224 612 516 T 22.9 0.1 0:11.93 dd

7 root 20 0 0 0 0 S 0.3 0.0 0:00.22 rcu_sched

8 root 20 0 0 0 0 S 0.3 0.0 0:00.21 rcuos/0

Wie Sie oben sehen können, wird die CPU-Nutzung von 100% auf fast 20% für Multi-Core-CPUs begrenzt.

Herzlichen Glückwunsch! Wir haben cpulimit erfolgreich getestet, um die CPU-Nutzung in Ubuntu zu begrenzen.

4 Links

• Ubuntu : http://www.ubuntu.com/
• cpulimit : https://github.com/opsengine/cpulimit