O Salt (Saltstack) pode coletar e retransmitir dados para Graphite, Ganglia ou Zenoss?

Estou iniciando um novo projeto e considerando o uso do Ansible ou Salt para automação de implantação e, talvez, orquestração mais sofisticada (gerenciamento e federação de servidores).

Com Sal Eu estou querendo saber se há alguma integração entre ele e grafite ou Zenoss ou gânglios ... usando o sal 0mq conexões para transmitir os dados dos "lacaios" sal para o monitoramento / gráficas de banco de dados / coletores.

Alguém mais olhou para isso?

Eu usei o salt-stack por mais de 6 meses agora para gerenciar mais de 40 nós.

em Minha configuração atual, eu uso:

• Icinga como Monitoring Server
• NRPE para executar as verificações nos nós
• A grafite coleta os dados dos nós collectd
• collectd para coletar e enviar métricas para grafite
• gdash para um bom painel para visualizar as métricas de grahite
• salt-stack e finalmente salt-stack para implementar as configurações do NRPE / Collectd em cada nó

isso também é executado no CentOS 6.x

minha experiência até agora é que a pilha de sal é boa para registrar tudo. Mas, a longo prazo, executando o Daemon nos nós, não é estável.

muitas vezes tenho problemas em não alcançar o mestre ou a memória inchada dos minions de sal. Isso pode ser corrigido com uma solução fácil e fácil de reiniciar a cada 24 horas / semana, os lacaios de sal.

mas esse problema no salt-minion não torna utilizável coletar dados sobre o 0mq Framework.

minha configuração atual é segura. Posso registrar alterações rapidamente com o salt-stack e o collectd nos nós faz o truque.

Acho que Salt ou Ansible não foram criados para essa tarefa e acho que eles não podem ser usados ​​para esse fim.

Estou usando o Salt por vários meses e não notei as opções de funções que você deseja (nas configurações nem na documentação). Mas acho que você pode "adicionar" seus requisitos, pois o Salt está escrito em python - se for uma opção.

A maneira mais fácil é solicitar o salt para instalar o collectd, que pode coletar dados sobre o sistema (e possui conectores para grafite)

EDIT: Encontrei um projeto que implementa o monitoramento usando sal - salmão - dê uma olhada.

Você pode dar uma olhada no Sensu , é uma solução de monitoramento conectável a vários plugins da comunidade, incluindo grafite entre outros.

No entanto, o Sensu usa outra fila de mensagens para entregar mensagens, o RabbitMQ . Talvez seja necessário algum trabalho de codificação, mas você pode tentar substituir uma das duas filas de mensagens, pois os dois devem estar usando o protocolo AMQ para trocar mensagens.

Eu recomendo que você procure duas coisas: Salt Mine - http://docs.saltstack.com/topics/mine/ Salt Events - http://docs.saltstack.com/topics/event/index.html

Se você combiná-los com sua própria configuração de retorno, para armazenar resultados em grafite ou em qualquer outro listado. É possível usar o Salt para lidar com 'sondagem' de cima para baixo e 'evento' de baixo para cima. Eu não seria capaz de comentar sobre a eficácia de tal sistema, mas, em princípio, parece haver a possibilidade.

Descrevi minha jornada para o monitoramento de Nag por sub-segundo por host através da mina de sal e check_mk aqui: http://garthwaite.org/saltmine_check_mk_agent.html

O artigo percorre semanas de mexer sem parar para fazer tudo funcionar. Vou resumir a solução:

Crie um módulo check_mk personalizado para todos os 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')

Defina o intervalo de minas do lacaio para um minuto:

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

Configure o servidor de monitoramento para extrair toda a saída check_mk_agent do minion em um único arquivo json e, em seguida, configure check_mk para consultar esse arquivo em vez de quaisquer consultas de rede. Tudo realizado com o seguinte script no assistente de monitoramento:

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

Atualize a cada minuto:

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

Por fim: altere a fonte de dados para todos os destinos do nagios em /etc/check_mk/main.mk:

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