Kann Salt (Saltstack) Daten für Graphit, Ganglien oder Zenoss sammeln und weiterleiten?

Ich starte ein neues Projekt und erwäge, Ansible oder Salt für die Automatisierung der Bereitstellung und möglicherweise für eine ausgefeiltere Orchestrierung (Serververwaltung und Verbund) zu verwenden.

Mit Salz frage ich mich , wenn eine Integration zwischen ihm und es gibt Graphite oder Zenoss oder Ganglia ... das Salzes mit 0mq Verbindungen die Daten aus dem Salz „Günstlinge“ Relay für die Überwachung / grafischen Darstellung Datenbank / Sammler.

Hat sich das noch jemand angesehen?

Ich habe Salt-Stack seit über 6 Monaten verwendet, um mehr als 40 Knoten zu verwalten.

In meinem aktuellen Setup verwende ich:

• Icinga als Überwachungsserver
• NRPE zum Ausführen der Überprüfungen auf den Knoten
• Graphit sammelt die Daten von den gesammelten Knoten
• Collectd zum Sammeln und Verschieben von Metriken auf Graphit
• gdash für ein schönes Dashboard zur Visualisierung der Grahite-Metriken
• Salt-Stack und schließlich Salt-Stack, um die Konfigurationen für NRPE / Collectd auf jedem Knoten auszurollen

Dies läuft auch unter CentOS 6.x.

Meine bisherige Erfahrung ist, dass der Salzstapel gut ist, um alles einzuschreiben. Da Daemon jedoch langfristig auf den Knoten ausgeführt wird, ist es nicht stabil.

Ich habe oft Probleme damit, den Meister nicht zu erreichen oder das Gedächtnis der Salzschergen aufzublähen. Dies kann mit einer einfachen Problemumgehung behoben werden, die Sie alle 24 Stunden / Woche die Salt-Minions neu starten.

Dieses Problem in Salt-Minion macht es jedoch nicht verwendbar, Daten über das 0mq-Framework zu sammeln.

Mein aktuelles Setup läuft sicher. Ich kann Änderungen mit Salt-Stack ziemlich schnell registrieren und das Sammeln auf den Knoten macht den Trick.

Ich denke, Salt oder Ansible sind nicht für diese Aufgabe geschaffen und ich denke, sie können nicht für diesen Zweck verwendet werden.

Ich benutze Salt seit mehreren Monaten und habe keine der gewünschten Funktionsoptionen (in Konfigurationen oder Dokumentationen) bemerkt. Aber ich denke, Sie können Ihre Anforderungen "hinzufügen", da Salt in Python geschrieben ist - wenn es eine Option ist.

Am einfachsten ist es, Salt zu bestellen, um collectd zu installieren, das Daten über das System sammeln kann (und über Anschlüsse für Graphit verfügt).

EDIT: Ich fand ein Projekt , das Gerät Überwachung Salz - Lachs - einen Blick darauf werfen.

Vielleicht möchten Sie einen Blick auf Sensu werfen , eine Überwachungslösung, die mit vielen Community-Plugins, einschließlich Graphit, steckbar ist .

Sensu verwendet jedoch eine andere Messaging-Warteschlange, um Nachrichten zu übermitteln, RabbitMQ . Möglicherweise sind einige Codierungsarbeiten erforderlich, aber Sie können versuchen, eine der beiden Messaging-Warteschlangen zu ersetzen, da beide das AMQ-Protokoll zum Austauschen von Nachrichten verwenden sollten.

Ich empfehle Ihnen, zwei Dinge zu untersuchen: Salt Mine - http://docs.saltstack.com/topics/mine/ Salt Events - http://docs.saltstack.com/topics/event/index.html

Wenn Sie diese mit Ihrem eigenen Returner-Konfigurationssetup kombinieren, um die Ergebnisse in Graphit oder einem der anderen von Ihnen aufgelisteten zu speichern. Es ist denkbar, dass Sie Salt verwenden, um das "Probing" von oben nach unten und das "Eventing" von unten nach oben zu handhaben. Ich würde die Wirksamkeit eines solchen Systems nicht kommentieren können, aber im Prinzip scheint es die Möglichkeit zu geben.

Ich habe meine Reise zur Überwachung von Nagios unter der Sekunde pro Host über das Salzbergwerk und check_mk hier beschrieben: http://garthwaite.org/saltmine_check_mk_agent.html

Der Artikel geht durch wochenlanges Basteln, um alles zum Laufen zu bringen. Ich werde die Lösung zusammenfassen:

Erstellen Sie ein benutzerdefiniertes check_mk-Modul für alle 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')

Stellen Sie das Minenintervall des Minions auf eine Minute ein:

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

Konfigurieren Sie den Überwachungsserver so, dass alle check_mk_agent-Ausgaben des Minions in eine einzelne JSON-Datei übertragen werden, und konfigurieren Sie check_mk so, dass diese Datei anstelle von Netzwerkabfragen abgefragt wird. Alles wird mit dem folgenden Skript für den Überwachungs-Minion ausgeführt:

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

Jede Minute aktualisieren:

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

Schließlich: Ändern Sie die Datenquelle für alle Nagios-Ziele in /etc/check_mk/main.mk:

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