Nota:

Questa esercitazione è disponibile in un ambiente di laboratorio gratuito fornito da Oracle.
Utilizza valori di esempio per le credenziali, la tenancy e i compartimenti Oracle Cloud Infrastructure. Al termine del laboratorio, sostituire questi valori con quelli specifici del tuo ambiente cloud.

Esegui gruppi di controllo versione 2 su Oracle Linux

Introduzione

Control Groups (cgroups) è una funzione kernel Linux che consente di limitare, assegnare le priorità e allocare le risorse come il tempo CPU, la memoria e la larghezza di banda della rete per i processi in esecuzione.

Questa esercitazione guida l'utente limitando il tempo della CPU per i processi utente utilizzando i cgroups v2.

Obiettivi

In questo laboratorio imparerai a:

Abilitare i cgroups v2
Impostare un limite CPU soft per un processo utente
Impostare un limite CPU permanente per un processo utente

Prerequisiti

Un sistema con Oracle Linux 8 installato con la configurazione seguente:
- un utente non root con autorizzazioni sudo

Imposta ambiente laboratorio

Nota: quando si utilizza l'ambiente di laboratorio gratuito, consultare Oracle Linux Lab Basics per le istruzioni di connessione e altro tipo.

Prima di iniziare con il laboratorio, dobbiamo completare alcuni articoli di housekeeping. Gli elementi creati sono utilizzati per dimostrare la limitazione delle capacità dei gruppi.

Crea script di generazione del carico

Se non è già connesso, aprire un terminale e connettersi tramite ssh al sistema ol8-server.
```
ssh oracle@<ip_address_of_ol8-server>
```

Creare lo script foo.exe.

echo '#!/bin/bash

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

Copiare lo script foo.exe in una posizione nel file $PATH e impostare le autorizzazioni appropriate.
```
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: (facoltativo) se è in esecuzione con SELinux enforcing:
```
sudo sestatus
```
Correggere le etichette SELinux dopo aver copiato e modificato le autorizzazioni eseguendo il seguente comando:
```
sudo /sbin/restorecon -v /usr/local/bin/foo.exe
```

Crea servizio di generazione caricamento

Creare il file 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

Copiare lo script foo.service nella posizione in cui si trovano gli script systemd e impostare le autorizzazioni appropriate.
```
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: (facoltativo) se si esegue SELinux enforcing, correggere le etichette SELinux dopo aver copiato e modificato le autorizzazioni eseguendo il seguente comando:
```
sudo /sbin/restorecon -v /etc/systemd/system/foo.service
```
Ricaricare il daemon e quindi systemd riconosce il nuovo servizio.
```
sudo systemctl daemon-reload
```

Avviare foo.service e controllarne lo stato.

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

Crea utenti

Ulteriori utenti consentiranno di eseguire lo script di generazione del carico sotto questi diversi account e pesi CPU diversi.

Creare utenti e impostare password.

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

Consente le connessioni SSH.

Copiare la chiave SSH dall'account utente 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

Ripetere l'operazione per l'utente 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

Aprire un nuovo terminale e verificare che entrambe le connessioni SSH funzionino.
```
ssh ralph@<ip_address_of_ol8-server>
```
Quindi exit la sessione e ripetere l'operazione per l'utente seguente.
```
ssh alice@<ip_address_of_ol8-server>
```
Uscire dalla sessione e chiudere la finestra del terminale.

Attivare i gruppi v2

Per impostazione predefinita, Oracle Linux attiva i gruppi v1 al momento del boot. Per usare i cgroups v2, è necessario configurare manualmente i parametri del kernel di boot.

Tornare al terminale in cui si è connessi come oracle.
Aggiungere il parametro kernel systemd dei cgroups v2.
```
sudo grubby --update-kernel=ALL --args="systemd.unified_cgroup_hierarchy=1"
```
È invece possibile specificare solo la voce di boot corrente eseguendo sudo grubby --update-kernel=/boot/vmlinuz-$(uname -r) --args="systemd.unified_cgroup_hierarchy=1".
Eseguire il reboot del sistema.
```
sudo reboot
```
Il completamento del riavvio richiede qualche minuto.

Nota: non è possibile eseguire il ssh nel sistema finché il reboot non viene completato e il daemon sshd è in esecuzione.
Connettersi di nuovo tramite ssh al sistema ol8-server.
```
ssh oracle@<ip_address_of_ol8-server>
```

Verificare che i gruppi v2 siano stati attivati.

sudo mount -l | grep cgroup

Output di esempio:

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

Controllare il contenuto della directory attivata dei gruppi.

ll /sys/fs/cgroup

Output di esempio:

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

L'output mostra il gruppo di controllo root nella posizione predefinita. La directory contiene i file di interfaccia con il prefisso cgroup e le directory correlate a systemd che terminano in .scope e .slice.

Uso del file system virtuale

Prima di iniziare, è necessario conoscere meglio il file system virtuale dei cgroups attivato all'indirizzo /sys/fs/cgroup.

Mostra quali CPU partecipano al cpuset per tutti gli utenti.
```
cat /sys/fs/cgroup/cpuset.cpus.effective
```
Output di esempio:
```
[oracle@ol8-server ~]$ cat /sys/fs/cgroup/cpuset.cpus.effective
0-1
```
La nostra casella di test è stata un'istanza di Oracle Linux 8 distribuita su una forma VM.Standard2.1 che è un sistema dual-core.
Mostra i controller attivi.
```
cat /sys/fs/cgroup/cgroup.controllers
```
Output di esempio:
```
[oracle@ol8-server ~]$ cat /sys/fs/cgroup/cgroup.controllers
cpuset cpu io memory pids rdma
```
È utile vedere il controller cpuset presente come lo utilizzeremo più tardi in questo laboratorio.

Mostra i processi generati da oracle.

In primo luogo, è necessario determinare l'ID utente (UID) di oracle.

who
id

Output di esempio:

[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

Utilizzando l'UID, è possibile trovare la slice degli utenti oracle.

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

Output di esempio:

[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 assegna a ogni utente una slice denominata user-<UID>.slice. Cosa c'è sotto questo elenco?

cd user-1001.slice
ls

Output di esempio:

[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

Si tratta dei gruppi di livello superiore per l'utente oracle. Tuttavia, non esistono processi elencati in cgroup.procs. Quindi, qual è l'elenco dei processi utente?

cat cgroup.procs

Output di esempio:

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

Quando oracle ha aperto la sessione SSH all'inizio di questo laboratorio, la sessione utente ha creato un'unità secondaria di ambito. In questo ambito è possibile controllare l'cgroup.procs per un elenco di processi generati in tale sessione.

Nota: l'utente può disporre di più sessioni in base al numero di connessioni al sistema; pertanto, sostituire 3 nell'esempio seguente, se necessario.

cd session-3.scope
ls
cat cgroup.procs

Output di esempio:

[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

Ora che abbiamo trovato i processi difficili, possiamo utilizzare systemd-cgls per mostrare le stesse informazioni in una vista simile ad albero.

Nota: quando viene eseguito dal file system virtuale, systemd-cgls limita l'output del cgroup alla directory di lavoro corrente.

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

Output di esempio:

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

Limitare le memorie centrali CPU utilizzate

Con i gruppi v2, systemd ha il controllo completo del controller cpuset. Questo livello di controllo consente a un amministratore di pianificare il lavoro solo su una specifica memoria centrale CPU.

Controllare le CPU per user.slice.

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

Output di esempio:

[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

Il file cpuset.cpus.effective mostra i core effettivi utilizzati da user.slice. Se il parametro non esiste nella directory cgroup specifica oppure non viene impostato, il valore viene ereditato dall'elemento padre, che risulta essere la directory radice cgroup di livello superiore per questo caso.

Limitare le slice system e 0, 1001 e 989 al core 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

Output di esempio:

[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: il valore No such file or directory indica che, per impostazione predefinita, la slice system eredita il valore cpuset.cpus.effective dall'elemento padre.

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

Limitare l'utente ralph al core CPU 1.

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

Output di esempio:

[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

Aprire un nuovo terminale e connettersi tramite ssh come ralph al sistema ol8-server.
```
ssh ralph@<ip_address_of_ol8-server>
```

Eseguire il test utilizzando lo script foo.exe.

foo.exe &

Verificare i risultati.

top

Una volta eseguito top, premere 1 key per visualizzare le CPU singolarmente.

Output di esempio:

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

Digitare q per uscire dall'alto.

Metodo alternativo per controllare l'esecuzione di un processo da parte del processore.

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

Output di esempio:

[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 colonna psr indica il numero di CPU del processo cmd o effettivo.

Uscire e chiudere la finestra di terminale utilizzata per eseguire il login come ralph.
Terminare il job foo.exe.

Tornare al terminale in cui si è connessi come oracle ed eseguire il comando seguente.
```
sudo pkill sha1sum
```

Regolare il peso della CPU per gli utenti

Tempo per partecipare al divertimento di alice. Ha un lavoro critico da completare, e quindi le daremo due volte la priorità normale sulla CPU.

Assegnare alice alla stessa CPU di ralph.

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

Impostare CPUWeight.

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

Il peso predefinito è 100, quindi 200 è il doppio di quel numero.

Aprire un nuovo terminale e connettersi tramite ssh come ralph al sistema ol8-server.
```
ssh ralph@<ip_address_of_ol8-server>
```
Eseguire foo.exe come ralph.
```
foo.exe &
```
Aprire un altro nuovo terminale e connettersi tramite ssh come alice al sistema ol8-server.
```
ssh alice@<ip_address_of_ol8-server>
```
Eseguire foo.exe come alice.
```
foo.exe &
```

Verificare tramite top che alice ottenga la priorità più alta.

top

Una volta eseguita la prima esecuzione, premere 1 key per visualizzare le CPU singolarmente.

Output di esempio:

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

Tornare al terminale collegato come utente oracle.

Caricare system.slice utilizzando foo.service.

sudo systemctl start foo.service

Verificare che l'output principale sia ancora in esecuzione nella finestra del terminale alice. Verificare che foo.service utilizzi la CPU 0, mentre gli utenti dividono la CPU 1 in base al peso.

Output di esempio:

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

Assegna una quota CPU

Infine, limiteremo il tempo CPU per ralph.

Tornare al terminale collegato come utente oracle.

Impostare la quota su 5%

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

La modifica ha effetto immediato, come si evince dall'output principale ancora in esecuzione nel terminale utente alice.

Output di esempio:

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

Ripristinare il limite sull'utente ralph utilizzando la finestra del terminale oracle.

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

La quota viene scritta nel file cpu.max e le impostazioni predefinite sono max 100000.

Output di esempio:

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

È possibile abilitare i gruppi v2, limitare gli utenti a una CPU specifica quando il sistema è in fase di caricamento e bloccarli in modo da utilizzare solo una percentuale della CPU specificata. Dai un'occhiata alle altre risorse per saperne di più su Oracle Linux.

Per ulteriori informazioni

Vedere altre risorse correlate.

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti di apprendimento gratuito sul canale Oracle Learning YouTube. Inoltre, visitare education.oracle.com/learning-explorer per diventare Oracle Learning Explorer.

Per la documentazione del prodotto, visitare il sito Oracle Help Center.

Titolo e informazioni sul copyright

Run Control Groups Version 2 on Oracle Linux

F54928-01

March 2022