Estou procurando ferramentas de Monitoramento do Sistema, que são GUI e Cli ou baseadas na Web, que incluem funções básicas como

• Utilização do CPU

• Uso da Ram

• Trocar Uso

• Uso de disco (espaço / E / S)

• Monitoramento de Calor

Sei que existem muitas ferramentas que posso usar, mas estou procurando uma única ferramenta que possua essas funções básicas.

Olhares - Olho no seu sistema

O Glances é um software livre (licenciado pela LGPL) para monitorar seu sistema operacional GNU / Linux ou BSD a partir de uma interface de texto. O Glances usa a biblioteca libstatgrab para recuperar informações do seu sistema e é desenvolvida em Python.

Instalação

Abra um terminal ( Ctrl+ Alt+ T) e execute os seguintes comandos:

No Ubuntu 16.04 e acima, você pode apenas digitar sudo apt install glances, mas a versão 2.3 tem esse bug . Outro:

Visão geral da instalação fácil de scripts

curl -L https://raw.githubusercontent.com/nicolargo/glancesautoinstall/master/install.sh | sudo /bin/bash

OU

wget -O- https://raw.githubusercontent.com/nicolargo/glancesautoinstall/master/install.sh | sudo /bin/bash

Instalação manual

sudo apt-get install python-pip build-essential python-dev lm-sensors
sudo pip install psutil logutils bottle batinfo https://bitbucket.org/gleb_zhulik/py3sensors/get/tip.tar.gz zeroconf netifaces pymdstat influxdb elasticsearch potsdb statsd pystache docker-py pysnmp pika py-cpuinfo bernhard
sudo pip install glances

Uso básico

Para começar, glancesbasta digitar o glancesterminal.

À primeira vista, você verá muitas informações sobre os recursos do seu sistema: CPU, Carga, Memória, Trocar Rede, E / S de Disco e Processos, tudo em uma página; por padrão, o código de cor significa:

GREEN : the statistic is “OK”
BLUE : the statistic is “CAREFUL” (to watch)
VIOLET : the statistic is “WARNING” (alert)
RED : the statistic is “CRITICAL” (critical)

Quando o Glances está em execução, você pode pressionar algumas teclas especiais para fornecer comandos:

c: Sort processes by CPU%  
m: Sort processes by MEM%  
p: Sort processes by name  
i: Sort processes by IO Rate  
d: Show/hide disk I/O stats  
f: Show/hide file system stats  
n: Show/hide network stats  
s: Show/hide sensors stats  
b: Bit/s or Byte/s for network IO  
w: Delete warning logs  
x: Delete warning and critical logs  
1: Global CPU or Per Core stats  
h: Show/hide this help message  
q: Quit (Esc and Ctrl-C also work)  
l: Show/hide log messages

Processador, Ram, Monitoramento de Trocas

Monitoramento de disco

Monitoramento de Calor do Sistema

Se você digitar glances --help, encontrará ( -eAtivar o módulo de sensores (somente Linux))

glances -e

Arquivo de configuração

Você pode definir seus limites no arquivo de configuração do Glances, no GNU / Linux, onde está localizado o arquivo de configuração padrão /etc/glances/glances.conf.

Modo cliente / servidor

Outro recurso interessante dessa ferramenta de monitoramento é que você pode iniciá-lo no modo servidor apenas digitando glances -s, isso produzirá uma saída como o servidor Glances em execução em 0.0.0.0:61209 e agora você pode conectar-se a ele em outro computador usando os olhares -c @ servidor em que @server é o endereço IP ou o nome do host do servidor.

O Glances usa um servidor XML / RPC e pode ser usado por outro software cliente. No modo servidor, você pode definir o endereço de ligação (-B ADDRESS) e a porta TCP de escuta (-p PORT), o endereço de ligação padrão é 0.0.0.0 (o Glances escutará em todas as interfaces de rede) e a porta TCP é 61209. Em modo cliente, você pode definir a porta TCP do servidor (porta -p). No modo cliente / servidor, os limites são definidos pelo lado do servidor. A versão 1.6 introduz uma senha opcional para acessar o servidor (senha -P) que, se configurada no servidor, também deve ser usada no cliente.

_{Fontes adicionais: PyPI , Github , Linuxaria}

Atualizar

Monitorando o contêiner juju apenas por exemplo, como as coisas se parecem com Imagem Grande

No terminal no 1 Glances está sendo executado no modo servidor, no terminal no 2 juju o contêiner está sendo executado apt-get updatee no terminal 3 glances -c 192.168.1.103Glances está conectado ao contêiner ip

Observa o uso da CPU

O próprio Glances parece exigir picos de período do uso da CPU enquanto está ativo, conforme evidenciado pelo gráfico de uso do monitor do sistema. Se o gráfico é preciso - então, usando os olhares, desiste cerca de 1/4 da CPU em um sistema. Isso tem efeito para aqueles que estão monitorando as cargas de CPU nos servidores.

indicador-SysMonitor

O Indicator-SysMonitor faz um pouco, mas faz bem. Depois de instalado e executado, ele exibe o uso da CPU e RAM no painel superior. Simples.

Baixe aqui

Conky

Um dos meus favoritos pessoais

Screenlet, você encontrará vários monitores de CPU e RAM com estilos diferentes incluídos no pacote de screenlets - todos disponíveis no Ubuntu Software Center.

Olhares

Para instalar:

sudo apt-get install python-pip build-essential python-dev
sudo pip install Glances
sudo pip install PySensors

VMSTAT

Exibe informações sobre CPU, memória, processos, etc.

IOSTAT

Esta ferramenta de linha de comando exibirá estatísticas sobre sua CPU, informações de E / S para suas partições do disco rígido, NFS (Network File System) etc. Para instalar o iostat, execute este comando:

sudo apt-get install sysstat

Para iniciar o relatório, execute este comando:

iostat

Para verificar apenas as estatísticas da CPU, use este comando:

iostat -c

Para mais parâmetros, use este comando:

iostat --help

MPSTAT

O utilitário de linha de comando mpstat exibirá o uso médio da CPU por processador. Para executá-lo, use simplesmente este comando:

mpstat

Para uso da CPU por processador, use este comando:

mpstat -P ALL

Saidar

O Saidar também permite monitorar as atividades do dispositivo do sistema através da linha de comando.

Você pode instalar é com este comando:

sudo apt-get install saidar

Para iniciar o monitoramento, execute este comando:

saidar -c -d 1

As estatísticas serão atualizadas a cada segundo.

GKrellM

O GKrellM é um widget personalizável com vários temas que são exibidos nas informações do dispositivo do sistema de desktop (CPU, temperatura, memória, rede, etc.).

Para instalar o GKrellM, execute este comando:

sudo apt-get install gkrellm

Monitorix

O Monitorix é outro aplicativo com uma interface de usuário baseada na Web para monitorar dispositivos do sistema.

Instale-o com estes comandos:

sudo add-apt-repository ppa:upubuntu-com/ppa
sudo apt-get update
sudo apt-get install monitorix

Inicie o Monitorix através deste URL:

http://localhost/monitorix/

A seguir estão as ferramentas para monitorar um sistema linux

1. Comandos do sistema, como top, free -m, vmstat, iostat, iotop, sar, netstatetc. Nada chega perto estes utilitário linux quando você está depurando um problema. Estes comandos fornecem uma imagem clara que está dentro do servidor
2. SeaLion : Agent executa todos os comandos mencionados em # 1 (também definidos pelo usuário) e as saídas desses comandos podem ser acessadas em uma bela interface da web. Essa ferramenta é útil quando você está depurando centenas de servidores, pois a instalação é clara e simples. E é GRÁTIS
3. Nagios : É a mãe de todas as ferramentas de monitoramento / alerta. É muita personalização, mas muito difícil de configurar para iniciantes. Existem conjuntos de ferramentas chamadas plugins nagios que cobrem praticamente todas as métricas importantes do Linux
4. Munin
5. Densidade do servidor: um serviço pago baseado na nuvem que coleta métricas importantes do Linux e oferece aos usuários a capacidade de criar plug-ins próprios.
6. New Relic: Outro bem conhecido serviço de monitoramento hospedado.
7. Zabbix

Nos últimos anos eu tenho usado:

Indicador de carga do sistema

disponível no Software Center

topo

O topo está monitorando o software, listando todos os processos com uso de CPU / RAM, uso geral de CPU / RAM e mais Além disso, é instalado principalmente por padrão

htop

O htop é como uma versão estendida do top. Ele possui todos os recursos acima, mas você pode ver os processos filhos e personalizar a exibição de tudo. Também tem cores.

iotop

O iotop destina-se especificamente ao monitoramento de E / S do Hard rive. Ele lista todos os processos e mostra o uso do disco rígido para leitura e gravação.

Você pode tentar o sysmon . Embora não seja tão sofisticado quanto o Glances, é muito direto e fácil de usar.

Se você deseja se sujar e criar scripts em python, aqui estão alguns princípios básicos do monitoramento do sistema com Python para você começar.

Você precisará de um módulo externo chamado psutilpara monitorar a maioria das coisas. É mais fácil usar um instalador de módulo externo em vez de construir a partir da fonte.

Nota: Estes exemplos estão escritos em Python 2.7

sudo apt-get install pip
sudo pip install psutil

Agora que temos os módulos instalados, podemos começar a codificar.

Primeiro, crie um arquivo chamado usage.py.

gedit ~/usage.py

Comece importando psutil

import psutil

Em seguida, crie uma função para monitorar a porcentagem em que seus núcleos de CPU estão executando.

def cpu_perc(): 

    cpu_perc = psutil.cpu_percent(interval=1, percpu=True) 
    for i in range(len(cpu_perc)):
        print "CPU Core", str(i+1),":", str(cpu_perc[i]), "%"

Vamos detalhar um pouco, certo?

A primeira linha cpu_num = psutil.cpu_percent(interval=1, percpu=True),, localiza a porcentagem em que os núcleos da CPU estão sendo executados e a atribui a uma lista chamada cpu_perc.

Esse loop aqui

for i in range(len(cpu_num)):
    print "CPU Core", str(i+1),":", str(cpu_perc[i]), "%"

é um loop for que imprime a porcentagem atual de cada um dos núcleos da CPU.

Vamos adicionar o uso da RAM.

Crie uma função chamada ram_perc.

def ram_perc():
    mem = psutil.virtual_memory()
    mem_perc = mem.percent
    print "RAM: ", mem_perc, "%"

psutil.virtual_memory fornece um conjunto de dados contendo fatos diferentes sobre a RAM do seu computador.

Em seguida, você pode adicionar alguns fatos sobre sua rede.

def net():
    net = psutil.net_io_counters()
    mbytes_sent = float(net.bytes_sent) / 1048576
    mbytes_recv = float(net.bytes_recv) / 1048576
    print "MB sent: ", mbytes_sent
    print "MB received: ", mbytes_recv

Como psutil.net_io_counters()apenas nos fornece informações sobre pacotes enviados e recebidos em bytes, foi necessária alguma conversão.

Para obter algumas informações sobre o espaço de troca, adicione esta função.

def swap_perc():
    swap = psutil.swap_memory()
    swap_perc = swap.percent

Este é bem direto.

A temperatura é meio difícil de fazer; portanto, você pode precisar fazer algumas pesquisas para descobrir o que funcionará com o seu hardware. Você terá que exibir o conteúdo de um determinado arquivo.

O uso do disco é muito mais fácil que a temperatura. Tudo que você precisa fazer é passar o disco que você deseja monitorar (ou seja:) /através de uma determinada função.

def disks():
    if len(sys.argv) > 1:
        for disk in range(1, len(sys.argv)):
            tmp = psutil.disk_usage(sys.argv[disk])
            print sys.argv[disk], "\n"
            print "Megabytes total: ",
            print str(float(tmp.total) / 1048576)
            print "Megabytes used: ",
            print str(float(tmp.used) / 1048576)
            print "Megabytes free: ",
            print str(float(tmp.free) / 1048576)
            print "Percentage used: ",
            print tmp.percent, "\n"

A saída original psutil.disk_usageé essa,

>>>psutil.disk_usage('/')
sdiskusage(total=21378641920, used=4809781248, free=15482871808, percent=22.5)

mas você também pode apenas receber total, used, free, ou percent.

O programa completo: (as funções acima mencionadas foram combinadas)

import psutil, os, sys
mem_perc = 0 #init var
swap_perc = 0 #init var
mbytes_sent = 0 #init var
mbytes_recv = 0 #init var
cpu_perc = 0 #init var
swap = 0 #init var
mem = 0 #init var
net = 0 #init var



def disp(degree):
    global cpu_perc
    global swap
    global swap_perc
    global mem
    global mem_perc
    global net
    global mbytes_sent
    global mbytes_recv

    cpu_perc = psutil.cpu_percent(interval=1, percpu=True)
    swap = psutil.swap_memory()
    swap_perc = swap.percent
    mem = psutil.virtual_memory()
    mem_perc = mem.percent
    net = psutil.net_io_counters()
    mbytes_sent = float(net.bytes_sent) / 1048576
    mbytes_recv = float(net.bytes_recv) / 1048576

    os.system('clear') #clear the screen

    print "-"*30
    print "CPU"
    print "-"*30
    print "CPU Temperature: " , degree, "'C"
    for i in range(len(cpu_perc)):
        print "CPU Core", str(i+1),":", str(cpu_perc[i]), "%"

    print "-"*30
    print "MEMORY"
    print "-"*30
    print "RAM: ", mem_perc, "%"
    print "Swap: ", swap_perc, "%"
    print "-"*30
    print "NETWORK"
    print "-"*30
    print "MB sent: ", mbytes_sent
    print "MB received: ", mbytes_recv
    print "-"*30
    print "DISKS"
    print "-"*30

    if len(sys.argv) > 1:
        for disk in range(1, len(sys.argv)):
            tmp = psutil.disk_usage(sys.argv[disk])
            print sys.argv[disk], "\n"
            print "Megabytes total: ",
            print str(float(tmp.total) / 1048576)
            print "Megabytes used: ",
            print str(float(tmp.used) / 1048576)
            print "Megabytes free: ",
            print str(float(tmp.free) / 1048576)
            print "Percentage used: ",
            print tmp.percent, "\n"

def main():
    print("Press Ctrl+C to exit")
    while True:
        temp = open("/sys/class/thermal/thermal_zone0/temp").read().strip().lstrip('temperature :').rstrip(' C')
        temp = float(temp) / 1000
        disp(temp)

main()

A linha temp = open("/sys/class/thermal/thermal_zone0/temp").read().strip().lstrip('temperature :').rstrip(' C')pode não funcionar com sua configuração de hardware.

Execute este programa na linha de comando. Passe os discos que você deseja monitorar como argumentos na linha de comando.

$ python usage.py /

Press Ctrl+C to exit

------------------------------
CPU
------------------------------
CPU Temperature:  39.0 'C
CPU Core 1 : 4.8 %
CPU Core 2 : 1.0 %
CPU Core 3 : 0.0 %
CPU Core 4 : 4.9 %
------------------------------
MEMORY
------------------------------
RAM:  33.6 %
Swap:  6.4 %
------------------------------
NETWORK
------------------------------
MB sent:  2.93382358551
MB received:  17.2131490707
------------------------------
DISKS
------------------------------
/ 

Megabytes total:  13952.484375
Megabytes used:  8542.6640625
Megabytes free:  4678.5703125
Percentage used:  61.2 

/media/calvin/Data 

Megabytes total:  326810.996094
Megabytes used:  57536.953125
Megabytes free:  269274.042969
Percentage used:  17.6 

Espero que isto ajude! Comente se você tiver alguma dúvida.

https://github.com/calthecoder/sysmon-1.0.1

O systat do pacote tem uma ferramenta chamada sarque faz tudo o que você deseja. Ele também pode coletar dados históricos para que você possa ver o que aconteceu há algum tempo.

O SeaLion pode ser uma ferramenta útil, pois possui comandos internos para monitorar o desempenho do servidor, bem como você pode adicionar seus próprios comandos personalizados, scirpts e saída de log. É muito fácil configurar e descobrir o que deu errado em um horário específico.

Eu recomendo http://conky.sourceforge.net/

Muito fácil de configurar e uso mínimo de recursos.

Existe uma ferramenta interna chamada gnome-system-monitor. Ele pode fazer tudo o que você mencionou, exceto o monitoramento de calor.

Nagios parece ser o mais popular e personalizável, mas eu não o escolheria para GUI.

A solução de código aberto do Zabbix monitora tudo o que você mencionou, além de fornecer gráficos baseados em tempo para o monitoramento do desempenho.

Se você está procurando uma GUI ainda mais limpa, consulte o Zenoss. O Zenoss é uma ferramenta de código aberto baseada na Web, mas oferece análise de serviço e análise de causa raiz com sua ferramenta de propriedade.

1. O freecomando é o comando mais simples e fácil de usar para verificar o uso de memória no linux / ubuntu.

   free -m
   

2. Verificar o uso da memória é ler o /proc/meminfoarquivo.

   cat /proc/meminfo
   

3. O vmstatcomando com a sopção

   vmstat -s
   

4. O topcomando geralmente é usado para verificar o uso da memória e da CPU por processo.

   top
   

5. O comando htop também mostra o uso da memória junto com vários outros detalhes.

   htop
   

6. Para descobrir informações de hardware sobre a RAM instalada.

   sudo dmidecode -t 17
   

Eu gosto de usar o conkyque pode ser configurado de qualquer maneira que você quiser:

Você pode pesquisar no Google conkye encontrar 787.000 acessos. Há algo para todos.

Na parte superior do visor, observe "Tela de bloqueio: 4 minutos de brilho: 2074". Eles são gerados pelo "Indicator-Sysmonitor", que permite a exibição no indicador systray / application usando um script bash.

Para um tutorial sobre como configurar o "Indicator-Sysmonitor", consulte: O BASH pode ser exibido no sistema como indicador de aplicativo?

verifique a ferramenta de monitoramento eginnovations Linux - http://www.eginnovations.com/web/linux-server-monitoring.htm

baseado na Web, simples de instalar e até suportar virtualização Linux.

Eu acho que você deve dar uma olhada no Agentless Monitor do AppPerfect, que abrange vários aspectos do monitoramento, como monitoramento de aplicativos JAVA / J2EE, monitoramento de servidores, monitoramento de banco de dados, monitoramento de transações, monitoramento de transações, monitoramento de rede, monitoramento de log e monitoramento do sistema. É grátis e fácil de usar.

No meu caso, essa resposta deste link me ajudou muito.

Costumava ser um usuário do Windows? Você pode querer um equivalente do Ubuntu ao Gerenciador de Tarefas do Windows e abri-lo através da combinação de teclas Ctrl + Alt + Del.

O Ubuntu possui o utilitário interno para monitorar ou eliminar os processos em execução do sistema, que funcionam como o "Gerenciador de Tarefas", chamado Monitor do Sistema.

A tecla de atalho Ctrl + Alt + Del por padrão é usada para abrir a caixa de diálogo de logout no Ubuntu Unity Desktop. Não é útil para usuários que estão acostumados a acessar rapidamente o Gerenciador de Tarefas.

Para alterar as configurações da tecla, abra o utilitário Teclado no Unity Dash (ou Configurações do sistema -> Teclado).

Na guia Atalhos -> Atalhos personalizados, clique no ícone de adição para adicionar um atalho. Digite o nome do Gerenciador de tarefas e comando gnome-system-monitor.

Depois de adicionado, clique no local onde diz “Desativar” e pressione Ctrl + Alt + Delete. Você verá uma caixa de diálogo "A tecla de atalho ... já está sendo usada para efetuar logout", clique em Reatribuir e pronto!