Guia para Domínio Avançado dos Comandos do Linux – parte 3: gerenciamento de recursos


por Arup Nanda Oracle ACE Director

Publicado em janeiro de 2009

Nesta parte do guia, você aprenderá comandos avançados do Linux para monitorar os componentes físicos

Um sistema Linux consiste em diversos componentes físicos importantes, como CPU, memória, placa de rede e dispositivos de armazenamento. Para gerenciar com eficácia um ambiente Linux, o ideal é poder medir as várias métricas desses recursos – quanto o componente está processando, se há gargalos e assim por diante – com razoável precisão.

Nas outras partes desta série, você aprendeu alguns comandos para medir métricas em nível macro. Já nesta parte você aprenderá comandos avançados do Linux para monitorar componentes físicos especificamente. Mais precisamente, aprenderá os comandos das seguintes categorias:

Component

Commands

Memory

free, vmstat, mpstat, iostat, sar

CPU

vmstat, mpstat, iostat, sar

I/O

vmstat, mpstat, iostat, sar

Processes

ipcs, ipcrm


Como se pode ver, alguns comandos aparecem em mais de uma categoria. Isso ocorre porque eles podem executar muitas tarefas. Alguns comandos são mais adequados a alguns componentes – por exemplo, iostat para I/O –, mas é preciso entender as diferenças em seu funcionamento e usar os mais convenientes para você.

Na maioria dos casos, um único comando pode não ser útil para entender o que realmente está acontecendo. Você deve conhecer vários comandos para obter as informações desejadas.

"free"

Uma dúvida frequente é: “Quanta memória está sendo usada pelos meus aplicativos e pelos vários processos do servidor, usuário e sistema?” Ou então: “Quanta memória está livre neste momento?” Se a memória usada pelos processos em execução ultrapassar a RAM disponível, eles serão transferidos para o swap. Assim, uma dúvida subsequente é: “Quanto swap está sendo usado?”.

O comando "free" responde a todas essas dúvidas. E o melhor é que uma opção bastante útil, –m , mostra a memória livre em megabytes:

# free -m
             total     used    free    shared   buffers    cached
Mem:          1772     1654     117        0         18        618
-/+ buffers/cache:     1017     754
Swap:         1983     1065     918


O resultado anterior mostra que o sistema tem 1.772 MB de RAM, do qual 1.654 MB está sendo usado, deixando 117 MB de memória livre. A segunda linha mostra os buffers e as alterações no tamanho de cache na memória física. A terceira linha mostra a utilização do swap.

Para mostrar as mesmas informações em kilobytes e gigabytes, substitua a opção -m por -k ou -g, respectivamente. Também é possível detalhar até o nível dos bytes, usando a opção –b.

# free -b
             total     used    free     shared    buffers     cached
Mem:    1858129920 1724039168  134090752     0   18640896  643194880
-/+ buffers/cache: 1062203392  795926528
Swap:   2080366592 1116721152  963645440


A opção –t mostra o total na parte inferior do resultado (soma da memória física com o swap):

# free -m -t
             total     used    free     shared    buffers     cached
Mem:          1772     1644     127          0         16        613
-/+ buffers/cache:     1014     757
Swap:         1983     1065     918
Total:        3756     2709    1046


Apesar de o comando "free" não mostrar as porcentagens, podemos extrair e formatar partes específicas do resultado para mostrar a memória usada como uma porcentagem apenas do total:

# free -m | grep Mem | awk '{print ($3 / $2)*100}' 
98.7077


Isso é conveniente em scripts de shell, em que os números específicos são importantes. Por exemplo, talvez você queira disparar um alerta quando a porcentagem da memória livre ficar abaixo de um limite específico.

De maneira semelhante, para encontrar a porcentagem do swap usado, você pode escrever:

free -m | grep -i Swap | awk '{print ($3 / $2)*100}'


Use o free para monitorar a carga de memória exercida por um aplicativo. Por exemplo, verifique a memória livre antes de iniciar o aplicativo de backup e verifique-a imediatamente após o início. A diferença poderia ser atribuída ao consumo pelo aplicativo de backup.

Utilização para usuários Oracle

Enfim, como usar esse comando para gerenciar o servidor Linux que opera seu ambiente Oracle? Uma das causas mais comuns dos problemas de performance é a falta de memória, fazendo o sistema fazer “swap” de áreas da memória no disco temporariamente. Talvez seja impossível eliminar por completo o swap, mas muito swap indica falta de memória livre.

Em vez disso, você pode usar o free para obter as informações de memória livre agora e prosseguir com o comando sar (mostrado mais adiante) para verificar a tendência histórica do consumo da memória e do swap. Se a utilização do swap for temporária, provavelmente será um pico isolado; mas se for acentuada durante um período de tempo, você deverá ficar atento. Há alguns possíveis e óbvios suspeitos das sobrecargas de memória crônicas:

  • Um grande SGA maior do que a memória disponível
  • Alocação muito grande no PGA
  • Algum processo com falhas que causa vazamento de memória

Para o primeiro caso, você deve verificar se o SGA é menor do que a memória disponível. Uma regra prática geral é usar cerca de 40% da memória física para o SGA, mas é evidente que você deve definir esse parâmetro com base na sua situação específica. No segundo caso, tente reduzir a grande alocação de buffer nas consultas. No terceiro caso, use o comando ps (descrito em uma parte anterior desta série) para identificar o processo específico que pode estar causando vazamento de memória.

"ipcs"

Quando um processo é executado, ele aproveita a “memória compartilhada”. Pode haver um ou vários segmentos de memória compartilhada por esse processo. Os processos enviam mensagens mutuamente (“comunicação entre processos” ou IPC) e usam semáforos. Para exibir as informações sobre os segmentos de memória compartilhada, as filas de mensagem IPC e os semáforos, basta usar um único comando: o ipcs.

A opção –m é bastante conhecida e exibe os segmentos de memória compartilhada.

# ipcs -m
 
------ Shared Memory Segments --------
key        shmid      owner     perms      bytes      nattch     status      
0xc4145514 2031618    oracle    660        4096       0                       
0x00000000 3670019    oracle    660        8388608    108                     
0x00000000 327684     oracle    600        196608     2          dest         
0x00000000 360453     oracle    600        196608     2          dest         
0x00000000 393222     oracle    600        196608     2          dest         
0x00000000 425991     oracle    600        196608     2          dest         
0x00000000 3702792    oracle    660        926941184  108                     
0x00000000 491529     oracle    600        196608     2          dest         
0x49d1a288 3735562    oracle    660        140509184  108                     
0x00000000 557067     oracle    600        196608     2          dest         
0x00000000 1081356    oracle    600        196608     2          dest         
0x00000000 983053     oracle    600        196608     2          dest         
0x00000000 1835023    oracle    600        196608     2          dest         


Esse resultado, obtido em um servidor que executa software Oracle, mostra os vários segmentos de memória compartilhada. Cada um está identificado exclusivamente por uma ID de memória compartilhada, mostrada na coluna “shmid”. (Mais adiante, você verá como usar o valor dessa coluna.) A coluna “owner” mostra o proprietário do segmento, enquanto “perms” mostra as permissões (o mesmo que as permissões do Unix) e “bytes” mostra o tamanho em bytes.

A opção -u mostra um resumo sucinto:

# ipcs -mu

------ Shared Memory Status --------
segments allocated 25
pages allocated 264305
pages resident  101682
pages swapped   100667
Swap performance: 0 attempts     0 successes

A opção –l mostra os limites (em contraste com os valores atuais):

# ipcs -ml
 
------ Shared Memory Limits --------
max number of segments = 4096
max seg size (kbytes) = 907290
max total shared memory (kbytes) = 13115392
min seg size (bytes) = 1


Se você perceber que os valores atuais são os valores do limite ou estão próximos a estes, deverá considerar o aumento do limite.

Você pode obter uma imagem detalhada de um segmento de memória compartilhada específico usando o valor shmid. A opção –i faz isso. A seguir você saberá como ver os detalhes do shmid 3702792:

# ipcs -m -i 3702792
 
Shared memory Segment shmid=3702792
uid=500 gid=502 cuid=500        cgid=502
mode=0660       access_perms=0660
bytes=926941184 lpid=12225      cpid=27169      nattch=113
att_time=Fri Dec 19 23:34:10 2008  
det_time=Fri Dec 19 23:34:10 2008  
change_time=Sun Dec  7 05:03:10 2008    


Mais adiante, você verá um exemplo de como interpretar o resultado anterior.

A opção -s mostra os semáforos no sistema:

# ipcs -s
 
------ Semaphore Arrays --------
key        semid      owner      perms      nsems     
0x313f2eb8 1146880    oracle    660        104       
0x0b776504 2326529    oracle    660        154     
… and so on …  


Esse resultado mostra alguns dados valiosos. Ele mostra que a matriz de semáforos com ID 1146880 tem 104 semáforos e que a outra tem 154. Se você somá-los, o valor total terá de ser inferior ao limite máximo definido pelo parâmetro do kernel (semmax). Ao instalar o Banco de Dados Oracle, o verificador de pré-instalação terá uma verificação para a definição de semmax. Mais adiante, quando o sistema atingir um estado constante, você poderá verificar a utilização real e ajustar o valor do kernel adequadamente.

Utilização para usuários Oracle

Como descobrir os segmentos de memória compartilhada usados pela instância do Banco de Dados Oracle? Para saber isso, use o comando oradebug. Primeiro, conecte-se ao banco de dados como sysdba:

# sqlplus / as sysdba

No SQL, use o comando oradebug da seguinte maneira:

SQL> oradebug setmypid
Statement processed.
SQL> oradebug ipc
Information written to trace file.


Para descobrir o nome do arquivo de rastreamento:

SQL> oradebug TRACEFILE_NAME
/opt/oracle/diag/rdbms/odba112/ODBA112/trace/ODBA112_ora_22544.trc


Agora, se você abrir o arquivo de rastreamento, verá as IDs de memória compartilhada. A seguir está um trecho do arquivo:

Area #0 `Fixed Size' containing Subareas 0-0
  Total size 000000000014613c Minimum Subarea size 00000000
   Area  Subarea    Shmid      Stable Addr      Actual Addr
      0        0 17235970 0x00000020000000 0x00000020000000
                              Subarea size     Segment size
                          0000000000147000 000000002c600000
 Area #1 `Variable Size' containing Subareas 4-4
  Total size 000000002bc00000 Minimum Subarea size 00400000
   Area  Subarea    Shmid      Stable Addr      Actual Addr
      1        4 17235970 0x00000020800000 0x00000020800000
                              Subarea size     Segment size
                          000000002bc00000 000000002c600000
 Area #2 `Redo Buffers' containing Subareas 1-1
  Total size 0000000000522000 Minimum Subarea size 00000000
   Area  Subarea    Shmid      Stable Addr      Actual Addr
      2        1 17235970 0x00000020147000 0x00000020147000
                              Subarea size     Segment size
                          0000000000522000 000000002c600000
... and so on ... 
                                  

A ID de memória compartilhada foi mostrada em vermelho em negrito. Você pode usar essa ID de memória compartilhada para obter os detalhes dela:

# ipcs -m -i 17235970
                                                                     

Outra observação útil é o valor de lpid – a ID do processo que teve contato com o segmento de memória compartilhada pela última vez. Para demonstrar o valor nesse atributo, use SQL*Plus para se conectar à instância de uma sessão diferente.

# sqlplus / as sysdba


Nessa sessão, descubra o PID do processo do servidor:

SQL> select spid from v$process
  2  where addr = (select paddr from v$session
  3     where sid =
  4        (select sid from v$mystat where rownum < 2)
  5  );
 
SPID
------------------------
13224


Agora execute novamente o comando ipcs com base no mesmo segmento de memória compartilhada:

# ipcs -m -i 17235970
 
Shared memory Segment shmid=17235970
uid=500 gid=502 cuid=500        cgid=502
mode=0660       access_perms=0660
bytes=140509184 lpid=13224      cpid=27169      nattch=113
att_time=Fri Dec 19 23:38:09 2008  
det_time=Fri Dec 19 23:38:09 2008  
change_time=Sun Dec  7 05:03:10 2008


Observe o valor de lpid, que foi alterado do valor original 12225 para 13224. O lpid mostra o PID do último processo que teve contato com o segmento de memória compartilhada, e você viu como esse valor é alterado.

O comando em si oferece pouco valor. O comando seguinte – ipcrm – permite agir com base no resultado, conforme você verá na seção a seguir.

ipcrm

Agora que você identificou a memória compartilhada e outras métricas de IPC, o que fazer com elas? Você já viu alguma utilização antes, como identificar a memória compartilhada usada pelo Oracle, verificar se o parâmetro do kernel para memória compartilhada está definido e assim por diante. Outra aplicação comum é remover a memória compartilhada, a fila de mensagens de IPC ou as matrizes de semáforos.

Para remover um segmento de memória compartilhada, observe o shmid do resultado do comando ipcs. Use a opção –m para remover o segmento. Para remover o segmento com ID 3735562, use:

# ipcrm –m 3735562


Isso removerá a memória compartilhada. Você também pode usar esse procedimento para eliminar semáforos e filas de mensagens de IPC também (usando os parâmetros –s e –q).

Utilização para usuários Oracle

Às vezes, ao encerrar a instância do banco de dados, os segmentos de memória compartilhada podem não ser limpos completamente pelo kernel do Linux. A memória compartilhada descartada não é útil; mas ela trava os recursos do sistema, deixando menos memória disponível para os outros processos. Nesse caso, você pode verificar qualquer segmento de memória compartilhada que restou pertencente ao usuário “oracle” e removê-lo (se houver) usando o comando "ipcrm".

vmstat

Quando chamado, o avô de todas as exibições relacionadas a memória e processo, o vmstat, é executado e publica continuamente suas informações. Ele consiste em dois argumentos:

# vmstat <interval> <count>


<interval> é o intervalo em segundos entre duas execuções. <count> é a quantidade de repetições que o vmstat faz. A seguir está uma amostra quando queremos que o vmstat seja executado a cada cinco segundos e pare após a décima execução. Cada linha do resultado aparece depois de cinco segundos e mostra as estatísticas nesse momento.

# vmstat 5 10
 procs -----------memory---------- --swap-- ---io--- --system-- ----cpu----
 r  b    swpd   free   buff  cache si   so   bi   bo   in   cs  us sy id wa
 0  0 1087032 132500  15260 622488 89   19    9    3    0    0   4 10 82  5
 0  0 1087032 132500  15284 622464  0    0  230  151 1095  858   1  0 98  1
 0  0 1087032 132484  15300 622448  0    0  317   79 1088  905   1  0 98  0
… shows up to 10 times.

O resultado mostra muitas informações sobre os recursos do sistema. Vamos examiná-las detalhadamente:

procs

Mostra a quantidade de processos.

r

Processo no aguardo para ser executado. Quanto maior for a carga no sistema, maior será a quantidade de processos aguardando para fazer os ciclos da CPU serem executados.

b

Processos de hibernação que não podem ser interrompidos, também conhecidos como processos “bloqueados”. É mais provável que esses processos estejam aguardando I/O, mas também podem ser destinados a outra tarefa também.


Às vezes, há outra coluna também, com o título “w”, que mostra a quantidade de processos que podem ser executados mas foram destinados à área de swap.

Os números de “b” devem ser próximos de 0. Se o número de “w” for alto, talvez seja necessária mais memória.

O próximo bloco mostra as métricas de memória:

swpd

Quantidade de memória virtual ou memória de swap (em KB).

free

Quantidade de memória física livre (em KB).

buff

Quantidade de memória usada como buffer (em KB).

cache

Kilobytes de memória física usada como cache.


A memória de buffer é usada para armazenar metadados de arquivos como i-nodes e dados de dispositivos de bloco bruto. A memória de cache é usada para os dados dos arquivos em si.

O próximo bloco mostra a atividade de swap:

si

Índice no qual a memória faz swap de volta do disco para a RAM física (em KB/s).

so

Índice no qual a memória faz swap da RAM física para o disco (em KB/s).


O próximo bloco diminui a velocidade da atividade de I/O:

bi

Índice no qual o sistema envia dados aos dispositivos de bloco (em blocos/s).

bo

Índice no qual o sistema lê os dados dos dispositivos de bloco (em blocos/s).


O próximo bloco mostra as atividades relacionadas ao sistema:

in

Quantidade de interrupções recebidas pelo sistema por segundo.

cs

Índice de alternância de contexto no espaço do processo (em número/s).


O último bloco provavelmente é o mais usado – as informações sobre a carga da CPU:

us

Mostra a porcentagem de CPU gasta em processos do usuário. Os processos Oracle entram nessa categoria.

sy

Porcentagem da CPU usada pelos processos do sistema, como todos os processos raiz.

id

Porcentagem de CPU livre.

wa

Porcentagem gasta em “aguardar I/O”.


Vamos ver como interpretar esses valores. A primeira linha do resultado é uma média de todas as métricas desde que o sistema foi reiniciado. Assim, ignore essa linha, porque ela não mostra o status atual. As outras linhas mostram as métricas em tempo real.

O ideal é que a quantidade de processos em aguardo ou bloqueados (no título “procs”) seja 0 ou próxima de 0. Se a quantidade for alta, o sistema não terá recursos suficientes como CPU, memória ou I/O. Essas informações são úteis ao diagnosticar problemas de performance.

Os dados sob “swap” indicam se está havendo excesso de swap. Se esse for o caso, você poderá ter memória física inadequada. Você deve reduzir a demanda de memória ou aumentar a RAM física.

Os dados em “io” indicam o fluxo de dados de e para os discos. Isso mostra a quantidade de atividade no disco, o que não necessariamente indica algum problema. Se você vir algum número grande em “proc” e a coluna “b” (processos sendo bloqueados) e alto I/O, o problema poderá ser uma grave contenção de I/O.

As informações mais úteis estão no título “cpu”. A coluna “id” mostra a CPU ociosa. Se você subtrair esse número de 100, obterá a porcentagem de CPU em uso. Lembra-se do comando top descrito em outra parte desta série? Ele também mostra um número de porcentagem de CPU livre. A diferença é: o top mostra essa porcentagem livre para cada CPU, enquanto o vmstat mostra a visualização consolidada para todas as CPUs.

O comando vmstat também mostra a discriminação detalhada da utilização da CPU: quanto é usado pelo sistema Linux, quanto é usado por um processo de usuário e quanto está em aguardo para I/O. Com base nessa discriminação, é possível determinar o que está contribuindo para o consumo da CPU. Se a carga da CPU do sistema for alta, será que há algum processo raiz, como execução de backup?

A carga do sistema deve ser constante ao longo de um período de tempo. Se o sistema mostrar um número alto, use o comando top para identificar o processo do sistema que está consumindo CPU.

Utilização para Usuários Oracle

Os processos Oracle (os processos em segundo plano e os de servidor) e os processos do usuário (sqlplus, apache etc.) estão em “us”. Se esse número for alto, use o top para identificar os processos. Se a coluna “wa” mostrar um número alto, ela indicará que o sistema de I/O é incapaz de acompanhar a quantidade de leitura ou gravação. Isso pode acontecer eventualmente como consequência de picos em atualizações intensas no banco de dados, causando trocas de logs e um pico subsequente em processos de arquivamento. Mas se a coluna mostrar constantemente um número grande, talvez haja um gargalo de I/O.

Os bloqueios de I/O em um banco de dados Oracle podem causar sérios problemas. Além dos problemas de performance, o I/O lento pode causar lentidão nas gravações do arquivo de controle, o que pode fazer com que um processo aguarde para adquirir um enqueue no arquivo de controle. Se a espera for superior a 900 segundos, e o que está na espera for um processo crucial como o LGWR, ele derrubará a instância do banco de dados.

Se você perceber que há muito swap, talvez o SGA esteja dimensionado grande demais para se ajustar à memória física. Você deve reduzir o tamanho do SGA ou aumentar a memória física.

mpstat

Outro comando útil para obter estatísticas relacionadas a CPU é mpstat. A seguir está um exemplo de resultado:

# mpstat -P ALL 5 2
Linux 2.6.9-67.ELsmp (oraclerac1)       12/20/2008
 
10:42:38 PM CPU %user %nice %system %iowait  %irq  %soft  %idle   intr/s
10:42:43 PM all  6.89  0.00   44.76    0.10  0.10   0.10  48.05  1121.60
10:42:43 PM   0  9.20  0.00   49.00    0.00  0.00   0.20  41.60   413.00
10:42:43 PM   1  4.60  0.00   40.60    0.00  0.20   0.20  54.60   708.40
 
10:42:43 PM CPU %user %nice %system %iowait  %irq  %soft  %idle   intr/s
10:42:48 PM all  7.60  0.00   45.30    0.30  0.00   0.10  46.70  1195.01
10:42:48 PM   0  4.19  0.00    2.20    0.40  0.00   0.00  93.21  1034.53
10:42:48 PM   1 10.78  0.00   88.22    0.40  0.00   0.00   0.20   160.48
 
Average:    CPU %user %nice %system %iowait  %irq  %soft  %idle   intr/s
Average:    all  7.25  0.00   45.03    0.20  0.05   0.10  47.38  1158.34
Average:      0  6.69  0.00   25.57    0.20  0.00   0.10  67.43   724.08
Average:      1  7.69  0.00   64.44    0.20  0.10   0.10  27.37   434.17


O resultado mostra as várias estatísticas para as CPUs do sistema. As opções –P ALL direcionam o comando para exibir as estatísticas para todas as CPUs, e não apenas uma específica. Os parâmetros 5 2 direcionam o comando para que seja executado a cada 5 segundos e por duas vezes. O resultado anterior mostra as métricas para todas as CPUs primeiro (agregadas) e para cada CPU individualmente. Por último, a média de todas as CPUs foi mostrada ao final.

Vamos ver o significado dos valores das colunas:

%user

Indica a porcentagem do processamento dessa CPU consumida pelos processos do usuário. Os processos do usuário não envolvem kernel e são usados para aplicativos, como um banco de dados Oracle. Nesse exemplo de resultado, a porcentagem de CPU do usuário é muito baixa.

 

 

%nice

Indica a porcentagem da CPU quando um processo sofreu downgrade pelo comando nice. O comando nice foi descrito em uma parte anterior desta série. Em resumo, ele altera a prioridade de um processo.

 

 

%system

Indica a porcentagem de CPU consumida pelos processos do kernel.

 

 

%iowait

Mostra a porcentagem do tempo de CPU consumido aguardando a ocorrência de I/O.

 

 

%irq

Indica a porcentagem de CPU usada para manipular interrupções de sistema.

 

 

%soft

Indica a porcentagem consumida para as interrupções de software.

 

 

%idle

Mostra o tempo ocioso da CPU.

 

 

%intr/s

Mostra o número total de interrupções recebidas pela CPU por segundo.


Talvez você esteja se perguntando qual é a finalidade do comando mpstat se já há o vmstat, descrito anteriormente. Há uma enorme diferença: o mpstat pode mostrar as estatísticas por processador, enquanto o vmstat mostra uma visualização consolidada de todos os processadores. Assim, é possível que um aplicativo mal escrito que não usa arquitetura multithreaded seja executado em um computador com vários processadores, mas não use todos. Consequentemente, uma CPU se sobrecarrega, enquanto as outras permanecem livres. Você pode diagnosticar facilmente esses tipos de problemas com o mpstat.

Utilização para Usuários Oracle

De maneira semelhante ao vmstat, o comando mpstat também produz estatísticas relativas à CPU, portanto toda a discussão relacionada a problemas de CPU aplica-se também ao mpstat. Quando você vê um baixo número %idle, sabe que há privação de CPU. Quando você vê um número %iowait mais alto, sabe que há algum problema com o subsistema de I/O na carga atual. Essas informações são bastante oportunas para resolver problemas na performance do banco de dados Oracle.

iostat

Uma parte crucial da avaliação de performance é a performance do disco. O comando iostat fornece as métricas de performance das interfaces de armazenamento.

# iostat
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)     12/27/2008
 
avg-cpu:  %user   %nice    %sys %iowait   %idle
          15.71    0.00    1.07    3.30   79.91
 
Device:           tps   Blk_read/s  Blk_wrtn/s   Blk_read   Blk_wrtn
cciss/c0d0       4.85        34.82      130.69  307949274 1155708619
cciss/c0d0p1     0.08         0.21        0.00    1897036       3659
cciss/c0d0p2    18.11        34.61      130.69  306051650 1155700792
cciss/c0d1       0.96        13.32       19.75  117780303  174676304
cciss/c0d1p1     2.67        13.32       19.75  117780007  174676288
sda              0.00         0.00        0.00        184          0
sdb              1.03         5.94       18.84   52490104  166623534
sdc              0.00         0.00        0.00        184          0
sdd              1.74        38.19       11.49  337697496  101649200
sde              0.00         0.00        0.00        184          0
sdf              1.51        34.90        6.80  308638992   60159368
sdg              0.00         0.00        0.00        184          0
... and so on ...


A parte inicial do resultado mostra métricas como CPU livre e esperas de I/O conforme se viu com o comando mpstat.

A parte seguinte do resultado mostra métricas muito importantes para cada um dos dispositivos de disco no sistema. Vamos ver o significado dessas colunas:

Device

O nome do dispositivo.

tps  

Quantidade de transferências por segundo, ou seja, quantidade de operações de I/O por segundo. Observação: esta é apenas a quantidade de operações de I/O; cada operação pode ser grande ou pequena.

Blk_read/s  

Quantidade de blocos lidos deste dispositivo por segundo. Os blocos normalmente têm 512 bytes de tamanho. Esse é um valor melhor da utilização do disco.

Blk_wrtn/s  

Quantidade de blocos gravados neste dispositivo por segundo.

Blk_read  

Quantidade de blocos lidos deste dispositivo até o momento. Atenção, pois isso não é o que está acontecendo neste exato momento. Esses muitos blocos já foram lidos do dispositivo. É possível que nada esteja sendo lido agora. Monitore este comando por algum tempo para saber se houve alguma alteração.

Blk_wrtn

Quantidade de blocos gravados no dispositivo.


Em um sistema com muitos dispositivos, o resultado pode ocupar várias telas – dificultando um pouco a investigação, principalmente se você estiver procurando um dispositivo específico. Você pode obter as métricas de um dispositivo específico passando-o como um parâmetro.

# iostat sdaj   
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)     12/27/2008
 
avg-cpu:  %user   %nice    %sys %iowait   %idle
          15.71    0.00    1.07    3.30   79.91
 
Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sdaj              1.58        31.93        10.65  282355456   94172401


As métricas de CPU mostradas no início podem não ser muito úteis. Para suprimir as estatísticas relacionadas à CPU mostradas no início do resultado, use a opção -d.
 
Você pode colocar parâmetros opcionais no final para que o iostat exiba as estatísticas do dispositivo em intervalos regulares. Para obter as estatísticas desse dispositivo a cada 5 segundos por 10 vezes, emita o seguinte código:

# iostat -d sdaj 5 10

You can display the stats in kilobytes instead of just bytes using
the -k option:

# iostat -k -d sdaj    
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)     12/27/2008
 
Device:            tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn
sdaj              1.58        15.96         5.32  141176880   47085232


Apesar de o resultado acima ter sua utilidade, há muitas informações não exibidas imediatamente. Por exemplo, uma das principais causas dos problemas de disco é o tempo de serviço de disco, ou seja, a velocidade com que o disco obtém os dados para o processo que os está solicitando. Para obter esse nível de métricas, é preciso obter as estatísticas “estendidas” sobre o disco, usando a opção -x.

# iostat -x sdaj
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)     12/27/2008
 
avg-cpu:  %user   %nice    %sys %iowait   %idle
          15.71    0.00    1.07    3.30   79.91
 
Device:    rrqm/s wrqm/s   r/s   w/s  rsec/s  wsec/s    rkB/s  ...  
sdaj         0.00   0.00  1.07  0.51   31.93   10.65    15.96  ... 

 

Device: wkB/s avgrq-sz avgqu-sz   await  svctm  %util
sadj     5.32    27.01     0.01    6.26   6.00   0.95


Vamos ver o significado dessas colunas:

Device  

O nome do dispositivo.

rrqm/s

A quantidade de solicitações de leitura combinadas por segundo. As solicitações de disco são enfileiradas. Sempre que possível, o kernel tenta fundir várias solicitações em uma. Essa métrica mede as solicitações de fusão para transferências de leitura.

wrqm/s  

De maneira semelhante às leituras, é a quantidade de solicitações de gravação que foram fundidas.

r/s  

A quantidade de solicitações de leitura por segundo emitidas para este dispositivo.

w/s 

De maneira semelhante, a quantidade de solicitações de gravação por segundo.

rsec/s 

A quantidade de setores lidos deste dispositivo por segundo.

wsec/s   

A quantidade de setores gravados neste dispositivo por segundo.

rkB/s   

Dados lidos por segundo deste dispositivo, em kilobytes por segundo.

wkB/s

Dados gravados neste dispositivo, em kb/s.

avgrq-sz

Tamanho médio das solicitações de leitura, em setores.

avgqu-sz  

Extensão média da fila de solicitações para este dispositivo.

await 

Tempo decorrido médio (em milissegundos) do dispositivo para solicitações de I/O. É a soma do tempo de serviço e do tempo de espera na fila.

svctm 

Tempo de serviço médio (em milissegundos) do dispositivo.

%util

Utilização de largura de banda do dispositivo. Se estiver próximo de 100%, o dispositivo ficará saturado.


Bem, até agora foram dadas muitas informações e elas podem representar um desafio em relação a como usá-las com eficácia. A próxima seção mostra como usar o resultado.

Como usar o Resultado

Você pode usar uma combinação dos comandos para extrair algumas informações significativas do resultado. Lembre-se de que os discos podem ficar lentos ao obter a solicitação dos processos. O tempo que o disco leva para transmitir seus dados para a fila é chamado de tempo de serviço. Se quiser descobrir os discos que têm os maiores tempos de serviço, escreva:

# iostat -x | sort -nrk13
sdat         0.00   0.00  0.00  0.00    0.00    0.00   0.00  ...   
sdv          0.00   0.00  0.00  0.00    0.00    0.00   0.00  ...   
sdak         0.00   0.00  0.00  0.14    0.00    1.11   0.00  ...   
sdm          0.00   0.00  0.00  0.19    0.01    1.52   0.01  ...   

sdat         0.00  18.80  0.00 64.06   64.05    0.00
sdv          0.00  17.16  0.00 18.03   17.64    0.00
sdak         0.55   8.02  0.00 17.00   17.00    0.24
sdm          0.76   8.06  0.00 16.78   16.78    0.32
... and so on ...


Isso mostra que o sdat do disco tem o maior tempo de serviço (64,05 ms). Por que o valor é tão alto? As possibilidades seriam inúmeras, mas as mais prováveis são:

  1. O disco recebe muitas solicitações, por isso o tempo de serviço médio tem valor alto.
  2. O disco está sendo utilizado com a máxima largura de banda possível.
  3. O disco é inerentemente lento.

Observando o resultado, percebemos que as leituras/segundo e as gravações/segundo são 0.00 (praticamente nada está acontecendo), por isso podemos excluir a possibilidade nº 1. A utilização também é 0.00% (última coluna), portanto a possibilidade nº 2 também está fora. Sobra a possibilidade nº 3. Entretanto, antes de tirarmos uma conclusão de que o disco é inerentemente lento, precisamos observar um pouco mais atentamente o disco. Podemos examiná-lo sozinho a cada 5 segundos por 10 vezes.

# iostat -x sdat 5 10


Se o resultado mostrar o mesmo tempo de serviço médio, índice de leituras e utilização, poderemos concluir que a possibilidade nº 3 é o fator mais provável. Se esses aspectos mudarem, poderemos obter outras pistas para entender por que o tempo de serviço tem valor alto para este dispositivo.

De maneira semelhante, você pode classificar na coluna de índice de leituras para exibir o disco sob índices de leituras constantes.

# iostat -x | sort -nrk6 
sdj          0.00   0.00   1.86  0.61  56.78   2.80   ... 
sdah         0.00   0.00   1.66  0.52  50.54  10.94   ... 
sdd          0.00   0.00   1.26  0.48  38.18  11.49   ... 

sdj         28.39   6.40  28.22  0.03  10.69   9.99   2.46
sdah        25.27   5.47  28.17  0.02  10.69  10.00   2.18
sdd         19.09   5.75  28.48  0.01   3.57   3.52   0.61

... and so on ...
   

As informações ajudam a localizar um disco que está “dinâmico” – ou seja, sujeito a inúmeras leituras ou gravações. Se o disco realmente estiver dinâmico, você deverá identificar o motivo disso; talvez um sistema de arquivos definido no disco esteja sujeito a inúmeras leituras. Se esse for o caso, você deverá considerar a execução de striping do sistema de arquivos em muitos discos para distribuir a carga, minimizando a possibilidade de que um disco específico fique dinâmico.

sar

Com base nas discussões anteriores, surge uma questão em comum: obter as métricas em tempo real não é o único ponto importante; a tendência histórica é igualmente importante.

Além disso, considere esta situação: quantas vezes alguém relata um problema de performance, mas quando paramos para investigá-lo, tudo está normal? Problemas de performance que ocorreram no passado são de difícil diagnóstico sem dados específicos a partir dessa época. Por fim, você vai querer examinar os dados de performance dos últimos dias para decidir sobre algumas configurações ou fazer ajustes.

O utilitário sar realiza essa meta. O sar é um acrônimo de System Activity Recorder, que grava as métricas dos principais componentes do sistema Linux – CPU, memória, discos, rede etc. – em um lugar especial: o diretório /var/log/sa. Os dados são gravados para cada dia em um arquivo chamado sa<nn>, onde <nn> é o dia do mês com dois dígitos. Por exemplo, o arquivo sa27 guarda os dados do dia 27 desse mês. Esses dados podem ser consultados pelo comando sar.

A maneira mais simples de usar o sar é sem nenhum argumento ou opção. A seguir está um exemplo:

# sar
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)     12/27/2008
 
12:00:01 AM       CPU    %user    %nice   %system   %iowait    %idle
12:10:01 AM       all    14.99     0.00      1.27      2.85    80.89
12:20:01 AM       all    14.97     0.00      1.20      2.70    81.13
12:30:01 AM       all    15.80     0.00      1.39      3.00    79.81
12:40:01 AM       all    10.26     0.00      1.25      3.55    84.93
... and so on ...


O resultado mostra as métricas relacionadas à CPU coletadas em intervalos de 10 minutos.
O significado das colunas é:

CPU

O identificador da CPU; “all” significa todas as CPUs.

%user

A porcentagem de CPU usada para processos do usuário. Os processos Oracle entram nesta categoria.

%nice

A porcentagem da utilização de CPU durante a execução em prioridade de nice.

%system

A porcentagem da CPU que executa processos de sistema.

%iowait

A porcentagem de CPU que aguarda I/O.

%idle

A porcentagem de CPU ociosa que aguarda o trabalho.


Com base no resultado anterior, você pode ver que o sistema está bem equilibrado; aliás, bastante subutilizado (conforme visto pelo alto nível de número ocioso da porcentagem). Prosseguindo pelo resultado, vemos:

... continued from above ...
03:00:01 AM       CPU     %user     %nice   %system   %iowait     %idle
03:10:01 AM       all     44.99      0.00      1.27      2.85     40.89
03:20:01 AM       all     44.97      0.00      1.20      2.70     41.13
03:30:01 AM       all     45.80      0.00      1.39      3.00     39.81
03:40:01 AM       all     40.26      0.00      1.25      3.55     44.93
... and so on ...


Isso indica uma situação diferente: o sistema foi carregado por alguns processos do usuário entre 3:00 e 3:40. Talvez uma consulta cara estivesse em execução; ou talvez um trabalho de RMAN estivesse em execução, consumindo toda essa CPU. É nessa hora que o comando sar é útil – ele reproduz os dados gravados mostrando os dados a partir de uma determinada hora, e não a partir de agora. Isso é exatamente o que você queria para realizar os três objetivos descritos no início desta seção: obter dados históricos, encontrar padrões de uso e entender as tendências.

Para ver os dados sar de um dia específico, basta abrir o sar com esse nome de arquivo, usando a opção -f conforme mostrado abaixo (para abrir os dados do dia 26)

# sar -f /var/log/sa/sa26


O resultado também pode exibir dados em tempo real, de maneira semelhante a vmstat ou mpstat.

Para obter os dados a cada 5 segundos por 10 vezes, use:

# sar 5 10
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)     12/27/2008
 
01:39:16 PM       CPU     %user     %nice   %system   %iowait     %idle
01:39:21 PM       all     20.32      0.00      0.18      1.00     78.50
01:39:26 PM       all     23.28      0.00      0.20      0.45     76.08
01:39:31 PM       all     29.45      0.00      0.27      1.45     68.83
01:39:36 PM       all     16.32      0.00      0.20      1.55     81.93
… and so on 10 times …

Você notou o valor “all” em CPU? Isso significa que as estatísticas foram introduzidas para todas as CPUs. Não há problema quando isso ocorre em um sistema com um único processador, mas em sistemas com
vários processadores, talvez você deseje estatísticas para CPUs individuais, além de uma agregada também. A opção -P ALL faz isso.

#sar -P ALL 2 2
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)     12/27/2008
 
01:45:12 PM       CPU     %user     %nice   %system   %iowait     %idle
01:45:14 PM       all     22.31      0.00     10.19      0.69     66.81
01:45:14 PM         0      8.00      0.00     24.00      0.00     68.00
01:45:14 PM         1     99.00      0.00      1.00      0.00      0.00
01:45:14 PM         2      6.03      0.00     18.59      0.50     74.87
01:45:14 PM         3      3.50      0.00      8.50      0.00     88.00
01:45:14 PM         4      4.50      0.00     14.00      0.00     81.50
01:45:14 PM         5     54.50      0.00      6.00      0.00     39.50
01:45:14 PM         6      2.96      0.00      7.39      2.96     86.70
01:45:14 PM         7      0.50      0.00      2.00      2.00     95.50
 
01:45:14 PM       CPU     %user     %nice   %system   %iowait     %idle
01:45:16 PM       all     18.98      0.00      7.05      0.19     73.78
01:45:16 PM         0      1.00      0.00     31.00      0.00     68.00
01:45:16 PM         1     37.00      0.00      5.50      0.00     57.50
01:45:16 PM         2     13.50      0.00     19.00      0.00     67.50
01:45:16 PM         3      0.00      0.00      0.00      0.00    100.00

01:45:16 PM         4      0.00      0.00      0.50      0.00     99.50
01:45:16 PM         5     99.00      0.00      1.00      0.00      0.00
01:45:16 PM         6      0.50      0.00      0.00      0.00     99.50
01:45:16 PM         7      0.00      0.00      0.00      1.49     98.51
 
Average:          CPU     %user     %nice   %system   %iowait     %idle
Average:          all     20.64      0.00      8.62      0.44     70.30
Average:            0      4.50      0.00     27.50      0.00     68.00
Average:            1     68.00      0.00      3.25      0.00     28.75
Average:            2      9.77      0.00     18.80      0.25     71.18
Average:            3      1.75      0.00      4.25      0.00     94.00
Average:            4      2.25      0.00      7.25      0.00     90.50
Average:            5     76.81      0.00      3.49      0.00     19.70
Average:            6      1.74      0.00      3.73      1.49     93.03
Average:            7      0.25      0.00      1.00      1.75     97.01


O resultado mostra o identificador de CPU (a partir de 0) e as estatísticas para cada um. Bem no final do resultado, você verá a média de execuções com base em cada CPU.

O comando sar não serve apenas para estatísticas relacionadas à CPU. Ele é útil para obter as estatísticas relacionadas à memória também. A opção -r mostra a utilização de memória extensiva.

# sar -r
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)     12/27/2008
 
12:00:01 AM kbmemfree kbmemused  %memused kbbuffers  ...
12:10:01 AM    712264  32178920     97.83   2923884  ...
12:20:01 AM    659088  32232096     98.00   2923884  ...
12:30:01 AM    651416  32239768     98.02   2923920  ...
12:40:01 AM    651840  32239344     98.02   2923920  ...
12:50:01 AM    700696  32190488     97.87   2923920  ...

 

12:00:01 AM  kbcached kbswpfree kbswpused  %swpused  kbswpcad
12:10:01 AM  25430452  16681300     95908      0.57       380
12:20:01 AM  25430968  16681300     95908      0.57       380
12:30:01 AM  25431448  16681300     95908      0.57       380
12:40:01 AM  25430416  16681300     95908      0.57       380
12:50:01 AM  25430416  16681300     95908      0.57       380



Vamos ver o significado de cada coluna:

kbmemfree

A memória livre disponível em KB nessa hora.

kbmemused 

A memória usada em KB nessa hora.

%memused

A porcentagem de memória usada.

kbbuffers 

Essa porcentagem de memória foi usada como buffer.

kbcached

Essa porcentagem de memória foi usada como cache.

kbswpfree

O espaço de swap livre em KB nessa hora.

kbswpused 

O espaço de swap usado em KB nessa hora.

%swpused 

A porcentagem de swap usada nessa hora.

kbswpcad

O swap em cache em KB nessa hora.


Bem no final do resultado, você verá o número médio para o período de tempo.

Você também pode obter estatísticas relacionadas à memória. A opção -B mostra a atividade relacionada à paginação.

# sar -B
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)     12/27/2008
 
12:00:01 AM  pgpgin/s pgpgout/s   fault/s  majflt/s
12:10:01 AM    134.43    256.63   8716.33      0.00
12:20:01 AM    122.05    181.48   8652.17      0.00
12:30:01 AM    129.05    253.53   8347.93      0.00
... and so on ...


A coluna mostra as métricas nessa hora, e não na hora atual.

pgpgin/s

A quantidade de paginação do disco para a memória, por segundo.

pgpgout/s

A quantidade de paginação da memória para o disco, por segundo.

fault/s

Falhas de página por segundo.

majflt/s

Principais falhas de página por segundo.


Para obter um resultado semelhante para atividades relacionadas a swap, você pode usar a opção -W.

# sar -W
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)   12/27/2008
 
12:00:01 AM  pswpin/s pswpout/s
12:10:01 AM      0.00      0.00
12:20:01 AM      0.00      0.00
12:30:01 AM      0.00      0.00
12:40:01 AM      0.00      0.00
... and so on ...


As colunas provavelmente são autoexplicativas, mas a seguir está a descrição de cada uma:

pswpin/s

Páginas de memória com swap de volta do disco para a memória, por segundo.

pswpout/s

Páginas de memória com swap de volta da memória para o disco, por segundo.


Se você perceber muito swap, poderá estar com a memória baixa. Não se trata de uma conclusão inevitável, mas sim de uma forte possibilidade.

Para obter as estatísticas do dispositivo de disco, use a opção -d:

# sar -d
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)     12/27/2008
 
12:00:01 AM       DEV       tps  rd_sec/s  wr_sec/s
12:10:01 AM    dev1-0      0.00      0.00      0.00
12:10:01 AM    dev1-1      5.12      0.00    219.61
12:10:01 AM    dev1-2      3.04     42.47     22.20
12:10:01 AM    dev1-3      0.18      1.68      1.41
12:10:01 AM    dev1-4      1.67     18.94     15.19
... and so on ...
Average:      dev8-48      4.48    100.64     22.15
Average:      dev8-64      0.00      0.00      0.00
Average:      dev8-80      2.00     47.82      5.37
Average:      dev8-96      0.00      0.00      0.00
Average:     dev8-112      2.22     49.22     12.08


A seguir está a descrição das colunas. Recapitulando, elas mostram as métricas nessa hora.

tps

Transferências por segundo. Transferências são operações de I/O. Observação: trata-se apenas de quantidade de operações; cada operação pode ser grande ou pequena. Assim, este parâmetro, por si só, não informa todos os aspectos.

rd_sec/s

Quantidade de setores lidos do disco por segundo.

wr_sec/s

Quantidade de setores gravados no disco por segundo.


Para obter as estatísticas de rede históricas, use a opção -n:

# sar -n DEV | more
Linux 2.6.9-42.0.3.ELlargesmp (prolin3)     12/27/2008
 
12:00:01 AM IFACE rxpck/s txpck/s rxbyt/s  txbyt/s rxcmp/s txcmp/s rxmcst/s
12:10:01 AM   lo    4.54    4.54   782.08   782.08  0.00    0.00     0.00
12:10:01 AM eth0    2.70    0.00   243.24     0.00  0.00    0.00     0.99
12:10:01 AM eth1    0.00    0.00     0.00     0.00  0.00    0.00     0.00
12:10:01 AM eth2    0.00    0.00     0.00     0.00  0.00    0.00     0.00
12:10:01 AM eth3    0.00    0.00     0.00     0.00  0.00    0.00     0.00
12:10:01 AM eth4  143.79  141.14 73032.72 38273.59  0.00    0.00     0.99
12:10:01 AM eth5    0.00    0.00     0.00     0.00  0.00    0.00     0.00
12:10:01 AM eth6    0.00    0.00     0.00     0.00  0.00    0.00     0.00
12:10:01 AM eth7    0.00    0.00     0.00     0.00  0.00    0.00     0.00
12:10:01 AM bond0 146.49  141.14 73275.96 38273.59  0.00    0.00     1.98
… and so on …
Average:    bond0 128.73  121.81 85529.98 27838.44  0.00    0.00     1.98
Average:    eth8    0.00    0.00     0.00     0.00  0.00    0.00     0.00
Average:    eth9    3.52    6.74   251.63 10179.83  0.00    0.00     0.00
Average:    sit0    0.00    0.00     0.00     0.00  0.00    0.00     0.00

Em resumo, você tem estas opções para o comando sar obter as métricas dos componentes:

Use esta opção …

… para obter estatísticas sobre:

-P

CPU(s) específica(s)

-d

Discos

-r

Memória

-B

Paginação

-W

Swap

-n

Rede


E se você quiser obter todas as estatísticas disponíveis em um único resultado? Em vez de chamar sar com todas essas opções, você pode usar a opção -A que mostra todas as estatísticas armazenadas nos arquivos sar.

Conclusão
Em resumo, usando esse conjunto limitado de comandos, você pode lidar com a maioria das tarefas envolvidas no gerenciamento de recursos em um ambiente Linux. Recomendo treinar esses comandos em seu ambiente para se familiarizar com eles, juntamente com as opções descritas neste artigo.

Nas próximas partes desta série, você aprenderá a monitorar e gerenciar a rede. Também aprenderá vários comandos que ajudam a gerenciar um ambiente Linux: descobrir quem fez login, definir perfis de shell, fazer backup usando cpio e tar e assim por diante.

Leituras Adicionais



Arup Nanda ( arup@proligence.com), é exclusivamente DBA Oracle há mais de 12 anos, com experiência em todas as áreas da tecnologia do Banco de Dados Oracle, tendo sido nomeado "DBA do Ano" pela Oracle Magazine em 2003. Arup é palestrante frequente e redator em eventos e diários relacionados à Oracle, além de Director Oracle ACE.