Hinweis:

Dieses Tutorial steht in einer von Oracle bereitgestellten kostenlosen Übungsumgebung zur Verfügung.
Er verwendet Beispielwerte für Oracle Cloud Infrastructure-Zugangsdaten, Mandanten und Compartments. Ersetzen Sie diese Werte beim Durchführen Ihrer Übung durch spezifische Werte für Ihre Cloud-Umgebung.

Kontrollgruppenversion 2 auf Oracle Linux ausführen

Einführung

Kontrollgruppen (cgroups) sind eine Linux-Kernelfunktion zum Begrenzen, Priorisieren und Zuweisen von Ressourcen wie CPU-Zeit, Arbeitsspeicher und Netzwerkbandbreite für laufende Prozesse.

Dieses Tutorial führt Sie durch die Begrenzung der CPU-Zeit für Benutzerprozesse mit cgroups v2.

Ziele

In dieser Übung lernen Sie Folgendes:

cgroups aktivieren v2
Soft CPU-Grenzwert für einen Benutzerprozess festlegen
Festlegen eines festen CPU-Limits für einen Benutzerprozess

Voraussetzungen

Ein System mit Oracle Linux 8 ist mit der folgenden Konfiguration installiert:
- Nicht-Root-Benutzer mit sudo-Berechtigungen

Übungsumgebung einrichten

Hinweis: Bei der Verwendung der kostenlosen Übungsumgebung finden Sie unter Oracle Linux Lab Basics für Verbindungen und weitere Verwendungsanweisungen.

Bevor wir mit der Übung beginnen, müssen wir einige Housekeeping-Artikel ausfüllen. Die erstellten Elemente dienen dazu, die Begrenzungsmöglichkeiten von cgroups zu demonstrieren.

Load-Generierungsskript erstellen

Falls noch keine Verbindung besteht, öffnen Sie ein Terminal, und stellen Sie über ssh eine Verbindung zum ol8-server-System her.
```
ssh oracle@<ip_address_of_ol8-server>
```

Erstellen Sie das Skript foo.exe.

echo '#!/bin/bash

/usr/bin/sha1sum /dev/zero' > foo.exe

Kopieren Sie das Skript foo.exe in einen Speicherort in $PATH, und legen Sie die entsprechenden Berechtigungen fest.
```
sudo mv foo.exe /usr/local/bin/foo.exe
sudo chown root:root /usr/local/bin/foo.exe
sudo chmod 755 /usr/local/bin/foo.exe
```
Hinweis: (Optional) Wenn Sie mit SELinux enforcing ausführen:
```
sudo sestatus
```
Korrigieren Sie die SELinux-Labels, nachdem Sie die Berechtigungen kopiert und geändert haben, indem Sie den folgenden Befehl ausführen:
```
sudo /sbin/restorecon -v /usr/local/bin/foo.exe
```

Load-Generating-Service erstellen

Erstellen Sie die Datei foo.service.

echo '[Unit]
Description=the foo service
After=network.target

[Service]
ExecStart=/usr/local/bin/foo.exe

[Install]
WantedBy=multi-user.target' > foo.service

Kopieren Sie das Skript foo.service in den Speicherort der systemd-Skripte, und legen Sie die entsprechenden Berechtigungen fest.
```
sudo mv foo.service /etc/systemd/system/foo.service
sudo chown root:root /etc/systemd/system/foo.service
sudo chmod 644 /etc/systemd/system/foo.service
```
Hinweis: (Optional) Wenn Sie mit SELinux enforcing ausführen, korrigieren Sie die SELinux-Labels, nachdem Sie Berechtigungen kopiert und geändert haben, indem Sie den folgenden Befehl ausführen:
```
sudo /sbin/restorecon -v /etc/systemd/system/foo.service
```
Laden Sie den Daemon neu, sodass vom System der neue Service erkannt wird.
```
sudo systemctl daemon-reload
```

Starten Sie foo.service, und prüfen Sie den Status.

sudo systemctl start foo.service
sudo systemctl status foo.service

Benutzer erstellen

Zusätzliche Benutzer können das Load-Generating-Skript unter diesen verschiedenen Konten und anderen CPU-Gewichten ausführen.

Benutzer erstellen und Passwörter festlegen

sudo useradd -u 8000 ralph
sudo useradd -u 8001 alice
echo "ralph:oracle" | sudo chpasswd
echo "alice:oracle" | sudo chpasswd

SSH-Verbindungen zulassen.

Kopieren Sie den SSH-Schlüssel aus dem Benutzeraccount oracle.

sudo mkdir /home/ralph/.ssh
sudo cp /home/oracle/.ssh/authorized_keys /home/ralph/.ssh/authorized_keys
sudo chown -R ralph:ralph /home/ralph/.ssh
sudo chmod 700 /home/ralph/.ssh
sudo chmod 600 /home/ralph/.ssh/authorized_keys

Wiederholen Sie den Vorgang für den alice-Benutzer.

sudo mkdir /home/alice/.ssh
sudo cp /home/oracle/.ssh/authorized_keys /home/alice/.ssh/authorized_keys
sudo chown -R alice:alice /home/alice/.ssh
sudo chmod 700 /home/alice/.ssh
sudo chmod 600 /home/alice/.ssh/authorized_keys

Öffnen Sie ein neues Terminal, und prüfen Sie, ob beide SSH-Verbindungen funktionieren.
```
ssh ralph@<ip_address_of_ol8-server>
```
Danach exit Sie die Session, und wiederholen Sie den Vorgang für den folgenden Benutzer.
```
ssh alice@<ip_address_of_ol8-server>
```
Beenden Sie die Session, und schließen Sie das Terminalfenster.

cgroups mounten v2

Oracle Linux hängt cgroups v1 standardmäßig beim Booten ein. Um cgroups v2 zu verwenden, müssen Sie die Boot-Kernel-Parameter manuell konfigurieren.

Kehren Sie zum Terminal zurück, in dem Sie als oracle angemeldet sind.
Fügen Sie den systemd-Kernel-Parameter v2 der cgroups hinzu.
```
sudo grubby --update-kernel=ALL --args="systemd.unified_cgroup_hierarchy=1"
```
Sie können stattdessen nur Ihren aktuellen Boot-Eintrag angeben, indem Sie sudo grubby --update-kernel=/boot/vmlinuz-$(uname -r) --args="systemd.unified_cgroup_hierarchy=1" ausführen.
Neustart.
```
sudo reboot
```
Das Booten dauert einige Minuten.

Hinweis: Sie können erst dann einen SSH-Vorgang in das System durchführen, wenn der Neustart abgeschlossen ist und der SSHd-Daemon ausgeführt wird.
Stellen Sie über ssh erneut eine Verbindung zum ol8-server-System her.
```
ssh oracle@<ip_address_of_ol8-server>
```

Prüfen Sie, ob die cgroups v2 gemountet wurden.

sudo mount -l | grep cgroup

Beispielausgabe:

cgroup2 on /sys/fs/cgroup type cgroup2 (rw,nosuid,nodev,noexec,relatime,seclabel,nsdelegate)

Prüfen Sie den Inhalt des gemounteten Cgroups-Verzeichnisses.

ll /sys/fs/cgroup

Beispielausgabe:

total 0
-r--r--r--.  1 root root 0 Mar 13 21:20 cgroup.controllers
-rw-r--r--.  1 root root 0 Mar 13 21:20 cgroup.max.depth
-rw-r--r--.  1 root root 0 Mar 13 21:20 cgroup.max.descendants
-rw-r--r--.  1 root root 0 Mar 13 21:20 cgroup.procs
-r--r--r--.  1 root root 0 Mar 13 21:20 cgroup.stat
-rw-r--r--.  1 root root 0 Mar 13 21:20 cgroup.subtree_control
-rw-r--r--.  1 root root 0 Mar 13 21:20 cgroup.threads
-rw-r--r--.  1 root root 0 Mar 13 21:20 cpu.pressure
-r--r--r--.  1 root root 0 Mar 13 21:20 cpuset.cpus.effective
-r--r--r--.  1 root root 0 Mar 13 21:20 cpuset.mems.effective
drwxr-xr-x.  2 root root 0 Mar 13 21:20 init.scope
-rw-r--r--.  1 root root 0 Mar 13 21:20 io.pressure
-rw-r--r--.  1 root root 0 Mar 13 21:20 memory.pressure
drwxr-xr-x. 87 root root 0 Mar 13 21:20 system.slice
drwxr-xr-x.  4 root root 0 Mar 13 21:24 user.slice

Die Ausgabe zeigt die root-Kontrollgruppe an ihrem Standardspeicherort. Das Verzeichnis enthält Schnittstellendateien mit allen Präfixen cgroup und Verzeichnisse im Zusammenhang mit systemd, die in .scope und .slice enden.

Mit dem virtuellen Dateisystem arbeiten

Bevor wir beginnen, müssen wir uns ein wenig über das virtuelle Cgroups-Dateisystem informieren, das unter /sys/fs/cgroup gemountet ist.

Zeigen Sie an, welche CPUs an den CPUs für alle teilnehmen.
```
cat /sys/fs/cgroup/cpuset.cpus.effective
```
Beispielausgabe:
```
[oracle@ol8-server ~]$ cat /sys/fs/cgroup/cpuset.cpus.effective
0-1
```
Unser Testfeld war eine Oracle Linux 8-Instanz, die auf einer VM.Standard2.1-Ausprägung bereitgestellt ist und ein Dual-Core-System ist.
Zeigen Sie an, welche Controller aktiv sind.
```
cat /sys/fs/cgroup/cgroup.controllers
```
Beispielausgabe:
```
[oracle@ol8-server ~]$ cat /sys/fs/cgroup/cgroup.controllers
cpuset cpu io memory pids rdma
```
Es ist gut, den cpuset Controller als vorhanden zu sehen, da wir ihn später in dieser Übung verwenden werden.

Von oracle gestartete Prozesse anzeigen.

Zuerst muss die Benutzer-ID (UID) von oracle bestimmt werden.

who
id

Beispielausgabe:

[oracle@ol8-server ~]$ who
oracle   pts/0        2022-03-13 21:23 (10.39.209.157)
[oracle@ol8-server ~]$ id
uid=1001(oracle) gid=1001(oracle) groups=1001(oracle),10(wheel) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023

Mit der UID finden Sie den oracle-Benutzerbereich.

cd /sys/fs/cgroup/user.slice
ls

Beispielausgabe:

[oracle@ol8-server ~]$ cd /sys/fs/cgroup/user.slice
[oracle@ol8-server user.slice]$ ls
cgroup.controllers      cgroup.subtree_control  memory.events        memory.pressure      pids.max
cgroup.events           cgroup.threads          memory.events.local  memory.stat          user-0.slice
cgroup.freeze           cgroup.type             memory.high          memory.swap.current  user-1001.slice
cgroup.max.depth        cpu.pressure            memory.low           memory.swap.events   user-989.slice
cgroup.max.descendants  cpu.stat                memory.max           memory.swap.max
cgroup.procs            io.pressure             memory.min           pids.current
cgroup.stat             memory.current          memory.oom.group     pids.events

Systemd weist jedem Benutzer einen Bereich mit dem Namen user-<UID>.slice zu. Was steht unter diesem Verzeichnis?

cd user-1001.slice
ls

Beispielausgabe:

[oracle@ol8-server user.slice]$ cd user-1001.slice/
[oracle@ol8-server user-1001.slice]$ ls
cgroup.controllers  cgroup.max.descendants  cgroup.threads  io.pressure        user-runtime-dir@1001.service
cgroup.events       cgroup.procs            cgroup.type     memory.pressure
cgroup.freeze       cgroup.stat             cpu.pressure    session-3.scope
cgroup.max.depth    cgroup.subtree_control  cpu.stat        user@1001.service

Dies sind die obersten Gruppen für den Benutzer oracle. Es sind jedoch keine Prozesse in cgroup.procs aufgeführt. Wo ist also die Liste der Benutzerprozesse?

cat cgroup.procs

Beispielausgabe:

[oracle@ol8-server user-1001.slice]$ cat cgroup.procs
[oracle@ol8-server user-1001.slice]$

Wenn oracle die SSH-Session zu Beginn dieser Übung geöffnet hat, hat die Benutzersession eine Geltungsbereichsuntereinheit erstellt. Unter diesem Geltungsbereich können Sie die cgroup.procs auf eine Liste der Prozesse prüfen, die unter dieser Session gestartet wurden.

Hinweis: Der Benutzer hat möglicherweise mehrere Sessions basierend auf der Anzahl der Verbindungen zum System. Daher ersetzen Sie 3 im Beispiel unten nach Bedarf.

cd session-3.scope
ls
cat cgroup.procs

Beispielausgabe:

[oracle@ol8-server user-1001.slice]$ cd session-3.scope/
[oracle@ol8-server session-3.scope]$ ls
cgroup.controllers  cgroup.max.depth        cgroup.stat             cgroup.type   io.pressure
cgroup.events       cgroup.max.descendants  cgroup.subtree_control  cpu.pressure  memory.pressure
cgroup.freeze       cgroup.procs            cgroup.threads          cpu.stat
[oracle@ol8-server session-3.scope]$ cat cgroup.procs
3189
3200
3201
54217

Da die Prozesse jetzt auf die harte Weise gefunden wurden, können Sie mit systemd-cgls dieselben Informationen in einer baumähnlichen Ansicht anzeigen.

Hinweis: Wenn die Ausführung im virtuellen Dateisystem erfolgt, begrenzt systemd-cgls die cgroup-Ausgabe auf das aktuelle Arbeitsverzeichnis.

cd /sys/fs/cgroup/user.slice/user-1001.slice
systemd-cgls

Beispielausgabe:

[oracle@ol8-server user-1001.slice]$ systemd-cgls
Working directory /sys/fs/cgroup/user.slice/user-1001.slice:
├─session-3.scope
│ ├─ 3189 sshd: oracle [priv]
│ ├─ 3200 sshd: oracle@pts/0
│ ├─ 3201 -bash
│ ├─55486 systemd-cgls
│ └─55487 less
└─user@1001.service
  └─init.scope
    ├─3193 /usr/lib/systemd/systemd --user
    └─3195 (sd-pam)

Belegte CPU-Cores begrenzen

Bei cgroups v2 hat systemd die vollständige Kontrolle über den CPUset-Controller. Mit dieser Steuerungsebene kann ein Administrator die Arbeit an einem bestimmten CPU-Core planen.

Prüfen Sie CPUs auf user.slice.

cd /sys/fs/cgroup/user.slice
ls
cat ../cpuset.cpus.effective

Beispielausgabe:

[oracle@ol8-server cgroup]$ cd /sys/fs/cgroup/user.slice/
[oracle@ol8-server user.slice]$ ls
cgroup.controllers      cgroup.subtree_control  memory.events        memory.pressure      pids.max
cgroup.events           cgroup.threads          memory.events.local  memory.stat          user-0.slice
cgroup.freeze           cgroup.type             memory.high          memory.swap.current  user-1001.slice
cgroup.max.depth        cpu.pressure            memory.low           memory.swap.events   user-989.slice
cgroup.max.descendants  cpu.stat                memory.max           memory.swap.max
cgroup.procs            io.pressure             memory.min           pids.current
cgroup.stat             memory.current          memory.oom.group     pids.events
[oracle@ol8-server user.slice]$ cat ../cpuset.cpus.effective
0-1

cpuset.cpus.effective zeigt die von user.slice tatsächlich verwendeten Cores. Wenn der Parameter nicht im spezifischen cgroup-Verzeichnis vorhanden ist oder nicht festgelegt wird, wird der Wert vom übergeordneten Verzeichnis übernommen. Dies ist in diesem Fall das oberste cgroup-Root-Verzeichnis.

Begrenzen Sie die Bereiche system und 0, 1001 und 989 auf den CPU-Core 0.

cat /sys/fs/cgroup/system.slice/cpuset.cpus.effective
sudo systemctl set-property system.slice AllowedCPUs=0
cat /sys/fs/cgroup/system.slice/cpuset.cpus.effective

Beispielausgabe:

[oracle@ol8-server user.slice]$ cat /sys/fs/cgroup/system.slice/cpuset.cpus.effective
cat: /sys/fs/cgroup/system.slice/cpuset.cpus.effective: No such file or directory
[oracle@ol8-server user.slice]$ sudo systemctl set-property system.slice AllowedCPUs=0
[oracle@ol8-server user.slice]$ cat /sys/fs/cgroup/system.slice/cpuset.cpus.effective
0

Hinweis: No such file or directory gibt an, dass der system-Bereich standardmäßig seinen cpuset.cpus.effective-Wert vom übergeordneten Element erbt.

sudo systemctl set-property user-0.slice AllowedCPUs=0
sudo systemctl set-property user-1001.slice AllowedCPUs=0
sudo systemctl set-property user-989.slice AllowedCPUs=0

Begrenzen Sie den ralph-Benutzer auf den CPU-Core 1.

sudo systemctl set-property user-8000.slice AllowedCPUs=1
cat /sys/fs/cgroup/user.slice/user-8000.slice/cpuset.cpus.effective

Beispielausgabe:

[oracle@ol8-server ~]$ sudo systemctl set-property user-8000.slice AllowedCPUs=1
[oracle@ol8-server ~]$ cat /sys/fs/cgroup/user.slice/user-8000.slice/cpuset.cpus.effective
1

Öffnen Sie ein neues Terminal, und stellen Sie eine Verbindung über ssh als ralph zum System ol8-server her.
```
ssh ralph@<ip_address_of_ol8-server>
```

Testen Sie den Vorgang mit dem Skript foo.exe.

foo.exe &

Prüfen Sie die Ergebnisse.

top

Wenn top ausgeführt wird, drücken Sie 1 key, um die CPUs einzeln anzuzeigen.

Beispielausgabe:

top - 18:23:55 up 21:03,  2 users,  load average: 1.03, 1.07, 1.02
Tasks: 155 total,   2 running, 153 sleeping,   0 stopped,   0 zombie
%Cpu0  :  6.6 us,  7.0 sy,  0.0 ni, 84.8 id,  0.0 wa,  0.3 hi,  0.3 si,  1.0 st
%Cpu1  : 93.0 us,  6.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.7 hi,  0.3 si,  0.0 st
MiB Mem :  14707.8 total,  13649.1 free,    412.1 used,    646.6 buff/cache
MiB Swap:   4096.0 total,   4096.0 free,      0.0 used.  13993.0 avail Mem

   PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
226888 ralph     20   0  228492   1808   1520 R  99.7   0.0 199:34.27 sha1sum
269233 root      20   0  223724   6388   1952 S   1.3   0.0   0:00.04 pidstat
   1407 root      20   0  439016  41116  39196 S   0.3   0.3   0:17.81 sssd_nss
   1935 root      20   0  236032   3656   3156 S   0.3   0.0   0:34.34 OSWatcher
   2544 root      20   0  401900  40292   9736 S   0.3   0.3   0:10.62 ruby
      1 root      20   0  388548  14716   9508 S   0.0   0.1   0:21.21 systemd
...

Geben Sie q ein, um den Anfang zu beenden.

Alternativ können Sie den Prozessor prüfen, der einen Prozess ausführt.

ps -eo pid,psr,user,cmd | grep ralph

Beispielausgabe:

[ralph@ol8-server ~]$ ps -eo pid,psr,user,cmd | grep ralph
 226715   1 root     sshd: ralph [priv]
 226719   1 ralph    /usr/lib/systemd/systemd --user
 226722   1 ralph    (sd-pam)
 226727   1 ralph    sshd: ralph@pts/2
 226728   1 ralph    -bash
 226887   1 ralph    /bin/bash /usr/local/bin/foo.exe
 226888   1 ralph    /usr/bin/sha1sum /dev/zero
 269732   1 ralph    ps -eo pid,psr,user,cmd
 269733   1 ralph    grep --color=auto ralph

Die Spalte psr ist die CPU-Nummer von cmd oder der tatsächliche Prozess.

Beenden und schließen Sie das Terminalfenster für die Anmeldung als ralph.
Beenden Sie den Job foo.exe.

Wechseln Sie zurück zum Terminal, in dem Sie als oracle angemeldet sind, und führen Sie den folgenden Befehl aus.
```
sudo pkill sha1sum
```

CPU-Gewichtung für Benutzer anpassen

Zeit für den alice-Join im Spaß. Sie hat einige kritische Arbeit zu erledigen, und deshalb geben wir ihr zweimal die normale Priorität auf der CPU.

Weisen Sie alice derselben CPU wie ralph zu.

sudo systemctl set-property user-8001.slice AllowedCPUs=1
cat /sys/fs/cgroup/user.slice/user-8001.slice/cpuset.cpus.effective

Legen Sie CPUWeight fest.

sudo systemctl set-property user-8001.slice CPUWeight=200
cat /sys/fs/cgroup/user.slice/user-8001.slice/cpu.weight

Die Standardgewichtung beträgt 100. 200 ist also doppelt so hoch wie die Zahl.

Öffnen Sie ein neues Terminal, und stellen Sie eine Verbindung über ssh als ralph zum System ol8-server her.
```
ssh ralph@<ip_address_of_ol8-server>
```
Führen Sie foo.exe als ralph aus.
```
foo.exe &
```
Öffnen Sie ein weiteres neues Terminal, und stellen Sie eine Verbindung über ssh als alice zum System ol8-server her.
```
ssh alice@<ip_address_of_ol8-server>
```
Führen Sie foo.exe als alice aus.
```
foo.exe &
```

Prüfen Sie über top, ob alice die höhere Priorität erhält.

top

Wenn der Top ausgeführt wird, drücken Sie 1 key, um die CPUs einzeln anzuzeigen.

Beispielausgabe:

top - 20:10:55 up 25 min,  3 users,  load average: 1.29, 0.46, 0.20
Tasks: 164 total,   3 running, 161 sleeping,   0 stopped,   0 zombie
%Cpu0  :  0.0 us,  0.0 sy,  0.0 ni, 96.5 id,  0.0 wa,  0.0 hi,  3.2 si,  0.3 st
%Cpu1  : 92.4 us,  7.6 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :  15715.8 total,  14744.6 free,    438.5 used,    532.7 buff/cache
MiB Swap:   4096.0 total,   4096.0 free,      0.0 used.  15001.1 avail Mem 

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND  
   7934 alice     20   0   15800   1768   1476 R  67.0   0.0   0:36.15 sha1sum  
   7814 ralph     20   0   15800   1880   1592 R  33.3   0.0   0:34.60 sha1sum  
      1 root      20   0  388476  14440   9296 S   0.0   0.1   0:02.22 systemd  
      2 root      20   0       0      0      0 S   0.0   0.0   0:00.00 kthreadd
...

Kehren Sie zum Terminal zurück, das als oracle-Benutzer angemeldet ist.

Laden Sie system.slice mit foo.service.

sudo systemctl start foo.service

Sehen Sie sich jetzt die obere Ausgabe an, die noch im Terminalfenster alice ausgeführt wird. Beachten Sie, dass foo.service CPU 0 belegt, während die Benutzer CPU 1 basierend auf ihren Gewichtungen teilen.

Beispielausgabe:

top - 19:18:15 up 21:57,  3 users,  load average: 2.15, 2.32, 2.25
Tasks: 159 total,   4 running, 155 sleeping,   0 stopped,   0 zombie
%Cpu0  : 89.1 us,  7.3 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.7 hi,  0.3 si,  2.6 st
%Cpu1  : 93.7 us,  5.3 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.7 hi,  0.3 si,  0.0 st
MiB Mem :  14707.8 total,  13640.1 free,    420.5 used,    647.2 buff/cache
MiB Swap:   4096.0 total,   4096.0 free,      0.0 used.  13984.3 avail Mem

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 280921 root      20   0  228492   1776   1488 R  93.4   0.0   0:07.74 sha1sum
 279185 alice     20   0  228492   1816   1524 R  65.6   0.0   7:35.18 sha1sum
 279291 ralph     20   0  228492   1840   1552 R  32.8   0.0   7:00.30 sha1sum
   2026 oracle-+  20   0  935920  29280  15008 S   0.3   0.2   1:03.31 gomon
      1 root      20   0  388548  14716   9508 S   0.0   0.1   0:22.30 systemd
      2 root      20   0       0      0      0 S   0.0   0.0   0:00.10 kthreadd
...

CPU-Quota zuweisen

Abschließend wird die CPU-Zeit für ralph begrenzt.

Kehren Sie zum Terminal zurück, das als oracle-Benutzer angemeldet ist.

Quote auf 5 % setzen

sudo systemctl set-property user-8000.slice CPUQuota=5%

Die Änderung wird sofort wirksam, wie in der oberen Ausgabe dargestellt, die noch im alice-Benutzerterminal ausgeführt wird.

Beispielausgabe:

top - 19:24:53 up 22:04,  3 users,  load average: 2.21, 2.61, 2.45
Tasks: 162 total,   4 running, 158 sleeping,   0 stopped,   0 zombie
%Cpu0  : 93.0 us,  4.7 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.7 hi,  0.0 si,  1.7 st
%Cpu1  : 91.7 us,  5.6 sy,  0.0 ni,  0.0 id,  0.0 wa,  1.0 hi,  1.0 si,  0.7 st
MiB Mem :  14707.8 total,  13639.4 free,    420.0 used,    648.4 buff/cache
MiB Swap:   4096.0 total,   4096.0 free,      0.0 used.  13984.7 avail Mem

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 280921 root      20   0  228492   1776   1488 R  97.4   0.0   6:26.75 sha1sum
 279185 alice     20   0  228492   1816   1524 R  92.1   0.0  12:21.12 sha1sum
 279291 ralph     20   0  228492   1840   1552 R   5.3   0.0   8:44.84 sha1sum
      1 root      20   0  388548  14716   9508 S   0.0   0.1   0:22.48 systemd
      2 root      20   0       0      0      0 S   0.0   0.0   0:00.10 kthreadd
...

Setzen Sie die Memory Cap für den Benutzer ralph mit dem Terminalfenster oracle zurück.

echo "max 100000" | sudo tee -a user-8000.slice/cpu.max

Die Quota wird in die Datei cpu.max geschrieben, und die Standardwerte sind max 100000.

Beispielausgabe:

[oracle@ol8-server user.slice]$ echo "max 100000" | sudo tee -a user-8000.slice/cpu.max
max 100000

Sie können cgroups v2 aktivieren, Benutzer auf eine bestimmte CPU beschränken, wenn das System ausgelastet ist, und sie nur auf einen Prozentsatz dieser CPU sperren. Weitere Informationen zu Oracle Linux finden Sie in unseren anderen Ressourcen.

Weitere Informationen

Weitere zugehörige Ressourcen anzeigen:

Weitere Lernressourcen

Sehen Sie sich andere Übungen zu docs.oracle.com/learn an, oder greifen Sie auf weitere Inhalte für kostenloses Lernen im Oracle Learning YouTube-Kanal zu. Außerdem besuchen Sie education.oracle.com/learning-explorer, um Oracle Learning Explorer zu werden.

Produktdokumentation finden Sie im Oracle Help Center.

Titel und Copyright-Informationen

Run Control Groups Version 2 on Oracle Linux

F54924-01

March 2022