Czy Salt (Saltstack) może gromadzić i przekazywać dane dla Graphite, Ganglia lub Zenoss?

Zaczynam nowy projekt i zastanawiam się nad wykorzystaniem Ansible lub Salt do automatyzacji wdrażania i, być może, bardziej wyrafinowanej organizacji (zarządzanie serwerami i federacja).

Solą Zastanawiam się, czy istnieje jakaś integracja między nim a Graphite lub Zenoss lub zwojach ... używając soli 0mq połączeń do przekazywania danych z „sługusów” sól do monitorowania / database / wykresów kolektorów.

Czy ktoś jeszcze na to spojrzał?

Używam stosu soli od ponad 6 miesięcy, aby zarządzać ponad 40 węzłami.

w mojej bieżącej konfiguracji używam:

• Icinga jako serwer monitorowania
• NRPE do przeprowadzania kontroli w węzłach
• grafit zbiera dane z zebranych węzłów
• zebrane do zbierania i wypychania metryk do grafitu
• gdash dla przyjemnego pulpitu nawigacyjnego do wizualizacji wskaźników szarości
• salt-stack i wreszcie salt-stack do wdrożenia konfiguracji NRPE / Collectd na każdym węźle

als działa to pod CentOS 6.x

moje dotychczasowe doświadczenie jest takie, że stos soli jest dobry do zapisania wszystkiego. Ale jako długoterminowe uruchamianie Daemona na węzłach, jego niestabilność.

często mam problemy z nieosiągnięciem mistrza lub rozdęciem pamięci na sługusach soli. Można to naprawić za pomocą łatwego obejścia polegającego na tym, że restartujesz co 24 godziny / raz na tydzień szukając minionków soli.

ale ten problem w solankach sprawia, że ​​zbieranie danych w ramach 0mq jest niemożliwe.

moja obecna konfiguracja działa bezpiecznie. Mogę rejestrować zmiany dość szybko dzięki stosowi soli i gromadzenie ich w węzłach załatwia sprawę.

Myślę, że Salt lub Ansible nie są stworzone do tego zadania i myślę, że nie można ich do tego przyzwyczaić.

Używam Soli od kilku miesięcy i nie zauważyłem opcji pożądanych funkcji (w konfiguracjach ani dokumentacji). Ale myślę, że możesz „dodać” swoje wymagania, ponieważ Salt jest napisany w Pythonie - jeśli jest to opcja.

Najprostszym sposobem jest zamówienie soli do zainstalowania kolekcji, która może gromadzić dane o systemie (i ma złącza do grafitu)

EDYCJA: Znalazłem projekt, który wdraża monitorowanie za pomocą soli - łososia - spójrz.

Możesz rzucić okiem na Sensu , jest to rozwiązanie do monitorowania z wieloma wtyczkami społeczności, w tym między innymi grafitem .

Jednak Sensu korzysta z innej kolejki przesyłania wiadomości, RabbitMQ . Być może potrzebne są pewne prace związane z kodowaniem, ale możesz spróbować zastąpić jedną z dwóch kolejek wiadomości, ponieważ oba powinny używać protokołu AMQ do wymiany wiadomości.

Polecam przyjrzeć się dwóm rzeczom: Salt Mine - http://docs.saltstack.com/topics/mine/ Salt Events - http://docs.saltstack.com/topics/event/index.html

Jeśli połączysz je z własną konfiguracją modułu zwracającego, aby przechowywać wyniki w graficie lub w dowolnej z innych wymienionych list. Można sobie wyobrazić użycie Soli do obsługi „sondowania” od góry do dołu i „zdarzenia” od dołu do góry. Nie byłbym w stanie wypowiedzieć się na temat skuteczności takiego systemu, ale w zasadzie wydaje się, że jest taka możliwość.

Swoją podróż do monitorowania nag-sub-sekund-na-gospodarza za pośrednictwem kopalni soli i check_mk tutaj: http://garthwaite.org/saltmine_check_mk_agent.html

Artykuł omawia kolejne tygodnie majsterkowania, aby wszystko działało. Podsumuję rozwiązanie:

Utwórz niestandardowy moduł check_mk dla wszystkich stworów:

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

Ustaw interwał minowy miniona na jedną minutę:

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

Skonfiguruj serwer monitorowania, aby pobierał wszystkie dane wyjściowe check_mk_agent stwora do pojedynczego pliku json, a następnie skonfiguruj check_mk, aby wyszukiwał ten plik zamiast zapytań sieciowych. Wszystko to zrealizowano za pomocą następującego skryptu na stworze monitorującym:

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

Aktualizuj co minutę:

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

Wreszcie: zmień źródło danych dla wszystkich celów nagios w /etc/check_mk/main.mk:

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