23 nov

Instalación de Graphite en HA

Graphite en HA

Instalar Graphite para HA

Vamos a explicar como montar un sistema de Graphite en HA , en esta entrada explicaba como hacer la instalación inicial de graphite , así que partimos de un escenario donde ya tenemos un Graphite instalado y lo que queremos es asegurarnos que en el caso que caiga no nos quedemos sin sistema de métricas.

Por último antes de empezar, el sistema de alta disponibilidad que vamos a montar es tipo mirror.

Pues vamos al lío…

Partes de Graphite

Graphite se compone de una serie de demonios que trabajan al unisono para poder generar las graphicas, vamos a explicar que papel tiene cada uno de ellos, ya que será interesante para entender como montar el sistema de alta disponibilidad.

Carbon-Relay: Es el encargado de tratar la métrica que recibimos en primera instancia, decidira a que carbon-cache enviara la metrica segun el tipo de balanceo que le hayamos dicho (consistent-hashing o relays-rules)

  • Consistent-hashing : Este método se utiliza cuando las métricas siempre irán a los mismos carbón-caches y tenemos más de uno, básicamente lo que hacemos en un balanceo tipo Round-Robin
  • Relays-rules: Dependiendo del patron de la metrica el relay enviará el dato a un o otro carbon-cache(o a otro relay).

/opt/graphite/conf/carbon.conf

# Use relay-rules.conf to route metrics to destinations based on pattern rules
#RELAY_METHOD = rules
#
# Use consistent-hashing for even distribution of metrics between destinations
#RELAY_METHOD = consistent-hashing

Carbon Cache : Este demonio tiene dos funciones, por un lado es el encargado de escribir la métrica en disco y por otro lado es el encargado de recibir las peticiones de la webapp.

Whisper: Es el sistema de escritura que se utiliza por defecto, las métricas se grabaran en fichero wsp (whisper) de forma secuencial.

Webapp : Esta es la parte con la que veremos las metricas, es un django servido por un apache.

Arquitectura deseada.

Donde queremos llegar.

Graphite HA structure

Vamos a explicar el flujo de datos que tendremos y después explicaremos como se configura esta arquitectura.

  1. Los servidores 1 y 2 serán iguales y los servidores 3-4 también.
  2. La estructura se compone de 4 servidores, los 4 tendrán configurado Graphite con la instalación normal (así resulta mas fácil)
  3. Tendremos un balanceador para que nos enviara las peticiones en round robin a los primeros Carbon-relays (Servidor 1 y 2)

Flujo de envío de datos.

  1. Enviaremos las métrias al balanceador
  2. El balanceador en RoundRobin enviara cada métrica a un Carbon-relays de los servidores 1 y 2
  3. Los servidores 1 y 2 enviaran la métrica recibida a los Carbon-relays de los servidores 3-4 a través, NO es roundrobin, tendremos factor de replicación 2 con dos servidores, así que la métrica se enviara dos veces.
  4. Los Carbon-relays de los sservidores 3 y 4 recibirán la métrica, estos se encargaran de enviarlos a los Carbon-cache, tendremos 2 por máquina (un Carbon-cache una Cpu), en este caso con factor de replicación 1, una métrica para cada Carbon-cache (RoundRobin).
  5. Carbon-Cache recibirá la métrica y la grabará en whisper.

 Flujo de consulta de datos

  1. La peticiones las enviaremos a los servidores 3-4.
  2. La peticion llegará al balancedador, este por RoundRobin enviara a uno de los dos sevidores (3-4)
  3. La Webapp recibirá la petición, primero de todo irá al Memcache de los servidores 1-2 para comprobar que no tenga el dato. (Memcache no es necesario, pero aligera la carga)
  4. Si el dato no se encuentra lanzará la petición a los Carbon-cache del mismo servidor por los puertos 7102 y 7002.
  5. Carbon-cache ira a disco  buscar el dato y lo entregará a la webapp

 

Como podemos ver lo que estamos haciendo es simplemente repartir el dato que recibimos entre dos sistemas, de esta manera tendremos un espejo de la arquitectura de Graphite, los servidor 1-3 y los servidores 2-4, pudiendo romper cualquier elemento sin perder servicio.

 

Configuración de la alta disponibilidad

Como hemos visto la arquitectura es simétrica, así pues la configuración de los servidores 1-3 será la misma que la de los servidor 2-4.

Configuración de carbon-relay (Servidores 1-2)

Estos servidores los configuraremos exclusivamente en la sección relay del fichero de configuración de carbon.conf

Le diremos configuraremos el puerto normal y el puerto donde enviaremos las métricas Pickle, (altamente recomendado enviar todo lo que podamos por Pickle)

/opt/graphite/conf/carbon.conf

LINE_RECEIVER_INTERFACE = 0.0.0.0
LINE_RECEIVER_PORT = 2003
PICKLE_RECEIVER_INTERFACE = 0.0.0.0
PICKLE_RECEIVER_PORT = 2014

Seleccionaremos el método de balanceo que queramos, en nuestro caso como queremos un espejo tendremos que activar consistent-hashing

RELAY_METHOD = consistent-hashing

Ahora el factor de replicación, en estos Carbon-relays deberá ser 2, ya que queremos que cada métrica se envíe a ambos grupos de servidores (2-4)


REPLICATION_FACTOR = 2

Como es lógico le tendremos que decir donde están esos servidores, los puertos que ponemos serán los puertos Pickle, ya que todas las comunicaciones que se muevan en el sistema deberían ser Pickle

DESTINATIONS = Servidor3:2014, Servidor4:2014

Esta configuración sera igual en los servidores 1 y 3

Configuración de carbon-relay (Servidores 3-4)

La métrica que se envía desde los servidores 1-2 deberá ser recibida por los Carbon-relay de los servidores 3-4, en este caso ponemos un Carbon-relay por delante ya que vamos a tener mas de un Carbon-cache y nos interesa que podamos balancear entre ellos.

En el fichero carbon.conf de los servidores 3-4 en la seccion [relay], deberemos poner lo siguiente:

/opt/graphite/conf/carbon.conf
PICKLE_RECEIVER_INTERFACE = 0.0.0.0
PICKLE_RECEIVER_PORT = 2014

Donde el PICKLE_RECEIVER_PORT deberá ser el mismo que hemos puesto en los destinos de los primeros Carbon-relay,

</pre>
RELAY_METHOD = consistent-hashing

Ahora el factor de replicación, en estos Carbon-relays deberá ser 1, ya que queremos que cada métrica se envíe a solo un Carbon-cache de los que tenemos en la misma máquina, o sea que consiguiremos un RoundRobin.

 

REPLICATION_FACTOR = 1

Como es lógico le tendremos que decir donde están esos servidores, los puertos que ponemos serán los puertos Pickle, ya que todas las comunicaciones que se muevan en el sistema deberían ser Pickle

DESTINATIONS = 127.0.0.1:2004, 127.0.0.1:2014

Configuración de carbon-cache (Servidores 3-4)

Como vemos en el esquema por cada servidor tendremos dos Carbon-cache, deberemos estar atentos a este punto ya que cambia un poco la configuración estándar.
Deberemos localizar dentro de la sección [cache] en el fichero carbon.conf de los servidores 3 y 4 los siguientes valores.

[cache]
PICKLE_RECEIVER_PORT = 2004
CACHE_QUERY_PORT = 7002

Podremos para el primer Carbon-cache los puertos donde podremos enviar las métricas PICKLE_RECEIVER_PORT, que deberá ser el mismo que hemos configurado en los Carbons-relay de los servidores 3-4.
Y el CACHE_QUERY_PORT que será el puerto por el que la Webapp enviará las consultas.

Con esto tendremos la configuración del primer Carbon-cache de un servidor, ahora deberemos configurar el segundo, tal que así.

[cache:b]
PICKLE_RECEIVER_PORT = 2104
CACHE_QUERY_PORT = 7102

Con esto creamos un nuevo carbón cache b siguiendo la misma lógica que con el primero

Por ultimo deberemos decirle al sistema que levante los dos Carbon-cache.

Podemos tener un init.d tal que así

#!/bin/sh
# !!! generated by puppet !!!

### BEGIN INIT INFO
# chkconfig: 2345 99 80
# Provides: carbon-cache
# Required-Start: $remote_fs $network $time
# Required-Stop: $remote_fs $network
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start/Stop carbon-cache
# Description: Enables Graphites carbon-cache data collecting engine
### END INIT INFO

case "$1" in
start)
python /opt/graphite/bin/carbon-cache.py --instance=a start
python /opt/graphite/bin/carbon-cache.py --instance=b start
;;
stop)
python /opt/graphite/bin/carbon-cache.py --instance=a stop
python /opt/graphite/bin/carbon-cache.py --instance=b stop
;;
status)
python /opt/graphite/bin/carbon-cache.py --instance=a status
python /opt/graphite/bin/carbon-cache.py --instance=b status
;;
restart)
$0 stop ; sleep 3 ; $0 start
RC=$?
exit $RC
;;
*)
echo "Usage: $0 {start|stop|restart|status}"
exit 1
;;
esac

exit

Esta configuración será la misma para el servidor 4

Configuración de la Webapp

Ya solo nos queda la Webapp esta se configura en un fichero diferente

Deberemos tocar las siguientes opciones:

vim  /opt/graphite/webapp/graphite/local_settings.py
MEMCACHE_HOSTS = ['Servidor1:11211','Servidor2:11211',]
CARBONLINK_HOSTS = ["127.0.0.1:7002:a", "127.0.0.1:7102:b"]

En el caso que utilicemos Memcache deberemos decirle donde esta y donde encontrara los carbon-query para hacer peticiones de datos, en nuestro esquema se encuentran en la misma máquina.

Esta configuración es la misma para servidor 4

Y con eso ya tendremos el sistema montado, si todo salio bien, en el momento que le enviemos un métrica al Carbon-relay servidor 1 o 2 esta se repartirá entre los servidores 3 y 4

30 sep

Send graphite data

Bueno después de explicar como instalar y configurar graphite con wsgi, vamos a ver como hacer un pequeño script para enviar los datos a graphite, pero como somos un poco vagos, vamos a utilizar uno hecho por el compañero Tomas, que podemos encontrarlo en su github basic-monitoring.sh

Con ese script de base, os explico que hace cada cosa y como tratar los datos.

Pues venga vamos al lío.

Primero de todo debemos entender como tenemos que enviarle la información a graphite, debemos enviarla con una estructura predefinida, nombredelametrica valor timestamp, un ejemplo para que se vea más claro.

servers.raspberry.loadavg_1min 0.03 1373628644

Donde

servers.raspberry.loadavg_1min -> Sera la estructura de carpetas que tendremos siendo el ultimo valor (loadavg_1min) la metrica.

0.03 -> Sera el valor de la metrica

1373628644 -> el tiempo en unixtime (segundos)

Pues vamos a ir montando opciones para cada tipo de valor.

CPU

Podemos sacar la carga de la CPU tal que así.


#!/bin/bash
now=`date +%s`
host=raspberry

#Load average
read un cinc quinze resta < /proc/loadavg
data="servers.$host.loadavg_1min $un $now n servers.$host.loadavg_5min $cinc $now n servers.$host.loadavg_15min $quinze $now n"

Si hacemos un echo $data veremos


servers.raspberry.loadavg_1min 0.03 1373628644 n servers.raspberry.loadavg_5min 0.08 1373628644 n servers.raspberry.loadavg_15min 0.08 1373628644 n

Como tenemos que enviar valor tras valor utilizaremos echo con la opcion -e para que coja cada n y lo convierta en salto de linea. Una vez tenemos los datos estructurados debemos enviarlo al puerto 2003 del servidor de graphite y esto es  tan fácil como hacer un nc.

Pues aqui el ejemplo.


echo -e $data |nc -w 5 ipdelservidor 2003 2>&2

Pues visto esto vamos a sacar las métricas de la memoria.

Memoria

Aquí lo que hacemos es sacar la información del comando free -o y lo pasamos a %,  después lo añadimos a la métrica anterior.


data="$data `free -o|awk -v host=$host -v now=$now '(NR==2) {printf("servers.%s.memory %s %s \n ", host, $3/$2*100, now)} (NR==3) {printf("servers.%s.swap %s %s\n ", host, $3/$2*100, now)}'`"

Ahora los datos de CPU y disco, que los sacaremos con el comando sar. (debemos instalar el sar si no lo tenemos, sudo apt-get install sysstat)


data="$data `sar -u 3|awk -v host=$host -v now=$now 'END {printf("servers.%s.cpu %s %s \n ", host, 100-$8, now)}'`"

data="$data `sar -b 3|awk -v host=$host -v now=$now 'END {printf("servers.%s.disk.totalops %s %s \n servers.%s.disk.readops %s %s \n servers.%s.disk.writeops %s %s \n servers.%s.disk.breads %s %s \n servers.%s.disk.bwrites %s %s \n ", host, $2, now, host, $3, now, host, $4, now, host, $5, now, host, $6, now)}'`"

Y lo enviamos todo con


echo -e $data |nc -w 5 $carbon_server 2003 2>&2

Y con esto deberíamos empezar a ver los datos aparecer en nuestro Graphite!

Bonus track

Hace poco encontré como sacar la temperatura de nuestra rasbperry y aquí os pongo los comando, que podéis unir a la lista de arriba para enviar a graphite.


# Temperatura
tempcpu=$((`cat /sys/class/thermal/thermal_zone0/temp|cut -c1-2`)).$((`cat /sys/class/thermal/thermal_zone0/temp|cut -c3-5`))
echo servers.$host.tempcpu $tempcpu $now | nc -w 5 ipservergraphite 2003 2>&2
tempgpu=`/opt/vc/bin/vcgencmd measure_temp|cut -c6-9`
echo servers.$host.tempgpu $tempgpu $now | nc -w 5 ipservergraphite 2003 2>&2

La verdad es que hay que cambiar algunas cosas partiendo del script de compañero Tomas, así que os dejo el que yo utilizo, ya que de esa forma si lo pones debe funcionar a la primera.

#!/bin/bash
now=`date +%s`
host=raspberry

#Load average
read un cinc quinze resta < /proc/loadavg
data="servers.$host.loadavg_1min $un $now n servers.$host.loadavg_5min $cinc $now n servers.$host.loadavg_15min $quinze $now n"

#Memoria
data="$data `free -o|awk -v host=$host -v now=$now '(NR==2) {printf("servers.%s.memory %s %s \n ", host, $3/$2*100, now)} (NR==3) {printf("servers.%s.swap %s %s\n ", host, $3/$2*100, now)}'`"

#Recollim CPU
data="$data `sar -u 3 3|awk -v host=$host -v now=$now 'END {printf("servers.%s.cpu %s %s \n ", host, 100-$8, now)}'`"

#Recollim dades de disc
data="$data `sar -b 3 3|awk -v host=$host -v now=$now 'END {printf("servers.%s.disk.totalops %s %s \n servers.%s.disk.readops %s %s \n servers.%s.disk.writeops %s %s \n servers.%s.disk.breads %s %s \
n servers.%s.disk.bwrites %s %s \n ", host, $2, now, host, $3, now, host, $4, now, host, $5, now, host, $6, now)}'`"

# Temperatura
tempcpu=$((`cat /sys/class/thermal/thermal_zone0/temp|cut -c1-2`)).$((`cat /sys/class/thermal/thermal_zone0/temp|cut -c3-5`))
echo servers.$host.tempcpu $tempcpu $now | nc -w 5 ipgraphite 2003 2>&2
tempgpu=`/opt/vc/bin/vcgencmd measure_temp|cut -c6-9`
echo servers.$host.tempgpu $tempgpu $now | nc -w 5 ipgraphite 2003 2>&2
#Enviem dades
echo -e $data | sed 's:,:.:g' | nc -w 5 ipgraphite 2003 2>&2
exit $?

Resultado?
El siguiente….

Captura de pantalla de 2013-07-25 17:34:48

Ale a disfrutarlo!!

14 may

Estadísticas VMware con PowerCLI y Graphite.

Voy a explicar como unir dos mundos, vamos a montar un sistema que nos permita sacar datos de los rendimientos de nuestra plataforma virtual (VMWARE) a través de Powercli, y los enviaremos a Graphite, utilizaremos por un lado una herramienta en Windows (powercli) y un sistema para generar gráficas que corre en Linux, un gráfico de la arquitectura por servicios seria el siguiente. La idea principal que me llevo a esta solución, es cuando deseamos mostrar al cliente las estadísticas de sus máquinas sin querer que acceda a la vcenter, eso y la falta de dinero para comprar una solución super chula y super caras, de esta manera le podemos dar una URL, para que vea los datos que desee.

grafica

Pensar que es a nivel de servicio, o sea que no debemos tener 3 maquinas :), bien pues por un lado tendremos ps de power shell que recogerá las métricas cada 10 minutos conectandose a vcenter, y lo dejara en un recurso compartido para que posteriormente la máquina de graphite lo trate y genere la gráfica.

Para saber montar graphite y conocer un poco más el producto os recomiendo que os paseis por el blog de mi compañero de labores, que hace un tiempo hizo un post muy interesante al respecto. http://www.tomas.cat/blog/ca/instal%C2%B7lant-graphite-0910-debian-squeeze.

Vale ahora tenemos el sistema de gráficas montado, pues vamos a por los otros puntos que es lo interesante de este post.

Punto 1 – Instalamos powercli en una maquina windows.

Nos lo bajamos de VMWARE, y lo instalamos, la instalación es muy básica y típica de siguiente y siguiente y más siguiente y espera y siguiente y ale finalizar!

Una vez instalado nos iremos al escritorio y ejecutaremos VMware vSphere PowerCLI.exe

Nos dará un error de certificado, pero no os preocupéis aquí explico como solucionarlo.

Punto 2 – Scripts de Powercli

Bien ya tenemos el powercli instalado, ahora vamos con los scripts para poder coger los datos, si quereis ver el codigo de forma mas amigable yo utilizo, http://powergui.org/downloads.jspa


add-pssnapin VMware.VimAutomation.Core
$metrics = "net.usage.average"
$start = (Get-Date).AddMinutes(-10)
Connect-VIServer -Server ipservidor  -User dominiousuario -Password contraseña
$resource = Get-ResourcePool | select name | where { $_.Name -ne “Resources”}

$resource | Sort-Object Name,Time |
Export-Csv "C:psnetresource.csv" -NoTypeInformation -UseCulture

$vmlist = Import-CSV "C:psnetresource.csv"

foreach ($list in $vmlist) {
      $esxImpl = Get-VM -Location $list.name | where { $_.PowerState -eq “PoweredOn”}
      $report = Get-Stat -Entity $esxImpl -Stat $metrics -Realtime -Start $start | `
      Group-Object -Property EntityId,Timestamp | %{
      New-Object PSObject -Property @{
      Name = $_.Group[0].Entity.Name
      Time = [int][double]::Parse((Get-Date -UFormat %s $_.Group[0].Timestamp))
      netActAvg = [math]::Round(($_.Group | Measure-Object -Property Value -Average).Average, 2)
}
}
$file=$list.name
$report | Sort-Object Name,Time | `
Export-Csv "C:psnet$file.csv" -NoTypeInformation -UseCulture

get-content C:psnet$file.csv | %{$_ -replace ' ',''} | %{$_ -replace ';',' '} | %{$_ -replace '"',''} | %{$_ -replace 'Name',''} | %{$_ -replace 'netActAvg',''} | %{$_ -replace 'Time',''} | %{$_ -replace ',','.'} | out-file -Encoding ASCII "ruta compartida entre ambas maquinas"
}

Invoke-VMScript -VM deploy-pre -ScriptText "/bin/bash /mnt/shared/sysprod/nuevo/ntt/bin/graphite_vmware_net.sh" -HostUser usuario -HostPassword contraseña -GuestUser usuariodelamaquinavirtual -GuestPassword contraseña

disconnect-viserver -Server IP -Confirm:$False

Bueno este ps lo que hace es sacar la media de los ultimos 10 minutos del trafico de red, voy a explicar linea por linea lo que hacemos.

add-pssnapin VMware.VimAutomation.Core

-Como vamos a lanzar el script con el administrador de tareas de windows, lo haremos a través de powershell, asi que debemos cargar las librerias de VMWARE para utilizar los metodos o VI Toolkit

$metrics = “net.usage.average”

-En esta variable le pondremos la metrica que queremos sacar, en este caso es la media del tráfico de red, pero podemos utilizar cpu.usage.average, mem.usage.average etc..

$start = (Get-Date).AddMinutes(-10)

-Aquí le diremos el tiempo de datos que queremos recoger, en este caso 10 minutos, o sea por cada ejecución nos dará los datos de los últimos 10 minutos de todas las maquinas virtuales.

Connect-VIServer -Server ipservidor  -User dominiousuario -Password contraseña

Nos conectamos a nuestro vcenter, modificaremos y pondremos nuestro usuario y contraseña.

$resource = Get-ResourcePool | select name | where { $_.Name -ne “Resources”}

– Esto ya es algo particular de mi plataforma, lo que hago es sacar todos los resources de vmware, lo hago porque en graphite organizo las métricas por entornos y cada entorno es un resource, mas adelante lo entenderéis.

$resource | Sort-Object Name,Time | Export-Csv “C:psnetresource.csv” -NoTypeInformation -UseCulture
$vmlist = Import-CSV “C:psnetresource.csv”

-Exportamos los resultados a un csv e importamos la lista de máquinas.

Después hacemos el bucle donde buscamos aquellas que estan encendidas y sacamos los resultado.
$report | Sort-Object Name,Time | `
Export-Csv “C:psnet$file.csv” -NoTypeInformation -UseCulture

-Nos quedamos con los campos que nos interesan nombre y fecha y los exportamos a un CSV.

get-content C:psnet$file.csv | %{$_ -replace ‘ ‘,”} | %{$_ -replace ‘;’,’ ‘} | %{$_ -replace ‘”‘,”} | %{$_ -replace ‘Name’,”} | %{$_ -replace ‘netActAvg’,”} | %{$_ -replace ‘Time’,”} | %{$_ -replace ‘,’,’.’} | out-file -Encoding ASCII “ruta compartida entre ambas maquinas”

-Ahora tratamos el csv para dejarlo medio listo para graphite, quitando aquello que no queremos y dejándolo en el recurso compartido para la maquina de graphite.

Invoke-VMScript -VM deploy-pre -ScriptText “/bin/bash /mnt/shared/sysprod/nuevo/ntt/bin/graphite_vmware_net.sh” -HostUser usuario -HostPassword contraseña -GuestUser usuariodelamaquinavirtual -GuestPassword contraseña

-Por ultimo llamamos a un script que tenemos en la maquina Linux, que se encarga de volver a tratar cada fichero y enviarlo a graphite, esta parte seguro que se puede hacer directamente desde powershell, pero no encontré la forma ni las ganas ;), así que intente volver a territorio conocido…, si alguien lo mejora bienvenido sea…

disconnect-viserver -Server IP -Confirm:$False

Y nos desconectamos.

Bueno, después de lanzar el ps, el resultado de los fichero sera algo tal que:


"1-INT-01";"38";"1367839360"
"1-INT-01";"15";"1367839380"
"1-INT-01";"13";"1367839400"
"1-INT-01";"16";"1367839420"
"1-INT-01";"10";"1367839440"
...

Debemos coger los resultados y dejar algo tal que


vmware.Entornos_de_Test.1-INT-01.avgnet 27 1367848820
vmware.Entornos_de_Test.1-INT-01.avgnet 9 1367848840
vmware.Entornos_de_Test.1-INT-01.avgnet 7 1367848860
vmware.Entornos_de_Test.1-INT-01.avgnet 8 1367848880
vmware.Entornos_de_Test.1-INT-01.avgnet 10 1367848900
vmware.Entornos_de_Test.1-INT-01.avgnet 10 1367848920
vmware.Entornos_de_Test.1-INT-01.avgnet 28 1367848940
vmware.Entornos_de_Test.1-INT-01.avgnet 9 1367848960
vmware.Entornos_de_Test.1-INT-01.avgnet 9 1367848980

Ya que para que graphite lo entienda debemos enviarlo [clave+separación+valor+separación+timestamp unix format] donde algo puede ser más de una opción separado por puntos, por cada . tendremos una carpeta en graphite, tal que…

Captura de pantalla de 2013-05-08 11:39:56

En este caso por ejemplo lo que le mandamos es vmware.Entornos_de_Test.1-INT-01.avgnet y la estructura que creamos será la que veis en la imagen.

Bueno hasta aqui la parte del script de powercli, ahora vamos a mirar el de Linux, que lo lanzamos con el INVOKE, como ya os dije seguro que se puede hacer todo desde powershell y estoy abierto a mejoras.

Vamos a revisar entonces el script.


#!/bin/bash
source=recursocompartido
:> /tmp/datosnet
cd $source
dos2unix *
find . -name '* *' | sort | while read FILE
do
NEWFILE=`echo ${FILE} | sed 's/ /_/g;'`
mv "${FILE}" ${NEWFILE}
echo ${NEWFILE}
done

for site in *;
do
echo $site
awk -v site=$site '{printf ("vmware.%s.%s.avgnet %s %sn",site,$1, $2, $3-7200)}' $site >> /tmp/datosnet
rm -rf $site

done

cat /tmp/datosnet | nc manage 2003

exit $?

Comentamos lo que hacemos.

1.- Definimos un source, que será el recurso compartido donde dejamos los ficheros de powercli

2.- Vaciamos el fichero donde unimos todos los datos

3.- Pasamos el formato windows raro a unix.

4.- Ahora lo que hacemos es modificar los ficheros que tienen en nombre separado y unirlos con _

5.- Y hacemos el awk, donde dejamos los resultados como nos interesa, a medida que los vamos tratando los metemos en el fichero datosnet y eliminarmos el origen.

6.- Ahora se lo enviamos a graphite de forma muy sencilla, con un nc al puerto 2003.

Si todo salio bien deberemos ir a graphite y ver algo tal que:

Captura de pantalla de 2013-05-06 16:41:08

Recordar como habíamos dejado el fichero datos.  (vmware.Entornos_de_Test.1-INT-01.avgnet 27 1367848820), en este caso es carpeta vmware dentro los recurso, dentro el nombre de maquina y dentro las métricas, después separación, valor y tiempo.

Si de damos a la métrica tendremos algo así.

Captura de pantalla de 2013-05-06 16:45:19

Bien ahora que tenemos el proceso vamos automatizarlo con el gestor de tareas de windows, lo más importante es poner bien la ruta donde tenemos powershell, por defecto esta en C:WindowsSystem32WindowsPowerShellv1.0powershell.exe

Y como parámetro le pasamos el ps.

Captura de pantalla de 2013-05-08 12:13:32

No hay mejor forma que de probar que lanzarlo…

Si todo salio bien tendremos las estadísticas en graphite.

En resumidas cuentas, esto es una forma sencilla y gratuita de conseguir sacar las métricas de vcenter y ofrecerlas en un gráfico, digo ofrecerlas ya que con graphite podemos crear Dashboard personalizados y compartirlos de forma muy sencilla a través de la URL, esto nos puede servir por ejemplo para permitir que el usuario de una máquina virtual pueda comprobar el rendimiento de la misma, sin necesidad entrar en vcenter.

Captura de pantalla de 2013-05-7658

Ale a disfrutarlo!