1
Monitoramento de Redes utilizando Netflow
e Software Livre: estudo de caso no POP-GO1
Giovane César Moreira Moura
POP-GO – Ponto de Presença da RNP em Goiás
Praça Universitária, S/N. Setor Universitário. Escola de Engenharia,
Prédio UFGNET. CEP-74605-220 – Goiânia,GO
[email protected]
Resumo.
Este artigo trata do uso de Netflow como ferramenta para monitoramento da
rede do POP-GO. Mostramos como foi automatizado o processo de
caracterização do tráfego utilizando somente software livre em sistema
operacional Linux. Todo código-fonte desenvolvido é disponibilizado neste
artigo.
1. Introdução
O monitoramento de redes tem a função de prover dados e ferramentas para
auxiliar o engenheiro de tráfego ou administrador de redes em basicamente quatro
atividades:
a) Dimensionamento de infra-estrutura de TI: Este é um dos problemas mais
difíceis para os administradores resolverem. O monitoramento fornece dados tais como a
porcentagem do uso do link, o atraso inerente da rede, o tempo de resposta, etc. Esses
dados podem ser valiosos para determinar os gargalos do sistema, que são pontos a serem
alterados para uma melhor desempenho. Um exemplo seria de uma empresa que fosse
lançar um novo produto com venda pela internet. Como deveria ser expandido sua
infraestrutura afim de atender a nova demanda, que aumentaria com o lançamento do
novo produto? Se não for feito um dimensionamento correto, os usuários podem não
conseguir finalizar a compra no site da empresa. Como conseqüência, eles simplesmente
deixarão de comprar. O sucesso do produto depende é diretamente relacionado ao
desempenho do sistema.
b) Segurança: segurança atualmente não é mais uma opção, é uma necessidade
para todos os tamanhos de empresas. Tanto para guardar os segredos comerciais e também
para garantir a privacidade dos consumidores e funcionários. Imagine uma loja varejista
online que tivesse todo o seu cadastro de clientes extraviado, incluindo dados como
número de cartão de crédito. O monitoramento neste caso fornece marcas sobre atividades
suspeitas na rede e pode ser usado para identificar origem de tentativas de ataques.
c) Caracterização do tráfego: Um administrador pode querer saber quais serviços
estão sendo mais utilizados na rede, e para isso o monitoramento é feito para indicar o uso
de cada serviço em relação a capacidade da rede. Um exemplo seria separar o tráfego por
serviços (http, ftp, smtp) para dimensionar corretamente o sistema. No POP-GO fizemos
uma caracterização do tráfego que será mostrada neste mesmo artigo.
d) Estudo em geral.
1 Ponto de Presença da RNP em Goiás
2
Dentre as diversas tecnologias de monitoramento de redes, duas se destacam. A
primeira e mais simples é o uso do protocolo SNMP [SNM 2005] . SNMP vem embutido
em vários dispositivos como roteadores domésticos ADSL, switches e dispositivos de
redes em geral. SNMP também pode ser instalado em sistemas operacionais.SNMP é o
protocolo mais utilizado para monitoramento, pois é fácil de ser configurado, requer
pouca largura de banda e pouca carga de CPU. Além de parâmetros de rede, SNMP pode
monitorar outros parâmetros não inerentes a rede, como o espaço em disco de uma
estação, temperatura, etc... . Para estudos iniciais de monitoramento, recomenda-se o uso
de SNMP. Existe ferramentas livres que integram o monitoramento com SNMP, entre elas
o JFFNMS [JFF 2005] Cacti [CAC 2005] . Porém para os dados que necessitávamos o
SNMP não nos atendia.
Outra tecnologia utilizada para monitoramento de redes é o Cisco IOS Netflow
[NET 2005]. Foi esta tecnologia que utilizamos no POP-GO para caracterização do
tráfego, devido a uma série de fatores, como facilidade de trabalhar com grande volume
de dados, conseguir monitorar o tráfego por endereços IP específicos e já estar disponível
no nosso ponto de monitoramento: o roteador de borda.
No item 2 explicamos o porquê do monitoramento, no item 3 explicamos o projeto
de monitoramento do POP-GO, bem como o configuração do software necessário, tanto
quanto a disponibilização de todo código desenvolvido sob licença GPL. No item 4
comentamos os resultados obtidos, com as metas cumpridas. O item 5 é a conclusão do
projeto, e invoca a comunidade para trabalhar com o código. Há ainda 5 anexos ao artigo,
que trazem o código fonte desenvolvido para este projeto.
2. Necessidade de monitoramento
A origem deste projeto foi a necessidade de um único relatório. E a partir da
entrega deste relatório, continuamos o projeto estendendo para um uso diversificado.
O relatório exigido surgiu a partir de um problema detectado. O POP-GO é
conectado ao POP-DF1 via uma conexão ATM alugada de uma operadora de telefonia
( um contrato anual, licitado todo ano). No ano de 2004, a empresa que fornecia o link era
então a Brasil Telecom [BRT 2005] . Detectamos que quando um usuário de dentro da
rede do POP-GO tentava acessar um site hospedado em Goiás (exemplo: Detran-GO –
www.detran-go.gov.br), os pacotes deste usuário saíam do POP-GO e iam até Curitiba-PR
para então voltarem para Goiânia. Os pacotes percorriam um caminho muito extenso pelo
país, ocasionando maior atraso para o usuário final e uma sobrecarga desnecessária aos
demais enlaces da RNP (DF,RJ e PR) para rotear pacotes que poderiam ter ficado dentro
do estado de GO mesmo. Para solucionar este problema, foi pensado um projeto de Ponto
de Troca de Tráfego2 entre POP-GO e Brasil Telecom. PTT é um conceito implementado
em roteadores de borda(no nosso caso um Cisco 7500). A implantação de um PTT
exigiria um maior uso de memória e recursos do roteador. Foi necessário então um estudo
de viabilidade do projeto, para justificar o uso de tais recursos. Deveríamos descobrir
quanto de tráfego da rede do POP-GO se destinava a rede da Brasil Telecom (entenda-se
todos os clientes da Brasil Telecom , incluindo-se usuários de ADSL,empresas que
contratam link da concessionária, o governo, e etc..) e quanto do tráfego que entrava na
rede POP-GO proveniente da rede da Brasil Telecom. Se fosse uma porcentagem
significativa de todo tráfego, o PTT seria algo interessante para ambas partes.
1 Ponto de Presença da RNP no Distrito Federal
2 PTT - Ponto de Troca de Tráfego Internet é uma rede eletrônica de alta velocidade onde as redes
distintas se conectam por meio de roteadores IP com o propósito de troca de tráfego.
3
3. Projeto de monitoramento
Como obter esses dados para o relatório? Para explicar melhor, é necessário
mostrar a topologia do POP-GO na Figura 1:
Figura 1: Topologia Lógica do POP-GO
Esta figura representa a topologia lógica em alto nível do POP-GO (sem
considerar a REMAV Goiânia, a qual seu tráfego fica apenas dentro da rede do POP-GO,
não passando para a internet). Observe que o POP-GO conecta UFG,
Embrapa,CEFET,Sectec e a secretaria municipal de Educação ao POP-DF, e de lá a
Internet. Para o tal, todo o tráfego destes clientes vai para um conjunto de switches
(representado pelo switch maior), culminando roteador de borda Cisco 7500. Ou seja,
basta apenas monitorar todo o tráfego por um ponto da rede, no roteador de borda. Se um
aluno de dentro da UFG tenta acessar, por exemplo, o site www.detran.go.gov.br (que
pertence a rede Brasil Telecom), esses dados passam pela rede da UFG inteira até alcançar
o Cisco 7500 do POP-GO. E lá conseguimos também monitorar o quanto de tráfego de
entrada da Brasil Telecom acessa nossa rede. Uma analogia seria como se o Cisco 7500
fosse uma ponte que liga uma ilha (rede do POP-GO) a um continente(Internet).
Para realizar o monitoramento apenas no roteador de borda, a Cisco disponibiliza a
tecnologia Netflow [NET 2005]. Cisco IOS Netflow é um software disponível no roteador
Cisco 7500 do POP-GO, que provê um conjunto chave de serviços para aplicações IP,
incluindo contagem de tráfico de rede, billing baseado no uso da rede (por exemplo,
monitorar quanto de download um determinado IP realizou), permitem um maior
planejamento da rede, maior segurança, monitoramento de tentativas de DoS1 e DDoS2 e
caracterização do tráfego. Podemos extrair diversas informações, sobre os usuários da
rede e quais aplicativos estão usando, horário de pico, roteamento, etc.
O funcionamento do Netflow é basicamente o seguinte: a medida que os pacotes
passam por suas interaces, o roteador ( Figura 1) gera dados sobre o tráfego (que são
“logs” dos pacotes). Desses fluxos ele acumula dados com características únicas,como
1 Denial of Service, ou ataque de negação de serviço
2 Distributed Denial of Service, ou ataque distribuído de negação de serviço.
4
endereço IP, aplicação, CoS. Então esses dados condensados são exportados para um
coletor que os recebe,armazena e então analisa (no nosso caso, utilizamos uma estação
IBM Netfinity PIII 550Mhz para coleta de dados utilizando Slackware Linux [SLA
2005]). Vide Figura 2.
O software de coleta faz parte do flow-tools [FLO 2005] , que é um conjunto de
ferramentas livres). Um dos softwares integrantes do flow-tools, o flow-capture, fica
captando os dados vindos do Cisco 7500 na porta 9800 utilizando UPD como protocolo de
transporte (diminuindo o overnhead). A título de ilustração, no POP-GO coletávamos até
220MB/dia, em dias de tráfego intenso. O volume de dados é diretamente proporcional a
quantidade de tráfego. É um volume expressivo de dados, visto que estes são dados brutos
e precisam ser tratados por softwares para se extrair a informação desejada.
Como o Netflow coleta os fluxos e sumariza usando IP, poderíamos aplicar regras
na análise dos dados coletados e obter respostas a perguntas como: “queremos saber qual
a porcentagem dos dados que passam pelo nosso roteador vão para a rede da Brasil
Telecom e qual a porcentagem dos dados de entrada que vem de lá”, apenas informando a
nossa ferramenta de análise, o flow-tools, quais faixas de endereços IP pertenciam a rede
Brasil Telecom .
Com o projeto definido, bastava apenas a implementação do que foi estipulado. O
que foi feito durante a execução foi basicamente:
1. Pedir para o pessoal da administração da RNP no Rio de Janeiro configurar
remotamente o Cisco 7500 para exportar os dados coletados pelo Netflow para nossa
estação coletora (IBM PIII 550Mhz).
2. Configurar a estação para coletar os dados.
3. Esperar o tempo de coleta. Para termos uma boa estatística, precisávamos de um
bom espaço amostral, que foi definido para um período de 37 dias de coleta.
4. Gerar o relatório após os 37 dias.
O relatório foi então entregue no dia 23/09/2004. Descobrimos então que a Brasil
Telecom respondeu por 17,64% dos uploads e 11,65% dos downloads na rede do POPGO. Neste ponto finalizou-se o objetivo inicial, porém não paramos por aí.
Uma vez que a máquina a coletora ainda continuava a receber os dados do
Netflow, decidimos então ampliar o uso da ferramenta para obter outras análises, uma
extensão para caracterização de tráfego automatizada.
Essa extensão se basearia em:
a) Analisar os dados diariamente e extrair informações. Queriamos ter informações
sobre o volume total de upload e download e também o tráfego de entrada e saídas nas
portas 80(http), 20(ftp), 25(snmp).
b) Que essa análise fosse automática, e gerasse gráficos todos os dias.
c) Esses gráficos fossem disponibilizados no site do POP-GO.
Para executar tal projeto, precisariamos deixar a máquina coletora sempre online
recebendo fluxos de netflow, 24horas por dia, 7 dias por semana, e então analisar e
armazenar. Baseado em nossa experiência anterior com o JFFNMS [JFF 2005], o qual
usa a ferramenta RRDTool [RRD 2005] para armazenar os dados e gerar os gráficos
colhidos via SNMP, decidimos utilizar o RRDTool para armazenar e gerar dados a partir
da colteta do Netflow. Até este momento tinhámos relatórios do flow-tools e sabíamos
5
onde queríamos chegar, que era ter gráficos com RRDTool. O que fizemos foi
desenvolver scripts para automatizar a tarefa.
Nossa infra estrutura para o projeto é descrita na Figura 2:
Figura 2:Hardware e Software envolvido no projeto
No roteador não fizemos nada; ficou por conta do pessoal da RNP do Rio de
Janeiro configurá-lo para exportar os fluxos para nossa estação. E nessa estação que todo
trabalho foi executado. Depois de analisar os dados e gerar os gráficos, é tudo transmitido
via ssh com chave para o servidor web do PoP-GO.
3.1 Configuração da estação coletora
Para configurar a estação coletora, a primeira coisa é instalar o pacote flow-tools.
Feito isso, utilizamos o flow-capture para coletar os dados, com o comando abaixo:
#flow-capture -w /netflow -E20G <ip_estação_coletora>/0/9800
Este comando informa ao flow-capture(software integrante do flow-tools) para
coletar os dados na porta 9800 e os armazenar na pasta /netflow, num total de 20G (-E20G
- quando este limite é atingido, os dados mais antigos são sobrepostos).
Com esta linha é criado automaticamente uma estrutura de diretórios dentro de
/netflow separados por ano, mês e dia. E dentro do dia em questão é que os arquivos
dos fluxos são propriamente armazenados.
A árvore diretórios criada pode ser vista na Figura 3:
6
|-|
|
|
|
|
|
|
|
|
2004
|-- 2004-10
|
|-- 2004-10-01
|
|-- 2004-10-02
|
|-- 2004-10-03
|
|-- 2004-10-04
|
|-- 2004-10-05
|
|-- 2004-10-06
|
|-- 2004-10-07
|
|-- 2004-10-08
Figura 3: Estrutura de Diretórios criada pelo flow-capture
Dentro de cada diretório é que ficam os arquivos de flows, quem podem ser vistos
na Figura 4 :
bash-3.00$ du -h
1.3M
1.3M
1.2M
1.2M
ft-v05.2005-08-09.000000-0300
ft-v05.2005-08-09.001500-0300
ft-v05.2005-08-09.003000-0300
ft-v05.2005-08-09.004500-0300
Figura 4: Flows armazenados
A nomenclatura destes arquivos segue o padrão: ft indica flow-tools, v05 é a
versão do Netflow, 2005-08-09 é a data do arquivo, e 001500 é a hora , ou seja,
00:15min. -0300 significa o fuso horário, que é GMT -3 para o Brasil.
Flow-tools são um conjunto de ferramentas. Para utilizá-las, basta encadear no
shell (bash no nosso caso) por pipes para obter os relatórios desejados. Seguem alguns
dos principais componentes do flow-tools na Tabela 1 :
Aplicativo
Função
flow-filter
Filtra o tráfego baseado em campos como porta. Por exemplo,
podemos querer saber quanto tráfego da AS Brasil telecom
corresponde a porta 80. Então marcamos os flows com flow-tag e
passamos para o flow-filter..
flow-cat
Concatena os arquivos de flow. Tipicamente os arquivos de flows
são referentes a 5 ou 15 minutos de exports. Use flow cat para
concatená-los e aumentar suas análises para perídos de tempo
maiores.
flow-report
Gera relatórios. Relatório contém IP de origem e destino, AS de
origem e destino. Mais de 50 tipos de relatórios são suportados.
flow-dscan
Ferramenta simples para detectar scanners na rede e tentativas de
ataques de negação de serviços (DDoS e DoS)
flow-header
flow-stat
Exibe metadados do flow.
Gerá relatórios também, dentre mais de 30 tipos possíveis.
Tabela 1: Alguns aplicativos flow-tools
7
Um exemplo do uso de flow-tools seria a execução do comando abaixo:
flow-cat /netflow | flow-filter -p25 |flow-stat -f0
Flow-cat concatena os arquivos do Netflow que estão abaixo da árvore /netflow,
então passa para a flow-filter via pipe, que filtra os fluxos que possuem tráfego na porta
25. Flow-stat gera relatório a partir dos dados vindos da cadeia de comandos anteriores.
Parte deste relatório é exibido abaixo:
## --- ---- ---- Report Information --- --- --#
# Fields:
Total
# Symbols:
Disabled
# Sorting:
None
# Name:
Overall Summary
#
# Args:
/usr/local/netflow/bin/flow-stat -f0
#
Total Flows
: 161145
Total Octets
: 203357738
Total Packets
: 3360762
Total Time (1/1000 secs) (flows): 1288065068
Duration of data (realtime)
: 86400
Duration of data (1/1000 secs) : 86470120
Average flow time (1/1000 secs) : 7993.0000
Average packet size (octets)
: 60.0000
Average flow size (octets)
: 1261.0000
Average packets per flow
: 20.0000
Average flows / second (flow)
: 1.8636
Average flows / second (real)
: 1.8651
Average Kbits / second (flow)
: 18.8142
Average Kbits / second (real)
: 18.8294
Visto um exemplo básico, passamos agora ao ambiente de produção, como é feito
o monitoramento.
Todo processo é resumido em scripts agendadados para o crond, para ser
executado a partir de 00:01 horas. O conteúdo do script daily, que é executado pelo
crond, pode ser visto na Figura 5 .
#!/bin/bash
#scrip daily – a ser executado diariamente pelo crond
#Giovane Moreira [email protected]
#scripts abaixo (n_generatte,n_ripdata e NGRAPHS geram o no
#final os gráficos, que são passados via scp ao servidor web
/var/scripts/n_generate
/var/scripts/n_ripdata
/var/scripts/NGRAPHS
scp -r -i /var/grafico/.ssh/id_rsa /var/scripts/graphs/
login@servidorweb:/var/www/htdocs/
Figura 5: Script daily, executado as 00:01 pelo crond
8
O fluxograma deste processo pode ser visto na Figura 6:
Figura 6: Fluxograma completo do projeto
Como se pode ver, daily na verdade invoca 3 scripts e realiza uma cópia dos
arquivos via scp para o servidor web.
3.2 Software desenvolvidos
Com a idéia do projeto já em mente, nos voltamos agora aos softwares
desenvolvidos no projeto, todos sobre a licença GPL. Estes softwares são os que o script
daily invoca. Incluem 3 scripts em shell e um software em C.
Script n_generate: gerar os relatórios do flow-tools a partir do que foi
armazenado no disco. Sempre se analisa os dados do dia anterior, por isso date recebe 1
day ago. Como produto gera uma série de arquivos com extensão txt, que são os relatórios
com várias linhas e informações. Disponível no Anexo 1.
Script n_ripdata: script que se contém expressões regulares para extrair dos
relatórios completos apenas os campos chaves que vão para o RRDTool para gerarem os
gráficos. Por exemplo, queremos saber quantos bytes passaram de upload na porta 25, e
armazenar isso em um arquivo para que possa ser lido, apenas o número total. E então
esse valor é armazenado nos arquivos do RRDTool. Disponível no Anexo 2
Software converte.c: Os relatórios que o n_ripdata estão em bytes. Este software
então converte de bytes para gigabytes os valores. Disponível no Anexo 3.
Script NGRAPHS: script responsável por gerar os gráficos e disponibilizar
automaticamente nos diretórios. Cria os gráficos, gera diretórios de acordo com a data.
Disponível no Anexo 4.
3.3 Entendendo o RRDTool
RRDTool é o software chave para gerenciar os dados fornecidos pelo Netflow e
gerar gráfico. Uma documentação de como foi implementado no POP-GO o uso do
RRDTool pode ser visto no Anexo 5.
4. Resultados Obtidos
Os resultados obtidos foram uma ferramenta automática que coleta, analisa, gera
gráficos e disponibiliza no servidor web usando apenas software livre na estações.
São disponibilizados diversos tipos de gráficos. O primeiro tipo é que condensa
todo o volume de uploads e downloads num gráfico apenas. Abaixo seguem os gráficos
9
disponibilizados para os dias 1 à 7 de agosto de 2005:
Um dos gráficos obtidos pode ser visto na Figura 7.
Figura 7: Gráfico gerado pelo RRDTool. Downloads de 1 à 7 de agosto.
Pela legenda da figura, percebe-se a curva de downloads no POP-GO durante uma
semana do mês de agosto de 2005. O valor máximo de download para um único dia desta
semana foi de 98.9GB. Percebe-se que a maior parte do tráfego do download não é
relacionado as portas mais comuns, como 80,20 e 25. O tráfego peer-to-peer [P2P 2005] é
um dos grandes responsáveis pelo restante dos downloads.
Outro gráfico é o que mostra todo o upload no mesmo período. Pode ser visto na
Figura 8.
Figura 8: Uploads de 1 à 7 de agosto
A Figura 7 e Figura 8 retrataram o tráfego caracterizado, ou seja , por portas.
Para um comparativo em termos de volume total (sem caracterização), podemos ver a
Figura 9:
10
Figura 9: Volume total de uploads e downloads
Mais gráficos podem ser consultados no site do POP-GO [POP 2005] , na seção
monitoramento. Existem gráficos mensais, gráficos de uploads e downloads por porta
(gráfico só para porta 80, 25 ,etc.)
5. Conclusão
A partir da necessidade de um relatório para viabilização de um PTT foi gerado
todo um projeto de monitoramento para o POP-GO. Geramos softwares que automatizam
toda a parte de caracterização do tráfego, desde a coleta a disponibilização no site do
POP-GO [POP 2005]. Com exceção do roteador Cisco,todos os demais softwares usados
neste projeto foram softwares livres. E todo o código produzido volta agora para a
comunidade em forma de software livre.
Ficou demonstrado a força do software livre na área de monitoramento de rede e a
capacidade de integração das mais diversas ferramentas. Com o flow-tools se coleta os
dados, e o RRDTool armazena os dados e gera os gráficos (e por sua vez RRDTool
utiliza outra grama de aplicativos livres, como a biblioteca gráfica GD para gerar
gráficos), então automatizamos este processo com scripts em Shell e código em C e
finalmente disponibilizar o conteúdo no servidor web (Apache) do POP-GO via scp.
Como produto final temos a seção “Monitoramento” do site do POP-GO sendo
atualizada automaticamente.
Temos a esperança que a comunidade melhore o código e venha a integrar com
outras ferramentas de monitoramento, como o JFFNMS [JFF 2005].
11
6. Referências
[SNM 2005] Net-SNMP . http://net-snmp.sourceforge.net/
[JFF 2005] JJFNMS - Just For Fun Network Management System.
http://www.jffnms.org
[CAC 2005] Cacti: The Complete RRDTool-based Graphing Solution.
http://www.cacti.net
[NET 2005] Cisco IOS Software NetFlow.
http://www.cisco.com/warp/public/732/Tech/nmp/netflow/index.shtml
[BRT 2005] Brasil Telecom - http://www.brasiltelecom.com.br/
[SLA 2005] The Slackware Linux Project. http://slackware.com/
[FLO 2005] flow-tools. http://www.splintered.net/sw/flow-tools/
[RRD 2005] RRDTool – About RRDTool.
http://people.ee.ethz.ch/~oetiker/webtools/rrdtool/
[P2P 2005] Peer-to-Peer – Wikipedia. http://en.wikipedia.org/wiki/Peer-topeer
[POP 2005] Ponto de Presença da RNP em Goiás http://www.pop-go.rnp.br
12
Anexo 1: Script n_generate
#n_generate é um software livre; você pode redistribui-lo e/ou
#modifica-lo dentro dos termos da Licença Pública Geral GNU como
#publicada pela Fundação do Software Livre (FSF); na versão 2 da
#Licença.
#Este programa é distribuido na esperança que possa ser util,
#mas SEM NENHUMA GARANTIA; sem uma garantia implicita de ADEQUAÇÂO
#a qualquer MERCADO ou APLICAÇÃO EM PARTICULAR. Veja a Licença
#Pública Geral GNU para maiores detalhes.
#!/bin/bash
#n_generate: script para acessar os diretórios gerados pelo flowcapture e então gerar os dados necessários para gerar os gráficos
via rrdtool.
#date recebe data no formato 2005/2005-07/2005-07-08, que é a
#estrutura de diretórios do flow-capture que contem os flows.
data=`date --date '1 days ago' +%Y/%Y-%m/%Y-%m-%d`
netflow_dir=/usr/local/netflow/bin
dir=/netflow/$data/
#acessa o diretório dos fluxos do dia.
cd $dir
echo $dir
#Gera upload.txt que contém o Upload Total do roteador
$netflow_dir/flow-cat $dir |$netflow_dir/flow-stat -f18>
/netflow/${data}/upload.txt
#Download Total
$netflow_dir/flow-cat $dir |$netflow_dir/flow-stat -f17
>/netflow/${data}/download.txt
#Upload na Porta 80
$netflow_dir/flow-cat $dir
|$netflow_dir/flow-filter -P80 |
$netflow_dir/flow-stat -f0 > /netflow/${data}/p80u.txt
#Download na Porta 80$netflow_dir/flow-cat $dir
|
$netflow_dir/flow-filter -p80 |$netflow_dir/flow-stat -f0 >
/netflow/${data}/p80d.txt
#Upload na Porta 20
$netflow_dir/flow-cat $dir
|$netflow_dir/flow-filter -P20 |
$netflow_dir/flow-stat -f0 >/netflow/${data}/p20u.txt
#Download na Porta 20
$netflow_dir/flow-cat $dir
|$netflow_dir/flow-filter -p20 |
$netflow_dir/flow-stat -f0 >/netflow/${data}/p20d.txt
#Upload na Porta 25
$netflow_dir/flow-cat $dir
|$netflow_dir/flow-filter -P25 |
$netflow_dir/flow-stat -f0 >/netflow/${data}/p25u.txt
#Download na Porta 25
13
$netflow_dir/flow-cat $dir
|$netflow_dir/flow-filter -p25 |
$netflow_dir/flow-stat -f0 >/netflow/${data}/p25d.txt
14
Anexo 2: Script n_ripdata
#n_ripdata é um software livre; você pode redistribui-lo e/ou
#modifica-lo dentro dos termos da Licença Pública Geral GNU como
#publicada pela Fundação do Software Livre (FSF); na versão 2 da
#Licença.
#Este programa é distribuido na esperança que possa ser util,
#mas SEM NENHUMA GARANTIA; sem uma garantia implicita de ADEQUAÇÂO
#a qualquer MERCADO ou APLICAÇÃO EM PARTICULAR. Veja a Licença
#Pública Geral GNU para maiores detalhes.
#!/bin/bash
#n_ripdata: script para extrair dados dos relatórios do flowtools, para então usar no RRDTTOOL
#como converter data em timestamp: date -d040914 +%s
netflow_dir=/usr/local/netflow/bin/
data=`date --date '1 days ago' +%Y/%Y-%m/%Y-%m-%d `
datastamp=`date --date '1 days ago' +%s`
cd /netflow/${data}
#abaixo são expressões regulares que extraem os campos que serão
#armazenados em arquivos _rrd.txt para leitura do RRDTool, apenas
o
#dado que interessa. É feito uma execução para cada txt.
#upload total
head -13 upload.txt|tail -1 | sed "s/\W* \W* \(\W\)/\1/g "
-F" " '{print $3}' > upload_rrd.txt
| awk
#download total
head -13 download.txt|tail -1 | sed "s/\W* \W* \(\W\)/\1/g "
awk -F" " '{print $3}' >download_rrd.txt
#download na porta 80
head -11 p80d.txt |tail -1 | sed "s/\W* \W* \(\W\)/\1/g "
-F" " '{print $3}' >p80d_rrd.txt
|
| awk
#download na porta 20
head -11 p20d.txt |tail -1 | sed "s/\W* \W* \(\W\)/\1/g "
-F" " '{print $3}' >p20d_rrd.txt
| awk
#download na porta 25
head -11 p25d.txt |tail -1 | sed "s/\W* \W* \(\W\)/\1/g "
-F" " '{print $3}' >p25d_rrd.txt
| awk
#upload na porta 80
head -11 p80u.txt |tail -1 | sed "s/\W* \W* \(\W\)/\1/g "
-F" " '{print $3}' >p80u_rrd.txt
| awk
#upload na porta 20
head -11 p20u.txt |tail -1 | sed "s/\W* \W* \(\W\)/\1/g "
-F" " '{print $3}' > p20u_rrd.txt
| awk
#upload na porta 25
15
head -11 p25u.txt |tail -1 | sed "s/\W* \W* \(\W\)/\1/g "
-F" " '{print $3}' >p25u_rrd.txt
| awk
#esses dados são gerados em bytes, queremos convertê-los para
#gigabytes, por isso chamamos o programa a.out (feito em c) para
#executar isso. E grava no mesmo arquivo. Apenas converte de bytes
#para gbytes.
temp=$(cat upload_rrd.txt)
/var/scripts/a.out $temp > upload_rrd.txt
temp=$(cat download_rrd.txt)
/var/scripts/a.out $temp > download_rrd.txt
temp=$(cat p20d_rrd.txt)
/var/scripts/a.out $temp > p20d_rrd.txt
temp=$(cat p20u_rrd.txt)
/var/scripts/a.out $temp > p20u_rrd.txt
temp=$(cat p25d_rrd.txt)
/var/scripts/a.out $temp > p25d_rrd.txt
temp=$(cat p25u_rrd.txt)
/var/scripts/a.out $temp > p25u_rrd.txt
temp=$(cat p80d_rrd.txt)
/var/scripts/a.out $temp > p80d_rrd.txt
temp=$(cat p80u_rrd.txt)
/var/scripts/a.out $temp > p80u_rrd.txt
#agora é que precisamos colocar os arquivos na forma que o RRDTOOL
#consegue armazenar. A saída será algo na forma: 40:30:20:20.30
#na documentação do rrdtool será explicado o porque desta forma.
#arquivo que o netflow lê e armazena. Versão dos downloads.
temp=`cat download_rrd.txt``echo :``cat p80d_rrd.txt``echo :``cat
p20d_rrd.txt``echo :``cat p25d_rrd.txt`
echo $temp > update_d
#arquivo que o netflow lê e armazena. Versão dos uploads.
temp=`cat upload_rrd.txt``echo :``cat p80u_rrd.txt``echo :``cat
p20u_rrd.txt``echo :``cat p25u_rrd.txt`
echo $temp >update_u
#comando que faz o rrdtool atualizar sua base com os arquivos
#coletados do dia. Apenas atualiza.
/usr/bin/rrdtool update /var/scripts/download.rrd $datastamp:`cat
update_d`
/usr/bin/rrdtool update /var/scripts/upload.rrd $datastamp:`cat
update_u`
16
Anexo 3: converte.c
//*converte é um software livre; você pode redistribui-lo e/ou
modifica-lo dentro dos termos da Licença Pública Geral GNU como
publicada pela Fundação do Software Livre (FSF); na versão 2 da
Licença.
Este programa é distribuido na esperança que possa ser util, mas
SEM NENHUMA GARANTIA; sem uma garantia implicita de ADEQUAÇÂO
qualquer MERCADO ou APLICAÇÃO EM PARTICULAR. Veja a Licença
Pública Geral GNU para maiores detalhes.*/
// converte.c – software de conversão de valores de byte para
gigabytes.
#include <stdlib.h>
# include <stdio.h>
#include <math.h>
int main(int argc, char *argv[]) {
if(argc != 2) return(99);
printf("%.3f",((atof(argv[1])/1024)/1024)/1024);
return(0);
}
17
Anexo 4: Script NGRAPHS
#NGRAPHS é um software livre; você pode redistribui-lo e/ou
#modifica-lo dentro dos termos da Licença Pública Geral GNU como
#publicada pela Fundação do Software Livre (FSF); na versão 2 da
#Licença.
#Este programa é distribuido na esperança que possa ser util,
#mas SEM NENHUMA GARANTIA; sem uma garantia implicita de ADEQUAÇÂO
#a qualquer MERCADO ou APLICAÇÃO EM PARTICULAR. Veja a Licença
#Pública Geral GNU para maiores detalhes.
#!/bin/bash
#NGRAPHS: script de criação de gráficos, árvore de diretórios de
disponibilização no apache. por Giovane Moreira [email protected]
#primeiramente devemos testar se há realmente os diretórios para
guardar os gráficos. A estrutura de diretórios segue o padrã
#graphs/ANO/MES <DENTRO DE MES TEM AS PASTAS
#mensal,1st,2nd,3rd,last,cada qual com 6 gráficos distintos.
#após atualizar os rrd , é preciso gerar os gráficos novamente e
#disponibilizar.
cd /var/scripts
ano=`date +%y`
mes=`date +%m`
temp=`date +%d`
ano_mes=`echo graphs/$ano/$mes`
ano_dir=`echo graphs/$ano`
rrdtool=/usr/bin/rrdtool
#determina qual semana estamos, se é 1, 2 3 ou 4
if [ $temp -lt 8 ]; then
semana=1
elif [ $temp -ge 7 ] && [ $temp -lt 15 ]; then
semana=2
elif [ $temp -ge 15 ] && [ $temp -lt 22 ]; then
semana=3
else semana=4
fi
#testa se os diretórios existem. Os gráfico são organizados
#árvore como: <ano><mes><semana>
if [ -d $ano_mes ];
then
echo "os dir estão ok"
elif [ -d $ano_dir ];
then
#cria dir do mes novo
mkdir /var/scripts/graphs/$ano/$mes
numa
18
mkdir
mkdir
mkdir
mkdir
mkdir
/var/scripts/graphs/$ano/$mes/mensal
/var/scripts/graphs/$ano/$mes/1st
/var/scripts/graphs/$ano/$mes/2nd
/var/scripts/graphs/$ano/$mes/3rd
/var/scripts/graphs/$ano/$mes/last
else
mkdir
mkdir
mkdir
mkdir
mkdir
mkdir
mkdir
/var/scripts/graphs/$ano
/var/scripts/graphs/$ano/$mes
/var/scripts/graphs/$ano/$mes/mensal
/var/scripts/graphs/$ano/$mes/1st
/var/scripts/graphs/$ano/$mes/2nd
/var/scripts/graphs/$ano/$mes/3rd
/var/scripts/graphs/$ano/$mes/last
fi
#funções que geram os gráficos.. serão invocadas logo
abaixo...
#Geral_updown: gera gráfico de upload e download total, sem
#dividir por portas.
Geral_updown() {
#gráfico down e upload total
syear=$1 #syear = start year – ano de início
smonth=$2
sday=$3
eano=$4 #eano = end ano – ano de fim
emes=$5
eday=$6
#essa variáveis valem para todas as funções de gráficos
desse
#script. Delimitam o intervalo de início e fim da
geração dos
#gráficos.
$rrdtool graph Geral_updown.gif --start `date -d
${syear}${smonth}${sday} +%s` --end `date -d ${eano}${emes}${eday}
+%s` --title "PoP-GO: Cisco - Downloads e Uploads Volume Total Ano:$syear Mês:$smonth" --vertical-label "gigabytes"
DEF:download=download.rrd:download:LAST
DEF:upload=upload.rrd:upload:LAST
LINE1:download#ff0000:"Downloads" LINE2:upload#0400ff:"Uploads"
'GPRINT:download:LAST:Último Download\:%2.1lf GB'
'GPRINT:upload:LAST:Último Upload\:%2.1lf GB'
'GPRINT:download:MAX:Download Max\:%2.1lf GB'
'GPRINT:upload:MAX:Upload Max\:%2.1lf GB' 'GPRINT:download:
MIN:Download Mín\:%2.1lf GB' 'GPRINT:upload:MIN:Upload Mín\:%2.1lf
GB' -w 509
}
#gera o gráfico de upload e download nas portas específicas.
Portas_updown() {
#gráfico down e upload nas portas específicas
19
syear=$1
smonth=$2
sday=$3
eano=$4
emes=$5
eday=$6
porta=$7
$rrdtool graph P${porta}_updown.gif --start `date -d
${syear}${smonth}${sday} +%s` --end `date -d ${eano}${emes}${eday}
+%s` --title "PoP-GO: Cisco - Downloads e Uploads Volume Total Porta $porta Ano:$syear Mês:$smonth" --vertical-label "gigabytes"
DEF:download=download.rrd:p${porta}d:LAST
DEF:upload=upload.rrd:p${porta}u:LAST
LINE1:download#ff0000:"Downloads Porta $porta"
LINE2:upload#0400ff:"Uploads Porta $porta"
'GPRINT:download:LAST:Último Download\:%2.1lf GB'
'GPRINT:upload:LAST:Último Upload\:%2.1lf GB'
'GPRINT:download:MAX:Download Max\:%2.1lf GB' 'GPRINT:up
load:MAX:Upload Max\:%2.1lf GB' 'GPRINT:download:MIN:Download
Mín\:%2.1lf GB' 'GPRINT:upload:MIN:Upload Mín\:%2.1lf GB' -w 509
}
All_down() {
#gráfico download geral e na P80,P20 e P25
syear=$1
smonth=$2
sday=$3
eano=$4
emes=$5
eday=$6
$rrdtool graph All_down.gif --start `date -d
${syear}${smonth}${sday} +%s` --end `date -d ${eano}${emes}${eday}
+%s` --title "PoP-GO: Cisco - Downloads - Volume Total Total,Portas 80,20,25 Ano:$syear Mês:$smonth" --vertical-label
"gigabytes" DEF:download=download.rrd:download:LAST
DEF:p80d=download.rrd:p80d:LAST DEF:p20d=download.rrd:p20d:LAST
DEF:p25d=download.rrd:p25d:LAST LINE1:download#ff0000:"Download
Total" LINE2:p80d#0400:"Download Porta 80"
LINE3:p20d#00FF00:"Download Porta 20"
'GPRINT:download:LAST:Último Download\:%2.1lf GB'
'GPRINT:p80d:LAST:Último Download
80\:%2.1lf GB' 'GPRINT:p20d:LAST:Último Download P20\:%2.1lf GB'
'GPRINT:p25d:LAST:Último Download P25\:%2.1lf GB'
'GPRINT:download:MAX:Download Max\:%2.1lf GB'
'GPRINT:p80d:MAX:Download Max P80 \:%2.1lf GB'
'GPRINT:p20d:MAX:Download Max P20 \:%2.1lf GB'
'GPRINT:p25d:MAX:Download Max P25:%2.1lf GB'
'GPRINT:download:MIN:Download Mín\:%2.1lf GB'
'GPRINT:p80d:MIN:Download Mín P80\:%2.1lf GB'
'GPRINT:p20d:MIN:Download Mín P20\:%2.1lGB'
'GPRINT:p25d:MIN:Download Mín P25\:%2.1lf GB' -w 509
}
20
All_up() {
#gráfic upload geral e na P80,P20 e P25
$rrdtool graph All_up.gif --start `date -d
${syear}${smonth}${sday} +%s` --end `date -d ${eano}${emes}${eday}
+%s` --title "PoP-GO: Cisco -Uploads - Volume Total Total,Portas 80,20,25 Ano:$syear Mês:$smonth" --vertical-label
"gigabytes" DEF:upload=upload.rrd:upload:LAST DEF:p80u=upload
rd:p80u:LAST DEF:p20u=upload.rrd:p20u:LAST
DEF:p25u=upload.rrd:p25u:LAST LINE1:upload#ff0000:"Upload Total"
LINE2:p80u#0400ff:"Upload Porta 80"
INE3:p20u#00FF00:"Upload Porta 20" 'GPRINT:upload:LAST:Último
Upload\:%2.1lf GB' 'GPRINT:p80u:LAST:Último Upload P80\:%2.1lf GB'
'GPRINT:p20u:LAST:Último Upload P20\:%2.1lf GB'
'GPRINT:p25u:LAST:Último Upload P25\:%2.1lf GB'
'GPRINT:upload:MAX:Upload Max\:%2.1lf GB' 'GPRINT:p80u:MAX:Upload
Max P80 \:%2.1lf GB' 'GPRINT:p20u:MAX:Upload Max P20 \:%2.1lf GB'
'GPRINT:p25u:MAX:Upload Max P25 \:%2.1lf GB'
'GPRINT:upload:MIN:Upload Mín\:%1lf GB' 'GPRINT:p80u:MIN:Upload
Mín P80\:%2.1lf GB' 'GPRINT:p20u:MIN:Upload Mín P20\:%2.1lf GB'
'GPRINT:p25u:MIN:Upload Mín P25\:%2.1lf GB' -w 509
}
#funções agora que setam variáveis e então invocam as funçoes
#geradoras de gráficos...#Mensal gera gráficos para o mês inteiro,
invocando funções anteriores:
Mensal () {
#seta syear, smonth e sday, eyear,emonth e eday e invoca
syear=$ano
smonth=$mes
sday=01
eyear=$ano
emonth=$mes
eday=07
Geral_updown $syear $smonth $sday $eyear $emonth $eday ;
Portas_updown $syear $smonth $sday $eyear $emonth $eday
80;
Portas_updown $syear $smonth $sday $eyear $emonth $eday
20;
Portas_updown $syear $smonth $sday $eyear $emonth $eday
25;
All_down $syear $smonth $sday $eyear $emonth $eday ;
All_up $syear $smonth $sday $eyear $emonth $eday;
#move paras as devidas pastas
mv Geral_updown.gif /var/scripts/graphs/$ano/$mes/1st/
mv P80_updown.gif /var/scripts/graphs/$ano/$mes/1st/
mv P25_updown.gif /var/scripts/graphs/$ano/$mes/1st/
mv P20_updown.gif /var/scripts/graphs/$ano/$mes/1st/
mv All_down.gif /var/scripts/graphs/$ano/$mes/1st/
mv All_up.gif /var/scripts/graphs/$ano/$mes/1st/
21
}
#segunda no caso se for a segunda semana do mês
Segunda () {
#seta syear, smonth e sday, eyear,emonth e eday
e invoca
syear=$ano
smonth=$mes
sday=08
eyear=$ano
eday=15
emonth=$mes
Geral_updown $syear $smonth $sday $eyear $emonth $eday ;
Portas_updown $syear $smonth $sday $eyear $emonth $eday
80;
Portas_updown $syear $smonth $sday $eyear $emonth $eday
20;
Portas_updown $syear $smonth $sday $eyear $emonth $eday 25;
All_down $syear $smonth $sday $eyear $emonth $eday ;
All_down $syear $smonth $sday $eyear $emonth $eday ;
All_up $syear $smonth $sday $eyear $emonth $eday;
#move paras as devidas pastas
mv Geral_updown.gif /var/scripts/graphs/$ano/$mes/2nd/
mv P80_updown.gif /var/scripts/graphs/$ano/$mes/2nd/
mv P25_updown.gif /var/scripts/graphs/$ano/$mes/2nd/
mv P20_updown.gif /var/scripts/graphs/$ano/$mes/2nd/
mv All_down.gif /var/scripts/graphs/$ano/$mes/2nd/
mv All_up.gif /var/scripts/graphs/$ano/$mes/2nd/
}
#para terceira semana do mês
Terceira () {
#seta syear, smonth e sday, eyear,emonth e eday
e invoca
syear=$ano
smonth=$mes
sday=16
eyear=$ano
emonth=$mes
eday=21
Geral_updown $syear $smonth $sday $eyear $emonth $eday ;
Portas_updown $syear $smonth $sday $eyear $emonth $eday
80;
Portas_updown $syear $smonth $sday $eyear $emonth $eday
20;
Portas_updown $syear $smonth $sday $eyear $emonth $eday
25;
All_down $syear $smonth $sday $eyear $emonth $eday ;
All_up $syear $smonth $sday $eyear $emonth $eday ;
22
#move as pastas pros devidos locaiss pastas
mv Geral_updown.gif /var/scripts/graphs/$ano/$mes/3rd/
mv P80_updown.gif /var/scripts/graphs/$ano/$mes/3rd/
mv P25_updown.gif /var/scripts/graphs/$ano/$mes/3rd/
mv P20_updown.gif /var/scripts/graphs/$ano/$mes/3rd/
mv All_down.gif /var/scripts/graphs/$ano/$mes/3rd/
mv All_up.gif /var/scripts/graphs/$ano/$mes/3rd/
}
#para última semana do mês
Last () {
#seta syear, smonth e sday, eyear,emonth e eday
e invoca
syear=$ano
smonth=$mes
sday=22
eyear=$ano
emonth=$mes
#informa se o mês tem 30 ou 31 ou 28 dias.
case $mes in
O1) eday=31 ;;
02) eday=28 ;;
03) eday=31 ;;
04) eday=30 ;;
05) eday=31 ;;
06) eday=30 ;;
07) eday=31 ;;
08) eday=31 ;;
09) eday=30 ;;
10) eday=31 ;;
11) eday=30 ;;
12) eday=31 ;;
esac
Geral_updown $syear $smonth $sday $eyear $emonth $eday ;
Portas_updown $syear $smonth $sday $eyear $emonth $eday 80;
Portas_updown $syear $smonth $sday $eyear $emonth $eday 20;
Portas_updown $syear $smonth $sday $eyear $emonth $eday 25;
All_down $syear $smonth $sday $eyear $emonth $eday ;
All_up $syear $smonth $sday $eyear $emonth $eday;
#move paras as devidas pastas
mv Geral_updown.gif /var/scripts/graphs/$ano/$mes/last/
mv P80_updown.gif /var/scripts/graphs/$ano/$mes/last/
mv P25_updown.gif /var/scripts/graphs/$ano/$mes/last/
mv P20_updown.gif /var/scripts/graphs/$ano/$mes/last/
mv All_down.gif /var/scripts/graphs/$ano/$mes/last/
mv All_up.gif /var/scripts/graphs/$ano/$mes/last/
}
All_down $syear $smonth $sday $eyear $emonth $eday ;
All_up $syear $smonth $sday $eyear $emonth $eday;
23
#move paras as devidas pastas
mv Geral_updown.gif /var/scripts/graphs/$ano/$mes/last/
mv P80_updown.gif /var/scripts/graphs/$ano/$mes/last/
mv P25_updown.gif /var/scripts/graphs/$ano/$mes/last/
mv P20_updown.gif /var/scripts/graphs/$ano/$mes/last/
mv All_down.gif /var/scripts/graphs/$ano/$mes/last/
mv All_up.gif /var/scripts/graphs/$ano/$mes/last/
}
#se for a 1ª semana, não há necessidade de gerar gráfico da
2ªsemana.
if [ $semana -eq 1 ]; then
#gera graficos mensal apenas, e copias ele pra pasta 1st..
pq #sao iguasi!
Mensal ;
Primeira ;
elif [ $semana -eq 2 ]; then
#gera grafico mensal, 1st e 2nd
Mensal ;
Primeira ;
Segunda ;
elif [ $semana -eq 3 ]; then
#gera grafico mensal, 1st, 2nd e 3rd
Mensal ;
Primeira ;
Segunda ;
Terceira ;
elif [ $semana -eq 4 ]; then
#gera todos os graficos
Mensal ;
Primeira ;
Segunda ;
Terceira ;
Last ;
fi
#copia os gráficos para o diretório correto.
cp -r /var/scripts/graphs /var/www/htdocs
chown -R nobody /var/www/htdocs/graphs
24
Anexo 5: Entendendo o RRDTool
RRDtool é uma ferramenta que cria arquivos na ordem round-robin e então
armazena os valores (como uma base de dados) e depois pode gerar gráficos a partir
desses valores. É uma evolução de outro projeto, o MRTG. Enquanto MRTG é focado em
aplicações SNMP, o RRDTool pode ser usado para monitorar qualquer tipo de dado,
desde dados de rede de computadores a crescimento de bactérias. Para gerar gráficos, ele
requer a biblioteca gráfica GD.
Antes de usarmos o RRDtool no projeto, precisamos criar os arquivos .rrd , que
serão a base de dados para os dados. É nele que serão inseridos os valores diários de
upload na porta 80, upload total, download na porta 20, etc... .
No uso no PoP-GO decidi criar 2 arquivos: um para downloads e outro para
uploads. Utilizei o comando:
#Arquivo RRD de downloads
rrdtool create download.rrd --start `date -d 040930 +%s` --step
86400 DS:download:GAUGE:86400:0:200 DS:p80d:GAUGE:86400:0:200
DS:p20d:GAUGE:86400:0:200 DS:p25d:GAUGE:864
00:0:200 RRA:LAST:0.5:1:7 RRA:LAST:0.5:1:30 RRA:LAST:0.5:1:365
#Arquivo RRD de Uploads
rrdtool create upload.rrd --start `date -d 040930 +%s` --step
86400 DS:upload:GAUGE:86400:0:200 DS:p80u:GAUGE:86400:0:200
DS:p20u:GAUGE:86400:0:200 DS:p25u:GAUGE:86400:0
:200 RRA:LAST:0.5:1:7 RRA:LAST:0.5:1:30 RRA:LAST:0.5:1:365
A sintaxe do arquivo de downloads quanto o de uploads é basicamente a mesma,
de forma que basta explicar apenas um deles. O parâmetro create download.rrd passa ao
RRDtool que criaremos um arquivo novo do zero, com data inicial em 30/09/04 , passado
pelo parâmetro --start . O parâmetro step informa que o passo em segundos que
atualizaremos o arquivo, ou seja, o arquivo será atualizado a cada 24 horas, ou 86400
segundos. É que nossa análise é feita após o fim do dia, onde extraímos tudo que
aconteceu. Já o parâmetro DS:ds-name:DST:dst arguments significa que estamos criando
uma fonte de dados. DS é sigla para Data Source (fonte de dados). Temos várias fontes no
script, e pegando como exemplo a DS:p80u:GAUGE:86400:0:200 temos que p80u é
um nome para nossa data source (na verdade, armazena os uploads da porta 80,sintaxe
que eu uso, você pode usar a que quiser). GAUGE significa que devemos armazenar
nosso dado com ele chega. Outras opções no lugar de GAUGE seriam DERIVE, que
armazena a derivada da reta valor que chega em relação ao valor anterior. Existem outros
tipos de fonte de dados (DST – data source types), consulte as páginas de manual do
software para mais informações. Como argumentos estamos usando 86400, que é o
período para atualização do arquivo. E 0:200 no caso define a faixa máxima de valores
que pode variar este dado, no caso nosso de 0 gigabytes a 200 gigabytes. Qualquer valor
fora deixa faixa será interpretado com UNKNOWN. Por exemplo, não é possível que
tenhamos download abaixo de 0.
No que se refere ao comando RRA:LAST:0.5:1:7, RRA é a sigla para RoundRobin Archive. Um RRA consiste de dados estatísticos de DS(data sources). A sintaxe
genérica para o RRA é RRA:AVERAGE | MIN | MAX | LAST:xff:steps:rows , que na
25
verdade é parâmetro que diz o que deve ser feito com os dados do DS.Pode ser uma
média e armazenar de hora em hora, mas no nosso caso ele armazena o último valor
recebido. É o arquivo que determina quantos slots tem para armazenar dados, evitando o
crescimento linear da base de dados. Ele armazena amostras para semana,mês e ano no
nosso caso.
Depois destes arquivos criados, o primeiro passo o armazenar os dados neles, feito
da seguinte forma:
# esse comando diz para atualizar o arquivo dowload.rrd com a data
#atual e o conteúdo extraído de update_d. Vide NGRAPHS.
rrdtool update /var/scripts/download.rrd $datastamp:`cat update_d`
Ou seja, inserimos um valor como por exemplo 20:40:40:32, que serão os valroes
dos downloads geral, na porta 80, 20 e 25 para o dia (representado por $datastamp, vide
NGRAPHS) em questão. No outro dia, quando rodarmos o script, o datastamp será outro e
atualizará automaticamente o valor.
Com os dados “populados”, basta agora gerarmos os gráficos. O RRDtool fornece
um parâmetro para criar gráficos. Vejamos o exemplo:
$rrdtool graph Geral_updown.gif --start `date -d
${syear}${smonth}${sday} +%s` --end `date -d ${eano}${emes}${eday}
+%s` --title "PoP-GO: Cisco - Downloads e Uploads Volume Total Ano:$syear Mês:$smonth" --vertical-label "gigabytes"
DEF:download=download.rrd:download:LAST
DEF:upload=upload.rrd:upload:LAST
LINE1:download#ff0000:"Downloads" LINE2:upload#0400ff:"Uploads"
'GPRINT:download:LAST:Último Download\:%2.1lf GB'
'GPRINT:upload:LAST:Último Upload\:%2.1lf GB'
'GPRINT:download:MAX:Download Max\:%2.1lf GB'
'GPRINT:upload:MAX:Upload Max\:%2.1lf GB' 'GPRINT:download:
MIN:Download Mín\:%2.1lf GB' 'GPRINT:upload:MIN:Upload Mín\:%2.1lf
GB' -w 509
}
O parâmetro graph diz ao rrdtool para criar um gráfico de nome
Geral_updown.gif, a partir da data depois de --start. Essa data é a do dia anterior, visto
que geramos o gráfico e análises após a meia noite. Estabelecemos o fim do gráfico pela
opção --end . O parâmetro --title informa qual será o título que aparecerá no gráfico, no
cabeçalho,
como
na
figura
acima
foi
PoP-GO
...
.
A
linha
DEF:download=download.rrd:download:LAST serve para buscar dados no arquivo rrd.
Dentro de download.rrd, pegaremos o valor da DS download com a função de
consolidação LAST e armazenaremos num nome virtual (vname) também chamado
download. Esse vname é o download após DEF:. Aí dentro deste comando quando
quisermos nos refererir a este valor de download dentro de download.rrd, usaremos o
nome download apenas. O parâmetro LINE1:download#ff0000:"Downloads" cria uma
linha da cor ff0000 que conterá o valor de download variando no no intervalo de tempo
que
escolhemos
acima
com
--start
e
--end
.
O
parâmetro
'GPRINT:download:MAX:Download Max\:%2.1lf GB' imprime uma linha que diz
Downlaod Max no gráfico e joga o conteúdo de download na frente. O parâmetro -w 509
informa a largura máxima da figura, que será 509 pixels. Foi necessário para padronizar o
tamanho do gráfico para o site do PoP-GO.
Pode parecer um pouco complicado, mas torna-se fácil com o uso diário.
26
Recomendo leitura das páginas de manual e tutoriais do site oficial do RRDTool. Com
isso fecha-se nossas ferramentas desenvolvidas e obtivemos o resultado desejado.