Sysstat: exemplos práticos de uso do comando sar

O SAR é um programa de monitoramento da performance do sistema Linux.
Neste post, vamos mostrar como o aplicativo funciona, através de exemplos práticos, que podem ser usados no dia a dia do sysadmin, para obter dados sobre processamento, E/S, desempenho do armazenamento na memória etc.
Uma vez instalado, é simples fazer o monitoramento da performance do Linux e levantar estatísticas de uso do sistema, com o uso de alguns comandos no terminal.

O sar faz parte do pacote de aplicativos de monitoramento SYSSTAT, desenvolvidos em C, pelo programador francês Sebastien Godard.
O fato de ser desenvolvido em linguagem C, implica em um programa leve, rápido e que interfere muito pouco nas atividades do sistema, durante sua execução.

• Veja como instalar o pacote sysstat e o sar no Linux (Debian, Ubuntu, Red Hat etc.) e dicas básicas de configuração antes do uso.

Uso básico do sar

O sar pode ser executado direto na linha de comando, por qualquer usuário, sem privilégios especiais. Veja:

sar -V

este comando serve para mostrar a versão do sar, em execução:

sysstat versão 10.2.0
(C) Sebastien Godard (sysstat <at> orange.fr)

Uma vez que você tenha o sar instalado e funcionando, pode executar mais alguns comandos com ele.
O exemplo, abaixo, mostra as estatísticas referentes ao uso da CPU do seu computador, com 1 segundo de intervalo, 5 vezes:

sar 1 5

Este foi o resultado no meu computador:

Linux 3.13.0-32-generic (VoYag3r) 	29-07-2014 	_i686_	(2 CPU)

17:04:49        CPU     %user     %nice   %system   %iowait    %steal     %idle
17:04:50        all     23,62      0,00      1,51      0,00      0,00     74,87
17:04:51        all     43,72      0,00      2,01      0,00      0,00     54,27
17:04:52        all     28,50      0,00      2,50      0,00      0,00     69,00
17:04:53        all     33,00      0,00      2,00      0,00      0,00     65,00
17:04:54        all     30,77      0,00      1,03      0,00      0,00     68,21
Média:         all     31,92      0,00      1,81      0,00      0,00     66,26

Alguns exemplos práticos de uso do sar, na linha de comando

Há 2 maneiras básicas de invocar o sar, na linha de comando:

• acompanhado por uma opção (sem especificar um arquivo de dados saXX).
  Isto fará o aplicativo procurar pelos dados contidos no arquivo saXX do dia atual e exibir os dados gravados até aquele momento.
• acompanhado de uma opção e especificando o arquivo saXX, através do parâmetro -f.
  Isto o fará exibir os dados referentes à performance obtida até a data especificada no arquivo.

Nota: o XX, usado acima, se refere ao dia do mês.
Nos exemplos que seguem, vou explicar como obter dados da performance do sistema no dia de hoje.
Se quiser se referir a uma data especial, basta adicionar o parâmetro -f /var/log/sysstat/saXX ao final da linha de comando do sar.
Toda vez em que você executar o comando sar, ele irá mostrar, na primeira linha, um texto semelhante a este:

Linux 3.13.0-32-generic (VoYag3r) 	01-08-2014 	_i686_	(2 CPU)

Esta linha de texto mostra:

• A versão do kernel Linux do sistema: 3.13.0-32-generic.
• O hostname a que os dados se referem: VoYag3r.
• A data a que se referem os dados 01-08-2014.
• A arquitetura do sistema: _i686_.
• O número de CPUs disponíveis no sistema: 2 CPU.

Em tempo, o comando sar -u, serve para mostrar o uso cumulativo, em tempo real, de todas as unidades de processamento do sistema.
Se você usar o parâmetro ALL, vai ver mais informações. Experimente:

sar -u ALL

Você pode usar as opções -P ALL para ver estatísticas de uso de todos os núcleos das CPUs separados:

sar -P ALL 1 2

O resultado, abaixo, mostra as estatísticas dos núcleos (0 e 1) da CPU, com 1 segundo de intervalo, 2 vezes:

Linux 3.13.0-32-generic (VoYag3r) 01-08-2014 _i686_ (2 CPU)

17:00:03        CPU     %user     %nice   %system   %iowait    %steal     %idle
17:00:04        all     58,88      0,00      1,02      0,00      0,00     40,10
17:00:04          0     17,17      0,00      3,03      0,00      0,00     79,80
17:00:04          1    100,00      0,00      0,00      0,00      0,00      0,00

17:00:04        CPU     %user     %nice   %system   %iowait    %steal     %idle
17:00:05        all     54,00      0,00      1,00      0,00      0,00     45,00
17:00:05          0      8,16      0,00      1,02      0,00      0,00     90,82
17:00:05          1    100,00      0,00      0,00      0,00      0,00      0,00

Média:         CPU     %user     %nice   %system   %iowait    %steal     %idle
Média:         all     56,42      0,00      1,01      0,00      0,00     42,57
Média:           0     12,69      0,00      2,03      0,00      0,00     85,28
Média:           1    100,00      0,00      0,00      0,00      0,00      0,00

Como obter estatísticas individuais de um dos núcleos (cores)

Se você tem um processador, com vários núcleos, pode obter valores individuais do uso de cada um, com o parâmetro -P.
Se eu quiser ver apenas os resultados do segundo núcleo, eu uso o parâmetro -P 1 (lembrando que a contagem dos núcleos começa em 0).
No exemplo, abaixo, o sar vai mostrar as estatísticas do segundo núcleo, com 1 seg. de intervalo, 5 vezes. Veja como fica:

sar -P 1 1 5

Linux 3.13.0-32-generic (VoYag3r) 	01-08-2014 	_i686_	(2 CPU)

17:07:19        CPU     %user     %nice   %system   %iowait    %steal     %idle
17:07:20          1     15,84      0,00      3,96      0,00      0,00     80,20
17:07:21          1     43,00      0,00      5,00      0,00      0,00     52,00
17:07:22          1     19,39      0,00      2,04      0,00      0,00     78,57
17:07:23          1    100,00      0,00      0,00      0,00      0,00      0,00
17:07:24          1    100,00      0,00      0,00      0,00      0,00      0,00
Média:           1     55,71      0,00      2,20      0,00      0,00     42,08

Estatísticas de uso de memória

Vamos deixar os números das CPUs de lado por um momento.
No exemplo, que segue, vou mostrar como usar o sar para obter dados do uso da memória do sistema.
A coluna kbmemfree se refere à memória livre. kbmemused, se refere a memória em uso. Os valores estão em kilobytes.
O comando sar -r 1 3 mostra as estatísticas gerais de uso da memória, com 1 segundo de intervalo, 3 vezes:

sar -r 1 3

veja o resultado:

Linux 3.13.0-32-generic (VoYag3r) 	01-08-2014 	_i686_	(2 CPU)

17:29:16    kbmemfree kbmemused  %memused kbbuffers  kbcached  kbcommit   %commit  kbactive   kbinact   kbdirty
17:29:17       304296   1747916     85,17     13572    710340   3142020     44,73    792276    870516       168
17:29:18       303924   1748288     85,19     13572    710340   3142020     44,73    791900    870516       168
17:29:19       303212   1749000     85,23     13572    710340   3142020     44,73    792796    870516       168
Média:        303811   1748401     85,20     13572    710340   3142020     44,73    792324    870516       168

Experimente outras variações do comando:

• sar -r
• sar -r 1 5
• sar -r 1 3 -f /var/log/sysstat/sa30

Como acompanhar o uso da memória swap

O parâmetro -S pode ser usado para acompanhar o uso da memória swap no sistema.
Este comando pode ser usado para determinar se o seu sistema está fazendo uso do swapping ou não — se as colunas kbswpused e %swpused estiverem com valores zerados, então o sistema não está usando a memória swap.
O comando, abaixo, mostra as estatísticas de uso do swap, com intervalo de 1 segundo, 5 vezes:

sar -S 1 5

Como você pode ver, no meu sistema, está havendo uso do swapping:

Linux 3.13.0-32-generic (VoYag3r) 	01-08-2014 	_i686_	(2 CPU)

17:54:43    kbswpfree kbswpused  %swpused  kbswpcad   %swpcad
17:54:44      4970576      2020      0,04         0      0,00
17:54:45      4970576      2020      0,04         0      0,00
17:54:46      4970576      2020      0,04         0      0,00
17:54:47      4970576      2020      0,04         0      0,00
17:54:48      4970576      2020      0,04         0      0,00
Média:       4970576      2020      0,04         0      0,00

E no seu?

Outras maneiras úteis de usar o sar

Você pode experimentar também estas outras variações de uso do sar:

• sar -S
• sar -S -f /var/log/sysstat/sa30 — vai buscar os dados do dia 30 (sa30).
• sar -R — para identificar o número de páginas de memória liberadas, usadas e em cache a cada segundo, no sistema.
• sar -H — para identificar as hugepages (em KB) em uso ou disponíveis.
• sar -B — para gerar estatísticas (em KB) de dados paginados em relação ao disco por segundo.
• sar -W — para gerar estatísticas de swap de páginas por segundo.

Como acompanhar o fluxo (Entrada/Saída) de dados

O comando, abaixo, mostra as estatísticas de fluxo de entrada e saída de dados (E/S), a cada 1 segundo e 3 vezes:

sar -b 1 3

Linux 3.13.0-32-generic (VoYag3r) 	04-08-2014 	_i686_	(2 CPU)

21:43:48          tps      rtps      wtps   bread/s   bwrtn/s
21:43:49         0,00      0,00      0,00      0,00      0,00
21:43:50         1,00      0,00      1,00      0,00    328,00
21:43:51         0,00      0,00      0,00      0,00      0,00
Média:          0,33      0,00      0,33      0,00    109,33

Significado dos campos

• tps – Transactions per second ou transações por segundo (leitura e gravação incluídas).
• rtps – Read transactions per second ou transações de leitura por segundo.
• wtps – Write transactions per second ou transações de escrita por segundo.
• bread/s – Bytes read per second ou bytes lidos por segundo.
• bwrtn/s – Bytes written per second ou bytes escritos por segundo.

Monitorando atividades de dispositivos de E/S

O comando sar -d, para sermos objetivos aqui, pode ser usado para monitorar as atividades individuais de dispositivos de bloco e identificar atividades específicas de cada dispositivo.

Entenda o que são: Dispositivos de bloco ou block devices

Sistemas operacionais podem suportar um segundo tipo de dispositivo de disco conhecido como block device — dispositivos para os quais o kernel provê caching. (FreeBSD handbook).
É um arquivo que representa um dispositivo de hardware. Um arquivo especial de bloco, se distingue de outros por oferecer acesso ao dispositivo de hardware de forma a que suas características (a do hardware) não sejam visíveis ao sistema. (OpenGroup).

Veja um exemplo, na imagem abaixo:

Para entender melhor a imagem acima, a coluna DEV é a que mostra os dispositivos.
Os nomes dos dispositivos podem vir acompanhados de uma numeração indicadora da quantidade possível de dispositivos conectáveis.
Tomemos o seguinte exemplo: dev20-1.
A numeração que sucede o nome do dispositivo quer dizer que ele aceita a conexão de 1 até 20 outros dispositivos: dev1, dev2, dev3... dev20.
Eu acho mais fácil entender esta listagem, com o uso do parâmetro -p -d. Assim:

sar -p -d 1 1

Linux 3.13.0-32-generic (VoYag3r) 	05-08-2014 	_i686_	(2 CPU)

19:23:44          DEV       tps  rd_sec/s  wr_sec/s  avgrq-sz  avgqu-sz     await     svctm     %util
19:23:45          sda      0,00      0,00      0,00      0,00      0,00      0,00      0,00      0,00

Média:           DEV       tps  rd_sec/s  wr_sec/s  avgrq-sz  avgqu-sz     await     svctm     %util
Média:           sda      0,00      0,00      0,00      0,00      0,00      0,00      0,00      0,00

Com o uso do parâmetro -p é possível ter nomes mais detalhados, como sda, sdb, sda1, sda2, sdc1, etc.
Experimente mais algumas variantes do comando:

• sar -d -f /var/log/sysstat/sa>XX — substitua o XX pelo dia do mês, cujos dados você deseja ver.
• sar -p -d 1 10

Determine os valores do context switching por segundo

O parâmetro -w vai exibir a quantidade total de processos criados por segundo, na primeira coluna, e o número de chaveamentos realizados por segundo (cswch/s), na outra coluna.
Veja como:

sar -w 1 3

Linux 3.13.0-32-generic (VoYag3r) 	06-08-2014 	_i686_	(2 CPU)

14:12:17       proc/s   cswch/s
14:12:18         0,00    492,00
14:12:19         0,00    650,00
14:12:20         0,00    619,00
Média:          0,00    587,00

Definição de context switch

O termo context switch ou process switching, em inglês, pode ser traduzido como “troca de contexto”, em uma tradução literal. Eu prefiro a palavra chaveamento. Leia mais na Wikipedia.
O context switching, ou chaveamento, pode ser descrito, mais especificamente, como uma das seguintes ações do kernel, em relação a processos e threads:

• suspensão da progressão de um processo e armazenamento do estado da CPU — ou seja o contexto deste processo, em algum lugar da memória;
• recuperação do contexto de outro processo armazenado na memória e sua reintegração nos registros da CPU e
• retorno ao contador do programa (ou seja, à linha de código em que o processo anterior foi interrompido) para retomá-lo.

(The Linux Information Project).

Nas minhas palavras, chaveamento é quando o kernel suspende a execução de um processo ou thread na CPU e retoma a execução de qualquer outro processo, que já havia sido suspenso anteriormente — sendo que um processo é, por definição, a instância de um programa em execução.

Experimente outras variações do exemplo dado:

• sar -w
• sar -w 1 5
• sar -w -f /var/log/sysstat/saXX

Como ver estatísticas de rede com o sar

O comando sar, em conjunto com o parâmetro -n, pode ser usado para obter informações sobre o desempenho de diversos aspectos do uso da rede no seu sistema — o que inclui o número de pacotes recebidos/transmitidos através da interface de rede, número de falhas etc.
Além do parâmetro -n, é necessário dizer o dispositivo de rede do qual se deseja recolher as informações.
Veja no quadro informativo abaixo:

• DEV – Exibe estatísticas vitais para dispositivos de rede eth0, eth1, wlan0 etc.
• EDEV – Exibe números das falhas referentes aos dispositivos de rede.
• NFS – Mostra as atividades dos clientes do sistema de arquivos de rede (Network File System).
• NFSD – Mostra as atividades dos servidores NFS.
• SOCK – Lista os sockets do IPv4 em uso.
• IP – Exibe o tráfego na rede IPv4.
• EIP – Mostra os erros na rede IPv4.
• ICMP – Mostra o tráfego na rede ICMPv4.
• EICMP – Exibe erros na rede ICMPv4.
• TCP – Exibe o tráfego na rede TCPv4.
• ETCP – Exibe erros na rede TCPv4.
• UDP – Mostra o tráfego de rede UDPv4.
• as opções SOCK6, IP6, EIP6, ICMP6, UDP6 são equivalentes às anteriores, só que voltadas para redes IPv6.
• ALL – Exibe todas as informações dos itens anteriores. A saída deste comando é bastante extensa.

Exemplo de uso:

sar -n IP 1 2

Linux 3.13.0-32-generic (VoYag3r) 	06-08-2014 	_i686_	(2 CPU)

17:51:58       irec/s  fwddgm/s    idel/s     orq/s   asmrq/s   asmok/s  fragok/s fragcrt/s
17:51:59         3,00      0,00      3,00      0,00      0,00      0,00      0,00      0,00
17:52:00         0,00      0,00      0,00      0,00      0,00      0,00      0,00      0,00
Média:          1,50      0,00      1,50      0,00      0,00      0,00      0,00      0,00

Relacione os dados obtidos pelo sar, usando start time

Ao analisar os dados do histórico, contido no arquivo /var/log/sysstat/saXX, com o uso da opção sar -f, é possível observar todos os dados exibidos a começar pelo horário de 12:00 a.m ou 00:00:00.
Você pode mudar a hora do início do relatório.
O parâmetro -s hh:mi:ss permite especificar um horário personalizado para o sistema usar como horário de início do relatório.
Veja como indicar o início do relatório de média de carga, para as 06 da manhã:

sar -q -f /var/log/sysstat/sa05 -s 06:00:00

Como não há meios (até a versão que eu estou usando) de estabelecer uma hora limite pro relatório, é necessário lançar mão de “outros artifícios”.
No exemplo abaixo, a saída do comando é filtrada pelo comando head:

sar -q -f /var/log/sysstat/sa05 -s 06:00:00 | head
Linux 3.13.0-32-generic (VoYag3r) 	05-08-2014 	_i686_	(2 CPU)

06:05:01      runq-sz  plist-sz   ldavg-1   ldavg-5  ldavg-15   blocked
06:15:01            0       303      0,27      0,23      0,13         0
06:25:01            0       334      0,25      0,31      0,27         0
06:35:01            0       336      0,35      0,20      0,22         1
06:45:01            0       333      0,04      0,15      0,20         0
06:55:01            0       334      0,12      0,13      0,16         0
07:05:01            0       333      0,25      0,25      0,19         0
07:15:01            0       333      0,09      0,15      0,15         0

O comando head

A função do comando head é exibir a primeira parte de cada arquivo enviado para ele.
Como padrão, o comando exibe as primeiras 10 linhas do arquivo.

No exemplo, abaixo, usei o comando grep para filtrar as saídas que ocorrem aos 15 minutos de cada hora. Veja como ficou:

sar -q -f /var/log/sysstat/sa05 -s 06:00:00 | grep -i ":15:01"

06:15:01            0       303      0,27      0,23      0,13         0
07:15:01            0       333      0,09      0,15      0,15         0
08:15:01            0       338      0,04      0,11      0,14         0
09:15:01            2       336      0,25      0,16      0,15         0
10:15:01            0       337      0,16      0,19      0,16         0
11:15:01            0       337      0,09      0,17      0,24         0
12:15:01            0       343      0,52      0,54      0,79         0
13:15:01            0       334      0,06      0,07      0,12         0
14:15:01            3       351      0,94      0,77      0,63         0
15:15:01            0       349      0,40      0,50      0,50         0
16:15:01            0       345      0,42      0,39      0,42         0
17:15:01            5       390      3,79      2,93      2,08         0
18:15:01            0       356      0,21      0,32      0,94         0
19:15:01            0       359      0,46      0,65      0,71         0
20:15:01            0       364      0,75      0,49      0,61         0
21:15:01            1       362      0,74      0,45      0,47         0
22:15:01            2       362      0,28      0,39      0,48         0
23:15:01            4       362      0,43      0,46      0,54         0

Fila de execução e média de carga

No exemplo anterior, mostrei o uso da opção -q (mas não expliquei para que servia…) 😉
Esta opção informa o comprimento da fila e a média da carga, nos últimos intervalos de 1, 5 e 15 minutos.
Veja no quadro abaixo, os significados dos cabeçalhos de cada coluna.

significado do relatório

O parâmetro -q retorna valores, em 6 colunas:

• runq-sz — comprimento da fila (número de tarefas esperando sua hora de execução).
• plist-sz — Número de itens na lista de tarefas.
• ldavg-1 — Média de carga (de trabalho) do sistema, no último minuto.
  A média da carga é computada a partir da quantidade média de tarefas que estejam ou que possam estar em execução (R state) e o número de tarefas em “dormência” ininterrupta (D state) dentro do intervalo especificado (1 minuto).
• ldavg-5 — Média de carga do sistema nos últimos 5 minutos.
• ldavg-15 — Média de carga do sistema nos últimos 15 minutos.
• blocked — Número momentâneo de tarefas bloqueadas, esperando a conclusão do fluxo de E/S.

Veja um exemplo:

sar -q 1 5

Linux 3.13.0-32-generic (VoYag3r) 	07-08-2014 	_i686_	(2 CPU)

15:39:02      runq-sz  plist-sz   ldavg-1   ldavg-5  ldavg-15   blocked
15:39:03            1       322      0,42      0,56      0,68         0
15:39:04            1       321      0,38      0,55      0,67         0
15:39:05            3       321      0,38      0,55      0,67         0
15:39:06            1       321      0,38      0,55      0,67         0
15:39:07            4       321      0,38      0,55      0,67         0
Média:             2       321      0,39      0,55      0,67         0

Conclusão

Há inúmeras outras formas de aplicação do sar, que irão surgir com o uso e as necessidades.
Combinar o programa com outros comandos Linux é uma forma de multiplicar suas possibilidades.

Leia outros artigos, sobre este assunto, para aumentar seus conhecimentos:

Como instalar o sysstat e o sar no seu sistema.
Blackmoreops: Exemplos de uso do sar. (english)
Crybit: Monitoramento de carga e memória com o SAR. (english)
O comando grep.