Publicado el 06 octubre 2016

Cómo controlar la RAM de tu servidor

Un servidor lento o sobrecargado es un servidor inútil. Hay muchos tipos de servidores, pero todos ellos tienen una cosa en común: deben trabajar con rapidez y deben ser capaces de entregar la información solicitada de una forma eficiente. La RAM (Random Access Memory) es como sabéis uno de los componentes más importantes de un servidor, y uno de los principales a tener en cuenta cuando compramos o alquilamos un servidor. Aquí vamos a ver cómo funciona la RAM en un servidor Linux, y te mostraremos algunos comandos útiles para que sepas cómo saber cuánta está utilizando tu servidor.

Vamos a poner un ejemplo sencillo, comparando un servidor con una oficina. El procesador sería el oficinista, la RAM sería el escritorio de trabajo, el Disco Duro sería un armario archivador, las aplicaciones y programas instalados serían las carpetas dentro del armario archivador, y la ROM sería la lista de tareas a realizar por el oficinista.

Siguiendo este ejemplo, cuando un programa se ejecuta en el servidor, un archivo se saca de un cajón y se coloca en el escritorio (RAM) para que el oficinista (Procesador) tenga acceso a él. Cuando el oficinista (Procesador) ha terminado con el archivo, éste se coloca en el armario archivador (Disco Duro). En teoría, cuanto más grande sea el escritorio (RAM), más archivos (programas) podremos poner sobre él sin necesidad de apilarlos para acceder a ellos. En un escritorio más pequeño, será necesario depositar los archivos unos encima de otros, y perderemos más tiempo buscando el archivo concreto que nos interesa.

Cuando la RAM falla es posible que los procesos se detengan de forma inesperada. ¿Cómo podemos saber si necesitamos aumentarla?

Comprueba los logs ubicados en /var/log/messages o /var/log/syslog.

Si ves algo como esto (en un Kernel 2.4.23 o superior):

Oct 05 10:21:43 www kernel: __alloc_pages: 0-order allocation failed (gfp=0x1d2/0)
Oct 05 10:21:44 www kernel: __alloc_pages: 0-order allocation failed (gfp=0x1f0/0)

O como esto (en un Kernel anterior a 2.4.23):

Oct 05 23:49:03 www kernel: Out of Memory: Killed process 31088 (java).
Oct 05 23:49:03 www kernel: Out of Memory: Killed process 31103 (java).

Significa que las aplicaciones necesitan más memoria de la que pueden obtener del servidor.

Interpretando el comando Free

El comando «free -m» te mostrará cuánta memoria estás utilizando, y la salida será parecida a esta:

# free -m
             total       used       free     shared    buffers     cached
Mem:          2008       1951         57          0        142        575
-/+ buffers/cache:       1234        774
Swap:         3812         35       3777

El parámetro «used» (usado) de la primera línea (1951) no está muy alejado del parámetro «total» porque a Linux le gusta utilizar cualquier memoria de repuesto para almacenar en caché los bloques de disco.

Dentro de la columna «used» el parámetro más importante a tener en cuenta es la segunda fila «-/+ buffers/cache» (1234). Esta es la memoria que tus aplicaciones están usando actualmente. Para un rendimiento óptimo, este valor debe ser siempre inferior al valor «total» de la primera fila (2008). En concreto, para evitar errores de falta de memoria, debe ser inferior al valor «total» de la memoria (2008) y al valor «total» de Swap (3812).

Si quieres ver rápidamente cuánta memoria te queda todavía libre, debes fijarte en la segunda línea de la columna «free» (774). Este valor es la resta del valor total de la memoria (2008) menos el valor de la memoria real usada (1234).

Ten en cuenta que el propio Kernel del servidor necesita un poco de Ram para almacenarla en caché y acelerar algunas tareas, por ejemplo, la escritura en disco. Así que si notas que el servidor va un poco lento pero echando un vistazo ves que la memoria parece estar perfecta, quizás necesites ampliarla un poco (o reducir el consumo de memoria de tus aplicaciones).

Interpretación del comando PS AUX

Si deseas ver dónde se está consumiendo la memoria, debes ejecutar el comando «ps aux«. Este comando te mostrará el porcentaje de memoria que cada proceso está utilizando. Se suele utilizar para localizar a los usuarios que más memoria están consumiendo (normalmente serán Apache, MySQL o Java).

En este fragmento, vemos que Java está usando el 39,2% de Memoria:

USER PID %CPU %MEM VSZ     RSS   TTY   STAT  START TIME COMMAND
root 854 0.5  39.2 239372  36208 pts/0 S     22:50 0:05
/usr/local/jdk/bin/java -Xms16m -Xmx64m -Djava.awt.headless=true -Djetty.home=/opt/jetty -cp /opt/jetty/ext/ant.jar:/opt/jetty/ext/jasper-compiler.jar:/opt/jetty/ext/jasper-runtime.jar:/opt/jetty/ext/jcert.jar:/opt/jetty/ext/jmxri.jar:/opt/jetty/ext/jmxtool

Interpretación del comando VMSTAT

El comando «vmstat» te ayuda a ver, entre otras cosas, si el servidor está tirando de la memoria Swap (memoria de intercambio). Echa un vistazo a la siguiente salida:

# vmstat 1 2
   procs                      memory    swap          io     system         cpu
 r  b  w   swpd   free   buff  cache  si  so    bi    bo   in    cs  us  sy  id
 0  0  0  39132   2416    804  15668   4   3     9     6  104    13   0   0 100
 0  0  0  39132   2416    804  15668   0   0     0     0   53     8   0   0 100
 0  0  0  39132   2416    804  15668   0   0     0     0   54     6   0   0 100

La primera fila muestra el promedio del servidor. Las columnas «si» (swap in) y «so» (swap out) te indican si el servidor ha tenido que echar mano de la memoria virtual para ejecutar las aplicaciones. El valor de estar columnas debe siempre ser 0 o estar cercano al 0. Si ves que en esos campos te aparecen valores de cientos o miles, significa que el servidor está necesitando intercambiar mucha memoria y esto consume muchos recursos de CPU, por lo que deberías considerar aumentar la memoria del servidor.

Otras columnas de interés son: «r» (runnable/ejecutable), «b» (blocked/bloqueada) y «w» (waiting/en espera), que te ayudarán a ver la carga del servidor. Los procesos en espera se están intercambiando, los procesos bloqueados normalmente están esperando en el I/O y los procesos ejecutables son los que están llevando a cabo alguna tarea en ese momento. Estos valores se combinan para conformar la carga de tu servidor.

Las columnas «bi» (bytes in) y «bo» (bytes out) muestran el I/O del disco, incluyendo la memoria swap desde y hacia el disco.

Las columnas «us» (user/usuario), «sy» (system/sistema) y «id» (idle/en reposo) muestran la cantidad de CPU que el servidor está utilizando. Cuando mayor sea el campo «id», tanto mejor.

Con estos comandos, podrás saber de una forma rápida si tu servidor está utilizando bien la RAM de que dispone, o si por el contrario va siendo hora de ampliarla.