¿Puede Salt (Saltstack) recopilar y transmitir datos para Graphite, Ganglia o Zenoss?

Estoy comenzando un nuevo proyecto y estoy considerando usar Ansible o Salt para la automatización de implementación y, quizás, una orquestación más sofisticada (administración y federación de servidores).

Con Salt, me pregunto si hay alguna integración entre él y Graphite o Zenoss o Ganglia ... usando las conexiones Salt 0mq para transmitir los datos de los "minions" de Salt a la base de datos / colectores de monitoreo / graficación.

¿Alguien más ha visto esto?

Utilicé Salt-stack durante más de 6 meses para administrar más de 40 nodos.

en Mi configuración actual uso:

• Icinga como servidor de supervisión
• NRPE para ejecutar las verificaciones en los nodos
• el grafito recopila los datos de los nodos recopilados
• Recopilado para recopilar y enviar métricas a grafito
• gdash para un buen tablero de instrumentos para visualizar las métricas de grahita
• salt-stack y finalmente salt-stack para desplegar las configuraciones para NRPE / Collectd en cada nodo

als esto funciona bajo CentOS 6.x

mi experiencia hasta ahora es que salt-stack es bueno para inscribir todo. Pero como Daemon de ejecución a largo plazo en los nodos, no es estable.

A menudo tengo problemas para no alcanzar el maestro o la hinchazón de la memoria de los minions de sal. Esto se puede solucionar con una solución fácil que reinicia cada 24 horas / una vez por semana los minions de sal.

pero este problema en salt-minion hace que no se pueda usar para recopilar datos sobre el Marco 0mq.

Mi configuración actual es segura. Puedo inscribir cambios bastante rápido con salt-stack y reunido en los nodos funciona.

Creo que Salt o Ansible no se crean para esa tarea y creo que no se pueden usar para ese propósito.

Estoy usando Salt durante varios meses y no me di cuenta de las opciones de funciones que desea (en configuraciones ni documentación). Pero creo que puede "agregar" sus requisitos ya que Salt está escrito en python, si es una opción.

La forma más fácil es ordenar sal para instalar collectd que puede recopilar datos sobre el sistema (y tiene conectores para grafito)

EDITAR: Encontré un proyecto que implementa el monitoreo usando sal - salmón - eche un vistazo.

Es posible que desee echar un vistazo a Sensu , es una solución de monitoreo que se puede conectar con muchos complementos de la comunidad, incluido el grafito, entre otros.

Sin embargo, Sensu usa otra cola de mensajes para entregar mensajes, RabbitMQ . Tal vez sea necesario un poco de trabajo de codificación, pero puede intentar reemplazar una de las dos colas de mensajes, ya que ambos deberían estar utilizando el protocolo AMQ para intercambiar mensajes.

Le recomiendo que mire dos cosas: mina de sal - http://docs.saltstack.com/topics/mine/ Salt Events - http://docs.saltstack.com/topics/event/index.html

Si combina esto con su propia configuración de configuración de devolución para almacenar resultados en grafito, o cualquiera de los otros que enumeró. Posiblemente podría usar Salt para manejar 'sondeo' de arriba hacia abajo y 'evento' de abajo hacia arriba. No podría comentar sobre la efectividad de tal sistema, pero en principio parece existir la posibilidad.

Describí mi viaje a la monitorización de nagios por sub-segundo por host a través de la mina de sal y check_mk aquí: http://garthwaite.org/saltmine_check_mk_agent.html

El artículo recorre semanas de retoques intermitentes para que todo funcione. Resumiré la solución:

Crea un módulo check_mk personalizado para todos los minions:

#!/usr/bin/env python
''' Support for running check_mk_agent over salt '''
import os
import salt.utils
from salt.exceptions import SaltException

def __virtual__():
    ''' Only load the module if check_mk_agent is installed '''
    if os.path.exists('/usr/bin/check_mk_agent'):
        return 'check_mk'
    return False

def agent():
    ''' Return the output of check_mk_agent '''
    return __salt__['cmd.run']('/usr/bin/check_mk_agent')

Establece el intervalo de minas de minion en un minuto:

salt '*' file.append /etc/salt/minion.d/mine.conf "mine_interval: 1"

Configure el servidor de monitoreo para extraer toda la salida check_mk_agent del minion en un solo archivo json, luego configure check_mk para consultar ese archivo en lugar de cualquier consulta de red. Todo cumplido con el siguiente script en el minion de monitoreo:

#!/usr/bin/env python
import sys
import json
import fcntl

DATAFILE="/dev/shm/cmk.json"
NAG_UID = 105
NAG_GID = 107

def do_update():
    import os
    import salt.client

    caller = salt.client.Caller()
    data = caller.function('mine.get', '*', 'check_mk.agent')

    lockfile = open(DATAFILE+".lock", "w")
    fcntl.flock(lockfile, fcntl.LOCK_EX)

    datafile = open(DATAFILE, "w")
    datafile.write(json.dumps(data))

    for f in (DATAFILE, DATAFILE+".lock"):
        os.chmod(f, 0644)
        os.chown(f, NAG_UID, NAG_GID)

def get_agent(minion):
    lockfile = open(DATAFILE+".lock", "w")
    fcntl.flock(lockfile, fcntl.LOCK_SH)

    data = json.load(file(DATAFILE))
    return data[minion]

if __name__ == '__main__':
    if len(sys.argv) != 2:
        print "Usage: mine_agent.py --update | <minion id>"
    elif sys.argv[1] in ['--update', '-u']:
        do_update()
    else:
        minion = sys.argv[1]
        print get_agent(minion)

Actualiza cada minuto:

$ cat /etc/cron.d/retrieve_mined_minion_data
*/1 * * * * root /etc/check_mk/mine_agent.py --update

Finalmente: cambie la fuente de datos para todos los objetivos nagios en /etc/check_mk/main.mk:

datasource_programs = [
  ( '/etc/check_mk/mine_agent.py <HOST>', ['mine'], ALL_HOSTS ),
]