História da tarefa
Empresas menores, de um lado, precisam de um monitoramento de qualidade de sua infraestrutura (especialmente à luz da virtualização generalizada), e, do outro lado, é financeiramente difícil para elas adquirirem novos equipamentos. Também é comum enfrentar problemas de servidor/hardware: frequentemente existem de 1 a 3 servidores em torre próximos às estações de trabalho dos usuários ou em um pequeno nicho/espaço.
É mais fácil usar uma montagem pronta (distribuição), que pode ser simplesmente carregada em um cartão microSD e inserida em um computador de placa única comum (beaglebone, famílias raspberry pi e orange pi, asus tinker board). Além disso, esse tipo de equipamento custa pouco e pode ser instalado em qualquer lugar.
Formulação do problema
Em muitos aspectos, o projeto se desenvolveu como uma espécie de trabalho de laboratório com a possibilidade de aplicação dos resultados.
Foi escolhida a sistema de monitoramento zabbix, pois é uma solução poderosa, gratuita e bem documentada.
A questão da plataforma de hardware se tornou urgente. Instalar uma máquina separada para monitoramento também não é uma boa solução — ou é caro adquirir novos equipamentos, ou se deve procurar equipamentos antigos + em pequenas empresas, frequentemente ocorrem problemas de servidor/hardware.
O uso do sistema de montagem buildroot permite criar soluções especializadas que podem ser operadas por pessoal com conhecimentos mínimos do sistema operacional da família Linux. Este sistema é amigável para iniciantes, mas ao mesmo tempo oferece amplas possibilidades de personalização nas mãos de um desenvolvedor experiente. Ele é ideal para resolver o problema de um monitoramento de TI econômico, mas funcional, que exige o mínimo de treinamento do pessoal que o opera.
Passos da solução
Foi decidido inicialmente criar um firmware para x86_64 para executar no qemu, pois é uma solução conveniente e rápida para depuração. Depois, portá-lo para um computador de placa única arm (eu gostei do asus tinker board).
O sistema de montagem escolhido foi o buildroot. Inicialmente, ele não possui o pacote zabbix, então precisei portá-lo. Havia problemas com a localidade russa, que foram resolvidos aplicando os patches correspondentes (observação: em versões mais recentes do buildroot, esses patches já não são necessários).
A portação do próprio pacote zabbix será descrita em um artigo separado.
Como tudo deve funcionar como um firmware (imagem do sistema imutável + arquivos de configuração/banco de dados recuperáveis), foi necessário escrever seus próprios targets, serviços e temporizadores do systemd (target, service, timer).
Foi decidido dividir o armazenamento em 2 partições — uma partição para os arquivos do sistema e uma partição para os arquivos de configuração modificáveis e do banco de dados do zabbix.
Resolver as questões relacionadas ao banco de dados foi um pouco mais complicado. Colocá-lo diretamente no armazenamento era indesejável. Ao mesmo tempo, o tamanho do banco pode ultrapassar o tamanho do possível ramdisk. Portanto, foi escolhida uma solução de compromisso: o banco de dados é colocado na segunda partição do cartão SD (cartões SLC modernos têm até 30.000 ciclos de gravação), mas há uma configuração que permite usar um armazenamento externo (por exemplo, um usb-hdd).
O monitoramento de temperatura foi implementado através do dispositivo RODOS-5. Claro, pode-se usar o Dallas 1820 diretamente, mas foi mais rápido e fácil conectar via USB.
Como carregador para x86_64, foi escolhido o grub2. Foi necessário escrever uma configuração mínima para iniciar.
Após a depuração no qemu, a portabilidade foi realizada no asus tinker board. A estrutura do meu overlay foi inicialmente projetada para ser multiplataforma — distinguindo as configurações específicas para cada placa (defconfig da placa, carregador, geração de imagem com a partição do sistema) e buscando a máxima uniformidade na configuração do sistema de arquivos/criação da imagem com os dados. Devido a essa preparação, a portabilidade foi rápida.
É altamente recomendável ler os artigos introdutórios:
Como compilar
Após clonar o repositório, a seguinte estrutura de arquivos é obtida:
[alexey@comp monitor]$ ls -1
buildroot-2019.05.tar.gz
overlay
README.md
run_me.shbuildroot-2019.05.tar.gz — archive do buildroot limpo
overlay — meu diretório com external-tree. É aqui que está tudo o que é necessário para compilar o firmware usando o buildroot
README.md — descrição do projeto e manual em inglês.
run_me.sh — script que prepara o sistema de compilação. Extrai o buildroot do arquivo, conecta o overlay (através do mecanismo external-tree) e permite escolher a placa de destino para a compilação.
[0] my_asus_tinker_defconfig
[1] my_beaglebone_defconfig
[2] x86_64_defconfig
Selecione defconfig, pressione A para abortar. Padrão [0]Depois disso, é suficiente acessar o diretório buildroot-2019.05 e executar o comando make.
Após a conclusão da construção, todos os resultados da construção estarão no diretório output/images:
[alexey@comp buildroot-2019.05]$ ls -1 output/images/
boot.img
boot.vfat
bzImage
data
data.img
external.img
external.qcow2
grub-eltorito.img
grub.img
intel-ucode
monitor-0.9-beta.tar.gz
qemu.qcow2
rootfs.cpio
sdcard.img
sys
updateArquivos necessários:
- sdcard.img — imagem do dispositivo para gravação em um cartão SD (via dd ou rufus no Windows).
- qemu.qcow2 — imagem do dispositivo para execução no qemu.
- external.qcow2 — imagem do dispositivo externo para o banco de dados.
- monitor-0.9-beta.tar.gz — arquivo para atualização através da interface web.
Geração de manuais
Não vale a pena escrever a mesma instrução várias vezes. É mais lógico escrever uma vez em markdown, depois convertê-la para PDF para download e HTML para a interface web. Isso é possível graças ao pacote pandoc.
Além disso, todos esses arquivos precisam ser gerados antes de a imagem do sistema ser construída, pois os scripts pós-construção já são inúteis. Portanto, a geração é realizada na forma de um pacote manuals. Você pode visualizar em overlay/package/manuals.
O arquivo manuals.mk (que realiza todo o trabalho)
################################################################################
#
# manuals
#
################################################################################
MANUALS_VERSION:= 1.0.0
MANUALS_SITE:= ${BR2_EXTERNAL_monitorOverlay_PATH}/package/manuals
MANUALS_SITE_METHOD:=local
define MANUALS_BUILD_CMDS
pandoc -s -o ${TARGET_DIR}/var/www/manual_en.pdf ${BR2_EXTERNAL_monitorOverlay_PATH}/../README.md
pandoc -f markdown -t html -o ${TARGET_DIR}/var/www/manual_en.html ${BR2_EXTERNAL_monitorOverlay_PATH}/../README.md
endef
$(eval $(generic-package))systemd
O mundo Linux está migrando ativamente para systemd, e eu tive que fazer isso também.
Uma das novidades agradáveis é a presença de temporizadores. Na verdade, sobre eles (e não só sobre eles) é escrito um artigo separado, mas vou resumir.
Há ações que precisam ser executadas periodicamente. Eu precisava iniciar o logrotate para limpar os logs do lighttpd e php-fpm. A maneira mais comum seria escrever os comandos no cron, mas eu decidi usar o temporizador monótono do systemd. Assim, o logrotate é iniciado em um intervalo de tempo estrito.
Claro, há a possibilidade de criar temporizadores que são acionados em datas específicas, mas isso não foi necessário para mim.
Exemplo de temporizador:
- Arquivo do temporizador
[Unit] Description=Temporizador do daemon RODOS
[Timer]
OnBootSec=1min
OnUnitActiveSec=1min
[Install]
WantedBy=timers.target
- Arquivo de serviço chamado pelo temporizador:
```bash
[Unit]
Description=Daemon RODOS temp
[Service]
ExecStart=/usr/bin/rodos.shPlacas suportadas
Asus tinker board — a placa principal na qual tudo deve funcionar. Escolhida por ser barata e bastante poderosa.
Beaglebone black — a primeira placa na qual o funcionamento foi testado (durante a busca por uma placa mais poderosa).
Qemu x86_64 — utilizado para desenvolvimento e depuração.
Como funciona
No início, ocorre uma restauração de configurações em duas etapas:
- execução do script settings_restore (através do serviço). Ele restaura as configurações básicas do sistema — fuso horário, localidade, configurações de rede etc.
- execução do script prepare (através do serviço) — aqui o zabbix é preparado, o banco de dados é configurado, e o IP é exibido no console.
Na primeira inicialização, o tamanho da segunda partição do cartão SD é determinado. Se houver espaço não alocado, o dispositivo será reparticionado, e a partição de dados ocupará todo o espaço livre. Isso é feito para reduzir o tamanho da imagem de instalação (sdcard.img). Além disso, nesse momento, um diretório de trabalho do postgresql é criado. É por isso que a primeira inicialização com um novo dispositivo leva mais tempo do que as sucessivas.
Ao conectar um disco externo, no momento da inicialização, ele procura um disco livre e o formata em ext4 com a etiqueta external.
Atenção! Ao conectar um disco externo (assim como ao desconectar ou substituí-lo), é necessário fazer backup e restaurar as configurações!
Para monitorar a temperatura, um dispositivo RODOS 5 é utilizado. O fabricante fornece os códigos-fonte de sua ferramenta para trabalhar com o dispositivo. Ao ligar o sistema, um temporizador rodos é iniciado, que executa essa ferramenta uma vez por minuto. A temperatura atual é gravada no arquivo /tmp/rodos_current_temp, após o que o zabbix pode monitorar esse arquivo como um sensor.
O dispositivo para armazenar a configuração é montado no diretório /data.
Ao iniciar o sistema e prepará-lo para o trabalho, a mensagem aparece no console:
Sistema iniciando, por favor aguardeApós a conclusão dos trabalhos preparatórios, a mensagem mudará para a exibição do endereço IP:
ip atual 192.168.1.32
Pronto para trabalharConfiguração do zabbix para monitoramento da temperatura
Para monitorar a temperatura, basta seguir 2 passos:
- conectar o dispositivo RODOS à porta USB
- criar um item de dados no zabbix
Abrimos a interface web do zabbix:
- Abrimos a seção Configuração → Hosts
- Clicamos em Itens na linha do nosso servidor zabbix
- Clicamos em Criar item
Inserimos os seguintes dados:
- nome — a seu critério (por exemplo, serverRoomTemp)
- Tipo — agente zabbix
- Chave — rodos
- Tipo — numérico
- Unidades — C
- Período de armazenamento do histórico — prazo de armazenamento do histórico. Deixei 10 dias
- Período de armazenamento de tendências — prazo de armazenamento da dinâmica de mudanças. Deixei 30 dias
- Nova aplicação — Temperatura da Sala do Servidor
E clicamos no botão ADICIONAR.
Gerenciamento de configurações através da interface web
A interface web é escrita em php. Existem funções principais:
- visualização do estado do dispositivo
- alteração das configurações de rede
- mudança da senha de usuário
- escolha do fuso horário
- backup/restauração/reset para configurações de fábrica
- possibilidade de conectar um disco externo
- Atualização do sistema
O acesso à interface web é protegido por senha. A página inicial é o manual.
Endereço da interface zabbix: ${ip/dns}/zabbix
Endereço da interface de gerenciamento: ${ip/dns}/manage
Iniciar no qemu
qemu-system-x86_64 -smp 4 -m 4026M -enable-kvm -machine q35,accel=kvm -device intel-iommu -cpu host -net nic -net bridge,br=bridge0 -device virtio-scsi-pci,id=scsi0 -drive file=output/images/qemu.qcow2,format=qcow2,aio=threads -device virtio-scsi-pci,id=scsi0 -drive file=output/images/external.qcow2,format=qcow2,aio=threads
Este comando iniciará o sistema com 4 núcleos, 2048 RAM, KVM ativado, uma placa de rede na ponte bridge0 e dois discos: um para o sistema e outro externo para postgresql.
As imagens podem ser convertidas e executadas no Virtualbox:
qemu-img convert -f qcow2 qemu.qcow2 -O vdi qcow2.vdi
qemu-img convert -f qcow2 external.qcow2 -O vdi external.vdiDepois, importá-los para o virtualbox e conectá-los via sata.
Conclusão
No processo, fiquei interessado em criar um produto funcional — com uma interface não muito bonita (não gosto de escrevê-las), mas que funcione e seja simples de configurar.
A última tentativa de instalar o zabbix-appliance no KVM mostrou a validade deste passo (depois da conclusão da instalação, o sistema não inicia). Talvez eu esteja fazendo algo errado 😉
Fonte: habr.com
