Come limitare il processo a livello di utente su Linux
Ulimit (limite utente) è un potente comando che aiuta a limitare le risorse del tuo sistema.
A volte, ma non molto spesso, un singolo utente può avviare troppi processi per rendere instabile il sistema. Per mitigare questo, possiamo usare il comando ulimit per limitare il numero di processi che ogni utente o gruppo può eseguire.
In questo tutorial, impariamo come limitare il processo a livello di utente su Linux.
Controlla tutti i limiti attuali
Puoi controllare tutti i limiti per l’utente attualmente connesso.
Eseguire il seguente comando ulimit con l’opzione -a:
ulimit -a

L’output del comando mostrerà i limiti correnti per la dimensione del file di base, la dimensione del segmento di dati, la dimensione del file, i file aperti, la dimensione della pipe, la dimensione dello stack, il tempo della CPU, i processi utente massimi, la memoria virtuale e altro.
Ecco alcuni dei limiti più comunemente usati:
- Dimensione del file di base: questa è la dimensione del file di base che verrà creato quando un programma va in crash. Il file principale contiene informazioni che possono essere utilizzate per eseguire il debug del programma.
- Dimensione segmento dati: questa è la dimensione del segmento dati per un programma. Il segmento dati è l’area di memoria che contiene i dati inizializzati del programma.
- Dimensione file: questa è la dimensione massima del file che può essere creata da un programma.
- File aperti: questo è il numero massimo di file che possono essere aperti da un programma.
- Dimensione dello stack: questa è la dimensione dello stack per un programma. Lo stack memorizza le variabili del programma locale e le informazioni sulle chiamate di funzione.
Nota: Il /proc
filesystem memorizza i limiti per processo nell’oggetto filesystem che si trova in /proc/4548/limits
dove “4548” è il PID del processo o l’identificatore del processo.
Trova il numero massimo di processi utente
In un sistema Linux, possiamo utilizzare il comando ulimit per controllare il numero massimo di processi che un utente può creare.
Possiamo controllare il limite corrente usando l’opzione -u:
ulimit -u

Abbiamo l’immagine qui sopra. Questo utente può creare 15419 processi.
Imposta ulimit per l’utente
Innanzitutto, dobbiamo accedere come utente di destinazione. Quindi esegui “ulimit -u” per trovare il numero massimo di processi utente. Il limite di processo corrente è 15419.
Per impostare temporaneamente questo valore, eseguiremo:
ulimit -u 15400

L’immagine sopra mostra che il nostro nuovo limite è 15400. La modifica è stata verificata con ulimit -u.
Si noti che i limiti impostati con ulimit sono validi solo per l’utente corrente e si applicano solo ai processi avviati da quell’utente. Inoltre, i limiti impostati con ulimit non sono persistenti, quindi verranno reimpostati quando l’utente si disconnette o il sistema viene riavviato.
Impostare su Permanente
È possibile impostare il numero massimo di processi che un utente può avviare in modo permanente nella maggior parte delle versioni di Linux. Questo è spesso il caso in uno scenario di vita reale.
Quando un utente accede, il sistema legge /etc/security/limits.conf per impostare quei limiti utente. Senza impostazioni, la maggior parte degli utenti può avviare un numero illimitato di processi.
Nota: se usi systemd, i limiti del servizio definiti in /etc/security/limits.conf o /etc/security/limits.d/*.conf vengono ignorati.
Tuttavia, è spesso auspicabile limitare il numero di processi che un utente può avviare. Ad esempio, dovresti evitare che un utente avvii troppi processi e quindi utilizzi troppe risorse di sistema.
I limiti di processo sono impostati per utente, quindi se desideri impostare limiti per più utenti, dovrai modificare /etc/security/limits.conf più volte.
Esegui quanto segue per controllare il file limits.conf:
cat /etc/security/limits.conf

Ci prenderemo il tempo per spiegare l’immagine sopra.
Il file /etc/security/limits.conf ha il seguente formato:
<domain> <type> <item> <value>
Il campo
Il campo
- “soft limit”: questo tipo di limite può essere superato da un processo con gli opportuni privilegi.
- “limite rigido”: questo tipo di limite non può essere superato da alcun processo, anche con i privilegi appropriati.
Il campo
Il campo
Ora modificheremo limits.conf. Useremo l’editor di testo nano. È necessario il privilegio di root per modificare il file; senza di esso, le modifiche non verranno salvate. Correre:
sudo nano /etc/security/limits.conf

Questo comando ci fornisce già l’output di cui abbiamo discusso in precedenza. Facciamo un ulteriore passo avanti. Ora aggiungeremo questa riga di codice:
ubuntu hard nproc 12444

Quindi salva il file e chiudi l’editor. Sarà necessario riavviare il sistema affinché le modifiche abbiano effetto.
Controlliamo il risultato. Eseguire quanto segue:
ulimit -a ubuntu

I nostri cambiamenti possono essere visti nell’immagine qui sopra.
Imposta il limite utente tramite systemd
Systemd legge dal file “/etc/systemd/system.conf” per impostazione predefinita. Di seguito sono riportati i limiti di sistema equivalenti a ulimits.
Directive ulimit equivalent Unit
LimitCPU= ulimit -t Seconds
LimitFSIZE= ulimit -f Bytes
LimitDATA= ulimit -d Bytes
LimitSTACK= ulimit -s Bytes
LimitCORE= ulimit -c Bytes
LimitRSS= ulimit -m Bytes
LimitNOFILE= ulimit -n Number of File Descriptors
LimitAS= ulimit -v Bytes
LimitNPROC= ulimit -u Number of Processes
LimitMEMLOCK= ulimit -l Bytes
LimitLOCKS= ulimit -x Number of Locks
LimitSIGPENDING= ulimit -i Number of Queued Signals
LimitMSGQUEUE= ulimit -q Bytes
LimitNICE= ulimit -e Nice Level
LimitRTPRIO= ulimit -r Realtime Priority
LimitRTTIME= No equivalent
Esempio:
Possiamo impostare un limite al numero massimo di processi che un servizio può creare per un dato utente o gruppo usando systemd. Useremo l’opzione LimitNPROC in [Service] sezione del file dell’unità di servizio, insieme al file Utente o gruppo opzione.
Il Utente o gruppo L’opzione specifica l’utente o il gruppo in base al quale il servizio deve essere eseguito e LimitNPROC L’opzione specifica il numero massimo di processi che il servizio può creare.
Per creare un file di unità di servizio, dobbiamo prima creare un file con estensione “.service” nella directory /etc/systemd/system.

Nell’immagine sopra, ho usato il comando “cd” per navigare nella directory /etc/systemd/system e ho creato un file di unità di servizio chiamato myservice01 con l’estensione “.service”. Utilizzando l’editor di testo nano, apriremo il file unit.
sudo nano /etc/system/system/myservice01.service
Ora aggiungeremo quanto segue al file unit per limitare a 10 il numero massimo di processi che il servizio può creare ed eseguiremo il servizio come utente “ubuntu”.
[Unit]
Description=My Service
[Service]
ExecStart=/etc/systemd/system/myservice01.service
LimitNPROC=10
User=ubuntu
[Install]
WantedBy=multi-user.target

In alternativa, se vogliamo eseguire il servizio come un gruppo specifico, possiamo utilizzare gruppo opzione invece di Utente opzione.
[Unit]
Description=My Service
[Service]
ExecStart=/etc/systemd/system/myservice01.service
LimitNPROC=10
Group=`sudo ubuntu`
[Install]
WantedBy=multi-user.target
Ora possiamo utilizzare il comando systemctl per avviare, arrestare e gestire il servizio, nonché abilitarlo o disabilitarlo per l’avvio automatico all’avvio.
Per avviare il servizio, utilizzare il seguente comando:
sudo systemctl start myservice01.service
Per abilitare l’avvio automatico del servizio all’avvio, utilizzare il seguente comando:
sudo systemctl enable myservice01.service
Conclusione
In Linux, ulimit è un comando che consente di impostare limiti sulle risorse che un utente può utilizzare, come il numero massimo di descrittori di file aperti o il numero massimo di processi per un utente.
systemd consente di impostare i limiti delle risorse per i servizi utilizzando le opzioni Limit* nel file dell’unità di servizio.
Spero che ti sia piaciuto leggere e per favore lascia i tuoi suggerimenti o feedback nella sezione commenti.