miércoles, 27 de mayo de 2015

Guía para Maestría Avanzada en Comandos Linux, Parte 3: Administración de Recursos



Guía para Maestría Avanzada en Comandos Linux, Parte 3: Administración de Recursos


por Arup Nanda ACE
Publicado en mayo de 2009
En esta entrega, aprenda los comandos avanzados de Linux para monitorear componentes físicos
Un sistema Linux está conformado por varios componentes físicos clave como CPU, memorias, tarjetas de red y dispositivos de almacenamiento. Para administrar de manera efectiva el entorno Linux, usted debería poder evaluar varias métricas de estos recursos—cuánto procesa cada componente, si existen cuellos de botella, entre otras cosas —con una precisión razonable.
En otras partes de esta serie usted aprendió algunos comandos para medir las métricas en un nivel macro. En esta entrega, no obstante, aprenderá los comandos avanzados de Linux para monitorear componentes físicos. En especial, aprenderá acerca de los comandos en las siguientes categorías:
ComponentCommands
Memoryfree, vmstat, mpstat, iostat, sar
CPUvmstat, mpstat, iostat, sar
I/Ovmstat, mpstat, iostat, sar
Processesipcs, ipcrm

Como puede observar, algunos comandos aparecen en más de una categoría. Esto se debe a que los comandos pueden desempeñar muchas tareas. Algunos comandos se ajustan mejor a otros componentes –por ej., iostat para I/O—pero debería comprender las diferencias en sus trabajos y utilizar aquellos con los que se sienta más cómodo.
En la mayoría de los casos, un solo comando no es útil para comprender lo que realmente está sucediendo. Usted debería conocer múltiples comandos para obtener la información que desea.

"free"

Una pregunta común es, “¿Cuánta memoria está siendo utilizada por mis aplicaciones y los distintos servidores, usuarios y procesos de sistemas?” O, “¿Cuánto espacio de memoria tengo libre en este momento?” Si la memoria utilizada por los procesos en ejecución es mayor la memoria RAM disponible, los procesos se trasladan a la memoria swap (memoria virtual). Por lo tanto, una pregunta complementaria sería, “¿Qué cantidad de memoria swap se está utilizando?”.
El comando “free” responde a todas estas preguntas. Es más, una opción muy útil, –m , muestra la memoria libre en megabytes:
# free -m
             total       used       free     shared    buffers     cached
Mem:          1772       1654        117          0         18        618
-/+ buffers/cache:       1017        754
Swap:         1983       1065        918

El output muestra que el sistema tiene 1.772 MB de RAM, de los cuales se utilizan 1.654 MB, dejando 117 MB de memoria libre. La segunda línea muestra los cambios de tamaño de caché y buffers en la memoria física. La tercera línea muestra la utilización de memoria swap.
Para expresar lo mismo en kilobytes y gigabytes, reemplace la opción -m con -k o -g respectivamente. Usted puede colocarse en el nivel de bytes también, utilizando la opción –b.
# free -b
             total       used       free     shared    buffers     cached
Mem:    1858129920 1724039168  134090752          0   18640896  643194880
-/+ buffers/cache: 1062203392  795926528
Swap:   2080366592 1116721152  963645440

La opción –t muestra el total al final del output (suma de memoria física más 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

A pesar de que “free” no muestra los porcentajes, podemos extraer y formatear partes específicas del output para mostrar la memoria utilizada como porcentaje del total solamente:
# free -m | grep Mem | awk '{print ($3 / $2)*100}' 
98.7077
Esto viene bien para los shell scripts en donde las cantidades específicas son importantes. Por ejemplo, usted quizás quiera generar un alerta cuando el porcentaje de memoria libre descienda por debajo de cierto límite.
De modo similar, para encontrar el porcentaje de swap utilizado, usted puede emitir:
free -m | grep -i Swap | awk '{print ($3 / $2)*100}'

Puede utilizar free para observar la carga de memoria empleada por una aplicación. Por ejemplo, controle la memoria libre antes de iniciar una aplicación de backup y luego contrólela inmediatamente luego de iniciarla. La diferencia podría atribuirse al consumo por parte de la aplicación de backup.

Para Usuarios de Oracle

Entonces, ¿cómo puede utilizar este comando para administrar el servidor Linux que ejecuta su entorno de Oracle? Una de las causas más comunes de los problemas de desempeño es la falta de memoria, lo que provoca que el sistema “intercambie” áreas de memoria en el disco de manera temporal. Cierto grado de intercambio es probablemente inevitable pero experimentar una gran cantidad de intercambio puede indicar falta de memoria libre.
En cambio, usted puede utilizar free para obtener información de la memoria libre y ahora hacer el seguimiento con el comando sar (que se muestra luego) para controlar la tendencia histórica del consumo de memoria y swap. Si el uso de swap es temporario, es probable que se trate de un pico (spike) por única vez; pero si se declara durante un período de tiempo, debería hacerlo notar. Existen algunas sospechas posibles y obvias de sobrecarga crónica de memoria:
  • SGA más amplia que la memoria disponible
  • Amplia asignación en PGA
  • Algunos procesos con bugs que producen la fuga de de memoria
Para el primer caso, usted debería asegurarse de que SGA sea menor a la memoria disponible. La regla general es utilizar alrededor del 40 por ciento de la memoria física para SGA, no obstante, debería definir ese parámetro sobre la base de su situación específica. En el segundo caso, usted debería intentar reducir la amplia asignación de buffers en consultas. En el tercer caso debería utilizar el comando “ps” (descripto en entregas anteriores de esta serie) para identificar el proceso específico que podría producir la fuga de memoria.

"ipcs"

Cuando se ejecuta un proceso, se adopta desde la “memoria compartida”. Puede haber uno o muchos segmentos de memoria compartida por proceso. Los procesos intercambian mensajes entre ellos (“comunicaciones entre procesos”, o IPC) y utilizan semáforos. Para desplegar información sobre segmentos de memoria compartida, colas de mensajes IPC y semáforos, usted puede utilizar un solo comando: ipcs.
La opción –m es muy conocida; despliega los segmentos de memoria compartida.
# 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         

Este output, tomado de un servidor que ejecuta software de Oracle, muestra los distintos segmentos de memoria compartida. Cada uno se identifica exclusivamente por un ID de memoria compartida, y se muestra en la columna “shmid”. (Más adelante verá cómo utilizar el valor de esta columna.) El “owner”, por supuesto, muestra el propietario del segmento, la columna “perms” muestra los permisos (igual que los permisos unix), y “bytes” muestra el tamaño de los bytes.
La opción -u muestra un breve resumen:
# ipcs -mu

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

La opción –l muestra los límites (en contraposición a los valores actuales):
# 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

Si usted ve que los valores reales se acercan o se encuentran en el límite, debería extender ese límite.
Puede obtener un panorama detallado de un segmento de memoria compartida utilizando el valor shmid. La opción –i logra esto. Usted verá los detalles de 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    

Más adelante verá un ejemplo de cómo interpretar el output de arriba.
La opción -s muestra los semáforos en el sistema:
# ipcs -s
 
------ Semaphore Arrays --------
key        semid      owner      perms      nsems     
0x313f2eb8 1146880    oracle    660        104       
0x0b776504 2326529    oracle    660        154     
… and so on …  

Esto muestra algunos de datos valiosos. Se observa que el grupo de semáforos de ID 1146880 posee 104 semáforos, y el otro tiene 154. Si usted los suma, el valor total debe ser menor al límite máximo definido por el parámetro kernel (semmax). Mientras se instala el software de la Base de Datos de Oracle, el controlador de preinstalación debe controlar los parámetros para semmax. Luego, cuando el sistema alcanza el estado seguro, usted puede controlar la utilización real y luego ajustar el valor kernel de manera adecuada.

Para Usuarios de Oracle

¿Cómo puede descubrir los segmentos de memoria compartida utilizados por la instancia de Base de Datos de Oracle? Para lograrlo, utilice el comando oradebug. Primero conéctese a la base de datos como sysdba:
# sqlplus / as sysdba

En el SQL, utilice el comando oradebug como se muestra abajo:
SQL> oradebug setmypid
Statement processed.
SQL> oradebug ipc
Information written to trace file.

Para descubrir el nombre del archivo de rastreo:
SQL> oradebug TRACEFILE_NAME
/opt/oracle/diag/rdbms/odba112/ODBA112/trace/ODBA112_ora_22544.trc

Ahora, si abre un archivo de rastreo, usted verá los IDs de la memoria compartida. Aquí se muestra un extracto del archivo:
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 ... 

El ID de memoria compartida se muestra en letra mayúsculas rojas. Usted puede utilizar este ID de memoria compartida para obtener los detalles de la memoria compartida:
# ipcs -m -i 17235970
Otra observación útil es el valor de lpid – el ID del proceso que por última vez alcanzó el segmento de memoria compartida. Para demostrar el valor en ese atributo, utilice SQL*Plus para conectarse a la instancia desde una sesión distinta.
# sqlplus / as sysdba

En esa sesión, descubra el PID del proceso del 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

Ahora vuelva a ejecutar el comando “ipcs” frente al mismo segmento de memoria compartida:
# 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

Preste atención al valor de “lpid”, que fue cambiado a 13224 desde el valor original 12225. El “lpid” muestra el PID del último proceso que alcanzó el segmento de memoria compartida, y observe cómo cambiaron los valores.
El comando por sí mismo, ofrece poco valor. El próximo comando – ipcrm – le permite actuar en base al output, como verá en la próxima sección.

ipcrm

Ahora que ha identificado la memoria compartida y demás métricas de IPC ¿qué hacer con ellas? Usted ya ha conocido su uso, por ejemplo, identificar le memoria compartida utilizada por Oracle, asegurar que el parámetro kernel para la memoria compartida haya sido establecido, etc. Otra aplicación común es eliminar la memoria compartida, la cola de mensajes IPC, o los grupos de semáforos.
Para eliminar el segmento de memoria compartida, observe su “shmid” del output del comando “ipcs”. Luego utilice la opción –m para eliminar el segmento. Para remover el segmento con ID 3735562, utilice
# ipcrm –m 3735562

Esto eliminará la memoria compartida. Usted también puede utilizarlo para eliminar colas de mensajes IPC y semáforos (utilizando los parámetros –s y –q).

Para Usuarios de Oracle

Algunas veces cuando se cierra la instancia de base de datos, los segmentos de memoria compartida pueden no eliminarse por completo por el kernel de Linux. La memoria compartida que queda no es utilizada; no obstante, invade los recursos del sistema reduciendo la cantidad de memoria disponible para otros procesos. En ese caso, usted puede controlar cualquier segmento de memoria compartida persistente que posee el usuario “oracle” y luego eliminarlo, si corresponde, utilizando el comando ”ipcrm”.

vmstat

Cuando se invoca vmstat, denominado el “abuelo” de todas las visualizaciones relacionadas con procesos y memorias, continuamente ejecuta y entrega su información. Toma dos segmentos:
# vmstat  
es el intervalo en segundos entre dos ejecuciones. es la cantidad de repeticiones que vmstat realiza. Vea un ejemplo de cuando usted desea que vmstat se ejecute cada cinco segundos y se detenga luego de la décima vez. Cada línea en el output se despliega después de cinco segundos y muestra las estadísticas en ese 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.

El output muestra mucha información sobre los recursos del sistema. Veámoslos en detalle:
procsMuestra la cantidad de procesos
rProceso en espera para ser ejecutado. Cuanto mayor es la carga del sistema, mayor la cantidad de procesos que esperan que los ciclos de CPU se ejecuten.
bProcesos en espera ininterrumpible, también conocidos como procesos “bloqueados”. Estos procesos generalmente esperan una I/O, pero también podrían referirse a otras cosas.

Algunas veces hay otra columna que se denomina “w”, la cual muestra la cantidad de procesos que pueden ser ejecutados pero que se han intercambiado al área de swap.
La cantidad que muestra “b” debería ser cercana a 0. Si la cantidad que se muestra en “w” es elevada, usted puede necesitar más memoria.
El siguiente cuadro muestra las métricas de memoria::
swpdCantidad de memoria virtual o memoria swap (en KB)
freeCantidad de memoria física libre (en KB)
buffCantidad de memoria utilizada como buffer (en KB)
cacheKilobytes de memoria física utilizados como caché

La memoria de buffer se utiliza para almacenar metadatos de archivos como i-nodes y datos de dispositivos de bloques en bruto. La memoria de caché se utiliza para datos de archivos.
El siguiente cuadro muestra la actividad de swap:
siÍndice en el cual la memoria realiza el intercambio del disco a la RAM física (en KB/seg.)
soÍndice en el cual la memoria realiza el intercambio al disco desde la memoria RAM física (en KB/seg.)

El siguiente cuadro muestra la actividad de I/O:
biÍndice en el cual el sistema envía datos a los dispositivos de bloque (en bloques/seg.)
boÍndice en el cual el sistema lee los datos desde los dispositivos de bloque (en bloques/seg.)

El siguiente cuadro muestra las actividades relacionadas con el sistema:
inCantidad de interrupciones del sistema por segundo
csÍndice de cambios de contexto en el espacio del proceso (en cantidad /seg.)

El último cuadro es probablemente el más utilizado –información sobre la carga de CPU:
usMuestra el porcentaje de CPU utilizado en los procesos del usuario. Los procesos de Oracle se presentan en esta categoría.
syPorcentaje de CPU utilizado por los procesos del sistema, tales como los procesos de raíz
idPorcentaje de CPU libre
waPorcentaje utilizado en “espera por I/O”

Veamos cómo interpretar estos valores. La primera línea del output es un promedio de todas las métricas desde el reinicio del sistema. Por lo tanto, ignore esa línea ya que no muestra el estado real. Las demás líneas muestran las métricas en tiempo real.
De modo ideal, la cantidad de procesos en espera o bloqueados (bajo el encabezado “procs”) debería ser 0 o cercana a 0. Si ésta es elevada, entonces el sistema no tiene demasiados recursos como CPU, memoria o I/O. Esta información resulta útil al momento de diagnosticar los problemas de desempeño.
Los datos bajo “swap” indican si se está produciendo un exceso de intercambio. Si ese es el caso, entonces quizás tenga memoria física inadecuada. Usted debería reducir la demanda de memoria o aumentar la memoria RAM física.
Los datos bajo “io” indican el flujo de datos desde y hasta el disco. Esto muestra la actividad del disco, sin indicar necesariamente la existencia de algún problema. Si usted observa un número elevado en “proc” y luego en la columna “b” (procesos que están siendo bloqueados) y I/O elevado, el problema podría deberse a una contención I/O severa.
La información más útil se presenta en el encabezado “cpu”. La columna “id” muestra la CPU inactiva. Si usted resta 100 a esa cantidad, obtiene el porcentaje de CPU ocupada. ¿Recuerda el comando “top” descripto en otra entrega de esta serie? Ese también muestra el porcentaje de CPU libre. La diferencia es: el comando “top” muestra el porcentaje libre para cada CPU mientras que el vmstat muestra la visión consolidada de todas las CPU.
El comando “vmstat” también muestra el desglose del uso de CPU: qué cantidad es utilizada por el sistema Linux, qué cantidad por un proceso de usuarios y por la espera para  I/O. A partir de este desglose usted puede determinar qué contribuye al consumo de la CPU. Si la carga del sistema de CPU es alta, ¿podría haber algún proceso raíz como un backup en ejecución?
La carga del sistema debería ser consistente durante un período de tiempo. Si el sistema muestra una cantidad elevada, utilice el comando “top” para identificar el porcentaje de consumo de CPU.

Para Usuarios de Oracle

Los procesos de Oracle (los procesos de antecedentes y del servidor) y los procesos de usuarios (sqlplus, apache, etc.) figuran bajo “us”. Si esta cantidad es elevada, utilice “top” para identificar los procesos. Si la columna “wa” muestra una cantidad elevada, esto indica que el sistema I/O no puede alcanzar la cantidad de lectura o escritura. Esto podría ocasionalmente disparar un resultado de picos en actualizaciones a la base de datos, lo que podría causar un cambio de registro y un pico posterior en los procesos de archivo. Pero, si muestra consistentemente una cifra elevada,  entonces podría estar en presencia de un cuello de botella de I/O.
Las obstrucciones de I/O en una base de datos de Oracle pueden causar serios problemas. Aparte de los problemas de desempeño, el lento flujo de I/O podría provoca enlentecer las escrituras de “controlfile”, lo que provocaría la espera de un proceso hasta adquirir “controlfile” en cola. Si la espera es de más de 900 segundos, y un proceso crítico está en espera, como LGWR, se elimina la instancia de base de datos.
Si el nivel de intercambio (swapping) es elevado, tal vez el tamaño de SGA sea muy alto para ajustarse a la memoria física. Usted debería reducir el tamaño de SGA o aumentar la memoria física.

mpstat

Otro comando útil para obtener las estadísticas relacionadas con la CPU es “mpstat”. Aquí se muestra un ejemplo del output:
# mpstat -P ALL 5 2
Linux 2.6.9-67.ELsmp (oraclerac1)       12/20/2008
 
10:42:38PM  CPU  %user %nice %system %iowait %irq %soft  %idle    intr/s
10:42:43PM  all   6.89  0.00   44.76    0.10 0.10  0.10  48.05   1121.60
10:42:43PM    0   9.20  0.00   49.00    0.00 0.00  0.20  41.60    413.00
10:42:43PM    1   4.60  0.00   40.60    0.00 0.20  0.20  54.60    708.40
 
10:42:43PM  CPU  %user %nice %system %iowait %irq %soft  %idle    intr/s
10:42:48PM  all   7.60  0.00   45.30    0.30 0.00  0.10  46.70   1195.01
10:42:48PM    0   4.19  0.00    2.20    0.40 0.00  0.00  93.21   1034.53
10:42:48PM    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

Muestra las distintas estadísticas para las CPU del sistema. Las opciones –P ALL ordena al comando desplegar las estadísticas de todas las CPU, no solamente de una específica. Los parámetros 5 2 ordenan al comando ejecutarse cada 5 segundos y durante 2 veces. El output de arriba muestra las métricas para todas las primeras CPU (agrupadas) y para cada CPU individualmente. Finalmente, el porcentaje para todas las CPU se muestra al final.
Veamos el significado de los valores de las columnas:
%userIndica el porcentaje de procesamiento para la CPU consume por proceso de usuario. Los procesos de usuarios son procesos que no son kernel utilizados para aplicaciones como las de la base de datos de Oracle. En este output de ejemplo, el porcentaje de CPU de usuario es muy pequeño.
  
%niceIndica el porcentaje de CPU cuando un proceso ha bajado su categoría por el comando nice. El comando nice ha sido descripto en una entrega anterior. En resumen, el comando nice cambia la prioridad de un proceso.
  
%systemIndica el porcentaje de CPU utilizado por los procesos kernel
  
%iowaitMuestra el porcentaje de tiempo de CPU utilizado por la espera de I/O
  
%irqIndica el porcentaje de CPU utilizado para manejar las interrupciones del sistema
  
%softIndica el porcentaje utilizado para las interrupciones de software
  
%idleMuestra el tiempo de inactividad de la CPU
  
%intr/sMuestra la cantidad total de interrupciones que la CPU recibe por segundo

Usted podría preguntarse cuál es el propósito del comando mpstat cuando usted ya posee vmstat, descripto anteriormente. Existe una gran diferencia: mpstat puede mostrar las estadísticas por procesador, mientras que vmstat ofrece una visión consolidada de todos los procesadores. Por lo tanto, es posible que una aplicación escasamente escrita que no utilice una arquitectura de múltiples threads se ejecute sobre un motor de múltiples procesadores pero que no utilice todos los procesadores. Como resultado, se produce la sobrecarga de una CPU mientras que las demás permanecen libres. Usted puede diagnosticar fácilmente estas clases de problemas por medio de mpstat.

Para Usuarios de Oracle

De modo similar a vmstat, el comando mpstat también produce estadísticas relacionadas con la CPU de manera que todos los debates relacionados con los problemas de CPU también se aplican a mpstat. Cuando usted observa un bajo nivel de %idle, sabe que está en presencia de una insuficiencia de CPU. Cuando observa una cantidad de %iowait mayor, usted sabe que existe algún problema con el subsistema I/O en torno a la carga actual. Esta información resulta útil para resolver rápidamente los problemas de desempeño de la base de datos de Oracle.

iostat

Una parte clave de la evaluación de desempeño es el desempeño del disco. El comando iostat brinda las métricas de desempeño de las interfaces de almacenamiento.
# 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 ...

La primera parte del output muestra las métricas como el espacio de CPU libre y las esperas I/O como ha podido ver en el comando mpstat.
La próxima parte del output muestra métricas muy importantes para cada uno de los dispositivos de disco en el sistema. Veamos lo que significan estas columnas:
DeviceNombre del dispositivo
tps  Cantidad de transferencias por segundo, es decir, cantidad de operaciones I/O por segundo. Nota: esta es solamente la cantidad de operaciones I/O; cada operación podría ser extensa o pequeña.
Blk_read/s  Cantidad de bloques leídos desde este dispositivo por segundo. Generalmente los bloques tienen un tamaño de 512 bytes. Este es el mejor valor de utilización de disco.
Blk_wrtn/s  Cantidad de bloques escritos en este dispositivo por segundo
Blk_read  Cantidad de bloques leídos desde este dispositivo al momento. Preste atención; no se refiere a lo que está sucediendo en ese momento. Estos bloques ya fueron leídos desde el dispositivo. Es posible que no se esté leyendo nada en ese momento. Observe esto por un rato para ver si se producen cambios.
Blk_wrtnCantidad de bloques escritos en el dispositivo

En un sistema con muchos dispositivos, el output podría aparecer a través de varias pantallas—haciendo que las cosas sean un poco difícil de examinar, especialmente si busca un dispositivo específico. Usted puede obtener las métricas para un dispositivo específico solamente utilizando ese dispositivo como 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

Las métricas de CPU mostradas al comienzo pueden no ser demasiado útiles. Para eliminar las estadísticas relacionadas con la CPU en el comienzo del output, utilice la opción -d.

Usted puede establecer parámetros adicionales al final para que iostat despliegue las estadísticas de dispositivo en intervalos regulares. Para obtener las estadísticas para este dispositivo cada 5 segundos durante 10 veces, emita lo siguiente:
# 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

A pesar de que el output de arriba puede ser útil, aún queda demasiada información que no está lista para ser desplegada. Por ejemplo, una de las causas de los problemas de disco es el tiempo de servicio de disco, es decir, la rapidez con la que el disco obtiene los datos para el proceso que los pide. Para alcanzar ese nivel de métricas, debemos obtener las estadísticas “extendidas” en el disco, utilizando la opción -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   
sdaj     5.32    27.01     0.01    6.26   6.00   0.95


Veamos el significado de las columnas:
Device  Nombre del dispositivo
rrqm/sCantidad de solicitudes de lectura fusionas por segundo. Las solicitudes de disco que se colocan en cola. Cuando es posible, kernel intenta fusionar varias solicitudes en una. Esta métrica mide las transferencias de fusión de las solicitudes de lectura.
wrqm/s  Similar a la de lectura, esta es la cantidad de solicitudes de escritura fusionadas.
r/s  Cantidad de solicitudes de lectura por segundo emitidas en este dispositivo
w/s Del mismo modo, se refiere a la cantidad de solicitudes de escritura por segundo
rsec/s Cantidad de sectores leídos desde este dispositivo por segundo
wsec/s   Cantidad de sectores escritos en el dispositivo por segundo
rkB/s   Datos leídos por segundo desde este dispositivo, en kilobytes por segundo
wkB/sDatos escritos en este dispositivo, en kb/s
avgrq-szTamaño promedio de solicitudes de lectura, en sectores
avgqu-sz  Longitud promedio de la cola de solicitudes para este dispositivo
await Promedio de tiempo transcurrido (en milisegundos) para el dispositivo de solicitudes I/O. Esto es la suma del tiempo de servicio + el tiempo de espera en cola.
svctm Promedio del tiempo de servicio (en milisegundos) del dispositivo
%utilUtilización de ancho de banda del dispositivo. Si es cercano al 100%, el dispositivo está saturado.

Ahora bien, tanta información puede presentar un desafío sobre cómo utilizarla de manera efectiva. La próxima sección muestra cómo utilizar el output.

Cómo Utilizarlo

Puede utilizar una combinación de comandos para obtener información del output. Recuerde, los discos podrían demorar en obtener la solicitud de los procesos. La cantidad de tiempo que le lleva al disco obtener los datos desde el disco y hasta la cola se denomina tiempo de servicio. Si desea ver los discos con los tiempos de servicio más elevados, usted debe emitir:
# 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 ...

Esto muestra que el sdat de disco tiene el tiempo de servicio más elevado (64.05 ms). ¿Por qué es tan alto? Puede haber varias posibilidades pero posiblemente éstas sean las tres más importantes:
  1. El disco contiene muchas solicitudes, por lo tanto el tiempo de servicio promedio es alto
  2. El disco está utilizando el máximo de ancho de banda.
  3. El disco es inherentemente lento.
Al observar el output vemos que reads/sec y writes/sec es de 0.00 (no sucede prácticamente nada), por lo tanto podemos excluir la #1. La utilización también es de 0.00% (la última columna), por lo tanto podemos excluir la #2. Así queda la #3. No obstante, antes de llegar a la conclusión de que el disco es inherentemente lento, necesitamos observar aquel disco un poco más de cerca. Podemos examinar ese disco solo cada 5 segundos, unas 10 veces.
# iostat -x sdat 5 10
Si el output muestra el mismo porcentaje de tiempo de servicio, los mismos índices de lectura, podemos concluir que el #3 es el factor más probable. Si ellos cambian, entonces podemos obtener más claves para comprender por qué el tiempo de servicio es alto para este dispositivo.
De manera similar, podemos buscar en la columna de índice de lectura para desplegar el disco bajo índices constantes de lectura.
# iostat -x | sort -nrk6 
sdj   0.00    0.00   1.86  0.61  56.78   12.80  28.39 ...    
sdah  0.00    0.00   1.66  0.52  50.54   10.94  25.27 ...    
sdd   0.00    0.00   1.26  0.48  38.18   11.49  19.09 ...    
sdj   6.40   28.22   0.03   10.69   9.99   2.46
sdah  5.47   28.17   0.02   10.69  10.00   2.18
sdd   5.75   28.48   0.01    3.57   3.52   0.61
   
... and so on ...
    
La información lo ayuda a localizar un disco que está “activo”—es decir, sujeto a muchas lecturas o escrituras. Si el disco se encuentra verdaderamente activo, usted debería identificar la razón de ello; tal vez un filesystem definido en el disco está sujeto a demasiadas lecturas. Si ese es el caso, usted debería considerar el hecho de descartar filesystem de los discos para distribuir la carga, minimizando así la posibilidad de que un disco específico esté activo.

sar

De los debates anteriores, surge un thread común: Obtener métricas en tiempo real no es lo más importante; la tendencia histórica también es importante.
Además, tenga en cuenta esta situación: ¿cuántas veces alguien plantea un problema de desempeño y cuando usted comienza a investigar, todo vuelve a la normalidad? Los problemas de desempeño que han ocurrido en el pasado son difíciles de diagnosticar si carece de datos específicos. Finalmente, usted decidirá examinar el desempeño de los datos en los últimos días para obtener algunos parámetros o para realizar algunos ajustes.
El comando sar cumple con ese objetivo. sar significa System Activity Recorder, y registra las métricas de los componentes clave del sistema Linux—CPU, Memoria, Discos, Redes, etc.—en un lugar especial: directory /var/log/sa. Los datos se graban cada día en un archivo denominado sa en donde es el día de dos dígitos del mes. Por ejemplo, el archivo sa27 contiene los datos para el día 27 de ese mes. Estos datos pueden ser consultados por el comando sar.
La manera más sencilla de utilizar sar es sin ningún argumento ni opción. Por ejemplo:
# 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 ...

El output muestra las métricas relacionadas con la CPU recogidas en intervalos de 10 minutos. Las columnas significan:
CPUIdentificador de CPU; “all” significa todas las CPU
%userPorcentaje de CPU utilizado para los procesos de usuarios. Los procesos de Oracle se presentan en esta categoría.
%niceEl % de utilización de CPU mientras se ejecuta una prioridad nice
%systemEl % de CPU que ejecuta los procesos del sistema
%iowaitEl % de CPU en espera para I/O
%idleEl % de CPU inactiva en espera de trabajos

En el output anterior, podemos ver que el sistema se encuentra bien balanceado; en realidad, por debajo del nivel infrautilizado (como se muestra en el alto grado de inactividad). Profundizando más el output podemos ver lo siguiente:
... 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 ...

Esto nos muestra otra historia: el sistema fue cargado por algunos procesos de usuarios entre las 3:00 y las 3:40. Tal vez se estaba ejecutando una consulta extensa; o tal vez se estaba ejecutando un trabajo RMAN, consumiendo así toda esa CPU. Aquí es en donde el comando sar es útil –despliega los datos registrados que muestran información de un momento específico, no del momento actual. Esto es exactamente lo que usted necesita para cumplir con los tres objetivos detallados al comienzo de esta sección: obtener datos históricos, encontrar patrones de uso y comprender las tendencias.
Si usted desea ver datos sar de un día específico, simplemente abra sar con ese nombre de archivo, utilizando la opción -f como se muestra abajo (para abrir los datos del día 26)
# sar -f /var/log/sa/sa26

También se pueden desplegar datos en tiempo real, similar a vmstat o mpstat. Para obtener los datos cada 5 segundos, durante 10 veces, utilice:
# 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 …


¿Notó el valor “all” debajo el título CPU? Esto significa que las estadísticas fueron cargadas para todas las CPU. Para un sistema de procesador único, esto está bien; pero en sistemas con  múltiples procesadores usted desea obtener las estadísticas tanto para cada CPU individual, como para el conjunto. La opción -P ALL cumple con esto.
#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

Esto muestra el identificador de CPU (comenzando con 0) y las estadísticas para cada uno. Al final del output usted verá el promedio de ejecuciones de cada CPU.
El comando sar no solo es para estadísticas relacionadas con la CPU. También es útil obtener las estadísticas relacionadas con la memoria. La opción -r muestra la utilización de memoria extensiva.
# sar -r
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)     12/27/2008
 
12:00:01 AM kbmemfree kbmemused  %memused kbbuffers  kbcached  ...
12:10:01 AM    712264  32178920     97.83   2923884  25430452  ...
12:20:01 AM    659088  32232096     98.00   2923884  25430968  ...
12:30:01 AM    651416  32239768     98.02   2923920  25431448  ...
12:40:01 AM    651840  32239344     98.02   2923920  25430416  ...
12:50:01 AM    700696  32190488     97.87   2923920  25430416  ...

12:00:01 AM  kbswpfree kbswpused  %swpused  kbswpcad
12:10:01 AM   16681300     95908      0.57       380
12:20:01 AM   16681300     95908      0.57       380
12:30:01 AM   16681300     95908      0.57       380
12:40:01 AM   16681300     95908      0.57       380
12:50:01 AM   16681300     95908      0.57       380


Veamos el significado de cada columna:
kbmemfreeMemoria libre disponible en KB en ese momento
kbmemused Memoria utilizada en KB en ese momento
%memused% de memoria utilizada
kbbuffers % de memoria utilizado como buffers
kbcached% de memoria utilizado como caché
kbswpfreeEspacio de swap libre en KB en ese momento
kbswpused Espacio de swap utilizado en KB en ese momento
%swpused % de swap utilizado en ese momento
kbswpcadSwap en caché en KB en ese momento

Al final del output, usted verá la cifra promedio para el período.
También puede obtener las estadísticas específicas relacionadas con la memoria. La opción -B muestra la actividad relacionada con la paginación.
# 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 ...

La columna muestra las métricas en ese momento, no las actuales.
pgpgin/sCantidad de páginas en la memoria desde el disco, por segundo
pgpgout/sCantidad de páginas fuera del disco, desde la memoria, por segundo
fault/sFallos de página por segundos
majflt/sPrincipales fallos de página por segundo

Para obtener un output similar para la actividad relacionada con el swapping, usted puede utilizar la opción -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 ...

Las columnas probablemente se explican por si mismas; pero aquí se detalla la descripción de cada una:
pswpin/sPáginas de memoria que vuelven a intercambiarse en la memoria desde el disco, por segundo
pswpout/sPáginas de la memoria intercambiadas al disco desde la memoria, por segundo

Si usted observa que el nivel de swapping es demasiado elevado, quizás podría estar quedándose sin memoria. No se trata de una conclusión anticipada, sino de una posibilidad.
Para obtener las estadísticas de los dispositivos de disco, utilice la opción -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

Aquí está la descripción de las columnas. Nuevamente, ellas muestran las métricas en ese momento.
tpsTransferencias por segundo. El término transferencias se refiere a las operaciones I/O. Nota: es solamente la cantidad de operaciones; cada operación puede ser extensa o pequeña. Por lo tanto, esto, por sí mismo, no es la historia completa.
rd_sec/sCantidad de sectores leídos desde el disco por Segundo
wr_sec/sCantidad de sectores escritos en el disco por Segundo

Para obtener el historial de estadísticas de red, usted puede utilizar la opción -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

En resumen, usted tiene estas opciones para el comando sar a fin de obtener las métricas para los componentes:
Utilice esta opción …
… para obtener estadísticas sobre:
-P
CPU(s) Específica(s)
-d
Discos
-r
Memoria
-B
Paginación
-W
Intercambio
-n
Red

¿Qué sucede si usted desea tener todas las estadísticas disponibles en un solo output? En lugar de invocar sar con todas estas opciones, usted puede utilizar la opción -A que muestra todas las estadísticas almacenadas en los archivos sar.

Conclusión

Para resumir, al utilizar estos grupos de comandos limitados usted puede manejar la mayoría de las tareas que intervienen en la administración de recursos en un entorno Linux. Sugiero que los practique en su entorno a fin de familiarizarse con estos comandos y con las opciones aquí descriptas.
En las próximas entregas, aprenderá cómo monitorear y administrar la red. También aprenderá varios comandos que lo ayudarán a administrar un entorno Linux: para descubrir quién se ha registrado para establecer procesos shell profile, realizar backups utilizando cpio y tar, entre otras cosas.

Lectura Adicional