Remarque :

Ce tutoriel est disponible dans un environnement de laboratoire gratuit fourni par Oracle.
Il utilise des exemples de valeur pour les informations d'identification, la location et les compartiments Oracle Cloud Infrastructure. A la fin de l'exercice, remplacez ces valeurs par celles propres à votre environnement cloud.

Exécution des groupes de contrôle version 2 sur Oracle Linux

Introduction

Les groupes de contrôle (cgroups) sont une fonctionnalité de noyau Linux permettant de limiter, de hiérarchiser et d'allouer des ressources telles que le temps CPU, la mémoire et la bande passante réseau pour l'exécution des processus.

Ce tutoriel vous guide tout au long de la limitation du temps CPU pour les processus utilisateur utilisant des cgroups v2.

Objectifs

Dans cet exercice, vous allez :

Activer les cgroups v2
Définir une limite d'UC souple pour un processus utilisateur
Définir une limite de CPU matérielle pour un processus utilisateur

Prérequis

Un système Oracle Linux 8 est installé avec la configuration suivante :
- un utilisateur non root avec des droits d'accès sudo ;

Environnement du laboratoire de configuration

Remarque : lorsque vous utilisez l'environnement d'exercices gratuits, reportez-vous à Notions de base d'Oracle Linux Lab pour obtenir des instructions de connexion et d'utilisation.

Avant de commencer l'exercice, nous devons effectuer quelques opérations d'entretien. Les éléments créés sont utilisés pour démontrer les capacités de limitation des cgroups.

Créer un script de génération de charge

Si ce n'est pas déjà fait, ouvrez un terminal et connectez-vous via ssh au système ol8-server.
```
ssh oracle@<ip_address_of_ol8-server>
```

Créez le script foo.exe.

echo '#!/bin/bash

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

Copiez le script foo.exe vers un emplacement dans $PATH et définissez les droits d'accès appropriés.
```
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
```
Remarque : (facultatif) en cas d'exécution avec SELinux enforcing :
```
sudo sestatus
```
Corrigez les libellés SELinux après avoir copié et modifié les autorisations en exécutant la commande suivante :
```
sudo /sbin/restorecon -v /usr/local/bin/foo.exe
```

Créer un service de génération de charge

Créez le fichier 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

Copiez le script foo.service dans lequel se trouvent les scripts systemd et définissez les droits d'accès appropriés.
```
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
```
Remarque : (facultatif) en cas d'exécution avec SELinux enforcing, corrigez les libellés SELinux après avoir copié et modifié les autorisations en exécutant la commande suivante :
```
sudo /sbin/restorecon -v /etc/systemd/system/foo.service
```
Rechargez le démon afin que systemd reconnaisse le nouveau service.
```
sudo systemctl daemon-reload
```

Démarrez foo.service et vérifiez son statut.

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

Créer des utilisateurs

D'autres utilisateurs pourront exécuter le script de génération de charge sous ces différents comptes et différents poids de CPU.

Créez des utilisateurs et définissez des mots de passe.

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

Autorisez les connexions SSH.

Copiez la clé SSH à partir du compte utilisateur 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

Répétez l'opération pour l'utilisateur alice.

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

Ouvrez un nouveau terminal et vérifiez que les deux connexions SSH fonctionnent.
```
ssh ralph@<ip_address_of_ol8-server>
```
Ensuite, exit la session et répétez l'opération pour l'utilisateur suivant.
```
ssh alice@<ip_address_of_ol8-server>
```
Quittez la session et fermez la fenêtre de terminal.

Monter les cgroups v2

Oracle Linux monte les groupes de cgroups v1 par défaut au moment de l'initialisation. Pour utiliser cgroups v2, vous devez configurer manuellement les paramètres du noyau d'initialisation.

Revenez au terminal sur lequel vous êtes connecté en tant que oracle.
Ajoutez le paramètre de noyau systemd cgroups v2.
```
sudo grubby --update-kernel=ALL --args="systemd.unified_cgroup_hierarchy=1"
```
Vous ne pouvez indiquer que votre entrée d'initialisation actuelle en exécutant sudo grubby --update-kernel=/boot/vmlinuz-$(uname -r) --args="systemd.unified_cgroup_hierarchy=1".
Redémarrez.
```
sudo reboot
```
La réinitialisation prendra quelques minutes.

Remarque : vous ne pourrez pas effectuer de ssh dans le système tant que la réinitialisation n'est pas terminée et que le démon sshd n'est pas en cours d'exécution.
Connectez-vous à nouveau via ssh au système ol8-server.
```
ssh oracle@<ip_address_of_ol8-server>
```

Vérifiez que cgroups v2 a été monté.

sudo mount -l | grep cgroup

Exemple de sortie :

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

Inspectez le contenu du répertoire monté des cgroups.

ll /sys/fs/cgroup

Exemple de sortie :

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

La sortie affiche le groupe de contrôle root à son emplacement par défaut. Le répertoire contient des fichiers d'interface dont le préfixe est cgroup et des répertoires associés à systemd qui se terminent par .scope et .slice.

Utilisation du système de fichiers virtuel

Avant de commencer, nous devons en apprendre un peu sur le système de fichiers virtuel cgroups monté sur /sys/fs/cgroup.

Affichez les CPU qui participent au CPU pour tous.
```
cat /sys/fs/cgroup/cpuset.cpus.effective
```
Exemple de sortie :
```
[oracle@ol8-server ~]$ cat /sys/fs/cgroup/cpuset.cpus.effective
0-1
```
Notre boîte de test était une instance Oracle Linux 8 déployée sur une forme VM.Standard2.1, qui est un système à double coeur.
Affichez les contrôleurs actifs.
```
cat /sys/fs/cgroup/cgroup.controllers
```
Exemple de sortie :
```
[oracle@ol8-server ~]$ cat /sys/fs/cgroup/cgroup.controllers
cpuset cpu io memory pids rdma
```
Il est préférable de voir le contrôleur de CPU présent car nous l'utiliserons plus tard dans cet exercice.

Afficher les processus générés dynamiquement par oracle.

Tout d'abord, nous devons déterminer l'ID utilisateur (UID) de oracle.

who
id

Exemple de sortie :

[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

A l'aide de l'UID, nous pouvons trouver la tranche d'utilisateurs oracle.

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

Exemple de sortie :

[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 affecte à chaque utilisateur une tranche nommée user-<UID>.slice. Qu'est-ce qui se trouve sous ce répertoire ?

cd user-1001.slice
ls

Exemple de sortie :

[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

Il s'agit des cgroups de niveau supérieur de l'utilisateur oracle. Toutefois, aucun processus n'est répertorié dans cgroup.procs. Alors, où se trouve la liste des processus utilisateur ?

cat cgroup.procs

Exemple de sortie :

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

Lorsque oracle a ouvert la session SSH au début de cet exercice, la session utilisateur a créé une sous-unité de portée. Sous cette portée, nous pouvons consulter cgroup.procs pour obtenir la liste des processus générés dynamiquement dans cette session.

Remarque : l'utilisateur peut avoir plusieurs sessions en fonction du nombre de connexions au système ; par conséquent, remplacez les 3 dans l'exemple ci-dessous si nécessaire.

cd session-3.scope
ls
cat cgroup.procs

Exemple de sortie :

[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

Maintenant que nous avons trouvé les processus comme il se doit, nous pouvons utiliser systemd-cgls pour afficher les mêmes informations dans une vue de type arborescence.

Remarque : lorsqu'elle est exécutée à partir du système de fichiers virtuel, systemd-cgls limite la sortie cgroup au répertoire de travail en cours.

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

Exemple de sortie :

[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)

Limiter les coeurs de processeur utilisés

Avec les cgroups v2, systemd dispose d'un contrôle total sur le contrôleur de CPU. Ce niveau de contrôle permet à un administrateur de planifier le travail uniquement sur un coeur de CPU spécifique.

Vérifiez les CPU pour user.slice.

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

Exemple de sortie :

[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 indique les coeurs réels utilisés par user.slice. Si le paramètre n'existe pas dans le répertoire cgroup spécifique ou si nous ne le définisons pas, la valeur est héritée du parent, ce qui est le répertoire racine cgroup de niveau supérieur pour ce cas.

Limitez les tranches system et 0, 1001 et 989 au coeur de CPU 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

Exemple de sortie :

[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

Remarque : No such file or directory indique que, par défaut, la tranche system hérite de sa valeur cpuset.cpus.effective du parent.

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

Limitez l'utilisateur ralph au coeur de CPU 1.

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

Exemple de sortie :

[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

Ouvrez un nouveau terminal et connectez-vous via ssh en tant que ralph au système ol8-server.
```
ssh ralph@<ip_address_of_ol8-server>
```

Testez l'utilisation du script foo.exe.

foo.exe &

Vérifiez les résultats.

top

Une fois que top est en cours d'exécution, appuyez sur 1 key pour afficher les CPU individuellement.

Exemple de sortie :

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
...

Saisissez q pour quitter le haut.

Autre moyen de vérifier le processeur exécutant un processus.

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

Exemple de sortie :

[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

La colonne psr est le numéro d'UC du processus cmd ou réel.

Quittez et fermez la fenêtre de terminal utilisée pour vous connecter en tant que ralph.
Arrêtez le travail foo.exe.

Revenez au terminal sur lequel vous êtes connecté en tant que oracle et exécutez la commande suivante.
```
sudo pkill sha1sum
```

Ajustement du poids de l'UC pour les utilisateurs

Temps nécessaire à la jointure alice pour l'amusement. Elle a un travail critique à réaliser et, par conséquent, nous lui accorderons deux fois la priorité normale sur le processeur.

Affectez alice à la même UC que ralph.

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

Définissez CPUWeight.

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

Le poids par défaut est 100, donc 200 est le double de ce nombre.

Ouvrez un nouveau terminal et connectez-vous via ssh en tant que ralph au système ol8-server.
```
ssh ralph@<ip_address_of_ol8-server>
```
Exécutez foo.exe en tant que ralph.
```
foo.exe &
```
Ouvrez un autre nouveau terminal et connectez-vous via ssh en tant que alice au système ol8-server.
```
ssh alice@<ip_address_of_ol8-server>
```
Exécutez foo.exe en tant que alice.
```
foo.exe &
```

Vérifiez via top que alice obtient la priorité la plus élevée.

top

Une fois le haut en cours d'exécution, appuyez sur 1 key pour afficher les CPU individuellement.

Exemple de sortie :

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
...

Revenez au terminal connecté en tant qu'utilisateur oracle.

Chargez system.slice à l'aide de foo.service.

sudo systemctl start foo.service

Examinez à présent la sortie supérieure toujours en cours d'exécution dans la fenêtre de terminal alice. Vérifiez que foo.service utilise l'UC 0, tandis que les utilisateurs fractionnent l'UC 1 en fonction de leur poids.

Exemple de sortie :

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
...

Affecter un quota d'UC

Enfin, nous limiterons le temps UC pour ralph.

Revenez au terminal connecté en tant qu'utilisateur oracle.

Définissez le quota sur 5 %.

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

La modification prend effet immédiatement, comme indiqué dans la sortie supérieure toujours en cours d'exécution dans le terminal utilisateur alice.

Exemple de sortie :

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
...

Rétablissez le plafond pour l'utilisateur ralph à l'aide de la fenêtre de terminal oracle.

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

Le quota est écrit dans le fichier cpu.max et les valeurs par défaut sont max 100000.

Exemple de sortie :

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

Vous pouvez activer les cgroups v2, limiter les utilisateurs à une CPU spécifique lorsque le système est en charge et les verrouiller pour n'utiliser qu'un pourcentage de cette CPU. Consultez nos autres ressources sur Oracle Linux.

Pour plus d'informations

Voir les autres ressources connexes :

Ressources de formation supplémentaires

Explorez d'autres exercices sur docs.oracle.com/learn ou accédez à davantage de contenu d'apprentissage gratuit sur le canal Oracle Learning YouTube. De plus, visitez le site education.oracle.com/learning-explorer pour devenir Oracle Learning Explorer.

Pour consulter la documentation du produit, consultez le centre d'aide Oracle.

Informations relatives au titre et au copyright

Run Control Groups Version 2 on Oracle Linux

F54927-01

March 2022