Elimina automaticamente processos que ao longo do tempo usam 95% + de recursos? Ubuntu

Question

Eu não sei sobre o seu computador, mas quando o meu está funcionando corretamente, nenhum processo está sugando 95% + ao longo do tempo. Eu gostaria de ter um pouco de segurança que mata qualquer processo se comportando assim. Isso me vem à mente porque, quando acordei hoje de manhã, meu laptop estava trabalhando a noite toda em um processo infantil de cromo perdido.

Isso provavelmente pode ser feito como um cron job, mas antes de eu fazer um trabalho em tempo integral criando algo assim, eu pensei que deveria verificar aqui. :) Eu odeio reinventar a roda.

    

Answer 1

Outros encontraram este problema, e embora não pareça haver nenhum mecanismo de prevenção embutido no Ubuntu, existem algumas ideias sobre como melhorar isso.

Existe uma pergunta de falha de servidor semelhante que menciona Monit pode ajudar.

    

Answer 2

Algum tempo atrás eu fiz um script para minhas aulas da Universidade, que estava controlando o uso de recursos do sistema (CPU e / ou RAM). Você pode facilmente alterar o uso máximo proibido editando variáveis no início do script. Script deve ser iniciado em backgroung assim:

nohup ./auto_killer.sh &

O script está procurando processos que usam muitos recursos a cada N segundos. Se algum processo usar muitos recursos, o usuário que o executar receberá uma mensagem de aviso em seu console. Se o mesmo processo for descoberto 2 vezes seguidas, será eliminado (e o usuário recebe informações sobre isso).

Aqui está o código:

#!/bin/bash

Check_Repeating_Time=3; # in seconds
Max_CPU_Usage='25.0'; #%
Max_RAM_Usage='2.0'; #%
Log_Path='/var/log/auto_killer_log'; # path to file when killing logs will be writed

while [ 1 ]; do

    ps -aux | 
    awk '{
        Username = $1;
        Proc_Name = $11;
        CPU_Usage = $3;
        RAM_Usage = $4;
        PID = $2;
        TTY = $7;

        if((CPU_Usage >= '$Max_CPU_Usage' || RAM_Usage >= '$Max_RAM_Usage' ) &&  !($1 == "USER" || $1 == "root" || $1 == "daemon" || $1 == "mysql" || $1 == "avahi" || $1 == "polkitd"))
        {
            Func_Num_of_Ocur = "cat ./auto_killer_data | grep "PID" | wc -l";
            Func_Num_of_Ocur |getline Str_Num_Of_Ocur;              

            if(Str_Num_Of_Ocur == "0")
            {
                system ("echo \"\" >> /dev/" TTY);
                system ("echo \"Process "Proc_Name" used to much of resources. It will be killed in '$Check_Repeating_Time' seconds if it wont stop!\" >> /dev/" TTY );
                system ("echo \"\" >> /dev/" TTY);
                system ("echo "PID" >> ./auto_killer_data.new");
            }
            else
            {
                system ("echo \"\" >> /dev/" TTY);
                system ("echo \"Process "Proc_Name" was killed because it used to much of system resources!\" >> /dev/" TTY );
                system ("echo \"\" >> /dev/" TTY);
                system ("kill -9 " PID);
                Data = "date";
                Data |getline Str_Data;
                system ("echo \""Str_Data"  "Username"  "Proc_Name" "TTY"\" >> '$Log_Path'");
            }
        }
    }';

    if [ -e ./auto_killer_data.new ]; then
        mv ./auto_killer_data.new ./auto_killer_data
    else    
        echo '' > ./auto_killer_data
    fi

    #We wait fo a while and repeate process
    sleep $Check_Repeating_Time\s;
done;

    

Answer 3

Já enfrentei o problema semelhante antes, e aqui está o pequeno código Python para resolvê-lo:

Link para o repositório do github

    

Answer 4

Eu criei um script, kill-process , que mata alguns processos listados em uma matriz, se o uso da CPU for maior que XX% por YY segundos ou processos de eliminação que estão executando mais de ZZ segundos.

• Você pode definir XX, YY, ZZ na parte superior do arquivo.
• Você pode usar um ps ou top para processos de verificação.
• Também há um modo de execução a seco para verificar, mas não para matar.
• No final, o script envia um email se alguns processos foram eliminados.

OBSERVAÇÃO: aqui está meu repo no Github: link

Parte essencial do script (um resumo de código para o comando principal):

#!/usr/bin/env bash

#max cpu % load
MAX_CPU=90
#max execution time for CPU percentage > MAX_CPU (in seconds 7200s=2h)
MAX_SEC=1800
#sort by cpu
SORTBY=9

#define a processes command name to check
declare -a KILLLIST
KILLLIST=("/usr/sbin/apache2" "/usr/bin/php5-cgi")

#iterate for each process to check in list
for PROCESS_TOCHECK in ${KILLLIST[*]}
do

    #retrive pid with top command order by SORTBY
    PID=$(top -bcSH -n 1 | grep $PROCESS_TOCHECK | sort -k $SORTBY -r | head -n 1 | awk '{print $1}')

    CPU=$(top -p $PID -bcSH -n 1 | grep $PROCESS_TOCHECK | sort -k $SORTBY -r | head -n 1 | awk '{print $9}')
    TIME_STR=$(top -p $PID -bcSH -n 1 | grep $PROCESS_TOCHECK | sort -k $SORTBY -r | head -n 1 | awk '{print $11}')

    # Decode the top CPU time format [dd-]hh:mm.ss.
    TIME_SEC=0
    IFS="-:" read c1 c2 c3 c4 <<< "$TIME_STR"

    #with top command time format is hh:mm.ss, so truncare seconds in c2
    c2=${c2%%.*}

    if [ -n "$c4" ]
    then
      TIME_SEC=$((10#$c4+60*(10#$c3+60*(10#$c2+24*10#$c1))))
    elif [ -n "$c3" ]
    then
      if [ "$CMD" = "ps" ]; then
        TIME_SEC=$((10#$c3+60*(10#$c2+60*10#$c1)))
      else
        TIME_SEC=$(((10#$c3*24)*60*60)+60*(10#$c2+60*10#$c1))             
      fi   
    else
      if [ "$CMD" = "ps" ]; then
        TIME_SEC=$((10#0+(10#$c2+60*10#$c1)))
      else
        TIME_SEC=$((10#0+60*(10#$c2+60*10#$c1)))
      fi
    fi

    #check if need to kill process
    if [ $CPU -gt $MAX_CPU ] && [ $TIME_SEC -gt $MAX_SEC ]; then
        kill -15 $PID
    fi

done

Uso:

bash killprocess.sh [dry|kill|--help] [top|ps] [cpu|time]