O Salt (Saltstack) pode reunir e transmitir dados para Graphite, Ganglia ou Zenoss?

Question

Estou iniciando um novo projeto e pensando em usar Ansible ou Sal para automação de implantação e, talvez, orquestração mais sofisticada (gerenciamento e federação de servidores).

Com Salt eu estou querendo saber se há alguma integração entre ele e Grafite ou Zenoss ou Ganglia ... usando o Salt conexões 0mq para retransmitir os dados dos" minions "Salt para o banco de dados / coletores de monitoramento / gráficos.

Alguém mais olhou para isso?

    

Answer 1

Eu usei o Sal Stack por mais de 6 meses para gerenciar mais de 40 nós.

na minha configuração atual eu uso:

• Icinga como servidor de monitoramento
• NRPE para executar as verificações nos nós
• grafite coleta os dados dos nós collectd
• collectd para coletar e enviar métricas para o grafite
• gdash para um bom painel para visualizar as métricas de grahite
• pilha de sal e, finalmente, pilha de sal para distribuir as configurações de NRPE / Collectd em cada nó

als isso roda sob o CentOS 6.x

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

Eu tenho muitas vezes problemas em não alcançar o mestre ou o inchaço da memória nos minions de sal. Isso pode ser corrigido com uma solução fácil que você reinicia a cada 24 horas / onceaweek the salt-minions.

mas esse problema no salt-minion não permite a coleta de dados no framework 0mq.

minha configuração atual é segura. Eu posso inscrever mudanças muito rapidamente com o stack de sal e coletar nos nós o truque.

    

Answer 2

Eu acho que Salt ou Ansible não são criados para essa tarefa e eu acho que eles não podem ser usados para esse propósito.

Estou usando o Salt por vários meses e não reparei nas opções de funções que você quer (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 é pedir ao sal para instalar o collectd que pode coletar dados sobre o sistema (e possui conectores para grafite)

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

    

Answer 3

Você pode querer dar uma olhada em Sensu , é uma solução de monitoramento plugável com vários plugins da comunidade, incluindo grafite entre outros.

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

    

Answer 4

Eu recomendo que você analise duas coisas: Mina de sal - link Eventos Salt - link

Se você combinar esses itens com a configuração de devolução do próprio armazenador para armazenar os resultados em grafite ou qualquer um dos outros listados. Você pode usar o Salt para lidar com o top down 'sondando' e bottom 'eventing'. Eu não seria capaz de comentar sobre a eficácia de tal sistema, mas em princípio parece haver a possibilidade.

    

Answer 5

Eu delineei minha jornada para o monitoramento de nagios de sub-segundo-por-hospedeiro através da mina de sal e check_mk aqui: link

O artigo aborda semanas de ajustes para que tudo funcione. 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 de minions 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 qualquer consulta de rede. Tudo realizado com o seguinte script no minion 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

Finalmente: Altere a fonte de dados para todos os alvos do nagios em /etc/check_mk/main.mk:

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