Monitorizar un proceso - Historial de revisiones

Lantolin en 09:37 4 dic 2018

2018-12-04T09:37:34Z

← Revisión anterior		Revisión del 09:37 4 dic 2018
Línea 80:		Línea 80:

	[[Category:Tips]]		[[Category:Tips]]
	[[Category:~~Tecnología~~]]		[[Category:Tecnologia]]
	[[Category:Linux]]		[[Category:Linux]]

Lantolin en 11:00 1 abr 2018

2018-04-01T11:00:04Z

← Revisión anterior		Revisión del 11:00 1 abr 2018
Línea 1:		Línea 1:
	Pongamos que queremos monitorizar la CPU y memoria que consume un proceso Linux a lo largo del tiempo y no tenemos ninguna herramienta en el servidor, ni [[wikipedia:Munin_(software)\|munin], ni [[wikipedia:Cacti_(software)\|Cacti]], ni nada parecido. O puede que tengamos estas herramientas pero que necesitemos un gráfico con una granularidad de menos de 5 minutos.		Pongamos que queremos monitorizar la CPU y memoria que consume un proceso Linux a lo largo del tiempo y no tenemos ninguna herramienta en el servidor, ni [[wikipedia:Munin_(software)\|munin]], ni [[wikipedia:Cacti_(software)\|Cacti]], ni nada parecido. O puede que tengamos estas herramientas pero que necesitemos un gráfico con una granularidad de menos de 5 minutos.

	Este método no tiene dependencias en el servidor en el que se ejecuta. Una vez generados los datos este ejemplo usa [[wikipedia:Gnuplot\|GNUplot] para pintar el resultado, pero se podría usar una hoja de cálculo.		Este método no tiene dependencias en el servidor en el que se ejecuta. Una vez generados los datos este ejemplo usa [[wikipedia:Gnuplot\|GNUplot]] para pintar el resultado, pero se podría usar una hoja de cálculo.

	== Recolectar los datos ==		== Recolectar los datos ==
Línea 45:		Línea 45:
	== Crear el gráfico ==		== Crear el gráfico ==

	Con [~~https~~:~~//en.wikipedia.org/wiki/~~Gnuplot GNUplot], para la CPU por ejemplo. Creamos el script <code>myplot.sh</code>:		Con [[wikipedia:Gnuplot\|GNUplot]], para la CPU por ejemplo. Creamos el script <code>myplot.sh</code>:

	<pre>		<pre>

Lantolin en 10:59 1 abr 2018

2018-04-01T10:59:22Z

← Revisión anterior		Revisión del 10:59 1 abr 2018
Línea 1:		Línea 1:
	Pongamos que queremos monitorizar la CPU y memoria que consume un proceso Linux a lo largo del tiempo y no tenemos ninguna herramienta en el servidor, ni [~~https~~:~~//en.wikipedia.org/wiki/~~Munin_(software) munin], ni [~~https~~:~~//en.wikipedia.org/wiki/~~Cacti_(software) Cacti], ni nada parecido. O puede que tengamos estas herramientas pero que necesitemos un gráfico con una granularidad de menos de 5 minutos.		Pongamos que queremos monitorizar la CPU y memoria que consume un proceso Linux a lo largo del tiempo y no tenemos ninguna herramienta en el servidor, ni [[wikipedia:Munin_(software)\|munin], ni [[wikipedia:Cacti_(software)\|Cacti]], ni nada parecido. O puede que tengamos estas herramientas pero que necesitemos un gráfico con una granularidad de menos de 5 minutos.

	Este método no tiene dependencias en el servidor en el que se ejecuta. Una vez generados los datos este ejemplo usa [~~https~~:~~//en.wikipedia.org/wiki/~~Gnuplot GNUplot] para pintar el resultado, pero se podría usar una hoja de cálculo.		Este método no tiene dependencias en el servidor en el que se ejecuta. Una vez generados los datos este ejemplo usa [[wikipedia:Gnuplot\|GNUplot] para pintar el resultado, pero se podría usar una hoja de cálculo.

	== Recolectar los datos ==		== Recolectar los datos ==

Lantolin en 18:19 30 mar 2018

2018-03-30T18:19:03Z

← Revisión anterior		Revisión del 18:19 30 mar 2018
Línea 5:		Línea 5:
	== Recolectar los datos ==		== Recolectar los datos ==

	En la maquina en la que corra el proceso ~~NombreProceso~~ creamos el siguiente script <code>monitor.sh</code>:		Localizamos un string único que nos permita identificar el proceso. Lanzamos:

			ps -e -o pid,fname,cmd

			y ahí buscamos como vamos a identificar a nuestro proceso (puede contener espacios).

			Pongamos que hemos visto que la manera de encontrar el proceso es buscar <code>/usr/lib/virtualbox/VirtualBox --comment tanis64</code>.

			En la maquina en la que corra el proceso que nos interesa creamos el siguiente script <code>monitor.sh</code>:

	<pre>		<pre>
Línea 12:		Línea 20:
	while [[ today != doomsday ]] ;		while [[ today != doomsday ]] ;
	do		do
	fichero=/tmp/~~NombreProceso~~.$(date +%Y-%m-%d).stats		read -r PID FNAME REST <<<$(ps -e -o pid,fname,cmd \| grep "${1}")
			fichero=/tmp/"${FNAME}.$(date +%Y-%m-%d).stats"
	echo -n "$(date +%d-%H:%M:%S) " >> ${fichero}		echo -n "$(date +%d-%H:%M:%S) " >> ${fichero}
	ps -e -o ~~fname,~~pid,pcpu,etime,vsz,osz,rss \| grep ~~NombreProceso~~ >> ${fichero}		ps -e -o pid,pcpu,etime,vsz,osz,rss \| grep "${PID}" >> ${fichero}
	sleep 5 ;		sleep 5 ;
	done;		done;
Línea 21:		Línea 30:
	Y lo lanzamos asi:		Y lo lanzamos asi:

	nohup ./monitor.sh &		nohup ./monitor.sh "/usr/lib/virtualbox/VirtualBox --comment tanis64" &

	~~== Pintarlos ==~~		Y nos creará un fichero en <code>/tmp/VirtualB.2018-03-30.stats</code> con un aspecto como el siguiente:

	~~En un GIF con~~ [https://en.wikipedia.org/wiki/Gnuplot GNUplot] por ejemplo~~, seria~~:		<pre>
			30-20:07:59 12128 10.4 04:05:55 5051332 - 2443744
			30-20:08:04 12128 10.4 04:06:00 5051332 - 2443740
			30-20:08:09 12128 10.4 04:06:05 5051332 - 2443740
			30-20:08:14 12128 10.4 04:06:10 5051332 - 2443740
			30-20:08:19 12128 10.4 04:06:15 5051332 - 2443740
			30-20:08:24 12128 10.4 04:06:20 5051332 - 2443740
			</pre>

			== Crear el gráfico ==

			Con [https://en.wikipedia.org/wiki/Gnuplot GNUplot], para la CPU por ejemplo. Creamos el script <code>myplot.sh</code>:

	<pre>		<pre>
			#!/bin/bash

	gnuplot << __EOF__		gnuplot << __EOF__
	set terminal ~~gif~~		set terminal x11 persist
	set style line 1 lt 1 lw 0		set style line 1 lt 1 lw 0
	~~set style line 2 lt 2 lw 0~~
	~~set style line 3 lt 3 lw 0~~
	~~set style line 4 lt 4 lw 0~~
	~~set style line 5 lt 5 lw 0~~
	~~set style line 6 lt 6 lw 0~~
	~~set style line 7 lt 7 lw 0~~
	~~set style line 8 lt 8 lw 0~~
	set xdata time		set xdata time
	set timefmt "%d-%H:%M:%S"		set timefmt "%d-%H:%M:%S"
	set format x "%H:%M"		set format x "%H:%M"
	plot "$1" using 1:4 with lines title "~~mbe-cache1~~" ls 1~~, "$2" using 1:4 with lines title "mbe-cache2" ls 2, "$3" using 1:4 with lines title "mbe-cache3" ls 3~~		plot "$1" using 1:3 with lines title "CPU Proceso1" ls 1
	quit		quit
	__EOF__		__EOF__
	</pre>		</pre>

			Y lo lanzamos:

			./myplot.sh /tmp/VirtualB.2018-03-30.stats

			Que nos daría un gráfico como este:

			[[Archivo:Grafico01.png]]

			Si queremos pintar mas de un proceso a la vez hay que añadir lineas como estas:

			set style line 2 lt 2 lw 0
			set style line 3 lt 3 lw 0

			Y sustituir la de plot por:

			plot "$1" using 1:3 with lines title "Proceso1" ls 1, "$2" using 1:3 with lines title "Proceso2" ls 2, "$3" using 1:3 with lines title "Proceso3" ls 3


	[[Category:Tips]]		[[Category:Tips]]
	[[Category:Tecnología]]		[[Category:Tecnología]]
	[[Category:Linux]]		[[Category:Linux]]

Lantolin: /* Recolectar los datos */

2018-03-30T17:33:58Z

Recolectar los datos

← Revisión anterior		Revisión del 17:33 30 mar 2018
Línea 12:		Línea 12:
	while [[ today != doomsday ]] ;		while [[ today != doomsday ]] ;
	do		do
	fichero=~~/var~~/tmp~~/lac~~/NombreProceso.$(date +%Y-%m-%d).stats		fichero=/tmp/NombreProceso.$(date +%Y-%m-%d).stats
	echo -n "$(date +%d-%H:%M:%S) " >> ${fichero}		echo -n "$(date +%d-%H:%M:%S) " >> ${fichero}
	ps -e -o fname,pid,pcpu,etime,vsz,osz,rss \| grep NombreProceso >> ${fichero}		ps -e -o fname,pid,pcpu,etime,vsz,osz,rss \| grep NombreProceso >> ${fichero}

Lantolin: Página creada con «Pongamos que queremos monitorizar la CPU y memoria que consume un proceso Linux a lo largo del tiempo y no tenemos ninguna herramienta en el servidor, ni [https://en.wikipe...»

2018-03-30T17:30:57Z

Página creada con «Pongamos que queremos monitorizar la CPU y memoria que consume un proceso Linux a lo largo del tiempo y no tenemos ninguna herramienta en el servidor, ni [https://en.wikipe...»

Página nueva

Pongamos que queremos monitorizar la CPU y memoria que consume un proceso Linux a lo largo del tiempo y no tenemos ninguna herramienta en el servidor, ni [https://en.wikipedia.org/wiki/Munin_(software) munin], ni [https://en.wikipedia.org/wiki/Cacti_(software) Cacti], ni nada parecido. O puede que tengamos estas herramientas pero que necesitemos un gráfico con una granularidad de menos de 5 minutos.

Este método no tiene dependencias en el servidor en el que se ejecuta. Una vez generados los datos este ejemplo usa [https://en.wikipedia.org/wiki/Gnuplot GNUplot] para pintar el resultado, pero se podría usar una hoja de cálculo.

== Recolectar los datos ==

En la maquina en la que corra el proceso NombreProceso creamos el siguiente script <code>monitor.sh</code>:

<pre>
#!/bin/bash

while [[ today != doomsday ]] ;
do
fichero=/var/tmp/lac/NombreProceso.$(date +%Y-%m-%d).stats
echo -n "$(date +%d-%H:%M:%S) " >> ${fichero}
ps -e -o fname,pid,pcpu,etime,vsz,osz,rss | grep NombreProceso >> ${fichero}
sleep 5 ;
done;
</pre>

Y lo lanzamos asi:

nohup ./monitor.sh &

== Pintarlos ==

En un GIF con [https://en.wikipedia.org/wiki/Gnuplot GNUplot] por ejemplo, seria:

<pre>
gnuplot << __EOF__
set terminal gif
set style line 1 lt 1 lw 0
set style line 2 lt 2 lw 0
set style line 3 lt 3 lw 0
set style line 4 lt 4 lw 0
set style line 5 lt 5 lw 0
set style line 6 lt 6 lw 0
set style line 7 lt 7 lw 0
set style line 8 lt 8 lw 0
set xdata time
set timefmt "%d-%H:%M:%S"
set format x "%H:%M"
plot "$1" using 1:4 with lines title "mbe-cache1" ls 1, "$2" using 1:4 with lines title "mbe-cache2" ls 2, "$3" using 1:4 with lines title "mbe-cache3" ls 3
quit
__EOF__
</pre>

[[Category:Tips]]
[[Category:Tecnología]]
[[Category:Linux]]