En este artículo comparto un sencillo script Bash que desarrollé para calcular el uptime (el tiempo que ha transcurrido desde que ha iniciado) de un servidor HTTP Apache. No confundir con el uptime del sistema operativo (tiempo transcurrido desde que ha iniciado el sistema, se obtiene con el comando uptime), sino que se trata de obtener el tiempo que lleva en ejecución el servicio "apache2" (el cual puede ser mucho menor al del sistema operativo si el servicio ha sido reiniciado).



Anteriormente expliqué cómo determinar todas las veces que Apache fue reiniciado de acuerdo a la información contenida en los logs del servidor. Esta vez he creado un simple script Bash para calcular directamente el uptime del servicio "apache2", el cual he llamado (muy originalmente) a2uptime.

#!/bin/bash

A2PID=$(ps axo pid,cmd,user | grep apache2 | grep root | grep -v $0 | grep -v grep | head -n 1 | cut -d' ' -f1)
A2SECONDS=$(ls -od --time-style=+%s /proc/$A2PID | cut -d' ' -f5)
A2DATE=$(ls -od --time-style=+%Y-%m-%d_%H-%M /proc/$A2PID | cut -d' ' -f5)
A2CHILDS=$(ps aux | grep apache | grep -v root | grep -v grep | wc -l)
A2PCPU=$(ps axo %cpu,cmd | grep apache2 | grep -v $0 | grep -v grep | sed -e 's/^ //' | cut -d' ' -f1 | sed -e 's/\.//')
A2PMEM=$(ps axo %mem,cmd | grep apache2 | grep -v $0 | grep -v grep | sed -e 's/^ //' | cut -d' ' -f1 | sed -e 's/\.//')

A2CPU=0
for i in $A2PCPU; do
  A2CPU=$((A2CPU + i))
done

A2CPUI=$((A2CPU / 10))
A2CPUD=$((A2CPU % 10))

A2MEM=0
for i in $A2PMEM; do
  A2MEM=$((A2MEM + i))
done

A2MEMI=$((A2MEM / 10))
A2MEMD=$((A2MEM % 10))

DATE=$(date +%s)
TIME=$(date +%H:%M:%S)

UPTIME=$((DATE - A2SECONDS))
DAYS=$((UPTIME / 86400))
UPTIME=$((UPTIME - DAYS * 86400))
HOURS=$((UPTIME / 3600))
UPTIME=$((UPTIME - HOURS * 3600))
MINUTES=$((UPTIME / 60))

echo " $TIME up $DAYS days, $HOURS:$MINUTES, $A2CHILDS child processes, $A2CPUI.$A2CPUD, $A2MEMI.$A2MEMD"

 

El funcionamiento del script es extremadamente sencillo. Primero identifica el PID del proceso apache2 iniciado por root (el primer proceso creado al iniciar el servicio "apache2"). Luego obtiene la fecha de creación de dicho proceso (expresada en segundos desde el primero de enero de 1970), de acuerdo a la fecha de creación del archivo correspondiente en el sistema de archivos /proc. El resto es una simple resta a la fecha actual y algunas divisiones para convertir el formato de la fecha.

Para que la salida del script a2uptime sea parecida a la del comando uptime, decidí además agregar información respecto a la cantidad actual de hijos en ejecución y un resumen de la utilización de CPU y memoria (por todo el servicio).

La salida del script muestra la hora actual; la cantidad de días, horas y minutos en ejecución; la cantidad de procesos hijos en ejecución; y por último el uso de CPU y memoria (expresado en porcentajes).

Resulta bastante similar si se compara con la salida de uptime:

root@wheezy# uptime
 10:43:45 up 537 days, 15:55,  1 user,  load average: 0.00, 0.01, 0.05
root@wheezy# ./a2uptime
 10:43:47 up 124 days, 22:42, 13 child processes, 0.0, 2.4

En el servidor de prueba, el servicio Apache se encuentra en ejecución desde hace más de 124 días. Es posible verificar la correctitud de esta información de forma sencilla. Primero obtener el PID del proceso apache2 iniciado por root:

root@wheezy# ps aux | grep apache | grep root | grep -v grep
root     24906  0.0  0.2 203644 20112 ?        Ss   Aug18   5:28 /usr/sbin/apache2 -k start

Se observa que el PID es 24906. Entonces, la fecha de creación del proceso 24906 es:

root@wheezy# ls -od --time-style=+%Y-%m-%d /proc/24906
dr-xr-xr-x 8 root 0 2015-08-18 /proc/24906

18 de agosto de 2015. A la fecha de publicación de este artículo es el día 21 de diciembre de 2015, así que saquen sus propias cuentas.


Tal vez pueda interesarte


Compartí este artículo