Salt (Saltstack) può raccogliere e inoltrare dati per grafite, gangli o zenoss?

Sto iniziando un nuovo progetto e sto pensando di utilizzare Ansible o Salt per l'automazione della distribuzione e, forse, un'orchestrazione più sofisticata (gestione del server e federazione).

Con Sale Mi chiedo se c'è qualche integrazione tra essa e grafite o Zenoss o gangli ... utilizzando il sale 0mq connessioni per trasmettere i dati dei "servitori" sale al monitoraggio / rappresentazione grafica di database / collezionisti.

Qualcun altro ha guardato questo?

ho usato salt-stack per oltre 6 mesi ora per gestire oltre 40 nodi.

nella mia configurazione attuale utilizzo:

• Icinga come server di monitoraggio
• NRPE per l'esecuzione dei controlli sui nodi
• la grafite raccoglie i dati dai nodi raccolti
• collectd per la raccolta e l' invio di metriche alla grafite
• gdash per un bel cruscotto per visualizzare le metriche di grahite
• salt-stack e infine salt-stack per distribuire le configurazioni per NRPE / Collectd su ciascun nodo

anche questo funziona con CentOS 6.x

la mia esperienza finora è che la pila di sale è buona per registrare tutto. Ma come Demone di esecuzione a lungo termine sui nodi, non è stabile.

ho spesso problemi con il non raggiungere il padrone o il gonfiore della memoria sui servi di sale. Questo può essere risolto con una soluzione alternativa semplice che riavvii ogni 24 ore / ogni settimana i servitori di sale.

ma questo problema in Salt-Minion rende non utilizzabile la raccolta di dati sul Framework 0mq.

la mia configurazione attuale funziona in modo sicuro. Posso registrare le modifiche abbastanza rapidamente con salt-stack e collectd sui nodi fa il trucco.

Penso che Salt o Ansible non siano stati creati per questo compito e penso che non possano essere utilizzati a tale scopo.

Sto usando Salt da diversi mesi e non ho notato le opzioni delle funzioni desiderate (nelle configurazioni o nella documentazione). Ma penso che tu possa "aggiungere" i tuoi requisiti dato che Salt è scritto in Python - se è un'opzione.

Il modo più semplice è ordinare salt per installare collectd che può raccogliere dati sul sistema (e ha connettori per la grafite)

EDIT: ho trovato un progetto che implementa il monitoraggio usando sale - salmone - dai un'occhiata.

Potresti dare un'occhiata a Sensu , è una soluzione di monitoraggio collegabile con molti plugin della community, tra cui la grafite, tra gli altri.

Tuttavia Sensu utilizza un'altra coda di messaggistica per recapitare i messaggi, RabbitMQ . Forse è necessario un po 'di lavoro di codifica, ma puoi provare a sostituire una delle due code di messaggistica, poiché entrambe dovrebbero usare il protocollo AMQ per scambiare messaggi.

Ti consiglio di esaminare due cose: Salt Mine - http://docs.saltstack.com/topics/mine/ Salt Events - http://docs.saltstack.com/topics/event/index.html

Se li combini con la tua configurazione di configurazione del restituitore per memorizzare i risultati in grafite o in uno qualsiasi degli altri che hai elencato. È possibile concepire Salt per gestire "sondaggi" dall'alto in basso e "eventi" dal basso verso l'alto. Non sarei in grado di commentare l'efficacia di un tale sistema, ma in linea di principio sembra esserci la possibilità.

Ho delineato il mio viaggio verso il monitoraggio dei naghi sub-second-per-host tramite la miniera di sale e check_mk qui: http://garthwaite.org/saltmine_check_mk_agent.html

L'articolo ripercorre settimane di armeggi e spegnimenti per far funzionare tutto. Riassumo la soluzione:

Crea un modulo check_mk personalizzato per tutti i seguaci:

#!/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')

Imposta l'intervallo miniera di Minion su un minuto:

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

Configura il server di monitoraggio per estrarre tutto l'output check_mk_agent del minion in un singolo file json, quindi configura check_mk per interrogare quel file invece di qualsiasi query di rete. Tutto realizzato con il seguente script sul seguace di monitoraggio:

#!/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)

Aggiorna ogni minuto:

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

Infine: modifica l'origine dati per tutti i target nagios in /etc/check_mk/main.mk:

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