Nota:

Este tutorial está disponible en un entorno de prácticas gratuitas proporcionado por Oracle.
Utiliza valores de ejemplo para credenciales, arrendamiento y compartimentos de Oracle Cloud Infrastructure. Al finalizar el laboratorio, sustituya estos valores por valores específicos de su entorno en la nube.

Ejecución de grupos de control versión 2 en Oracle Linux

Introducción

Control Groups (cgroups) es una función de núcleo de Linux para limitar, priorizar y asignar recursos, como tiempo de CPU, memoria y ancho de banda de red para ejecutar procesos.

En este tutorial se le guía por la limitación del tiempo de CPU para los procesos de usuario mediante cgroups v2.

Objetivos

En este laboratorio, aprenderá a:

Activar cgroups v2
Definir un límite de CPU variable para un proceso de usuario
Definir un límite estricto de CPU para un proceso de usuario

Requisitos

Un sistema con Oracle Linux 8 instalado con la siguiente configuración:
- un usuario no root con permisos sudo

Configurar entorno de prácticas

Nota: al utilizar el entorno de prácticas gratuitas, consulte Aspectos básicos del laboratorio de Oracle Linux para conocer la conexión y otras instrucciones de uso.

Antes de comenzar con el laboratorio, necesitamos completar algunos artículos para el mantenimiento. Los elementos creados se utilizan para demostrar las capacidades de limitación de cgroups.

Crear script de generación de carga

Si aún no está conectado, abra un terminal y conéctese mediante ssh al sistema ol8-server.
```
ssh oracle@<ip_address_of_ol8-server>
```

Cree el script foo.exe.

echo '#!/bin/bash

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

Copie el script foo.exe en una ubicación de $PATH y defina los permisos adecuados.
```
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
```
Nota: (Opcional) Si se ejecuta con SELinux enforcing:
```
sudo sestatus
```
Corrija las etiquetas de SELinux después de copiar y cambiar los permisos ejecutando el siguiente comando:
```
sudo /sbin/restorecon -v /usr/local/bin/foo.exe
```

Crear servicio de generación de carga

Cree el archivo 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

Copie la secuencia de comandos foo.service en la que se encuentran las secuencias de comandos systemd y defina los permisos adecuados.
```
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
```
Nota: (Opcional) Si se ejecuta con SELinux enforcing, corrija las etiquetas de SELinux después de copiar y cambiar los permisos ejecutando el siguiente comando:
```
sudo /sbin/restorecon -v /etc/systemd/system/foo.service
```
Vuelva a cargar el daemon, por lo que systemd reconoce el nuevo servicio.
```
sudo systemctl daemon-reload
```

Inicie foo.service y compruebe su estado.

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

Crear usuarios

Los usuarios adicionales permitirán ejecutar el script de generación de carga en estas distintas cuentas y diferentes pesos de CPU.

Cree usuarios y defina contraseñas.

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

Permitir conexiones SSH.

Copie la clave SSH de la cuenta de usuario 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

Repita el procedimiento para el usuario 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

Abra un nuevo terminal y verifique que funcionan ambas conexiones SSH.
```
ssh ralph@<ip_address_of_ol8-server>
```
A continuación, ejecute exit en la sesión y repita la sesión para el siguiente usuario.
```
ssh alice@<ip_address_of_ol8-server>
```
Salga de la sesión y cierre la ventana de terminal.

Montar cgroups v2

Oracle Linux monta los cgroups v1 de manera predeterminada en el momento del inicio. Para utilizar cgroups v2, debe configurar manualmente los parámetros del núcleo de inicio.

Vuelva al terminal donde está conectado como oracle.
Agregue el parámetro de núcleo systemd v2 de cgroups.
```
sudo grubby --update-kernel=ALL --args="systemd.unified_cgroup_hierarchy=1"
```
En su lugar, puede especificar solo su entrada de inicio actual ejecutando sudo grubby --update-kernel=/boot/vmlinuz-$(uname -r) --args="systemd.unified_cgroup_hierarchy=1".
Reiniciar.
```
sudo reboot
```
El reinicio tardará unos minutos en completarse.

Nota: No podrá ejecutar ssh en el sistema hasta que finalice el reinicio y se ejecute el daemon sshd.
Vuelva a conectarse mediante ssh al sistema ol8-server.
```
ssh oracle@<ip_address_of_ol8-server>
```

Verifique que se haya montado cgroups v2.

sudo mount -l | grep cgroup

Salida de ejemplo:

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

Inspeccione el contenido del directorio montado de cgroups.

ll /sys/fs/cgroup

Salida de ejemplo:

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 salida muestra el root control group en su ubicación predeterminada. El directorio contiene archivos de interfaz con el prefijo cgroup y directorios relacionados con systemd que terminan en .scope y .slice.

Trabajar con el sistema de archivos virtual

Antes de empezar, necesitamos aprender un poco sobre el sistema de archivos virtual de cgroups montado en /sys/fs/cgroup.

Muestre qué CPU participan en el conjunto de CPU para todos.
```
cat /sys/fs/cgroup/cpuset.cpus.effective
```
Salida de ejemplo:
```
[oracle@ol8-server ~]$ cat /sys/fs/cgroup/cpuset.cpus.effective
0-1
```
Nuestro cuadro de prueba fue una instancia de Oracle Linux 8 desplegada con una unidad VM.Standard2.1, que es un sistema de doble núcleo.
Muestre qué controladores están activos.
```
cat /sys/fs/cgroup/cgroup.controllers
```
Salida de ejemplo:
```
[oracle@ol8-server ~]$ cat /sys/fs/cgroup/cgroup.controllers
cpuset cpu io memory pids rdma
```
Es bueno ver el controlador cpuset presente, ya que lo usaremos más adelante en este laboratorio.

Muestre los procesos iniciados por oracle.

En primer lugar, necesitamos determinar el ID de usuario (UID) de oracle.

who
id

Salida de ejemplo:

[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

Con el UID, podemos encontrar el segmento de usuarios oracle.

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

Salida de ejemplo:

[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 asigna a cada usuario un segmento denominado user-<UID>.slice. Entonces, ¿qué hay en ese directorio?

cd user-1001.slice
ls

Salida de ejemplo:

[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

Estos son los cgroups de nivel superior para el usuario oracle. Sin embargo, no se muestran procesos en cgroup.procs. Por lo tanto, ¿dónde está la lista de procesos de usuario?

cat cgroup.procs

Salida de ejemplo:

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

Cuando oracle abrió la sesión SSH al principio de esta práctica, la sesión de usuario creó una subunidad de ámbito. En este ámbito, podemos comprobar cgroup.procs para obtener una lista de procesos iniciados en esa sesión.

Nota: El usuario puede tener varias sesiones basadas en el número de conexiones al sistema; por lo tanto, sustituya el 3 del ejemplo siguiente según sea necesario.

cd session-3.scope
ls
cat cgroup.procs

Salida de ejemplo:

[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

Ahora que encontramos los procesos de la manera difícil, podemos utilizar systemd-cgls para mostrar la misma información en una vista de árbol.

Nota: Cuando se ejecuta desde dentro del sistema de archivos virtual, systemd-cgls limita la salida de cgroup al directorio de trabajo actual.

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

Salida de ejemplo:

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

Limitación de los núcleos de CPU utilizados

Con los cgroups v2, systemd tiene el control total del controlador cpuset. Este nivel de control permite a un administrador programar el trabajo solo en un núcleo de CPU específico.

Compruebe las CPU para user.slice.

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

Salida de ejemplo:

[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 muestra los núcleos reales utilizados por user.slice. Si el parámetro no existe en el directorio cgroup específico o no lo definimos, el valor se hereda del principal, lo que sucede como el directorio raíz cgroup de nivel superior para este caso.

Restrinja los segmentos system y 0, 1001 y 989 del usuario al núcleo 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

Salida de ejemplo:

[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

Nota: No such file or directory indica que, por defecto, el segmento system hereda su valor cpuset.cpus.effective del principal.

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

Restrinja el usuario ralph al núcleo de CPU 1.

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

Salida de ejemplo:

[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

Abra un nuevo terminal y conéctese mediante ssh como ralph al sistema ol8-server.
```
ssh ralph@<ip_address_of_ol8-server>
```

Pruebe con el script foo.exe.

foo.exe &

Compruebe los resultados.

top

Una vez que top se esté ejecutando, pulse 1 key para mostrar las CPU individualmente.

Salida de ejemplo:

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

Escriba q para salir de la parte superior.

Forma alternativa de comprobar el procesador que ejecuta un proceso.

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

Salida de ejemplo:

[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 columna psr es el número de CPU de cmd o el proceso real.

Salga y cierre la ventana de terminal utilizada para iniciar sesión como ralph.
Matar el trabajo foo.exe.

Vuelva al terminal donde está conectado como oracle y ejecute el siguiente comando.
```
sudo pkill sha1sum
```

Ajuste del peso de CPU para usuarios

Tiempo para unir alice en la diversión. Ella tiene un trabajo crítico para completar y, por lo tanto, le daremos el doble de prioridad normal en la CPU.

Asigne alice a la misma CPU que ralph.

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

Defina CPUWeight.

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

El peso predeterminado es 100, por lo que 200 es el doble de ese número.

Abra un nuevo terminal y conéctese mediante ssh como ralph al sistema ol8-server.
```
ssh ralph@<ip_address_of_ol8-server>
```
Ejecute foo.exe como ralph.
```
foo.exe &
```
Abra otro nuevo terminal y conéctese mediante ssh como alice al sistema ol8-server.
```
ssh alice@<ip_address_of_ol8-server>
```
Ejecute foo.exe como alice.
```
foo.exe &
```

Verifique mediante top que alice está obteniendo la prioridad más alta.

top

Una vez que la parte superior se esté ejecutando, pulse 1 key para mostrar las CPU individualmente.

Salida de ejemplo:

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

Vuelva al terminal conectado como usuario oracle.

Cargue system.slice con foo.service.

sudo systemctl start foo.service

Observe ahora la salida superior que se sigue ejecutando en la ventana de terminal alice. Observe que foo.service consume la CPU 0, mientras que los usuarios dividen la CPU 1 en función de sus pesos.

Salida de ejemplo:

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

Asignar una cuota de CPU

Por último, limitaremos el tiempo de CPU para ralph.

Vuelva al terminal conectado como usuario oracle.

Defina la cuota en el 5%

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

El cambio se aplica inmediatamente, como se ve en la salida superior que se sigue ejecutando en el terminal de usuario alice.

Salida de ejemplo:

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

Revierta el límite en el usuario ralph mediante la ventana de terminal oracle.

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

La cuota se escribe en el archivo cpu.max y los valores por defecto son max 100000.

Salida de ejemplo:

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

Puede activar los cgroups v2, limitar los usuarios a una CPU específica cuando el sistema está en carga y bloquearlos para que utilicen solo un porcentaje de esa CPU. Consulte los demás recursos para obtener más información sobre Oracle Linux.

Para más información

Consulte otros recursos relacionados:

Más recursos de aprendizaje

Explore otras prácticas en docs.oracle.com/learn o acceda a contenido de aprendizaje más gratuito en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en un explorador de formación de Oracle.

Para obtener documentación sobre los productos, visite Oracle Help Center.

Título e Información de Copyright

Run Control Groups Version 2 on Oracle Linux

F54926-01

March 2022